Deletes a reaction made by a user on this message.
 @param user [User, #resolve_id] the user who used this reaction
 @param reaction [String, #to_reaction] the reaction to remove
187753
def delete_reaction(user, reaction)
      reaction = reaction.to_reaction if reaction.respond_to?(:to_reaction)
      API::Channel.delete_user_reaction(@bot.token, @channel.id, @id, reaction, user.resolve_id)
    end
902516
def destroy
      m = model.find(user_scoped.find(params[:id]).id)
      @record_saved = m     # copy for possible later use
      m.destroy

      prepare_list
      @record = model.new
      @flash_notice = t('delete_ok')
    end
381458
def delete_member(self, user):
        
        if not self.email_enabled:
            raise EmailNotEnabledError("See settings.EMAIL_ENABLED")
        return requests.delete(
            f"{self.api_url}/{self.address}/members/{user.email}",
            auth=("api", self.api_key),
        )
411182
def DeleteUser(self, user_link, options=None):
        
        if options is None:
            options = {}

        path = base.GetPathFromLink(user_link)
        user_id = base.GetResourceIdOrFullNameFromLink(user_link)
        return self.DeleteResource(path,
                                   'users',
                                   user_id,
                                   None,
                                   options)
43154
def destroy
      @subscription = Subscription.find(params[:id])
      @subscription.destroy
  
      respond_to do |format|
        format.html { redirect_to subscriptions_url }
        format.json { head :ok }
      end
    end
246954
def del_user(self, username):
        
        self._check_fix_users(username)
        try:
            del self.users[username]
        except Exception as e:
            raise UserDoesntExist(username, self.backend_name)
1054185
def delete(reason = nil)
      if token?
        API::Webhook.token_delete_webhook(@token, @id, reason)
      else
        API::Webhook.delete_webhook(@bot.token, @id, reason)
      end
    end
1031601
def delete
      user = Cadenero::User.find_by_id(params[:id])
      if user_signed_in?
        env['warden'].logout(:user)
        render json: {message: "Successful logout"}, status: :ok
      else
        render json: {message: "Unsuccessful logout user with id"}, status: :forbidden
      end
    end
1367073
def delete_emoji(emoji, reason: nil)
      API::Server.delete_emoji(@bot.token, @id, emoji.resolve_id, reason)
    end
490802
def delete_user(self, username):
        
        path = Client.urls['users_by_name'] % username
        return self._call(path, 'DELETE')
981310
def UsersDelete (self, user_id):
        
        if self.__SenseApiCall__('/users/{user_id}.json'.format(user_id = user_id), 'DELETE'):
            return True
        else:
            self.__error__ = "api call unsuccessful"
            return False
971985
def remove_from_subscriptions(self, subscription):
        
        assert isinstance(subscription, github.Repository.Repository), subscription
        headers, data = self._requester.requestJsonAndCheck(
            "DELETE",
            "/user/subscriptions/" + subscription._identity
        )
718063
public void removeReaction(Emoji emoji, boolean you) {
        Optional<Reaction> reaction = reactions.stream().filter(r -> emoji.equalsEmoji(r.getEmoji())).findAny();
        reaction.ifPresent(r -> ((ReactionImpl) r).decrementCount(you));
        reactions.removeIf(r -> r.getCount() <= 0);
    }
683131
def delete_user(self, user):
        
        name = utils.get_name(user)
        self._user_manager.delete(name)
674629
def delete_user(self, user_id):
        
        api = self._get_api(iam.AccountAdminApi)
        api.delete_user(user_id)
        return
1050828
def delete(options = {})
      options = options.merge(
        user_name: @user_name,
        certificate_id: @id
      )
      resp = @client.delete_signing_certificate(options)
      resp.data
    end
1056958
def delete(self, request, bot_id, hook_id, id, format=None):
        
        bot = self.get_bot(bot_id, request.user)
        hook = self.get_hook(hook_id, bot, request.user)
        recipient = self.get_recipient(id, hook, request.user)
        recipient.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)