/// <inheritdoc />
/// <summary>
/// Create a bundle item The SKU for the bundle itself must be unique and there can only be one SKU. Extra notes for price_override: The price of all the items (multiplied by the quantity) must equal the price of the bundle. With individual prices set, items will be processed individually and can be refunded as such. However, if all prices are set to null, the price of the bundle will be used and will be treated as one item. <br><br><b>Permissions Needed:</b> BUNDLES_ADMIN
/// </summary>
/// <param name="cascade">Whether to cascade group changes, such as in the limited gettable behavior. A 400 error will return otherwise if the group is already in use with different values.</param>
/// <param name="bundleItem">The bundle item object</param>
public void CreateBundleItem(bool?cascade, BundleItem bundleItem)
{
mWebCallEvent.WebPath = "/store/bundles";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (cascade != null)
{
mWebCallEvent.QueryParams["cascade"] = KnetikClient.ParameterToString(cascade);
}
mWebCallEvent.PostBody = KnetikClient.Serialize(bundleItem); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mCreateBundleItemStartTime = DateTime.Now;
mWebCallEvent.Context = mCreateBundleItemResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.POST;
KnetikLogger.LogRequest(mCreateBundleItemStartTime, "CreateBundleItem", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Add a user log entry <b>Permissions Needed:</b> owner
/// </summary>
/// <param name="logEntry">The user log entry to be added</param>
public void AddUserLog(UserActionLog logEntry)
{
mWebCallEvent.WebPath = "/audit/logs";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(logEntry); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mAddUserLogStartTime = DateTime.Now;
mWebCallEvent.Context = mAddUserLogResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.POST;
KnetikLogger.LogRequest(mAddUserLogStartTime, "AddUserLog", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Get a list of a country's states <b>Permissions Needed:</b> ANY
/// </summary>
/// <param name="countryCodeIso3">The iso3 code of the country</param>
public void GetCountryStates(string countryCodeIso3)
{
// verify the required parameter 'countryCodeIso3' is set
if (countryCodeIso3 == null)
{
throw new KnetikException(400, "Missing required parameter 'countryCodeIso3' when calling GetCountryStates");
}
mWebCallEvent.WebPath = "/location/countries/{country_code_iso3}/states";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "country_code_iso3" + "}", KnetikClient.ParameterToString(countryCodeIso3));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetCountryStatesStartTime = DateTime.Now;
mWebCallEvent.Context = mGetCountryStatesResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetCountryStatesStartTime, "GetCountryStates", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Retrieves a summation of wallet balances by currency code <b>Permissions Needed:</b> WALLETS_ADMIN
/// </summary>
public void GetWalletBalances()
{
mWebCallEvent.WebPath = "/wallets/totals";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetWalletBalancesStartTime = DateTime.Now;
mWebCallEvent.Context = mGetWalletBalancesResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetWalletBalancesStartTime, "GetWalletBalances", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Create a device <b>Permissions Needed:</b> ANY
/// </summary>
/// <param name="device">device</param>
public void CreateDevice(DeviceResource device)
{
// verify the required parameter 'device' is set
if (device == null)
{
throw new KnetikException(400, "Missing required parameter 'device' when calling CreateDevice");
}
mWebCallEvent.WebPath = "/devices";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(device); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mCreateDeviceStartTime = DateTime.Now;
mWebCallEvent.Context = mCreateDeviceResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.POST;
KnetikLogger.LogRequest(mCreateDeviceStartTime, "CreateDevice", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Create a shipping template Shipping Templates define a type of shipping and the properties they have.
/// </summary>
/// <param name="shippingTemplateResource">The new shipping template</param>
public void CreateShippingTemplate(ItemTemplateResource shippingTemplateResource)
{
mWebCallEvent.WebPath = "/store/shipping/templates";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(shippingTemplateResource); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mCreateShippingTemplateStartTime = DateTime.Now;
mWebCallEvent.Context = mCreateShippingTemplateResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.POST;
KnetikLogger.LogRequest(mCreateShippingTemplateStartTime, "CreateShippingTemplate", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Mark an invoice paid with Google Mark an invoice paid with Google. Verifies signature from Google and treats the developerPayload field inside the json payload as the id of the invoice to pay. Returns the transaction ID if successful. <br><br><b>Permissions Needed:</b> ANY
/// </summary>
/// <param name="request">The request for paying an invoice through a Google in-app payment</param>
public void HandleGooglePayment(GooglePaymentRequest request)
{
mWebCallEvent.WebPath = "/payment/provider/google/payments";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(request); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mHandleGooglePaymentStartTime = DateTime.Now;
mWebCallEvent.Context = mHandleGooglePaymentResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.POST;
KnetikLogger.LogRequest(mHandleGooglePaymentStartTime, "HandleGooglePayment", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Send a websocket message Sends a websocket message to one or more users. <br><br><b>Permissions Needed:</b> MESSAGING_ADMIN
/// </summary>
/// <param name="websocketResource">The new websocket message to be sent</param>
public void SendWebsocket(WebsocketMessageResource websocketResource)
{
mWebCallEvent.WebPath = "/messaging/websocket-message";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(websocketResource); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mSendWebsocketStartTime = DateTime.Now;
mWebCallEvent.Context = mSendWebsocketResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.POST;
KnetikLogger.LogRequest(mSendWebsocketStartTime, "SendWebsocket", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Get a list of supported expressions to use in conditions or actions Each resource contains a type and a definition that are read-only, all the other fields must be provided when using the expression in a rule. <br><br><b>Permissions Needed:</b> BRE_RULE_ENGINE_EXPRESSIONS_USER
/// </summary>
/// <param name="filterTypeGroup">Filter for expressions by type group</param>
public void GetBREExpressions(string filterTypeGroup)
{
mWebCallEvent.WebPath = "/bre/expressions";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (filterTypeGroup != null)
{
mWebCallEvent.QueryParams["filter_type_group"] = KnetikClient.ParameterToString(filterTypeGroup);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetBREExpressionsStartTime = DateTime.Now;
mWebCallEvent.Context = mGetBREExpressionsResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetBREExpressionsStartTime, "GetBREExpressions", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Returns a string representation of the provided expression <b>Permissions Needed:</b> BRE_RULE_ENGINE_RULES_ADMIN
/// </summary>
/// <param name="expression">The expression</param>
public void GetBREExpressionAsString(Expressionobject expression)
{
mWebCallEvent.WebPath = "/bre/rules/expression-as-string";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(expression); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetBREExpressionAsStringStartTime = DateTime.Now;
mWebCallEvent.Context = mGetBREExpressionAsStringResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.POST;
KnetikLogger.LogRequest(mGetBREExpressionAsStringStartTime, "GetBREExpressionAsString", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Delete an existing config <b>Permissions Needed:</b> CONFIGS_ADMIN
/// </summary>
/// <param name="name">The config name</param>
public void DeleteConfig(string name)
{
// verify the required parameter 'name' is set
if (name == null)
{
throw new KnetikException(400, "Missing required parameter 'name' when calling DeleteConfig");
}
mWebCallEvent.WebPath = "/configs/{name}";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "name" + "}", KnetikClient.ParameterToString(name));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mDeleteConfigStartTime = DateTime.Now;
mWebCallEvent.Context = mDeleteConfigResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.DELETE;
KnetikLogger.LogRequest(mDeleteConfigStartTime, "DeleteConfig", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Get a single rule <b>Permissions Needed:</b> BRE_RULE_ENGINE_RULES_ADMIN
/// </summary>
/// <param name="id">The id of the rule</param>
public void GetBRERule(string id)
{
// verify the required parameter 'id' is set
if (id == null)
{
throw new KnetikException(400, "Missing required parameter 'id' when calling GetBRERule");
}
mWebCallEvent.WebPath = "/bre/rules/{id}";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "id" + "}", KnetikClient.ParameterToString(id));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetBRERuleStartTime = DateTime.Now;
mWebCallEvent.Context = mGetBRERuleResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetBRERuleStartTime, "GetBRERule", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Link facebook account Links the current user account to a facebook account, using the acccess token from facebook. Can also be used to update the access token after it has expired. <br><br><b>Permissions Needed:</b> Non-facebook user token
/// </summary>
/// <param name="facebookToken">The token from facebook</param>
public void LinkAccounts(FacebookToken facebookToken)
{
mWebCallEvent.WebPath = "/social/facebook/users";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(facebookToken); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mLinkAccountsStartTime = DateTime.Now;
mWebCallEvent.Context = mLinkAccountsResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.POST;
KnetikLogger.LogRequest(mLinkAccountsStartTime, "LinkAccounts", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// List the challenges associated with a campaign <b>Permissions Needed:</b> ANY
/// </summary>
/// <param name="id">The campaign id</param>
/// <param name="filterStartDate">A comma separated string without spaces. First value is the operator to search on, second value is the challenge start date, a unix timestamp in seconds. Allowed operators: (GT, LT, EQ, GOE, LOE).</param>
/// <param name="filterEndDate">A comma separated string without spaces. First value is the operator to search on, second value is the challenge end date, a unix timestamp in seconds. Allowed operators: (GT, LT, EQ, GOE, LOE).</param>
/// <param name="size">The number of objects returned per page</param>
/// <param name="page">The number of the page returned, starting with 1</param>
/// <param name="order">A comma separated list of sorting requirements in priority order, each entry matching PROPERTY_NAME:[ASC|DESC]</param>
public void GetCampaignChallenges(long?id, string filterStartDate, string filterEndDate, int?size, int?page, string order)
{
// verify the required parameter 'id' is set
if (id == null)
{
throw new KnetikException(400, "Missing required parameter 'id' when calling GetCampaignChallenges");
}
mWebCallEvent.WebPath = "/campaigns/{id}/challenges";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "id" + "}", KnetikClient.ParameterToString(id));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (filterStartDate != null)
{
mWebCallEvent.QueryParams["filter_start_date"] = KnetikClient.ParameterToString(filterStartDate);
}
if (filterEndDate != null)
{
mWebCallEvent.QueryParams["filter_end_date"] = KnetikClient.ParameterToString(filterEndDate);
}
if (size != null)
{
mWebCallEvent.QueryParams["size"] = KnetikClient.ParameterToString(size);
}
if (page != null)
{
mWebCallEvent.QueryParams["page"] = KnetikClient.ParameterToString(page);
}
if (order != null)
{
mWebCallEvent.QueryParams["order"] = KnetikClient.ParameterToString(order);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetCampaignChallengesStartTime = DateTime.Now;
mWebCallEvent.Context = mGetCampaignChallengesResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetCampaignChallengesStartTime, "GetCampaignChallenges", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Returns a page of comments <b>Permissions Needed:</b> ANY
/// </summary>
/// <param name="context">Get comments by context type</param>
/// <param name="contextId">Get comments by context id</param>
/// <param name="size">The number of objects returned per page</param>
/// <param name="page">The number of the page returned, starting with 1</param>
public void GetComments(string context, int?contextId, int?size, int?page)
{
// verify the required parameter 'context' is set
if (context == null)
{
throw new KnetikException(400, "Missing required parameter 'context' when calling GetComments");
}
// verify the required parameter 'contextId' is set
if (contextId == null)
{
throw new KnetikException(400, "Missing required parameter 'contextId' when calling GetComments");
}
mWebCallEvent.WebPath = "/comments";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (context != null)
{
mWebCallEvent.QueryParams["context"] = KnetikClient.ParameterToString(context);
}
if (contextId != null)
{
mWebCallEvent.QueryParams["context_id"] = KnetikClient.ParameterToString(contextId);
}
if (size != null)
{
mWebCallEvent.QueryParams["size"] = KnetikClient.ParameterToString(size);
}
if (page != null)
{
mWebCallEvent.QueryParams["page"] = KnetikClient.ParameterToString(page);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetCommentsStartTime = DateTime.Now;
mWebCallEvent.Context = mGetCommentsResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetCommentsStartTime, "GetComments", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// List and search polls Get a list of polls with optional filtering. Assets will not be filled in on the resources returned. Use 'Get a single poll' to retrieve the full resource with assets for a given item as needed. <br><br><b>Permissions Needed:</b> ANY
/// </summary>
/// <param name="filterCategory">Filter for polls from a specific category by id</param>
/// <param name="filterTagset">Filter for polls with specified tags (separated by comma)</param>
/// <param name="filterText">Filter for polls whose text contains a string</param>
/// <param name="size">The number of objects returned per page</param>
/// <param name="page">The number of the page returned</param>
/// <param name="order">A comma separated list of sorting requirements in priority order, each entry matching PROPERTY_NAME:[ASC|DESC]</param>
public void GetPolls(string filterCategory, string filterTagset, string filterText, int?size, int?page, string order)
{
mWebCallEvent.WebPath = "/media/polls";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (filterCategory != null)
{
mWebCallEvent.QueryParams["filter_category"] = KnetikClient.ParameterToString(filterCategory);
}
if (filterTagset != null)
{
mWebCallEvent.QueryParams["filter_tagset"] = KnetikClient.ParameterToString(filterTagset);
}
if (filterText != null)
{
mWebCallEvent.QueryParams["filter_text"] = KnetikClient.ParameterToString(filterText);
}
if (size != null)
{
mWebCallEvent.QueryParams["size"] = KnetikClient.ParameterToString(size);
}
if (page != null)
{
mWebCallEvent.QueryParams["page"] = KnetikClient.ParameterToString(page);
}
if (order != null)
{
mWebCallEvent.QueryParams["order"] = KnetikClient.ParameterToString(order);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetPollsStartTime = DateTime.Now;
mWebCallEvent.Context = mGetPollsResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetPollsStartTime, "GetPolls", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// List and search currencies <b>Permissions Needed:</b> ANY
/// </summary>
/// <param name="filterDefault">Filter for the one currency that is set as default (true), or all that are not (false)</param>
/// <param name="filterEnabledCurrencies">Filter for alternate currencies setup explicitely in system config</param>
/// <param name="filterType">Filter currencies by type. Allowable values: ('virtual', 'real')</param>
/// <param name="size">The number of objects returned per page</param>
/// <param name="page">The number of the page returned, starting with 1</param>
/// <param name="order">A comma separated list of sorting requirements in priority order, each entry matching PROPERTY_NAME:[ASC|DESC]</param>
public void GetCurrencies(bool?filterDefault, bool?filterEnabledCurrencies, string filterType, int?size, int?page, string order)
{
mWebCallEvent.WebPath = "/currencies";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (filterDefault != null)
{
mWebCallEvent.QueryParams["filter_default"] = KnetikClient.ParameterToString(filterDefault);
}
if (filterEnabledCurrencies != null)
{
mWebCallEvent.QueryParams["filter_enabled_currencies"] = KnetikClient.ParameterToString(filterEnabledCurrencies);
}
if (filterType != null)
{
mWebCallEvent.QueryParams["filter_type"] = KnetikClient.ParameterToString(filterType);
}
if (size != null)
{
mWebCallEvent.QueryParams["size"] = KnetikClient.ParameterToString(size);
}
if (page != null)
{
mWebCallEvent.QueryParams["page"] = KnetikClient.ParameterToString(page);
}
if (order != null)
{
mWebCallEvent.QueryParams["order"] = KnetikClient.ParameterToString(order);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetCurrenciesStartTime = DateTime.Now;
mWebCallEvent.Context = mGetCurrenciesResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetCurrenciesStartTime, "GetCurrencies", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Get revenue info by item Get basic info about revenue from sales of all types, summed up within a time range and split out by specific item. Sorted for largest revenue at the top. <br><br><b>Permissions Needed:</b> REPORTING_REVENUE_ADMIN
/// </summary>
/// <param name="currencyCode">The code for a currency to get sales data for</param>
/// <param name="startDate">The start of the time range to aggregate, unix timestamp in seconds. Default is beginning of time</param>
/// <param name="endDate">The end of the time range to aggregate, unix timestamp in seconds. Default is end of time</param>
/// <param name="size">The number of objects returned per page</param>
/// <param name="page">The number of the page returned, starting with 1</param>
public void GetRevenueByItem(string currencyCode, long?startDate, long?endDate, int?size, int?page)
{
// verify the required parameter 'currencyCode' is set
if (currencyCode == null)
{
throw new KnetikException(400, "Missing required parameter 'currencyCode' when calling GetRevenueByItem");
}
mWebCallEvent.WebPath = "/reporting/revenue/products/{currency_code}";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "currency_code" + "}", KnetikClient.ParameterToString(currencyCode));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (startDate != null)
{
mWebCallEvent.QueryParams["start_date"] = KnetikClient.ParameterToString(startDate);
}
if (endDate != null)
{
mWebCallEvent.QueryParams["end_date"] = KnetikClient.ParameterToString(endDate);
}
if (size != null)
{
mWebCallEvent.QueryParams["size"] = KnetikClient.ParameterToString(size);
}
if (page != null)
{
mWebCallEvent.QueryParams["page"] = KnetikClient.ParameterToString(page);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetRevenueByItemStartTime = DateTime.Now;
mWebCallEvent.Context = mGetRevenueByItemResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetRevenueByItemStartTime, "GetRevenueByItem", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Returns a page of flag reports Context can be either a free-form string or a pre-defined context name. <br><br><b>Permissions Needed:</b> MODERATION_ADMIN
/// </summary>
/// <param name="excludeResolved">Ignore resolved context</param>
/// <param name="filterContext">Filter by moderation context</param>
/// <param name="filterContextId">Filter by moderation context ID</param>
/// <param name="size">The number of objects returned per page</param>
/// <param name="page">The number of the page returned, starting with 1</param>
public void GetModerationReports(bool?excludeResolved, string filterContext, string filterContextId, int?size, int?page)
{
mWebCallEvent.WebPath = "/moderation/reports";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (excludeResolved != null)
{
mWebCallEvent.QueryParams["exclude_resolved"] = KnetikClient.ParameterToString(excludeResolved);
}
if (filterContext != null)
{
mWebCallEvent.QueryParams["filter_context"] = KnetikClient.ParameterToString(filterContext);
}
if (filterContextId != null)
{
mWebCallEvent.QueryParams["filter_context_id"] = KnetikClient.ParameterToString(filterContextId);
}
if (size != null)
{
mWebCallEvent.QueryParams["size"] = KnetikClient.ParameterToString(size);
}
if (page != null)
{
mWebCallEvent.QueryParams["page"] = KnetikClient.ParameterToString(page);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetModerationReportsStartTime = DateTime.Now;
mWebCallEvent.Context = mGetModerationReportsResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetModerationReportsStartTime, "GetModerationReports", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Get user registration info Get user registration counts grouped by time range. <br><br><b>Permissions Needed:</b> REPORTING_USER_ADMIN
/// </summary>
/// <param name="granularity">The time duration to aggregate by</param>
/// <param name="startDate">The start of the time range to aggregate, unix timestamp in seconds. Default is beginning of time</param>
/// <param name="endDate">The end of the time range to aggregate, unix timestamp in seconds. Default is end of time</param>
/// <param name="size">The number of objects returned per page</param>
/// <param name="page">The number of the page returned, starting with 1</param>
public void GetUserRegistrations(string granularity, long?startDate, long?endDate, int?size, int?page)
{
mWebCallEvent.WebPath = "/reporting/users/registrations";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (granularity != null)
{
mWebCallEvent.QueryParams["granularity"] = KnetikClient.ParameterToString(granularity);
}
if (startDate != null)
{
mWebCallEvent.QueryParams["start_date"] = KnetikClient.ParameterToString(startDate);
}
if (endDate != null)
{
mWebCallEvent.QueryParams["end_date"] = KnetikClient.ParameterToString(endDate);
}
if (size != null)
{
mWebCallEvent.QueryParams["size"] = KnetikClient.ParameterToString(size);
}
if (page != null)
{
mWebCallEvent.QueryParams["page"] = KnetikClient.ParameterToString(page);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetUserRegistrationsStartTime = DateTime.Now;
mWebCallEvent.Context = mGetUserRegistrationsResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetUserRegistrationsStartTime, "GetUserRegistrations", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// View a user's notification settings
/// </summary>
/// <param name="userId">The id of the subscriber or 'me'</param>
/// <param name="size">The number of objects returned per page</param>
/// <param name="page">The number of the page returned, starting with 1</param>
/// <param name="order">A comma separated list of sorting requirements in priority order, each entry matching PROPERTY_NAME:[ASC|DESC]</param>
public void GetUserNotificationInfoList(string userId, int?size, int?page, string order)
{
// verify the required parameter 'userId' is set
if (userId == null)
{
throw new KnetikException(400, "Missing required parameter 'userId' when calling GetUserNotificationInfoList");
}
mWebCallEvent.WebPath = "/users/{user_id}/notifications/types";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "user_id" + "}", KnetikClient.ParameterToString(userId));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (size != null)
{
mWebCallEvent.QueryParams["size"] = KnetikClient.ParameterToString(size);
}
if (page != null)
{
mWebCallEvent.QueryParams["page"] = KnetikClient.ParameterToString(page);
}
if (order != null)
{
mWebCallEvent.QueryParams["order"] = KnetikClient.ParameterToString(order);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetUserNotificationInfoListStartTime = DateTime.Now;
mWebCallEvent.Context = mGetUserNotificationInfoListResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetUserNotificationInfoListStartTime, "GetUserNotificationInfoList", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// List valid values for a type Used to lookup users to fill in a user constant for example. Only types marked as enumerable are suppoorted here. <br><br><b>Permissions Needed:</b> BRE_RULE_ENGINE_VARIABLES_USER
/// </summary>
/// <param name="name">The name of the type</param>
/// <param name="filterName">Filter results by those with names starting with this string</param>
/// <param name="size">The number of objects returned per page</param>
/// <param name="page">The number of the page returned, starting with 1</param>
public void GetBREVariableValues(string name, string filterName, int?size, int?page)
{
// verify the required parameter 'name' is set
if (name == null)
{
throw new KnetikException(400, "Missing required parameter 'name' when calling GetBREVariableValues");
}
mWebCallEvent.WebPath = "/bre/variable-types/{name}/values";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "name" + "}", KnetikClient.ParameterToString(name));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (filterName != null)
{
mWebCallEvent.QueryParams["filter_name"] = KnetikClient.ParameterToString(filterName);
}
if (size != null)
{
mWebCallEvent.QueryParams["size"] = KnetikClient.ParameterToString(size);
}
if (page != null)
{
mWebCallEvent.QueryParams["page"] = KnetikClient.ParameterToString(page);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetBREVariableValuesStartTime = DateTime.Now;
mWebCallEvent.Context = mGetBREVariableValuesResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetBREVariableValuesStartTime, "GetBREVariableValues", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Returns list of endpoints called (method and url) <b>Permissions Needed:</b> USAGE_ADMIN
/// </summary>
/// <param name="startDate">The beginning of the range being requested, unix timestamp in seconds</param>
/// <param name="endDate">The ending of the range being requested, unix timestamp in seconds</param>
public void GetUsageEndpoints(long?startDate, long?endDate)
{
// verify the required parameter 'startDate' is set
if (startDate == null)
{
throw new KnetikException(400, "Missing required parameter 'startDate' when calling GetUsageEndpoints");
}
// verify the required parameter 'endDate' is set
if (endDate == null)
{
throw new KnetikException(400, "Missing required parameter 'endDate' when calling GetUsageEndpoints");
}
mWebCallEvent.WebPath = "/reporting/usage/endpoints";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (startDate != null)
{
mWebCallEvent.QueryParams["start_date"] = KnetikClient.ParameterToString(startDate);
}
if (endDate != null)
{
mWebCallEvent.QueryParams["end_date"] = KnetikClient.ParameterToString(endDate);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetUsageEndpointsStartTime = DateTime.Now;
mWebCallEvent.Context = mGetUsageEndpointsResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetUsageEndpointsStartTime, "GetUsageEndpoints", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Enable or disable direct notifications for a user Allows enabling or disabling messages for a given notification type when sent direct to the user. Notifications can still be retrieved by endpoint. For notifications broadcased to a topic, see the topic service to disable messages for the user there.
/// </summary>
/// <param name="typeId">The id of the topic</param>
/// <param name="userId">The id of the subscriber or 'me'</param>
/// <param name="silenced">silenced</param>
public void SilenceDirectNotifications(string typeId, string userId, ValueWrapperboolean silenced)
{
// verify the required parameter 'typeId' is set
if (typeId == null)
{
throw new KnetikException(400, "Missing required parameter 'typeId' when calling SilenceDirectNotifications");
}
// verify the required parameter 'userId' is set
if (userId == null)
{
throw new KnetikException(400, "Missing required parameter 'userId' when calling SilenceDirectNotifications");
}
// verify the required parameter 'silenced' is set
if (silenced == null)
{
throw new KnetikException(400, "Missing required parameter 'silenced' when calling SilenceDirectNotifications");
}
mWebCallEvent.WebPath = "/users/{user_id}/notifications/types/{type_id}/silenced";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "type_id" + "}", KnetikClient.ParameterToString(typeId));
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "user_id" + "}", KnetikClient.ParameterToString(userId));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(silenced); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mSilenceDirectNotificationsStartTime = DateTime.Now;
mWebCallEvent.Context = mSilenceDirectNotificationsResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.PUT;
KnetikLogger.LogRequest(mSilenceDirectNotificationsStartTime, "SilenceDirectNotifications", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Update an object <b>Permissions Needed:</b> INVENTORY_ADMIN
/// </summary>
/// <param name="templateId">The id of the template this object is part of</param>
/// <param name="objectId">The id of the object</param>
/// <param name="cascade">Whether to cascade group changes, such as in the limited gettable behavior. A 400 error will return otherwise if the group is already in use with different values.</param>
/// <param name="objectItem">The object item object</param>
public void UpdateObjectItem(string templateId, int?objectId, bool?cascade, ObjectResource objectItem)
{
// verify the required parameter 'templateId' is set
if (templateId == null)
{
throw new KnetikException(400, "Missing required parameter 'templateId' when calling UpdateObjectItem");
}
// verify the required parameter 'objectId' is set
if (objectId == null)
{
throw new KnetikException(400, "Missing required parameter 'objectId' when calling UpdateObjectItem");
}
mWebCallEvent.WebPath = "/objects/{template_id}/{object_id}";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "template_id" + "}", KnetikClient.ParameterToString(templateId));
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "object_id" + "}", KnetikClient.ParameterToString(objectId));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (cascade != null)
{
mWebCallEvent.QueryParams["cascade"] = KnetikClient.ParameterToString(cascade);
}
mWebCallEvent.PostBody = KnetikClient.Serialize(objectItem); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mUpdateObjectItemStartTime = DateTime.Now;
mWebCallEvent.Context = mUpdateObjectItemResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.PUT;
KnetikLogger.LogRequest(mUpdateObjectItemStartTime, "UpdateObjectItem", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Retrieve a challenge event leaderboard details Lists all leaderboard entries with additional user details. <br><br><b>Permissions Needed:</b> REPORTING_CHALLENGES_ADMIN
/// </summary>
/// <param name="filterEvent">A sepecific challenge event id</param>
/// <param name="size">The number of objects returned per page</param>
/// <param name="page">The number of the page returned</param>
/// <param name="order">A comma separated list of sorting requirements in priority order, each entry matching PROPERTY_NAME:[ASC|DESC]</param>
public void GetChallengeEventLeaderboard(long?filterEvent, int?size, int?page, string order)
{
mWebCallEvent.WebPath = "/reporting/events/leaderboard";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (filterEvent != null)
{
mWebCallEvent.QueryParams["filter_event"] = KnetikClient.ParameterToString(filterEvent);
}
if (size != null)
{
mWebCallEvent.QueryParams["size"] = KnetikClient.ParameterToString(size);
}
if (page != null)
{
mWebCallEvent.QueryParams["page"] = KnetikClient.ParameterToString(page);
}
if (order != null)
{
mWebCallEvent.QueryParams["order"] = KnetikClient.ParameterToString(order);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetChallengeEventLeaderboardStartTime = DateTime.Now;
mWebCallEvent.Context = mGetChallengeEventLeaderboardResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetChallengeEventLeaderboardStartTime, "GetChallengeEventLeaderboard", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Enable or disable messages for a user Useful for opt-out options on a single topic. Consider multiple topics for multiple opt-out options.
/// </summary>
/// <param name="id">The id of the topic</param>
/// <param name="userId">The id of the subscriber or 'me'</param>
/// <param name="disabled">disabled</param>
public void DisableTopicSubscriber(string id, string userId, ValueWrapperboolean disabled)
{
// verify the required parameter 'id' is set
if (id == null)
{
throw new KnetikException(400, "Missing required parameter 'id' when calling DisableTopicSubscriber");
}
// verify the required parameter 'userId' is set
if (userId == null)
{
throw new KnetikException(400, "Missing required parameter 'userId' when calling DisableTopicSubscriber");
}
// verify the required parameter 'disabled' is set
if (disabled == null)
{
throw new KnetikException(400, "Missing required parameter 'disabled' when calling DisableTopicSubscriber");
}
mWebCallEvent.WebPath = "/messaging/topics/{id}/subscribers/{user_id}/disabled";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "id" + "}", KnetikClient.ParameterToString(id));
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "user_id" + "}", KnetikClient.ParameterToString(userId));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(disabled); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mDisableTopicSubscriberStartTime = DateTime.Now;
mWebCallEvent.Context = mDisableTopicSubscriberResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.PUT;
KnetikLogger.LogRequest(mDisableTopicSubscriberStartTime, "DisableTopicSubscriber", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Set the status of a subscription Note that the new status may be blocked if the system is not configured to allow the current status to be changed to the new, to enforce proper flow. The default options for statuses are shown below but may be altered for special use cases. <br><br><b>Permissions Needed:</b> USERS_SUBSCRIPTIONS_ADMIN or owner
/// </summary>
/// <param name="userId">The id of the user</param>
/// <param name="inventoryId">The id of the user's inventory</param>
/// <param name="status">The new status for the subscription. Actual options may differ from the indicated set if the invoice status type data has been altered. Allowable values: ('current', 'canceled', 'stopped', 'payment_failed', 'suspended')</param>
public void SetSubscriptionStatus(int?userId, int?inventoryId, StringWrapper status)
{
// verify the required parameter 'userId' is set
if (userId == null)
{
throw new KnetikException(400, "Missing required parameter 'userId' when calling SetSubscriptionStatus");
}
// verify the required parameter 'inventoryId' is set
if (inventoryId == null)
{
throw new KnetikException(400, "Missing required parameter 'inventoryId' when calling SetSubscriptionStatus");
}
// verify the required parameter 'status' is set
if (status == null)
{
throw new KnetikException(400, "Missing required parameter 'status' when calling SetSubscriptionStatus");
}
mWebCallEvent.WebPath = "/users/{user_id}/subscriptions/{inventory_id}/status";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "user_id" + "}", KnetikClient.ParameterToString(userId));
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{" + "inventory_id" + "}", KnetikClient.ParameterToString(inventoryId));
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
mWebCallEvent.PostBody = KnetikClient.Serialize(status); // http body (model) parameter
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mSetSubscriptionStatusStartTime = DateTime.Now;
mWebCallEvent.Context = mSetSubscriptionStatusResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.PUT;
KnetikLogger.LogRequest(mSetSubscriptionStatusStartTime, "SetSubscriptionStatus", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Returns the authentication log for a user A log entry is recorded everytime a user requests a new token. Standard pagination available. <br><br><b>Permissions Needed:</b> SECURITY_ADMIN
/// </summary>
/// <param name="userId">The user id</param>
/// <param name="size">The number of objects returned per page</param>
/// <param name="page">The number of the page returned, starting with 1</param>
/// <param name="order">A comma separated list of sorting requirements in priority order, each entry matching PROPERTY_NAME:[ASC|DESC]</param>
public void GetUserLocationLog(int?userId, int?size, int?page, string order)
{
mWebCallEvent.WebPath = "/security/country-log";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (userId != null)
{
mWebCallEvent.QueryParams["user_id"] = KnetikClient.ParameterToString(userId);
}
if (size != null)
{
mWebCallEvent.QueryParams["size"] = KnetikClient.ParameterToString(size);
}
if (page != null)
{
mWebCallEvent.QueryParams["page"] = KnetikClient.ParameterToString(page);
}
if (order != null)
{
mWebCallEvent.QueryParams["order"] = KnetikClient.ParameterToString(order);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetUserLocationLogStartTime = DateTime.Now;
mWebCallEvent.Context = mGetUserLocationLogResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetUserLocationLogStartTime, "GetUserLocationLog", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}
/// <inheritdoc />
/// <summary>
/// Get a temporary signed S3 URL for download To give access to files in your own S3 account, you will need to grant KnetikcCloud access to the file by adjusting your bucket policy accordingly. See S3 documentation for details. <br><br><b>Permissions Needed:</b> S3_ADMIN
/// </summary>
/// <param name="bucket">S3 bucket name</param>
/// <param name="path">The path to the file relative the bucket (the s3 object key)</param>
/// <param name="expiration">The number of seconds this URL will be valid. Default to 60</param>
public void GetDownloadURL(string bucket, string path, int?expiration)
{
mWebCallEvent.WebPath = "/amazon/s3/downloadurl";
if (!string.IsNullOrEmpty(mWebCallEvent.WebPath))
{
mWebCallEvent.WebPath = mWebCallEvent.WebPath.Replace("{format}", "json");
}
mWebCallEvent.HeaderParams.Clear();
mWebCallEvent.QueryParams.Clear();
mWebCallEvent.AuthSettings.Clear();
mWebCallEvent.PostBody = null;
if (bucket != null)
{
mWebCallEvent.QueryParams["bucket"] = KnetikClient.ParameterToString(bucket);
}
if (path != null)
{
mWebCallEvent.QueryParams["path"] = KnetikClient.ParameterToString(path);
}
if (expiration != null)
{
mWebCallEvent.QueryParams["expiration"] = KnetikClient.ParameterToString(expiration);
}
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_client_credentials_grant");
// authentication settings
mWebCallEvent.AuthSettings.Add("oauth2_password_grant");
// make the HTTP request
mGetDownloadURLStartTime = DateTime.Now;
mWebCallEvent.Context = mGetDownloadURLResponseContext;
mWebCallEvent.RequestType = KnetikRequestType.GET;
KnetikLogger.LogRequest(mGetDownloadURLStartTime, "GetDownloadURL", "Sending server request...");
KnetikGlobalEventSystem.Publish(mWebCallEvent);
}