add status message: create request type missing
514710
public void typeMissing() {
		this.parameterMissing(
				ProtocolConstants.Parameters.Create.TYPE,
				"Please provide the type of the create request. Use \""
						+ CreateRequestType.USER.getIdentifier()
						+ "\" to create a user, \""
						+ CreateRequestType.FOLLOW.getIdentifier()
						+ "\" to create a follow edge or \""
						+ CreateRequestType.STATUS_UPDATE.getIdentifier()
						+ "\" to create a status update.");
	}
1216780
def debug(request, message, extra_tags='', fail_silently=False):
    """"""
    add_message(request, constants.DEBUG, message, extra_tags=extra_tags,
                fail_silently=fail_silently)
82144
private void addPostParams(final Request request) {
        if (friendlyName != null) {
            request.addPostParam("FriendlyName", friendlyName);
        }

        if (status != null) {
            request.addPostParam("Status", status.toString());
        }
    }
1310335
private void addPostParams(final Request request) {
        if (sampleSid != null) {
            request.addPostParam("SampleSid", sampleSid);
        }

        if (status != null) {
            request.addPostParam("Status", status);
        }
    }
1141669
private void addPostParams(final Request request) {
        if (friendlyName != null) {
            request.addPostParam("FriendlyName", friendlyName);
        }

        if (defaultServiceRoleSid != null) {
            request.addPostParam("DefaultServiceRoleSid", defaultServiceRoleSid);
        }

        if (defaultChannelRoleSid != null) {
            request.addPostParam("DefaultChannelRoleSid", defaultChannelRoleSid);
        }

        if (defaultChannelCreatorRoleSid != null) {
            request.addPostParam("DefaultChannelCreatorRoleSid", defaultChannelCreatorRoleSid);
        }

        if (readStatusEnabled != null) {
            request.addPostParam("ReadStatusEnabled", readStatusEnabled.toString());
        }

        if (reachabilityEnabled != null) {
            request.addPostParam("ReachabilityEnabled", reachabilityEnabled.toString());
        }

        if (typingIndicatorTimeout != null) {
            request.addPostParam("TypingIndicatorTimeout", typingIndicatorTimeout.toString());
        }

        if (consumptionReportInterval != null) {
            request.addPostParam("ConsumptionReportInterval", consumptionReportInterval.toString());
        }

        if (notificationsNewMessageEnabled != null) {
            request.addPostParam("Notifications.NewMessage.Enabled", notificationsNewMessageEnabled.toString());
        }

        if (notificationsNewMessageTemplate != null) {
            request.addPostParam("Notifications.NewMessage.Template", notificationsNewMessageTemplate);
        }

        if (notificationsAddedToChannelEnabled != null) {
            request.addPostParam("Notifications.AddedToChannel.Enabled", notificationsAddedToChannelEnabled.toString());
        }

        if (notificationsAddedToChannelTemplate != null) {
            request.addPostParam("Notifications.AddedToChannel.Template", notificationsAddedToChannelTemplate);
        }

        if (notificationsRemovedFromChannelEnabled != null) {
            request.addPostParam("Notifications.RemovedFromChannel.Enabled", notificationsRemovedFromChannelEnabled.toString());
        }

        if (notificationsRemovedFromChannelTemplate != null) {
            request.addPostParam("Notifications.RemovedFromChannel.Template", notificationsRemovedFromChannelTemplate);
        }

        if (notificationsInvitedToChannelEnabled != null) {
            request.addPostParam("Notifications.InvitedToChannel.Enabled", notificationsInvitedToChannelEnabled.toString());
        }

        if (notificationsInvitedToChannelTemplate != null) {
            request.addPostParam("Notifications.InvitedToChannel.Template", notificationsInvitedToChannelTemplate);
        }

        if (preWebhookUrl != null) {
            request.addPostParam("PreWebhookUrl", preWebhookUrl.toString());
        }

        if (postWebhookUrl != null) {
            request.addPostParam("PostWebhookUrl", postWebhookUrl.toString());
        }

        if (webhookMethod != null) {
            request.addPostParam("WebhookMethod", webhookMethod.toString());
        }

        if (webhookFilters != null) {
            for (String prop : webhookFilters) {
                request.addPostParam("WebhookFilters", prop);
            }
        }

        if (webhooksOnMessageSendUrl != null) {
            request.addPostParam("Webhooks.OnMessageSend.Url", webhooksOnMessageSendUrl.toString());
        }

        if (webhooksOnMessageSendMethod != null) {
            request.addPostParam("Webhooks.OnMessageSend.Method", webhooksOnMessageSendMethod.toString());
        }

        if (webhooksOnMessageSendFormat != null) {
            request.addPostParam("Webhooks.OnMessageSend.Format", webhooksOnMessageSendFormat);
        }

        if (webhooksOnMessageUpdateUrl != null) {
            request.addPostParam("Webhooks.OnMessageUpdate.Url", webhooksOnMessageUpdateUrl.toString());
        }

        if (webhooksOnMessageUpdateMethod != null) {
            request.addPostParam("Webhooks.OnMessageUpdate.Method", webhooksOnMessageUpdateMethod.toString());
        }

        if (webhooksOnMessageUpdateFormat != null) {
            request.addPostParam("Webhooks.OnMessageUpdate.Format", webhooksOnMessageUpdateFormat);
        }

        if (webhooksOnMessageRemoveUrl != null) {
            request.addPostParam("Webhooks.OnMessageRemove.Url", webhooksOnMessageRemoveUrl.toString());
        }

        if (webhooksOnMessageRemoveMethod != null) {
            request.addPostParam("Webhooks.OnMessageRemove.Method", webhooksOnMessageRemoveMethod.toString());
        }

        if (webhooksOnMessageRemoveFormat != null) {
            request.addPostParam("Webhooks.OnMessageRemove.Format", webhooksOnMessageRemoveFormat);
        }

        if (webhooksOnChannelAddUrl != null) {
            request.addPostParam("Webhooks.OnChannelAdd.Url", webhooksOnChannelAddUrl.toString());
        }

        if (webhooksOnChannelAddMethod != null) {
            request.addPostParam("Webhooks.OnChannelAdd.Method", webhooksOnChannelAddMethod.toString());
        }

        if (webhooksOnChannelAddFormat != null) {
            request.addPostParam("Webhooks.OnChannelAdd.Format", webhooksOnChannelAddFormat);
        }

        if (webhooksOnChannelDestroyUrl != null) {
            request.addPostParam("Webhooks.OnChannelDestroy.Url", webhooksOnChannelDestroyUrl.toString());
        }

        if (webhooksOnChannelDestroyMethod != null) {
            request.addPostParam("Webhooks.OnChannelDestroy.Method", webhooksOnChannelDestroyMethod.toString());
        }

        if (webhooksOnChannelDestroyFormat != null) {
            request.addPostParam("Webhooks.OnChannelDestroy.Format", webhooksOnChannelDestroyFormat);
        }

        if (webhooksOnChannelUpdateUrl != null) {
            request.addPostParam("Webhooks.OnChannelUpdate.Url", webhooksOnChannelUpdateUrl.toString());
        }

        if (webhooksOnChannelUpdateMethod != null) {
            request.addPostParam("Webhooks.OnChannelUpdate.Method", webhooksOnChannelUpdateMethod.toString());
        }

        if (webhooksOnChannelUpdateFormat != null) {
            request.addPostParam("Webhooks.OnChannelUpdate.Format", webhooksOnChannelUpdateFormat);
        }

        if (webhooksOnMemberAddUrl != null) {
            request.addPostParam("Webhooks.OnMemberAdd.Url", webhooksOnMemberAddUrl.toString());
        }

        if (webhooksOnMemberAddMethod != null) {
            request.addPostParam("Webhooks.OnMemberAdd.Method", webhooksOnMemberAddMethod.toString());
        }

        if (webhooksOnMemberAddFormat != null) {
            request.addPostParam("Webhooks.OnMemberAdd.Format", webhooksOnMemberAddFormat);
        }

        if (webhooksOnMemberRemoveUrl != null) {
            request.addPostParam("Webhooks.OnMemberRemove.Url", webhooksOnMemberRemoveUrl.toString());
        }

        if (webhooksOnMemberRemoveMethod != null) {
            request.addPostParam("Webhooks.OnMemberRemove.Method", webhooksOnMemberRemoveMethod.toString());
        }

        if (webhooksOnMemberRemoveFormat != null) {
            request.addPostParam("Webhooks.OnMemberRemove.Format", webhooksOnMemberRemoveFormat);
        }

        if (webhooksOnMessageSentUrl != null) {
            request.addPostParam("Webhooks.OnMessageSent.Url", webhooksOnMessageSentUrl.toString());
        }

        if (webhooksOnMessageSentMethod != null) {
            request.addPostParam("Webhooks.OnMessageSent.Method", webhooksOnMessageSentMethod.toString());
        }

        if (webhooksOnMessageSentFormat != null) {
            request.addPostParam("Webhooks.OnMessageSent.Format", webhooksOnMessageSentFormat);
        }

        if (webhooksOnMessageUpdatedUrl != null) {
            request.addPostParam("Webhooks.OnMessageUpdated.Url", webhooksOnMessageUpdatedUrl.toString());
        }

        if (webhooksOnMessageUpdatedMethod != null) {
            request.addPostParam("Webhooks.OnMessageUpdated.Method", webhooksOnMessageUpdatedMethod.toString());
        }

        if (webhooksOnMessageUpdatedFormat != null) {
            request.addPostParam("Webhooks.OnMessageUpdated.Format", webhooksOnMessageUpdatedFormat);
        }

        if (webhooksOnMessageRemovedUrl != null) {
            request.addPostParam("Webhooks.OnMessageRemoved.Url", webhooksOnMessageRemovedUrl.toString());
        }

        if (webhooksOnMessageRemovedMethod != null) {
            request.addPostParam("Webhooks.OnMessageRemoved.Method", webhooksOnMessageRemovedMethod.toString());
        }

        if (webhooksOnMessageRemovedFormat != null) {
            request.addPostParam("Webhooks.OnMessageRemoved.Format", webhooksOnMessageRemovedFormat);
        }

        if (webhooksOnChannelAddedUrl != null) {
            request.addPostParam("Webhooks.OnChannelAdded.Url", webhooksOnChannelAddedUrl.toString());
        }

        if (webhooksOnChannelAddedMethod != null) {
            request.addPostParam("Webhooks.OnChannelAdded.Method", webhooksOnChannelAddedMethod.toString());
        }

        if (webhooksOnChannelAddedFormat != null) {
            request.addPostParam("Webhooks.OnChannelAdded.Format", webhooksOnChannelAddedFormat);
        }

        if (webhooksOnChannelDestroyedUrl != null) {
            request.addPostParam("Webhooks.OnChannelDestroyed.Url", webhooksOnChannelDestroyedUrl.toString());
        }

        if (webhooksOnChannelDestroyedMethod != null) {
            request.addPostParam("Webhooks.OnChannelDestroyed.Method", webhooksOnChannelDestroyedMethod.toString());
        }

        if (webhooksOnChannelDestroyedFormat != null) {
            request.addPostParam("Webhooks.OnChannelDestroyed.Format", webhooksOnChannelDestroyedFormat);
        }

        if (webhooksOnChannelUpdatedUrl != null) {
            request.addPostParam("Webhooks.OnChannelUpdated.Url", webhooksOnChannelUpdatedUrl.toString());
        }

        if (webhooksOnChannelUpdatedMethod != null) {
            request.addPostParam("Webhooks.OnChannelUpdated.Method", webhooksOnChannelUpdatedMethod.toString());
        }

        if (webhooksOnChannelUpdatedFormat != null) {
            request.addPostParam("Webhooks.OnChannelUpdated.Format", webhooksOnChannelUpdatedFormat);
        }

        if (webhooksOnMemberAddedUrl != null) {
            request.addPostParam("Webhooks.OnMemberAdded.Url", webhooksOnMemberAddedUrl.toString());
        }

        if (webhooksOnMemberAddedMethod != null) {
            request.addPostParam("Webhooks.OnMemberAdded.Method", webhooksOnMemberAddedMethod.toString());
        }

        if (webhooksOnMemberAddedFormat != null) {
            request.addPostParam("Webhooks.OnMemberAdded.Format", webhooksOnMemberAddedFormat);
        }

        if (webhooksOnMemberRemovedUrl != null) {
            request.addPostParam("Webhooks.OnMemberRemoved.Url", webhooksOnMemberRemovedUrl.toString());
        }

        if (webhooksOnMemberRemovedMethod != null) {
            request.addPostParam("Webhooks.OnMemberRemoved.Method", webhooksOnMemberRemovedMethod.toString());
        }

        if (webhooksOnMemberRemovedFormat != null) {
            request.addPostParam("Webhooks.OnMemberRemoved.Format", webhooksOnMemberRemovedFormat);
        }

        if (limitsChannelMembers != null) {
            request.addPostParam("Limits.ChannelMembers", limitsChannelMembers.toString());
        }

        if (limitsUserChannels != null) {
            request.addPostParam("Limits.UserChannels", limitsUserChannels.toString());
        }
    }
372358
def add_issue_status(self, name, **attrs):
        
        return IssueStatuses(self.requester).create(self.id, name, **attrs)
216658
def method_missing(method_id, *args)
      if [:get, :post, :put, :delete].include?(method_id)
        path, options = *args
        options ||= {}
        options[:query] = (default_params.merge(options[:query] || {}))
        options[:headers] = (self.class.default_options[:headers].merge(options[:headers] || {}))

        CrowdFlower.request_hook.call(method_id, path, options) do
          self.class.send(method_id, url(path), options)
        end
      else
        super
      end
    end
1152295
function(req, res) {
        if (req.headers.accept == 'application/json') {
            res.header('Content-Type', 'application/json');
            res.status(200).json({
                data: {
                    ontologyTxt: req.rawOntology,
                    mimeType: req.mimeType
                },
                requestDelay: req.requestDelay,
                serverTime: new Date().getTime()
            });
        } else {
            res.header('Content-Type', req.mimeType);
            res.status(200).send(req.rawOntology);
        }
    }
874716
def add_issue_type(self, name, **attrs):
        
        return IssueTypes(self.requester).create(self.id, name, **attrs)
1335701
function initializeState(requester, updateParams) {
        var currentRequester = requester || "";
        _updateParams = updateParams;
        installerPath = path.resolve(updateDir, updateParams.installerName);
        postMessageToBrackets(MessageIds.NOTIFY_INITIALIZATION_COMPLETE, currentRequester);
    }
828131
def _create_and_update(self):
        
        data_json = self._create_json()
        data_json.update(self.additional_params)
        request_url = self._artifactory.drive + '/api/{uri}/{x.name}'.format(uri=self._uri, x=self)
        r = self._session.put(
            request_url,
            json=data_json,
            headers={'Content-Type': 'application/json'},
            auth=self._auth,
        )
        r.raise_for_status()
        rest_delay()
        self.read()
836026
function(res, text, httpStatus) {
		processLogger.log('fatal/request', text);
		apiUtils.errorResponse(res, text, httpStatus || 404);
	}
989862
def createissue(self, project_id, title, **kwargs):
        
        data = {'id': id, 'title': title}
        if kwargs:
            data.update(kwargs)
        request = requests.post(
            '{0}/{1}/issues'.format(self.projects_url, project_id),
            headers=self.headers, data=data, verify=self.verify_ssl, auth=self.auth, timeout=self.timeout)

        if request.status_code == 201:
            return request.json()
        else:
            return False
149384
def folder_created_message(self, request, folder):
        
        messages.success(request, _("Folder {} was created".format(folder)))
1327846
function (type, error = null, id = null) {
    type = type.toUpperCase()
    let errors = {
        'NO_DATA': 'No info for that id yet. Or maybe the data provided was wrong.',
        'BUSY': 'The server providing the info is busy right now. Try again.',
        'UNAVAILABLE': 'The server providing the info is unavailable right now. Try again later.',
        'EMPTY': 'The provider server was parsed correctly, but has no data to show. Try Again later.',
        'DOWN': 'The provider server is currently down. Try Again later.',
        'PARSER': 'Something went wrong when parsing the provider website.',
        'ACTION_REQUIRED': 'That tracker requires an aditional step in their website.'
    }

    let message = error != null ? error : errors[type]
    message = id != null ? message + ' ID:' + id : message
    return new Error(type + ' - ' + message)
}
241118
def build_request(request_type)
      case request_type
      when :setup_transaction
        SetupTransactionRequest.new(config)
      when :recurrent_transaction
        RecurrentTransactionRequest.new(config)
      when :refund_transaction
        RefundTransactionRequest.new(config)
      when :refund_info
        RefundInfoRequest.new(config)
      when :status
        StatusRequest.new(config)
      when :cancel
        CancelRequest.new(config)
      end
    end
149867
def add_status(options)
      time = options[:when] || Time.now

      params = {
        'd' => time.strftime('%Y%m%d'),
        't' => time.strftime('%H:%M'),
      }

      params[:v1] = options[:energy_generated] if options[:energy_generated]
      params[:v2] = options[:power_generated] if options[:power_generated]
      params[:v3] = options[:energy_consumed] if options[:energy_consumed]
      params[:v4] = options[:power_consumed] if options[:power_consumed]
      params[:v5] = options[:temperature] if options[:temperature]
      params[:v6] = options[:voltage] if options[:voltage]
      params[:c1] = 1 if options[:cumulative] == true
      params[:n]  = 1 if options[:net] == true

      response = self.class.post('/service/r2/addstatus.jsp', :body => params)

      raise('Bad Post') unless response.code == 200
    end