/// <summary> /// Updates an event in the player's incoming event mailbox. /// </summary> /// <remarks> /// Service Name - Event /// Service Operation - UpdateEventData /// </remarks> /// <param name="in_fromPlayerId"> /// The id of the player who sent the event /// </param> /// <param name="in_eventId"> /// The event id /// </param> /// <param name="in_jsonEventData"> /// The user-defined data for this event encoded in JSON. /// </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":null /// } /// </returns> public void UpdateIncomingEventData( string in_fromPlayerId, ulong in_eventId, string in_jsonEventData, SuccessCallback in_success = null, FailureCallback in_failure = null, object in_cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.EventServiceUpdateEventDataFromId.Value] = in_fromPlayerId; data[OperationParam.EventServiceUpdateEventDataEventId.Value] = in_eventId; if (Util.IsOptionalParameterValid(in_jsonEventData)) { Dictionary <string, object> eventData = JsonReader.Deserialize <Dictionary <string, object> > (in_jsonEventData); data[OperationParam.EventServiceUpdateEventDataData.Value] = eventData; } ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject); ServerCall sc = new ServerCall(ServiceName.Event, ServiceOperation.UpdateEventData, data, callback); m_brainCloudClientRef.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, string newItemData, 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.UserItemsServiceIncludeDef.Value] = includeDef; 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.UseUserItem, data, callback); _client.SendRequest(sc); }
/// <summary> /// Schedules raw notifications based on user local time. /// </param> /// <param name="profileId"> /// The profileId of the user to receive the notification /// </param> /// <param name="fcmContent"> /// Valid Fcm data content /// </param> /// <param name="iosContent"> /// Valid ios data content /// </param> /// <param name="facebookContent"> /// Facebook template string /// </param> /// <param name="minutesFromNow"> /// Minutes from now to send the push notification /// </param> /// <param name="success"> /// The success callback /// </param> /// <param name="failure"> /// The failure callback /// </param> /// <param name="cbObject"> /// The callback object /// </param> public void ScheduleRawPushNotificationMinutes( string profileId, string fcmContent, string iosContent, string facebookContent, int minutesFromNow, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.ProfileId.Value] = profileId; if (Util.IsOptionalParameterValid(fcmContent)) { data[OperationParam.PushNotificationSendParamFcmContent.Value] = JsonReader.Deserialize <Dictionary <string, object> >(fcmContent); } if (Util.IsOptionalParameterValid(iosContent)) { data[OperationParam.PushNotificationSendParamIosContent.Value] = JsonReader.Deserialize <Dictionary <string, object> >(iosContent); } if (Util.IsOptionalParameterValid(facebookContent)) { data[OperationParam.PushNotificationSendParamFacebookContent.Value] = JsonReader.Deserialize <Dictionary <string, object> >(facebookContent); } data[OperationParam.MinutesFromNow.Value] = minutesFromNow; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.PushNotification, ServiceOperation.ScheduleRawNotification, data, callback); _client.SendRequest(sc); }
/// <summary> /// Post the players score to the given social leaderboard. /// Pass leaderboard config data to dynamically create if necessary. /// 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. /// </summary> /// <remarks> /// Service Name - SocialLeaderboard /// Service Operation - PostScoreDynamic /// </remarks> /// <param name="in_leaderboardId"> /// The leaderboard to post to /// </param> /// <param name="in_score"> /// The score to post /// </param> /// <param name="in_data"> /// Optional user-defined data to post with the score /// </param> /// <param name="in_leaderboardType"> /// leaderboard type /// </param> /// <param name="in_rotationType"> /// Type of rotation /// </param> /// <param name="in_rotationReset"> /// Date to reset the leaderboard /// </param> /// <param name="in_retainedCount"> /// Hpw many rotations to keep /// </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":{ /// } /// } /// </returns> public void PostScoreToDynamicLeaderboard( string in_leaderboardId, long in_score, string in_jsonData, SocialLeaderboardType in_leaderboardType, RotationType in_rotationType, DateTime?in_rotationReset, int in_retainedCount, SuccessCallback in_success = null, FailureCallback in_failure = null, object in_cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = in_leaderboardId; data[OperationParam.SocialLeaderboardServiceScore.Value] = in_score; if (Util.IsOptionalParameterValid(in_jsonData)) { Dictionary <string, object> customData = JsonReader.Deserialize <Dictionary <string, object> >(in_jsonData); data[OperationParam.SocialLeaderboardServiceData.Value] = customData; } data[OperationParam.SocialLeaderboardServiceLeaderboardType.Value] = in_leaderboardType.ToString(); data[OperationParam.SocialLeaderboardServiceRotationType.Value] = in_rotationType.ToString(); if (in_rotationReset.HasValue) { data[OperationParam.SocialLeaderboardServiceRotationReset.Value] = in_rotationReset.Value.ToString("d-MM-yyyy HH:mm"); } data[OperationParam.SocialLeaderboardServiceRetainedCount.Value] = in_retainedCount; ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject); ServerCall sc = new ServerCall(ServiceName.SocialLeaderboard, ServiceOperation.PostScoreDynamic, data, callback); m_brainCloudClientRef.SendRequest(sc); }
/// <summary> /// Advanced universalId password reset using templates with expiry /// </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="expiryTimeInMin"> /// takes in an Expiry time to determine how long it will stay available /// </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 ResetUniversalIdPasswordAdvancedWithExpiry( string universalId, string serviceParams, int tokenTtlInMinutes, 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; data[OperationParam.AuthenticateServiceAuthenticateTokenTtlInMinutes.Value] = tokenTtlInMinutes; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure); ServerCall sc = new ServerCall(ServiceName.Authenticate, ServiceOperation.ResetUniversalIdPasswordAdvancedWithExpiry, data, callback); _client.SendRequest(sc); }
/// <summary> /// Redeem a code. /// </summary> /// <remarks> /// Service Name - redemptionCode /// Service Operation - REDEEM_CODE /// </remarks> /// <param name="scanCode"> /// The code to redeem /// </param> /// <param name="codeType"> /// The type of code /// </param> /// <param name="jsonCustomRedemptionInfo"> /// Optional - A JSON string containing custom redemption data /// </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 RedeemCode( string scanCode, string codeType, string jsonCustomRedemptionInfo, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.RedemptionCodeServiceScanCode.Value] = scanCode; data[OperationParam.RedemptionCodeServiceCodeType.Value] = codeType; if (Util.IsOptionalParameterValid(jsonCustomRedemptionInfo)) { Dictionary <string, object> customRedemptionInfo = JsonReader.Deserialize <Dictionary <string, object> >(jsonCustomRedemptionInfo); data[OperationParam.RedemptionCodeServiceCustomRedemptionInfo.Value] = customRedemptionInfo; } ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.RedemptionCode, ServiceOperation.RedeemCode, data, callback); _client.SendRequest(sc); }
/// <summary> /// Prepares a user file upload. On success the file will begin uploading /// to the brainCloud server.To be informed of success/failure of the upload /// register an IFileUploadCallback with the BrainCloudClient class. /// </summary> /// <param name="cloudPath">The desired cloud path of the file</param> /// <param name="cloudFilename">The desired cloud fileName of the file</param> /// <param name="shareable">True if the file is shareable</param> /// <param name="replaceIfExists">Whether to replace file if it exists</param> /// <param name="localPath">The path and fileName of the local file</param> /// <param name="success">The success callback</param> /// <param name="failure">The failure callback</param> /// <param name="cbObject">The callback object</param> public bool UploadFile( string cloudPath, string cloudFilename, bool shareable, bool replaceIfExists, string localPath, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { #if UNITY_WEBPLAYER || UNITY_WEBGL throw new Exception("File upload API is not supported on Web builds"); #else FileInfo info = new FileInfo(localPath); if (!info.Exists) { m_brainCloudClientRef.Log("File at " + localPath + " does not exist"); return(false); } Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.UploadLocalPath.Value] = localPath; data[OperationParam.UploadCloudFilename.Value] = cloudFilename; data[OperationParam.UploadCloudPath.Value] = cloudPath; data[OperationParam.UploadShareable.Value] = shareable; data[OperationParam.UploadReplaceIfExists.Value] = replaceIfExists; data[OperationParam.UploadFileSize.Value] = info.Length; ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.File, ServiceOperation.PrepareUserUpload, data, callback); m_brainCloudClientRef.SendRequest(sc); return(true); #endif }
/// <summary> /// Sends an event to the designated profile id with the attached json data. /// Any events that have been sent to a user will show up in their /// incoming event mailbox. If the recordLocally flag is set to true, /// a copy of this event (with the exact same event id) will be stored /// in the sending user's "sent" event mailbox. /// </summary> /// <remarks> /// Service Name - Event /// Service Operation - Send /// </remarks> /// <param name="toProfileId"> /// The id of the user who is being sent the event /// </param> /// <param name="eventType"> /// The user-defined type of the event. /// </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 SendEvent( string toProfileId, string eventType, string jsonEventData, SuccessCallback success = null, FailureCallback failure = null, object cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.EventServiceSendToId.Value] = toProfileId; data[OperationParam.EventServiceSendEventType.Value] = eventType; if (Util.IsOptionalParameterValid(jsonEventData)) { Dictionary <string, object> eventData = JsonReader.Deserialize <Dictionary <string, object> > (jsonEventData); data[OperationParam.EventServiceSendEventData.Value] = eventData; } ServerCallback callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); ServerCall sc = new ServerCall(ServiceName.Event, ServiceOperation.Send, data, callback); _client.SendRequest(sc); }
/// <summary> /// Finds matchmaking enabled players using a cloud code filter /// </summary> /// <remarks> /// Service Name - MatchMaking /// Service Operation - FIND_PLAYERS_USING_FILTER /// </remarks> /// <param name="in_rangeDelta"> /// The range delta /// </param> /// <param name="in_numMatches"> /// The maximum number of matches to return /// </param> /// <param name="in_jsonExtraParms"> /// Other parameters /// </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": { /// "matchesFound": [ /// { /// "pictureUrl": null, /// "playerName": "UserC-1239941736", /// "playerId": "c2b88d3f-2s32-43a6-9a71-0f0157e46505", /// "playerRating": 0, /// "summaryFriendData": null /// }, /// { /// "pictureUrl": null, /// "playerName": "UserA-914307852", /// "playerId": "96afefc7-02b2-4148-8d36-c62855d917b6", /// "playerRating": 0, /// "summaryFriendData": null /// } /// ] /// } /// } /// </returns> public void FindPlayersUsingFilter( long in_rangeDelta, long in_numMatches, string in_jsonExtraParms, SuccessCallback in_success = null, FailureCallback in_failure = null, object in_cbObject = null) { Dictionary <string, object> data = new Dictionary <string, object>(); data[OperationParam.MatchMakingServiceRangeDelta.Value] = in_rangeDelta; data[OperationParam.MatchMakingServiceNumMatches.Value] = in_numMatches; if (Util.IsOptionalParameterValid(in_jsonExtraParms)) { Dictionary <string, object> extraParms = JsonReader.Deserialize <Dictionary <string, object> >(in_jsonExtraParms); data[OperationParam.MatchMakingServiceExtraParams.Value] = extraParms; } ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject); ServerCall sc = new ServerCall(ServiceName.MatchMaking, ServiceOperation.FindPlayersUsingFilter, data, callback); m_brainCloudClientRef.SendRequest(sc); }
/// <summary> /// Post the players score to the given social leaderboard. /// Pass leaderboard config data to dynamically create if necessary. /// 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. /// </summary> /// <remarks> /// Service Name - leaderboard /// Service Operation - PostScoreDynamic /// </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="leaderboardType"> /// leaderboard type /// </param> /// <param name="rotationType"> /// Type of rotation /// </param> /// <param name="rotationReset"> /// Date to reset the leaderboard UTC /// </param> /// <param name="retainedCount"> /// How many rotations to keep /// </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 PostScoreToDynamicLeaderboard( string leaderboardId, long score, string jsonData, SocialLeaderboardType leaderboardType, RotationType rotationType, DateTime?rotationReset, int retainedCount, 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; } data[OperationParam.SocialLeaderboardServiceLeaderboardType.Value] = leaderboardType.ToString(); data[OperationParam.SocialLeaderboardServiceRotationType.Value] = rotationType.ToString(); if (rotationReset.HasValue) { data[OperationParam.SocialLeaderboardServiceRotationResetTime.Value] = Util.DateTimeToUnixTimestamp(rotationReset.Value); } data[OperationParam.SocialLeaderboardServiceRetainedCount.Value] = retainedCount; var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); var sc = new ServerCall(ServiceName.Leaderboard, ServiceOperation.PostScoreDynamic, data, callback); _brainCloudClient.SendRequest(sc); }
/// <summary> /// Method updates an existing entity's Acl on the server. /// </summary> /// <remarks> /// Service Name - GlobalEntity /// Service Operation - UpdateAcl /// </remarks> /// <param name="entityId"> /// The entity ID /// </param> /// <param name="version"> /// The version of the entity to update /// </param> /// <param name="jsonEntityAcl"> /// The entity's access control list as 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 UpdateEntityAcl( string entityId, int version, string jsonEntityAcl, 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; if (Util.IsOptionalParameterValid(jsonEntityAcl)) { var acl = JsonReader.Deserialize <Dictionary <string, object> >(jsonEntityAcl); data[OperationParam.GlobalEntityServiceAcl.Value] = acl; } var callback = BrainCloudClient.CreateServerCallback(success, failure, cbObject); var serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.UpdateAcl, data, callback); _client.SendRequest(serverCall); }
/// <summary> /// Method updates an existing entity's Acl on the server. /// </summary> /// <remarks> /// Service Name - GlobalEntity /// Service Operation - UpdateAcl /// </remarks> /// <param name="in_entityId"> /// The entity ID /// </param> /// <param name="in_version"> /// The version of the entity to update /// </param> /// <param name="in_jsonEntityAcl"> /// The entity's access control list as json. /// </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 UpdateEntityAcl( string in_entityId, int in_version, string in_jsonEntityAcl, 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; if (Util.IsOptionalParameterValid(in_jsonEntityAcl)) { Dictionary <string, object> acl = JsonReader.Deserialize <Dictionary <string, object> >(in_jsonEntityAcl); data[OperationParam.GlobalEntityServiceAcl.Value] = acl; } ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject); ServerCall serverCall = new ServerCall(ServiceName.GlobalEntity, ServiceOperation.UpdateAcl, data, callback); m_brainCloudClientRef.SendRequest(serverCall); }
private void button2_Click(object sender, EventArgs e) { //connect call = new ServerCall(this, formState.ServerAddress, formState.ServerLogin, formState.ServerPassword, MessageFromServerCall_Async, MessageFromServer); }
/// <summary>Sends a service request message to the server. </summary> /// <param name="serviceMessage">The message to send</param> internal void SendRequest(ServerCall serviceMessage) { // pass this directly to the brainCloud Class // which will add it to its queue and send back responses accordingly _comms.AddToQueue(serviceMessage); }
private void UnloadClient(object sender) { _server = null; // Unload only removes the reference to the proxy, doesn't do anything else, since the ALCs need to be cleaned up by the users before the GC can collect. _serverDelegate = null; }
private IEnumerator uploadGlyph() { if (HardwareController.Instance.getLastLocation().Equals(GPSLocation.UNDEFINED)) { statusPanel.showErrorStatus(CANNOT_ACCESS_LOCATION_ERROR); yield return(null); } else if (LoggedInUser.GetLoggedInUser() == null) { statusPanel.showErrorStatus(NO_LOGGED_IN_USER_ERROR); yield return(null); } else { statusPanel.showLoadingStatus("Creating Glyph"); double latitude = HardwareController.Instance.getLastLocation().latitude; double longitude = HardwareController.Instance.getLastLocation().longitude; double altitude = HardwareController.Instance.getLastLocation().altitude; ServerCall uploadGlyphCall; if (!publicToggle.isOn) { uploadGlyphCall = new ServerCall(ServerInteract.INSTANCE.AddPrivateGlyph(latitude, longitude, altitude)); } else { uploadGlyphCall = new ServerCall(ServerInteract.INSTANCE.AddPublicGlyph(latitude, longitude, altitude, dateTimePicker.getSelectedDateTime())); } yield return(StartCoroutine(uploadGlyphCall.call())); if (uploadGlyphCall.ReturnException != null) { statusPanel.showErrorStatus(uploadGlyphCall.ReturnException.Message); } else { OwnedGlyphEvent ownedGlyph = (OwnedGlyphEvent)uploadGlyphCall.ObjectResponse; LoggedInUser.GetLoggedInUser().ownedGlyphs.Add(ownedGlyph); statusPanel.showLoadingStatus("Uploading Picture"); ServerCall uploadToFirebaseCall = new ServerCall(ServerInteract.INSTANCE.UploadAddGlyphFileToFirebase(ownedGlyph.GetGlyph())); yield return(StartCoroutine(uploadToFirebaseCall.call())); if (uploadToFirebaseCall.ReturnException != null) { statusPanel.showErrorStatus(uploadToFirebaseCall.ReturnException.Message); } else { statusPanel.showStatus("Glyph Created!"); ApplicationFileManager.DeleteAddGlyphFile(); yield return(new WaitForSeconds(3)); SceneManager.LoadScene("Scenes/GroundViewScene"); } } } yield return("Done"); }
public async Task OrderStreamConvertsToGrid() { //Need to create delay for the first set of orders to come in var statusEvent = new ManualResetEvent(false); var isFired = false; //Listen for orders flowing in as json connection.ServerJsonReceived += (sender, jsonArgs) => { var args = ServerDataReceivedEventArgs <BlotterOrder> .DeserializeMessage(jsonArgs.RawJson); var grid = new FastWindowGridModel <BlotterOrder>(10); grid.LoadRowJson(jsonArgs.RowsJson); //Make sure data matches var props = typeof(BlotterOrder).GetProperties(); Assert.AreEqual(props.Length, grid.ColumnCount, "Grid column count should match the number of public properties in BlotterOrders"); for (var r = 0; r < grid.RowCount; r++) { for (var c = 0; c < grid.ColumnCount; c++) { var cellstr = grid.GetCellText(r, c).ToLower(); var propval = props[c].GetValue(args.Data.ElementAt(r)); if (propval is DateTime) { var cellval = DateTimeOffset.Parse(cellstr, CultureInfo.InvariantCulture).DateTime; Console.WriteLine($"({r},{c}): {propval} = {cellval}: {(DateTime)propval == cellval}"); Assert.AreEqual(propval, cellval); } else { var propstr = propval?.ToString().ToLower() ?? string.Empty; Console.WriteLine($"({r},{c}): {propstr} = {cellstr}: {propstr == cellstr}"); Assert.AreEqual(propstr, cellstr); } } } Console.WriteLine("Property match completed successfully."); isFired = true; statusEvent.Set(); }; //Listen for orders flowing in as byte arrays connection.ServerBytesReceived += (sender, bytesArgs) => { var args = ServerDataReceivedEventArgs <BlotterOrder> .DeserializeMessage(bytesArgs.RawData); var grid = new FastWindowGridModel <BlotterOrder>(10); grid.LoadRowObjects(bytesArgs.RowData); //Make sure data matches var props = typeof(BlotterOrder).GetProperties(); Assert.AreEqual(props.Length, grid.ColumnCount, "Grid column count should match the number of public properties in BlotterOrders"); for (var r = 0; r < grid.RowCount; r++) { for (var c = 0; c < grid.ColumnCount; c++) { var cellstr = (grid.GetCellText(r, c) ?? "").ToLower(); var propval = props[c].GetValue(args.Data.ElementAt(r)); if (propval is DateTime) { var cellval = DateTimeOffset.Parse(cellstr, CultureInfo.InvariantCulture).DateTime; Console.WriteLine($"({r},{c}): {propval} = {cellval}: {(DateTime)propval == cellval}"); Assert.AreEqual(propval, cellval); } else { var propstr = propval?.ToString().ToLower() ?? string.Empty; Console.WriteLine($"({r},{c}): {propstr} = {cellstr}: {propstr == cellstr}"); Assert.AreEqual(propstr, cellstr); } } } Console.WriteLine("Property match completed successfully."); isFired = true; statusEvent.Set(); }; //Make the call to open the orders stream and wait for the ServerDataReceived event to fire TWICE var callname = AppSettings["ordersStreamCall"]; Assert.IsNotNull(callname, "AppSettings should contain an entry for 'ordersStreamCall'"); //Call with sorting by price DESC var call = new ServerCall(1, callname, new List <object> { 0, 10, "DESC", "price" }); await connection.Send(call); statusEvent.WaitOne(5000); Assert.IsTrue(isFired, "ServerDataReceived event should fired."); }
public async Task OrderStreamUpdatesSorting() { //Need to create delay for the first set of orders to come in var statusEvent = new ManualResetEvent(false); var isFired = false; var count = 0; //Listen for orders flowing in as json connection.ServerJsonReceived += (sender, jsonArgs) => { var args = ServerDataReceivedEventArgs <BlotterOrder> .DeserializeMessage(jsonArgs.RawJson); switch (count) { case 1: { var prices = args.Data .Select(order => order.Price) .ToList(); Console.WriteLine(prices.Aggregate(new StringBuilder(), (sb, p) => sb.Append($"{p}, "))); for (var i = 1; i < prices.Count; i++) { Assert.IsTrue(prices[i] <= prices[i - 1], "Prices should be in descending order."); } count = 0; isFired = true; statusEvent.Set(); } break; case 2: { var prices = args.Data .Select(order => order.Price) .ToList(); Console.WriteLine(prices.Aggregate(new StringBuilder(), (sb, p) => sb.Append($"{p}, "))); for (var i = 1; i < prices.Count; i++) { Assert.IsTrue(prices[i] >= prices[i - 1], "Prices should be in ascending order."); } count = 0; isFired = true; statusEvent.Set(); } break; } }; //Listen for orders flowing in as byte arrays connection.ServerBytesReceived += (sender, bytesArgs) => { var args = ServerDataReceivedEventArgs <BlotterOrder> .DeserializeMessage(bytesArgs.RawData); switch (count) { case 1: { var prices = args.Data .Select(order => order.Price) .ToList(); Console.WriteLine(prices.Aggregate(new StringBuilder(), (sb, p) => sb.Append($"{p}, "))); for (var i = 1; i < prices.Count; i++) { Assert.IsTrue(prices[i] <= prices[i - 1], "Prices should be in descending order."); } count = 0; isFired = true; statusEvent.Set(); } break; case 2: { var prices = args.Data .Select(order => order.Price) .ToList(); Console.WriteLine(prices.Aggregate(new StringBuilder(), (sb, p) => sb.Append($"{p}, "))); for (var i = 1; i < prices.Count; i++) { Assert.IsTrue(prices[i] >= prices[i - 1], "Prices should be in ascending order."); } count = 0; isFired = true; statusEvent.Set(); } break; } }; //Make the call to open the orders stream and wait for the ServerDataReceived event to fire TWICE var callname = AppSettings["ordersStreamCall"]; Assert.IsNotNull(callname, "AppSettings should contain an entry for 'ordersStreamCall'"); //Call with sorting by price DESC var call = new ServerCall(1, callname, new List <object> { 0, 10, "DESC", "price" }); count = 1; await connection.Send(call); statusEvent.WaitOne(5000); Assert.IsTrue(isFired, "ServerDataReceived event should fired."); //Call with sorting by price ASC statusEvent.Reset(); call = new ServerCall(1, callname, new List <object> { 0, 10, "ASC", "price" }); count = 2; await connection.Send(call); statusEvent.WaitOne(5000); Assert.IsTrue(isFired, "ServerDataReceived event should fired."); }
public IEnumerator UpdateAvatarImage(User user) { ServerCall avatarCall = new ServerCall(ServerInteract.INSTANCE.ApplyAvatarTextureToImage(user, this)); yield return(StartCoroutine(avatarCall.call())); }