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));
}
});
}