/// <summary> /// Gifts item to the specified player. /// </summary> /// <remarks> /// Service Name - UserInventoryManagement /// Service Operation - GetUserItem /// </remarks> /// <param name="profileId"> /// </param> /// <param name="itemId"> /// </param> /// <param name="version"> /// </param> /// <param name="immediate"> /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void GiveUserItemTo( String profileId, String itemId, int version, bool immediate, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.UserInventoryManagementServiceProfileId.Value] = profileId; data[OperationParam.UserInventoryManagementServiceItemId.Value] = itemId; data[OperationParam.UserInventoryManagementServiceVersion.Value] = version; data[OperationParam.UserInventoryManagementServiceImmediate.Value] = immediate; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.UserInventoryManagement, ServiceOperation.GiveUserItemTo, data, callback); _client.SendRequest(sc); }
/// <summary> /// Sends an array of file details and returns /// the details of any of those files that have changed /// </summary> /// <remarks> /// Service Name - S3Handling /// Service Operation - GetUpdatedFiles /// </remarks> /// <param name="category"> /// Category of files on server to compare against /// </param> /// <param name="fileDetailsJson"> /// An array of file details /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void GetUpdatedFiles( string category, string fileDetailsJson, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); if (Util.IsOptionalParameterValid(category)) { data[OperationParam.S3HandlingServiceFileCategory.Value] = category; } data[OperationParam.S3HandlingServiceFileDetails.Value] = JsonReader.Deserialize <object[]>(fileDetailsJson); ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.S3Handling, ServiceOperation.GetUpdatedFiles, data, callback); _client.SendRequest(sc); }
/// <summary> /// Method returns a page of global leaderboard results. /// /// Leaderboards entries contain the player's score and optionally, some user-defined /// data associated with the score. /// /// Note: This method allows the client to retrieve pages from within the global leaderboard list /// </summary> /// <remarks> /// Service Name - leaderboard /// Service Operation - GetGlobalLeaderboardPage /// </remarks> /// <param name="leaderboardId"> /// The id of the leaderboard to retrieve. /// </param> /// <param name="sort"> /// Sort key Sort order of page. /// </param> /// <param name="startIndex"> /// The index at which to start the page. /// </param> /// <param name="endIndex"> /// The index at which to end the page. /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void GetGlobalLeaderboardPage( string leaderboardId, SortOrder sort, int startIndex, int endIndex, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { var data = new Dictionary <string, object>(); data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = leaderboardId; data[OperationParam.SocialLeaderboardServiceSort.Value] = sort.ToString(); data[OperationParam.SocialLeaderboardServiceStartIndex.Value] = startIndex; data[OperationParam.SocialLeaderboardServiceEndIndex.Value] = endIndex; var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); var sc = new ServerCall(ServiceName.Leaderboard, ServiceOperation.GetGlobalLeaderboardPage, data, callback); _client.SendRequest(sc); }
/// <summary> /// Advanced universalId password reset using templates /// </summary> /// <remarks> /// Service Name - Authenticate /// Operation - ResetUniversalIdPasswordAdvanced /// </remarks> /// <param name="appId"> /// The app id /// </param> /// <param name="universalId"> /// The email address to send the reset email to /// </param> /// <param name="serviceParams"> /// The parameters to send the email service. See documentation for full list /// http://getbraincloud.com/apidocs/apiref/#capi-mail /// </param> /// <param name="success"> /// The method to call in event of success /// </param> /// <param name="failure"> /// The method to call in the event of an error /// </param> /// <param name="cbObject"> /// The user supplied callback object /// </param> public void ResetUniversalIdPasswordAdvanced( string universalId, string serviceParams, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.AuthenticateServiceAuthenticateGameId.Value] = _client.AppId; data[OperationParam.AuthenticateServiceAuthenticateUniversalId.Value] = universalId; var jsonParams = JsonReader.Deserialize <Dictionary <string, object> >(serviceParams); data[OperationParam.AuthenticateServiceAuthenticateServiceParams.Value] = jsonParams; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure); ServerCall sc = new ServerCall(ServiceName.Authenticate, ServiceOperation.ResetUniversalIdPasswordAdvanced, data, callback); _client.SendRequest(sc); }
/// <summary> /// Gets the number of entries in a global leaderboard /// </summary> /// <remarks> /// Service Name - leaderboard /// Service Operation - GET_GLOBAL_LEADERBOARD_ENTRY_COUNT /// </remarks> /// <param name="leaderboardId"> /// The ID of the leaderboard /// </param> /// <param name="versionId"> /// The version of the leaderboard /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void GetGlobalLeaderboardEntryCountByVersion( string leaderboardId, int versionId, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { var data = new Dictionary <string, object>(); data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = leaderboardId; if (versionId > -1) { data[OperationParam.SocialLeaderboardServiceVersionId.Value] = versionId; } var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); var sc = new ServerCall(ServiceName.Leaderboard, ServiceOperation.GetGlobalLeaderboardEntryCount, data, callback); _client.SendRequest(sc); }
/// <summary> /// Purchases a quantity of an item from the specified store, ///if the user has enough funds. If includeDef is true, ///response includes associated itemDef with language fields /// limited to the current or default language. /// </summary> /// <remarks> /// Service Name - UserInventoryManagement /// Service Operation - GetUserItem /// </remarks> /// <param name="defId"> /// </param> /// <param name="quatity"> /// </param> /// <param name="shopId"> /// </param> /// <param name="includeDef"> /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void PurchaseUserItem( String defId, int quantity, string shopId, bool includeDef, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.UserInventoryManagementServiceDefId.Value] = defId; data[OperationParam.UserInventoryManagementServiceQuantity.Value] = quantity; data[OperationParam.UserInventoryManagementServiceShopId.Value] = shopId; data[OperationParam.UserInventoryManagementServiceIncludeDef.Value] = includeDef; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.UserInventoryManagement, ServiceOperation.PurchaseUserItem, data, callback); _client.SendRequest(sc); }
/// <summary> /// Uses the specified item, potentially consuming it. /// </summary> /// <remarks> /// Service Name - UserInventoryManagement /// Service Operation - UseUserItem /// </remarks> /// <param name="itemId"> /// </param> /// <param name="version"> /// </param> /// <param name="newItemData"> /// </param> /// <param name="includeDef"> /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void UseUserItem( string itemId, int version, Dictionary <string, object> newItemData, bool includeDef, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.UserInventoryManagementServiceItemId.Value] = itemId; data[OperationParam.UserInventoryManagementServiceVersion.Value] = version; data[OperationParam.UserInventoryManagementServiceNewItemData.Value] = newItemData; data[OperationParam.UserInventoryManagementServiceIncludeDef.Value] = includeDef; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.UserInventoryManagement, ServiceOperation.UseUserItem, data, callback); _client.SendRequest(sc); }
/// <summary> /// Sets the player's experience to an absolute value. Note that this /// is simply a set and will not reward the player if their level changes /// as a result. /// </summary> /// <remarks> /// Service Name - PlayerStatistics /// Service Operation - SetXpPoints /// </remarks> /// <param name="in_xpValue"> /// The amount to set the the player's experience to /// </param> /// <param name="in_success"> /// The success callback /// </param> /// <param name="in_failure"> /// The failure callback /// </param> /// <param name="in_cbObject"> /// The callback object /// </param> /// <returns> The JSON returned in the callback is as follows. /// { /// "status":200, /// "data":null /// } /// </returns> public void SetExperiencePoints( int in_xpValue, SuccessCallback in_success = null, FailureCallback in_failure = null, object in_cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.PlayerStatisticsExperiencePoints.Value] = in_xpValue; SuccessCallback successCallbacks = m_brainCloudClientRef.GetGamificationService().CheckForAchievementsToAward; if (in_success != null) { successCallbacks += in_success; } ServerCallback callback = BrainCloudClient.CreateServerCallback(successCallbacks, in_failure, in_cbObject); ServerCall sc = new ServerCall(ServiceName.PlayerStatistics, ServiceOperation.SetXpPoints, data, callback); m_brainCloudClientRef.SendRequest(sc); }
/// <summary> /// Partial increment of entity data field items. Partial set of items incremented as specified. /// </summary> /// <remarks> /// Service Name - entity /// Service Operation - INCREMENT_USER_ENTITY_DATA /// </remarks> /// <param name="entityId">The entity to increment</param> /// <param name="jsonData">The subset of data to increment</param> /// <param name="success">The success callback</param> /// <param name="failure">The failure callback</param> /// <param name="cbObject">The callback object</param> public void IncrementUserEntityData( string entityId, string jsonData, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { var data = new Dictionary <string, object>(); data[OperationParam.EntityServiceEntityId.Value] = entityId; if (Util.IsOptionalParameterValid(jsonData)) { var where = JsonReader.Deserialize <Dictionary <string, object> >(jsonData); data[OperationParam.EntityServiceData.Value] = where; } var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); var serverCall = new ServerCall(ServiceName.Entity, ServiceOperation.IncrementUserEntityData, data, callback); _client.SendRequest(serverCall); }
/// <summary> /// /// </summary> /// <remarks> /// Service Name - CustomEntity /// Service Operation - UpdateCustomEntityFields /// </remarks> /// <param name="context"> /// </param> /// <param name="pageOffset"> /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void UpdateEntityFields( string entityType, string entityId, int version, string fieldsJson, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.CustomEntityServiceEntityType.Value] = entityType; data[OperationParam.CustomEntityServiceEntityId.Value] = entityId; data[OperationParam.CustomEntityServiceVersion.Value] = version; data[OperationParam.CustomEntityServiceFieldsJson.Value] = JsonReader.Deserialize <Dictionary <string, object> >(fieldsJson);; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.CustomEntity, ServiceOperation.UpdateCustomEntityFields, data, callback); _client.SendRequest(sc); }
/// <summary> /// Method updates an existing entity's Owner and Acl on the server. /// </summary> /// <remarks> /// Service Name - globalEntity /// Service Operation - UPDATE_ENTITY_OWNER_AND_ACL /// </remarks> /// <param name="entityId"> /// The entity ID /// </param> /// <param name="version"> /// The version of the entity /// </param> /// <param name="ownerId"> /// The owner ID /// </param> /// <param name="acl"> /// The entity's access control list /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void UpdateEntityOwnerAndAcl( string entityId, long version, string ownerId, ACL acl, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { var data = new Dictionary <string, object>(); data[OperationParam.GlobalEntityServiceEntityId.Value] = entityId; data[OperationParam.GlobalEntityServiceVersion.Value] = version; data[OperationParam.OwnerId.Value] = ownerId; data[OperationParam.GlobalEntityServiceAcl.Value] = JsonReader.Deserialize(acl.ToJsonString()); var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); var serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.UpdateEntityOwnerAndAcl, data, callback); _brainCloudClient.SendRequest(serverCall); }
/// <summary> /// Updates the item data on the specified user item. /// </summary> /// <remarks> /// Service Name - UserInventoryManagement /// Service Operation - UpdateUserItemData /// </remarks> /// <param name="itemId"> /// </param> /// <param name="version"> /// </param> /// <param name="newItemData"> /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void UpdateUserItemData( string itemId, int version, string newItemData, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.UserItemsServiceItemId.Value] = itemId; data[OperationParam.UserItemsServiceVersion.Value] = version; var newItemDataDict = JsonReader.Deserialize <Dictionary <string, object> >(newItemData); data[OperationParam.UserItemsServiceNewItemData.Value] = newItemDataDict; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.UserItems, ServiceOperation.UpdateUserItemData, data, callback); _client.SendRequest(sc); }
/// <summary> /// Method updates an existing entity on the server. /// </summary> /// <remarks> /// Service Name - GlobalEntity /// Service Operation - Update /// </remarks> /// <param name="in_entityId"> /// The entity ID /// </param> /// <param name="in_version"> /// The version of the entity to update /// </param> /// <param name="in_jsonEntityData"> /// The entity's data as a json string /// </param> /// <param name="in_success"> /// The success callback. /// </param> /// <param name="in_failure"> /// The failure callback. /// </param> /// <param name="in_cbObject"> /// The user object sent to the callback. /// </param> /// <returns> The JSON returned in the callback is as follows: /// { /// "status":200, /// "data": /// { /// gameId : "game", /// entityId : "hucfshugvgvfhug", /// ownerId : "ubfcbvfbsdvbb", /// entityType : "", /// entityIndexedId : "", /// version : 1, /// timeToLive: 0, /// expiresAt : 9947395735758975, /// data : /// { /// field : "value" /// }, /// acl : /// { /// other, 1 /// }, /// createdAt : 74889479874, /// updatedAt : 73847474897487 /// /// } /// } /// </returns> public void UpdateEntity( string in_entityId, int in_version, string in_jsonEntityData, SuccessCallback in_success = null, FailureCallback in_failure = null, object in_cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.GlobalEntityServiceEntityId.Value] = in_entityId; data[OperationParam.GlobalEntityServiceVersion.Value] = in_version; Dictionary <string, object> entityData = JsonReader.Deserialize <Dictionary <string, object> >(in_jsonEntityData); data[OperationParam.GlobalEntityServiceData.Value] = entityData; ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject); ServerCall serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.Update, data, callback); m_brainCloudClientRef.SendRequest(serverCall); }
/// <summary> /// Sends a notification to multiple users consisting of alert content and custom data. /// </param> /// <param name="profileIds"> /// Collection of profile IDs to send the notification to /// </param> /// <param name="alertContentJson"> /// Body and title of alert /// </param> /// <param name="customDataJson"> /// Optional custom data /// </param> /// <param name="success"> /// The success callback /// </param> /// <param name="failure"> /// The failure callback /// </param> /// <param name="cbObject"> /// The callback object /// </param> public void SendNormalizedPushNotificationBatch( IList <string> profileIds, string alertContentJson, string customDataJson, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.PushNotificationSendParamProfileIds.Value] = profileIds; data[OperationParam.AlertContent.Value] = JsonReader.Deserialize <Dictionary <string, object> >(alertContentJson); if (Util.IsOptionalParameterValid(customDataJson)) { data[OperationParam.CustomData.Value] = JsonReader.Deserialize <Dictionary <string, object> >(customDataJson); } ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.PushNotification, ServiceOperation.SendNormalizedBatch, data, callback); _client.SendRequest(sc); }
/// <summary> /// Updates an event in the user's incoming event mailbox. /// </summary> /// <remarks> /// Service Name - Event /// Service Operation - UpdateEventData /// </remarks> /// <param name="evId"> /// The event id /// </param> /// <param name="jsonEventData"> /// The user-defined data for this event encoded in JSON. /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void UpdateIncomingEventData( string evId, string jsonEventData, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.EvId.Value] = evId; if (Util.IsOptionalParameterValid(jsonEventData)) { Dictionary <string, object> eventData = JsonReader.Deserialize <Dictionary <string, object> > (jsonEventData); data[OperationParam.EventServiceUpdateEventDataData.Value] = eventData; } ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.Event, ServiceOperation.UpdateEventData, data, callback); _client.SendRequest(sc); }
/// <summary> /// Removes the match and match history from the server. DEBUG ONLY, in production it is recommended /// the user leave it as completed. /// </summary> /// <remarks> /// Service Name - AsyncMatch /// Service Operation - Delete /// </remarks> /// <param name="ownerId"> /// Match owner identifier /// </param> /// <param name="matchId"> /// Match identifier /// </param> /// <param name="pushContent"> /// Match owner identifier /// </param> /// <param name="summary"> /// Match owner identifier /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> //string abandonedBy, public void AbandonMatchWithSummaryData( string ownerId, string matchId, string pushContent, string summary, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); //abandoneddby not needed? data["ownerId"] = ownerId; data["matchId"] = matchId; data["pushContent"] = pushContent; data["summary"] = JsonReader.Deserialize <Dictionary <string, object> >(summary); ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.AsyncMatch, ServiceOperation.AbandonMatchWithSummaryData, data, callback); _client.SendRequest(sc); }
/// <summary> /// Registers the given device token with the server to enable this device /// to receive push notifications. /// </param> /// <param name="in_device"> /// The device platform being registered. /// </param> /// <param name="in_token"> /// The platform-dependant device token needed for push notifications. /// </param> /// <param name="in_success"> /// The success callback /// </param> /// <param name="in_failure"> /// The failure callback /// </param> /// <param name="in_cbObject"> /// The callback object /// </param> /// <returns> JSON describing the new value of the statistics and any rewards that were triggered: /// { /// "status":200, /// "data":null /// } /// </returns> public bool RegisterPushNotificationDeviceToken( string in_device, string in_token, SuccessCallback in_success = null, FailureCallback in_failure = null, object in_cbObject = null) { bool bToReturn = false; Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.PushNotificationRegisterParamDeviceType.Value] = in_device; data[OperationParam.PushNotificationRegisterParamDeviceToken.Value] = in_token; ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject); ServerCall sc = new ServerCall(ServiceName.PushNotification, ServiceOperation.Register, data, callback); m_brainCloudClientRef.SendRequest(sc); bToReturn = true; return(bToReturn); }
/// <summary> /// Updates the "friend summary data" associated with the logged in user. /// Some operations will return this summary data. For instance the social /// leaderboards will return the player's score in the leaderboard along /// with the friend summary data. Generally this data is used to provide /// a quick overview of the player without requiring a separate API call /// to read their public stats or entity data. /// /// </summary> /// <remarks> /// Service Name - PlayerState /// Service Operation - UpdateSummary /// </remarks> /// <param name="jsonSummaryData"> /// A JSON string defining the summary data. /// For example: /// { /// "xp":123, /// "level":12, /// "highScore":45123 /// } /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// /// </param> public void UpdateSummaryFriendData( string jsonSummaryData, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); if (Util.IsOptionalParameterValid(jsonSummaryData)) { Dictionary <string, object> summaryData = JsonReader.Deserialize <Dictionary <string, object> >(jsonSummaryData); data[OperationParam.PlayerStateServiceUpdateSummaryFriendData.Value] = summaryData; } else { data = null; } ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.PlayerState, ServiceOperation.UpdateSummary, data, callback); _client.SendRequest(sc); }
/// <summary> /// Sends a notification to a "group" of user based on a brainCloud portal configured notification template. /// Includes JSON defining the substitution params to use with the template. /// See the Portal documentation for more info. /// </param> /// <param name="groupId"> /// Target group /// </param> /// <param name="alertContentJson"> /// Body and title of alert /// </param> /// <param name="customDataJson"> /// Optional custom data /// </param> /// <param name="success"> /// The success callback /// </param> /// <param name="failure"> /// The failure callback /// </param> /// <param name="cbObject"> /// The callback object /// </param> public void SendNormalizedPushNotificationToGroup( string groupId, string alertContentJson, string customDataJson, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.GroupId.Value] = groupId; data[OperationParam.AlertContent.Value] = JsonReader.Deserialize <Dictionary <string, object> >(alertContentJson); if (Util.IsOptionalParameterValid(customDataJson)) { data[OperationParam.CustomData.Value] = JsonReader.Deserialize <Dictionary <string, object> >(customDataJson); } ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.PushNotification, ServiceOperation.SendNormalizedToGroup, data, callback); m_brainCloudClientRef.SendRequest(sc); }
/// <summary> /// Gets a list of up to randomCount randomly selected entities from the server based on the where condition and specified maximum return count. /// </summary> /// <remarks> /// Service Name - globalEntity /// Service Operation - GET_RANDOM_ENTITIES_MATCHING /// </remarks> /// <param name="where">Mongo style query string</param> /// <param name="maxReturn">The maximum number of entities to return</param> /// <param name="success">The success callback</param> /// <param name="failure">The failure callback</param> /// <param name="cbObject">The callback object</param> public void GetRandomEntitiesMatching( string whereJson, int maxReturn, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { var data = new Dictionary <string, object>(); if (Util.IsOptionalParameterValid(whereJson)) { var where = JsonReader.Deserialize <Dictionary <string, object> >(whereJson); data[OperationParam.GlobalEntityServiceWhere.Value] = where; } data[OperationParam.GlobalEntityServiceMaxReturn.Value] = maxReturn; var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); var serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.GetRandomEntitiesMatching, data, callback); _client.SendRequest(serverCall); }
/// <summary> /// Atomically increment (or decrement) player statistics. /// Any rewards that are triggered from player statistic increments /// will be considered. Player statistics are defined through the brainCloud portal. /// Note also that the "xpCapped" property is returned (true/false depending on whether /// the xp cap is turned on and whether the player has hit it). /// </summary> /// <remarks> /// Service Name - PlayerStatistics /// Service Operation - Update /// </remarks> /// <param name="in_jsonData"> /// The JSON encoded data to be sent to the server as follows: /// { /// stat1: 10, /// stat2: -5.5, /// } /// would increment stat1 by 10 and decrement stat2 by 5.5. /// For the full statistics grammer see the api.braincloudservers.com site. /// There are many more complex operations supported such as: /// { /// stat1:INC_TO_LIMIT#9#30 /// } /// which increments stat1 by 9 up to a limit of 30. /// </param> /// <param name="in_success"> /// The success callback /// </param> /// <param name="in_failure"> /// The failure callback /// </param> /// <param name="in_cbObject"> /// The callback object /// </param> /// <returns> JSON describing the new value of the statistics and any rewards that were triggered: /// { /// "status":200, /// "data":{ /// "experiencePoints":10, /// "xpCapped":false, /// "rewardDetails":{ /// "xp":{ /// "experienceLevels":[ /// { /// "level":1, /// "reward":{ /// "currency":{ /// "gold":1000 /// } /// } /// } /// ] /// } /// }, /// "rewards":{ /// "experienceLevels":[ /// 1 /// ], /// "currency":{ /// "gold":1000 /// } /// }, /// "experienceLevel":1, /// "statistics":{ /// "LIVES":1 /// }, /// "currency":{ /// "gems":{ /// "purchased":0, /// "balance":10, /// "consumed":0, /// "awarded":10 /// }, /// "gold":{ /// "purchased":0, /// "balance":2000, /// "consumed":0, /// "awarded":2000 /// } /// } /// } /// } /// </returns> public void IncrementPlayerStats( string in_jsonData, SuccessCallback in_success = null, FailureCallback in_failure = null, object in_cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); Dictionary <string, object> statsData = JsonReader.Deserialize <Dictionary <string, object> > (in_jsonData); data[OperationParam.PlayerStatisticsServiceStats.Value] = statsData; SuccessCallback successCallbacks = m_brainCloudClientRef.GetGamificationService().CheckForAchievementsToAward; if (in_success != null) { successCallbacks += in_success; } ServerCallback callback = BrainCloudClient.CreateServerCallback(successCallbacks, in_failure, in_cbObject); ServerCall sc = new ServerCall(ServiceName.PlayerStatistics, ServiceOperation.Update, data, callback); m_brainCloudClientRef.SendRequest(sc); }
/// <summary> /// Creates custom data stream screen event /// </summary> /// <remarks> /// Service Name - DataStream /// Service Operation - CustomScreenEvent /// </remarks> /// <param name="eventName"> /// The name of the event /// </param> /// <param name="jsonEventProperties"> /// The properties of the event /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void CustomScreenEvent( string eventName, string jsonEventProperties, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.DataStreamEventName.Value] = eventName; if (Util.IsOptionalParameterValid(jsonEventProperties)) { Dictionary <string, object> eventProperties = JsonReader.Deserialize <Dictionary <string, object> >(jsonEventProperties); data[OperationParam.DataStreamEventProperties.Value] = eventProperties; } ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall serverCall = new ServerCall(ServiceName.DataStream, ServiceOperation.CustomScreenEvent, data, callback); _client.SendRequest(serverCall); }
/// <summary> /// Method updates an existing entity on the server. /// </summary> /// <remarks> /// Service Name - GlobalEntity /// Service Operation - Update /// </remarks> /// <param name="entityId"> /// The entity ID /// </param> /// <param name="version"> /// The version of the entity to update /// </param> /// <param name="jsonEntityData"> /// The entity's data as a json string /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void UpdateEntity( string entityId, int version, string jsonEntityData, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { var data = new Dictionary <string, object>(); data[OperationParam.GlobalEntityServiceEntityId.Value] = entityId; data[OperationParam.GlobalEntityServiceVersion.Value] = version; var entityData = JsonReader.Deserialize <Dictionary <string, object> >(jsonEntityData); data[OperationParam.GlobalEntityServiceData.Value] = entityData; var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); var serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.Update, data, callback); _client.SendRequest(serverCall); }
/// <summary> /// Executes a script on the server. /// </summary> /// <remarks> /// Service Name - Script /// Service Operation - Run /// </remarks> /// <param name="scriptName"> /// The name of the script to be run /// </param> /// <param name="jsonScriptData"> /// Data to be sent to the script in json format /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void RunScript( string scriptName, string jsonScriptData, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.ScriptServiceRunScriptName.Value] = scriptName; if (Util.IsOptionalParameterValid(jsonScriptData)) { Dictionary <string, object> scriptData = JsonReader.Deserialize <Dictionary <string, object> >(jsonScriptData); data[OperationParam.ScriptServiceRunScriptData.Value] = scriptData; } ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.Script, ServiceOperation.Run, data, callback); _client.SendRequest(sc); }
/// <summary> /// Finalize A Two Staged Purchase Transaction /// </summary> /// <remarks> /// Service Name - AppStore /// Service Operation - FINALIZE_PURCHASE /// </remarks> /// <param name="storeId"> /// The store storeId. Valid stores are: /// - itunes /// - facebook /// - appworld /// - steam /// - windows /// - windowsPhone /// - googlePlay /// </param> /// /// <param name="transactionId"> /// The Transaction Id returned in Start Transaction /// </param> /// <param name="transactionJson"> /// The specific store data required /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void FinalizePurchase( string storeId, string transactionId, string transactionJson, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.AppStoreServiceStoreId.Value] = storeId; data[OperationParam.AppStoreServiceTransactionId.Value] = transactionId; var transactionData = JsonReader.Deserialize <Dictionary <string, object> >(transactionJson); data[OperationParam.AppStoreServiceTransactionData.Value] = transactionData; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.AppStore, ServiceOperation.FinalizePurchase, data, callback); _client.SendRequest(sc); }
/// <summary> /// Post the players score to the given social leaderboard. /// You can optionally send a user-defined json string of data /// with the posted score. This string could include information /// relevant to the posted score. /// /// Note that the behaviour of posting a score can be modified in /// the brainCloud portal. By default, the server will only keep /// the player's best score. /// </summary> /// <remarks> /// Service Name - leaderboard /// Service Operation - PostScore /// </remarks> /// <param name="leaderboardId"> /// The leaderboard to post to /// </param> /// <param name="score"> /// The score to post /// </param> /// <param name="data"> /// Optional user-defined data to post with the score /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void PostScoreToLeaderboard( string leaderboardId, long score, string jsonData, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { var data = new Dictionary <string, object>(); data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = leaderboardId; data[OperationParam.SocialLeaderboardServiceScore.Value] = score; if (Util.IsOptionalParameterValid(jsonData)) { var customData = JsonReader.Deserialize <Dictionary <string, object> >(jsonData); data[OperationParam.SocialLeaderboardServiceData.Value] = customData; } var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); var sc = new ServerCall(ServiceName.Leaderboard, ServiceOperation.PostScore, data, callback); _client.SendRequest(sc); }
/// <summary> /// Retrieve a view of the group leaderboard surrounding the current group /// </summary> /// <remarks> /// Service Name - leaderboard /// Service Operation - GET_GROUP_LEADERBOARD_VIEW /// </remarks> /// <param name="leaderboardId"> /// the id of the leaderboard /// </param> /// <param name="groupId"> /// The groups Id /// </param> /// <param name="sort"> /// The groups Id /// </param> /// <param name="beforeCount"> /// The count of number of players before the current player to include. /// </param> /// <param name="afterCount"> /// The count of number of players after the current player to include. /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void GetGroupLeaderboardView( string leaderboardId, string groupId, SortOrder sort, int beforeCount, int afterCount, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { var data = new Dictionary <string, object>(); data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = leaderboardId; data[OperationParam.SocialLeaderboardServiceGroupId.Value] = groupId; data[OperationParam.SocialLeaderboardServiceSort.Value] = sort.ToString(); data[OperationParam.SocialLeaderboardServiceBeforeCount.Value] = beforeCount; data[OperationParam.SocialLeaderboardServiceAfterCount.Value] = afterCount; var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); var sc = new ServerCall(ServiceName.Leaderboard, ServiceOperation.GetGroupLeaderboardView, data, callback); _client.SendRequest(sc); }
/// <summary> /// Allows a quantity of a specified user item to be sold. ///If any quantity of the user item remains, ///it will be returned, potentially with the associated ///itemDef (with language fields limited to the current ///or default language), along with the currency refunded ///and currency balances. /// </summary> /// <remarks> /// Service Name - UserInventoryManagement /// Service Operation - SellUserItem /// </remarks> /// <param name="itemId"> /// </param> /// <param name="version"> /// </param> /// <param name="quantity"> /// </param> /// <param name="shopId"> /// </param> /// <param name="includeDef"> /// </param> /// <param name="success"> /// The success callback. /// </param> /// <param name="failure"> /// The failure callback. /// </param> /// <param name="cbObject"> /// The user object sent to the callback. /// </param> public void SellUserItem( string itemId, int version, int quantity, string shopId, bool includeDef, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.UserItemsServiceItemId.Value] = itemId; data[OperationParam.UserItemsServiceVersion.Value] = version; data[OperationParam.UserItemsServiceQuantity.Value] = quantity; data[OperationParam.UserItemsServiceShopId.Value] = shopId; data[OperationParam.UserItemsServiceIncludeDef.Value] = includeDef; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.UserItems, ServiceOperation.SellUserItem, data, callback); _client.SendRequest(sc); }
/// <summary> /// List user files from the given cloud path /// </summary> /// <param name="cloudPath">File path</param> /// <param name="recurse">Whether to recurse down the path</param> /// <param name="success">The success callback</param> /// <param name="failure">The failure callback</param> /// <param name="cbObject">The callback object</param> public void ListUserFiles( string cloudPath, bool?recurse, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); if (Util.IsOptionalParameterValid(cloudPath)) { data[OperationParam.UploadPath.Value] = cloudPath; } if (recurse.HasValue) { data[OperationParam.UploadRecurse.Value] = recurse.Value; } ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.File, ServiceOperation.ListUserFiles, data, callback); _client.SendRequest(sc); }
/// <summary> /// Like findLobby, but explicitely geared toward creating new lobbies /// </summary> /// /// otherUserCxIds support coming soon! /// public void CreateLobby(string in_roomType, int in_rating, bool in_isReady, Dictionary <string, object> in_extraJson, string in_teamCode, Dictionary <string, object> in_settings, string[] in_otherUserCxIds = null, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.LobbyRoomType.Value] = in_roomType; data[OperationParam.LobbyRating.Value] = in_rating; data[OperationParam.LobbySettings.Value] = in_settings; data[OperationParam.LobbyIsReady.Value] = in_isReady; if (in_otherUserCxIds != null) { data[OperationParam.LobbyOtherUserCxIds.Value] = in_otherUserCxIds; } data[OperationParam.LobbyExtraJson.Value] = in_extraJson; data[OperationParam.LobbyTeamCode.Value] = in_teamCode; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.Lobby, ServiceOperation.CreateLobby, data, callback); m_clientRef.SendRequest(sc); }