Completes a reminder

        :param complete_dict: the complete dict with the template id
        :param reminder_id: the reminder id
        :return: Response
773359
def complete_reminder(self, reminder_id, complete_dict):
        
        return self._create_put_request(
            resource=REMINDERS,
            billomat_id=reminder_id,
            command=COMPLETE,
            send_data=complete_dict
        )
471772
def mark_confirmation_as_clear(self, confirmation_id):
        
        return self._create_put_request(
            resource=CONFIRMATIONS,
            billomat_id=confirmation_id,
            command=CLEAR,
        )
700986
def mark_job_as_completed(job_id, data=None):
    
    update_dict = {
        "status": "complete",
        "data": json.dumps(data),
        "finished_timestamp": datetime.datetime.now(),
    }
    _update_job(job_id, update_dict)
817195
public function checkoutComplete($order_id)
    {
        $this->setOrderCheckoutComplete($order_id);
        $this->controlAccessCheckoutComplete();
        $this->setTitleCheckoutComplete();
        $this->setBreadcrumbCheckoutComplete();

        $this->setData('message', $this->getMessageCheckoutComplete());

        $this->setDataTemplatesCheckoutComplete();
        $this->hook->attach('order.complete.page', $this->data_order, $this->order, $this);
        $this->outputCheckoutComplete();
    }
1094632
def get_tags_of_reminder_per_page(self, reminder_id, per_page=1000, page=1):
        
        return self._get_resource_per_page(
            resource=REMINDER_TAGS,
            per_page=per_page,
            page=page,
            params={'reminder_id': reminder_id},
        )
515101
def complete_request(self, account_id, request_id, **params):
        """"""
        response = self._post(
            'v2', 'accounts', account_id, 'transactions', request_id,
            'complete', data=params)
        return self._make_api_object(response, APIObject)
630637
def reminders_list(self, **kwargs) -> SlackResponse:
        """"""
        self._validate_xoxp_token()
        return self.api_call("reminders.list", http_verb="GET", params=kwargs)
880182
def finishOpenID(request):
    
    result = {}

    # Because the object containing the query parameters is a
    # MultiValueDict and the OpenID library doesn't allow that, we'll
    # convert it to a normal dict.

    # OpenID 2 can send arguments as either POST body or GET query
    # parameters.
    request_args = util.normalDict(request.GET)
    if request.method == 'POST':
        request_args.update(util.normalDict(request.POST))

    if request_args:
        c = getConsumer(request)

        # Get a response object indicating the result of the OpenID
        # protocol.
        return_to = util.getViewURL(request, finishOpenID)
        response = c.complete(request_args, return_to)

        # Get a Simple Registration response object if response
        # information was included in the OpenID response.
        sreg_response = {}
        ax_items = {}
        if response.status == consumer.SUCCESS:
            sreg_response = sreg.SRegResponse.fromSuccessResponse(response)

            ax_response = ax.FetchResponse.fromSuccessResponse(response)
            if ax_response:
                ax_items = ax_response.data

        # Get a PAPE response object if response information was
        # included in the OpenID response.
        pape_response = None
        if response.status == consumer.SUCCESS:
            pape_response = pape.Response.fromSuccessResponse(response)

            if not pape_response.auth_policies:
                pape_response = None

        # Map different consumer status codes to template contexts.
        results = {
            consumer.CANCEL:
            {'message': 'OpenID authentication cancelled.'},

            consumer.FAILURE:
            {'error': 'OpenID authentication failed.'},

            consumer.SUCCESS:
            {'url': response.getDisplayIdentifier(),
             'sreg_response': sreg_response and sreg_response.iteritems(),
             'ax_response': ax_items.items(),
             'pape': pape_response}
        }

        result = results[response.status]

        print result
        if not result.has_key("error"):
            data_array = [it[1][0] for it in result["ax_response"]]
            data = {
                "login": None,
                "openid": result["url"],
                "first_name": data_array[0],
                "last_name": data_array[1],
                "email": data_array[2],
            }
            return create_profil_from_ipenid(request, data)

        if isinstance(response, consumer.FailureResponse):
            # In a real application, this information should be
            # written to a log for debugging/tracking OpenID
            # authentication failures. In general, the messages are
            # not user-friendly, but intended for developers.
            result['failure_reason'] = response.message

    return renderIndexPage(request, **result)
968620
def setCompleter( self, completer ):
        
        if ( self._completer == completer ):
            return
        elif ( self._completer ):
            self._completer.activated.disconnect(self.finishEditing)
        
        self._completer = completer
        
        if ( completer ):
            completer.activated.connect(self.finishEditing)
154729
def update_email_template(self, template_id, template_dict):
        
        return self._create_put_request(
            resource=EMAIL_TEMPLATES,
            billomat_id=template_id,
            send_data=template_dict
        )
1148883
def create_subtask(client, task_id, title, completed=False):
    '''  '''
    _check_title_length(title, client.api)
    data = {
            'task_id' : int(task_id) if task_id else None,
            'title' : title,
            'completed' : completed,
            }
    data = { key: value for key, value in data.items() if value is not None }
    response = client.authenticated_request(client.api.Endpoints.SUBTASKS, 'POST', data=data)
    return response.json()
722815
def complete_event(self, event_id: str):
        """"""
        event_ids = DB.get_list(self._processed_key)
        if event_id not in event_ids:
            raise KeyError('Unable to complete event. Event {} has not been '
                           'processed (ie. it is not in the processed '
                           'list).'.format(event_id))
        DB.remove_from_list(self._processed_key, event_id, pipeline=True)
        key = _keys.completed_events(self._object_type, self._subscriber)
        DB.append_to_list(key, event_id, pipeline=True)
        DB.execute()
1356853
def update_milestone(id, **kwargs):
    
    data = update_milestone_raw(id, **kwargs)
    if data:
        return utils.format_json(data)
759862
def send_reminders
      url = ApiRequest.base_path("questionpro.survey.sendReminder")
      result = self.class.get(url, body: self.options)

      self.full_response = result
      self.status = result['status']
      self.message = result['response']['result']
    end
645519
def reminder_date(self, reminder_date):
        
        if not self.can_update():
            self._tcex.handle_error(910, [self.type])

        reminder_date = self._utils.format_datetime(reminder_date, date_format='%Y-%m-%dT%H:%M:%SZ')
        self._data['reminderDate'] = reminder_date
        request = {'reminderDate': reminder_date}
        return self.tc_requests.update(self.api_type, self.api_sub_type, self.unique_id, request)
213556
def reminders_info(self, *, reminder: str, **kwargs) -> SlackResponse:
        
        self._validate_xoxp_token()
        kwargs.update({"reminder": reminder})
        return self.api_call("reminders.info", http_verb="GET", params=kwargs)
1073038
def get_list_subtasks(client, list_id, completed=False):
    '''  '''
    params = {
            'list_id' : int(list_id),
            'completed' : completed,
            }
    response = client.authenticated_request(client.api.Endpoints.SUBTASKS, params=params)
    return response.json()