public async void sendFieldOrder(string destEmail, string serverFileId) { var dict = new Dictionary <string, object> { { "email", destEmail }, { "serverFileUrl", serverFileId } }; await ParseCloud.CallFunctionAsync <string>("sendFieldOrder", dict); }
protected async Task AssignQuestionToStudent(string questionObjectId, string studentObjectId) { var query = new ParseQuery <PublicUserData>(); PublicUserData pud = await query.GetAsync(studentObjectId); //Student student = await pud.Student.FetchIfNeededAsync(); //PrivateStudentData psd = await student.PrivateStudentData.FetchIfNeededAsync(); Question question = Question.CreateWithoutData <Question>(questionObjectId); SuggestedQuestion suggestedQuestion = new SuggestedQuestion(); suggestedQuestion.Answered = false; suggestedQuestion.Question = question; suggestedQuestion.Response = null; suggestedQuestion.StudentBaseUserId = pud.BaseUserId; suggestedQuestion.Tutor = PublicUserData; await suggestedQuestion.SaveAsync(); //psd.AssignedQuestions.Add(suggestedQuestion); //await psd.SaveAsync(); IDictionary <string, object> parameters = new Dictionary <string, object> { { "baseUserId", pud.BaseUserId }, { "suggestedQuestionId", suggestedQuestion.ObjectId } }; await ParseCloud.CallFunctionAsync <string>("assignQuestion", parameters); }
IEnumerator GetGlobalTopScores() { var parameters = new Dictionary <string, object> { { "gameVersion", GlobalData.Instance.version }, { "gameModes", new List <string> { "ClassicMode", "GrowthMode", "PeriodicMode" } } }; var globalTopScoresTask = ParseCloud.CallFunctionAsync <IEnumerable>("GlobalTopScores", parameters); while (!globalTopScoresTask.IsCompleted) { yield return(null); } if (globalTopScoresTask.IsFaulted) { foreach (var e in globalTopScoresTask.Exception.InnerExceptions) { ParseException parseException = (ParseException)e; Debug.Log("Error getting global scores.\r\nError message: " + parseException.Message + "\r\nErrorCode: " + parseException.Code); } } else { IEnumerable <ParseObject> globalTopScores = globalTopScoresTask.Result.OfType <ParseObject>(); GlobalData.Instance.GlobalTopScores = globalTopScores.Select(s => new Leaderboard.DTOUserScore { Score = s.Get <int>("score"), GameMode = s.Get <string>("gameMode") }).ToList(); } }
IEnumerator CreateTeammate(string email) { string pass = GenerateTempPassword(); IDictionary <string, object> userDict = new Dictionary <string, object>(); userDict.Add("email", email); userDict.Add("password", pass); userDict.Add("team", User.CurrentUser.CompanyName); Task <IDictionary <string, object> > inviteTask = ParseCloud.CallFunctionAsync <IDictionary <string, object> >("inviteUser", userDict); while (!inviteTask.IsCompleted) { yield return(null); } if (inviteTask.IsFaulted) { LoadAlert.Instance.Done(); Debug.Log("creating teammate failed:\n" + inviteTask.Exception.ToString()); } else { StartCoroutine(GetNewUser(email, pass)); } }
public Task TestCloudFunctions() { IDictionary <string, object> response = new Dictionary <string, object>() { { "fosco", "ben" }, { "list", new List <object> { 1, 2, 3 } } }; var mockController = new Mock <IParseCloudCodeController>(); mockController.Setup(obj => obj.CallFunctionAsync <IDictionary <string, object> >(It.IsAny <string>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <string>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(response)); var mockCurrentUserController = new Mock <IParseCurrentUserController>(); ParseCorePlugins.Instance.CloudCodeController = mockController.Object; ParseCorePlugins.Instance.CurrentUserController = mockCurrentUserController.Object; return(ParseCloud.CallFunctionAsync <IDictionary <string, object> >("someFunction", null, CancellationToken.None).ContinueWith(t => { Assert.IsFalse(t.IsFaulted); Assert.IsFalse(t.IsCanceled); Assert.IsInstanceOf <IDictionary <string, object> >(t.Result); Assert.AreEqual("ben", t.Result["fosco"]); Assert.IsInstanceOf <IList <object> >(t.Result["list"]); })); }
/// <summary> /// Exists to ensure that generic types are AOT-compiled for the conversions we support. /// Any new value types that we add support for will need to be registered here. /// The method itself is never called, but by virtue of the Preserve attribute being set /// on the class, these types will be AOT-compiled. /// /// This also applies to Unity. /// </summary> private static List <object> CreateWrapperTypes() { return(new List <object> { (Action)(() => ParseCloud.CallFunctionAsync <object>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <bool>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <byte>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <sbyte>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <short>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <ushort>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <int>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <uint>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <long>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <ulong>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <char>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <double>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <float>(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <IDictionary <string, object> >(null, null, CancellationToken.None)), (Action)(() => ParseCloud.CallFunctionAsync <IList <object> >(null, null, CancellationToken.None)), typeof(FlexibleListWrapper <object, ParseGeoPoint>), typeof(FlexibleListWrapper <ParseGeoPoint, object>), typeof(FlexibleDictionaryWrapper <object, ParseGeoPoint>), typeof(FlexibleDictionaryWrapper <ParseGeoPoint, object>), }); }
public Task TestCloudFunctions() { Mock <IParseCloudCodeController> mockController = new Mock <IParseCloudCodeController>(); mockController.Setup(obj => obj.CallFunctionAsync <IDictionary <string, object> >(It.IsAny <string>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <string>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult <IDictionary <string, object> >(new Dictionary <string, object> { ["fosco"] = "ben", ["list"] = new List <object> { 1, 2, 3 } })); ParseCorePlugins.Instance = new ParseCorePlugins { CloudCodeController = mockController.Object, CurrentUserController = new Mock <IParseCurrentUserController>().Object }; return(ParseCloud.CallFunctionAsync <IDictionary <string, object> >("someFunction", null, CancellationToken.None).ContinueWith(t => { Assert.IsFalse(t.IsFaulted); Assert.IsFalse(t.IsCanceled); Assert.IsInstanceOfType(t.Result, typeof(IDictionary <string, object>)); Assert.AreEqual("ben", t.Result["fosco"]); Assert.IsInstanceOfType(t.Result["list"], typeof(IList <object>)); })); }
protected async Task SendMessage() { if (RecipientPublicData == null) { throw new Exception("no user selected"); } ParseObject message = await CreateNewMessage(); if (Conversation == null) { Conversation = await FindOrCreateNewConversation(); } ParseRelation <ParseObject> messages = Conversation.GetRelation <ParseObject>("messages"); messages.Add(message); Conversation["lastSent"] = DateTime.Now; await Conversation.SaveAsync(); IDictionary <string, object> parameters = new Dictionary <string, object> { { "senderBaseUserId", PublicUserData.BaseUserId }, { "receiverBaseUserId", RecipientPublicData.Get <string>("baseUserId") }, { "senderName", PublicUserData.DisplayName }, { "messageText", tbMessage.Text } }; await ParseCloud.CallFunctionAsync <string>("sendMessageNotification", parameters); tbMessage.Text = ""; tbType.Focus(); }
private async Task <Question> GetQuestion() { IDictionary <string, object> parameters = new Dictionary <string, object> { { "author", PublicUserData.ObjectId }, { "alreadyVisited", AlreadyVisited }, { "isAdmin", PublicUserData.UserType == Constants.UserType.ADMIN } }; Question res = await ParseCloud.CallFunctionAsync <Question>("oldestReportedQuestion", parameters); if (res != null) { return(res); } else { IDictionary <string, object> parameters2 = new Dictionary <string, object> { { "author", PublicUserData.ObjectId }, { "alreadyVisited", AlreadyVisited }, { "isAdmin", PublicUserData.UserType == Constants.UserType.ADMIN } }; Question res2 = await ParseCloud.CallFunctionAsync <Question>("oldestPendingQuestion", parameters2); return(res2); } ////var contentsQuery = from contents in new ParseQuery<QuestionContents>() //// where contents.Get<ParseObject>("author") != PublicUserData //// select contents; //var dataQuery = from data in new ParseQuery<QuestionData>() // where data.Get<string>("reviewStatus") == Constants.ReviewStatusType.PENDING // select data; //var questionQuery = from question in new ParseQuery<Question>() // //where question.Get<bool>("isActive") // where !AlreadyVisited.ToArray().Contains(question.ObjectId) // orderby question.CreatedAt descending // join data in dataQuery on question["questionData"] equals data // //join contents in contentsQuery on question["questionContents"] equals contents // select question; //Question res = null; //try //{ // res = await questionQuery.FirstAsync(); //} //catch (ParseException exc) //{ // if (AlreadyVisited.Count == 0) // { // AlreadyVisited.Clear(); // } // else // { // return null; // } //} //if (res == null) // res = await GetQuestion(); //return res; }
public async Task <ActionResult> CpuResult(string id) { IDictionary <string, object> dictionary = new Dictionary <string, object>(); dictionary.Add("id", "201809097001"); var a = await ParseCloud.CallFunctionAsync <object>("cpu2", dictionary); return(Json(a)); }
public static async Task <Question[]> ChooseTenRandomQuestions() { IDictionary <string, object> parameters = new Dictionary <string, object> { }; IList <Question> questions = await ParseCloud.CallFunctionAsync <IList <Question> >("chooseTenQuestions", parameters); return(questions.ToArray()); }
void Start() { var user = ParseUser.CurrentUser; IDictionary <string, string> userProfile = user.Get <IDictionary <string, string> >("profile"); usernameTXT.text = userProfile["name"]; ParseCloud.CallFunctionAsync <string>("httpRequest", new Dictionary <string, object>()).ContinueWith(t => Debug.Log("received: " + t.Result)); }
private async Task <bool> EmailExists(string email) { IDictionary <string, object> parameters = new Dictionary <string, object> { { "email", email } }; bool res = await ParseCloud.CallFunctionAsync <bool>("doesEmailExist", parameters); return(res); }
void AmountMinus() { red.SetActive(false); Label = GetComponentInChildren <UILabel> (); amount--; Debug.Log(amount); string str = amount.ToString(); var query = ParseObject.GetQuery("POST").WhereEqualTo("objectId", Post_Id); query.FindAsync().ContinueWith(t => { IEnumerable <ParseObject> result = t.Result; foreach (var obj in result) { obj["Like"] = str; int i = obj.Get <int>("Sum"); i--; obj["Sum"] = i; obj.SaveAsync(); Label.text = str; /*foreach (var ob in obj) { * string str=amount.ToString(); * obj["Like"] = str; * obj.SaveAsync(); * Label.text=str; * }*/ } }); IDictionary <string, object> parms = new Dictionary <string, object> { { "score", Post_Id } }; ParseCloud.CallFunctionAsync <IDictionary <string, object> >("score_computing_addquit", parms).ContinueWith(t3 => { var score = t3.Result; }); var query2 = ParseObject.GetQuery("JUDGE").WhereEqualTo("User", ParseUser.CurrentUser.Username).WhereEqualTo("Post_Id", Post_Id); query2.FirstAsync().ContinueWith(t2 => { ParseObject obj2 = t2.Result; obj2.DeleteAsync(); }); /*IEnumerable<ParseObject> result2 = query2.Result; * foreach (ParseObject obj2 in result2) { * obj2.DeleteAsync(); * Debug.Log(obj2.ObjectId); * } */ b = 0; Debug.Log("Minus!"); }
void OnChallengeRemind(string objectID, string facebookFriendId) { print("_________OnChallengeRemind: " + facebookFriendId); Dictionary <string, object> dic = new Dictionary <string, object>(); dic.Add("facebookFriendId", facebookFriendId); dic.Add("username", Data.Instance.userData.username); ParseCloud.CallFunctionAsync <string>("challengeRemind", dic).ContinueWith(t => Debug.Log("received: " + t.Result)); }
public static async Task <IList <SuggestedQuestion> > GetAssignedQuestionsBetweenStudentTutor(PublicUserData studentPublicData, PublicUserData tutorPublicData) { IDictionary <string, object> parameters = new Dictionary <string, object> { { "studentPublicDataId", studentPublicData.ObjectId }, { "tutorPublicDataId", tutorPublicData.ObjectId } }; IList <SuggestedQuestion> assignedQuestions = await ParseCloud.CallFunctionAsync <IList <SuggestedQuestion> >("assignedQuestionsToStudent", parameters); return(assignedQuestions); }
public PrivateProfileTablePage(bool fromTabBar = false) { InitializeComponent(); _vm = App.Locator.ProfilePlayer; this.BindingContext = _vm; _vm.fromTabBar = fromTabBar; skipButton.IsVisible = !fromTabBar; MessagingCenter.Subscribe <ParseFile>(this, "setProfilePicture", (obj) => { if (obj != null) { PictureCell.Image = new UriImageSource { Uri = obj.Url }; } }); skipButton.Clicked += async(sender, e) => { await Navigation.PushAsync(new RacketChoicePage()); }; PictureCell.Tapped += async(object sender, EventArgs e) => { await CrossMedia.Current.Initialize(); var file = await CrossMedia.Current.PickPhotoAsync(new PickMediaOptions { PhotoSize = PhotoSize.Small }); if (file != null) { //ParseFile savePicture; //var fileStream = file.GetStream(); //savePicture = new ParseFile("image.png", fileStream); PictureCell.Image = ImageSource.FromStream(() => { var stream = file.GetStream(); file.Dispose(); return(stream); }); using (var memoryStream = new MemoryStream()) { file.GetStream().CopyTo(memoryStream); var data = new Dictionary <string, object>(); data["array"] = memoryStream.ToArray(); var response = await ParseCloud.CallFunctionAsync <ParseFile>("saveProfilePicture", data); _vm.setProfilePicture(response); } } }; genderCell.Items.Add("Homme"); genderCell.Items.Add("Femme"); }
/* Emails * This section provides native capabilities for emails on Parse * */ public async void sendSignupNotification(string destEmail, string username) { if (destEmail == null) { destEmail = ""; } var dict = new Dictionary <string, object> { { "email", destEmail }, { "username", username } }; await ParseCloud.CallFunctionAsync <string>("sendSignupNotification", dict); }
public async Task SendRequestToStudent(PublicUserData StudentPublicData, PublicUserData TutorPublicData) { //Student student = await StudentPublicData.Student.FetchIfNeededAsync(); //PrivateStudentData privateStudentData = student.PrivateStudentData; IDictionary <string, object> parameters = new Dictionary <string, object> { { "publicStudentDataId", StudentPublicData.ObjectId }, { "publicTutorDataId", TutorPublicData.ObjectId } }; await ParseCloud.CallFunctionAsync <string>("tutorRequestToStudent", parameters); }
public bool TutorAlreadyRequestedStudent() { IDictionary <string, object> parameters = new Dictionary <string, object> { { "publicStudentDataId", StudentPublicData.ObjectId }, { "publicTutorDataId", PublicUserData.ObjectId } }; Task <bool> t = ParseCloud.CallFunctionAsync <bool>("tutorAlreadyRequestedStudent", parameters); t.Wait(); return(t.Result); }
IEnumerator GetFriendsScores() { HashSet <string> friendsIDs = new HashSet <string>(); foreach (var friend in friendsInfo) { friendsIDs.Add(friend.Key); } var parameters = new Dictionary <string, object> { { "gameVersion", GlobalData.Instance.version }, { "friendsIDs", friendsIDs.ToList() }, { "gameModes", new List <string> { "ClassicMode", "GrowthMode", "PeriodicMode" } } }; var friendsHighScoresTask = ParseCloud.CallFunctionAsync <IEnumerable>("FriendsHighScores", parameters); while (!friendsHighScoresTask.IsCompleted) { yield return(null); } if (friendsHighScoresTask.IsFaulted) { foreach (var e in friendsHighScoresTask.Exception.InnerExceptions) { ParseException parseException = (ParseException)e; Debug.Log("Error getting friends scores.\r\nError message: " + parseException.Message + "\r\nErrorCode: " + parseException.Code); } } else { IEnumerable <ParseObject> friendsHighScores = friendsHighScoresTask.Result.OfType <ParseObject>(); var friendsScores = new List <Leaderboard.DTOUserScore>(); foreach (var friendHighScore in friendsHighScores) { var facebookID = friendHighScore.Get <string>("facebookUserID"); var friendScore = new Leaderboard.DTOUserScore { Name = friendsInfo[facebookID].Name, UserID = facebookID, Score = friendHighScore.Get <int>("score"), GameMode = friendHighScore.Get <string>("gameMode") }; friendsScores.Add(friendScore); } GlobalData.Instance.FriendsScores = friendsScores; } }
public async Task <ITrainingSession> GetBestSessionAsync() { var result = await ParseCloud.CallFunctionAsync <ParseObject>("bestNetwork", new Dictionary <string, object> { { "networkVersion", _networkVersion } }); var networkGenes = JsonConvert.DeserializeObject <NeuralNetworkGene>((string)result["jsonNetwork"]); var network = NeuralNetworkFactory.GetInstance().Create(networkGenes); var session = new FakeTrainingSession(network, (double)result["eval"]); return(session); }
public int StudentAllTimeAnswered() { IDictionary <string, object> parameters = new Dictionary <string, object> { { "studentBaseId", StudentPublicData.BaseUserId }, }; Task <int> t = ParseCloud.CallFunctionAsync <int>("getStudentAllTimeAnswered", parameters); t.Wait(); return(t.Result); //return 10; }
private async void parseTest() { try { Dictionary <string, object> parameter = new Dictionary <string, object>(); var result = await ParseCloud.CallFunctionAsync <string>("loadTest", parameter); MessageBox.Show(result); } catch (Exception excep) { MessageBox.Show(excep.Message); } }
//Events.OnChallengeCreate(facebookFriendName, facebookFriendId, levelId, score); public void OnChallengeCreate(string facebookFriendName, string facebookFriendId, int levelId, float score) { print("______SEND: " + facebookFriendName + " " + facebookFriendId + " " + levelId + " " + score); Dictionary <string, object> dic = new Dictionary <string, object>(); dic.Add("facebookFriendName", facebookFriendName); dic.Add("facebookFriendId", facebookFriendId); dic.Add("levelId", levelId); dic.Add("score", score); dic.Add("username", Data.Instance.userData.username); ParseCloud.CallFunctionAsync <string>("challengeUpdate", dic).ContinueWith(t => Debug.Log("received: " + t.Result)); }
public async Task RemoveStudent(PublicUserData StudentPublicData, PublicUserData TutorPublicData) { Students = Common.RemoveFromList(Students, StudentPublicData); await this.SaveAsync(); Student student = await StudentPublicData.Student.FetchIfNeededAsync(); PrivateStudentData privateStudentData = student.PrivateStudentData; IDictionary <string, object> parameters = new Dictionary <string, object> { { "privateStudentDataId", privateStudentData.ObjectId }, { "tutorPublicDataId", TutorPublicData.ObjectId } }; await ParseCloud.CallFunctionAsync <string>("removeTutor", parameters); }
public IEnumerator GetPeriodHash() { var task = ParseCloud.CallFunctionAsync <string>("PeriodicHash", new Dictionary <string, object>()); while (!task.IsCompleted) { yield return(null); } if (task.IsFaulted) { foreach (var e in task.Exception.InnerExceptions) { Debug.Log("Exception type: " + e.GetType()); //Exception parseException = e; ParseException parseException = (ParseException)e; Debug.Log("Error message " + parseException.Message); Debug.Log("Error code: " + parseException.Code); } var ea = new PeriodHashEventArgs(); ea.Seed = 0; ea.Success = false; OnPeriodHashObtained(ea); } else { if (task.Result == null) { var ea = new PeriodHashEventArgs(); ea.Seed = 0; ea.Success = false; OnPeriodHashObtained(ea); } else { var seed = task.Result.GetHashCode(); GlobalData.Instance.rawSeed = task.Result.ToString(); GlobalData.Instance.periodicModeSeed = seed; var ea = new PeriodHashEventArgs(); ea.Seed = seed; ea.Success = true; OnPeriodHashObtained(ea); } } yield return(null); }
void UpdateAmount() { red.SetActive(true); Label = GetComponentInChildren <UILabel> (); ParseObject JUDGE = new ParseObject("JUDGE"); JUDGE ["Post_Id"] = Post_Id.ToString(); JUDGE ["Judge_type"] = "Like"; JUDGE ["User"] = ParseUser.CurrentUser.Username; JUDGE.SaveAsync(); Debug.Log("AddLike!"); var query = ParseObject.GetQuery("POST").WhereEqualTo("objectId", Post_Id); query.FindAsync().ContinueWith(t => { IEnumerable <ParseObject> result = t.Result; amount++; Debug.Log(amount); foreach (var obj in result) { string str = amount.ToString(); obj["Like"] = str; int i = obj.Get <int>("Sum"); i++; obj["Sum"] = i; obj.SaveAsync(); Label.text = str; } }); IDictionary <string, object> parms = new Dictionary <string, object> { { "score", Post_Id } }; ParseCloud.CallFunctionAsync <IDictionary <string, object> >("score_computing_add", parms).ContinueWith(t2 => { var score = t2.Result; }); //while (!queryTask.IsCompleted) yield return null; b = 1; Debug.Log("Update!"); }
public static List <Question> QueryQuestions(string subject, string category) { IDictionary <string, object> parameters = new Dictionary <string, object> { { "subject", subject ?? "" }, { "category", category ?? "" } }; Task <IList <ParseObject> > t = ParseCloud.CallFunctionAsync <IList <ParseObject> >("queryAllQuestions", parameters); t.Wait(); List <Question> questions = new List <Question>(); foreach (ParseObject o in t.Result) { questions.Add((Question)o); } return(questions); }
public void getPresentations(Action <IList <Presentation> > presentations) { ParseCloud.CallFunctionAsync <IList <ParseObject> > ("getPresentations", new Dictionary <string, object> ()).ContinueWith(t => { if (t.IsFaulted || t.IsCanceled) { Console.WriteLine("failed"); foreach (Exception e in t.Exception.InnerExceptions) { Console.WriteLine(e.Message); } } else { IList <ParseObject> result = t.Result; presentations(parseToPresentations(result)); } }); }