public void ShouldHandleInternalErrorsAndNotifyCallbacks() { IClientOperation errorSubscribeOperation = Substitute.For <IClientOperation>(); errorSubscribeOperation.ToJson().Returns(x => throw new Exception("forced error")); ParseQuery <ParseObject> query = new ParseQuery <ParseObject>(); _subscriptionFactory.CreateSubscriptionFunction = () => new TestSubscription(1, query) { CreateSubscribeClientOperationFunction = _ => errorSubscribeOperation }; LiveQueryException exception = null; ErrorCallback <ParseObject> errorCallback = Substitute.For <ErrorCallback <ParseObject> >(); errorCallback.Invoke(query, Arg.Do <LiveQueryException>(e => exception = e)); _parseLiveQueryClient.Subscribe(query).HandleError(errorCallback); _webSocketClientCallback.OnMessage(MockConnectedMessage()); // Trigger a re-subscribe // This will never get a chance to call op=subscribe, because an exception was thrown _webSocketClient.DidNotReceive().Send(Arg.Any <string>()); errorCallback.Received().Invoke(query, exception); Assert.AreEqual("Error when subscribing", exception.Message); Assert.NotNull(exception.GetBaseException()); }
public static async Task <ParseObject> GetQuestion(string objectId) { ParseQuery <ParseObject> query = ParseObject.GetQuery("Questions").Include("topics").Include("createdBy"); ParseObject question = await query.GetAsync(objectId); return(question); }
public void ShouldCloseSubscriptions() { ParseQuery <ParseObject> query = new ParseQuery <ParseObject>("test"); EventCallback <ParseObject> eventCallback = Substitute.For <EventCallback <ParseObject> >(); UnsubscribeCallback <ParseObject> unsubscribeCallback = Substitute.For <UnsubscribeCallback <ParseObject> >(); Subscription <ParseObject> subscription = Subscribe(query) .HandleEvent(Event.Create, eventCallback) .HandleUnsubscribe(unsubscribeCallback); _parseLiveQueryClient.Unsubscribe(query); _webSocketClient.Received().Send(Arg.Any <string>()); _webSocketClientCallback.OnMessage(MockUnsubscribedMessage(subscription.RequestId)); unsubscribeCallback.Received().Invoke(query); ParseObject parseObject = new ParseObject("Test") { ObjectId = "testId" }; _webSocketClientCallback.OnMessage(MockObjectEventMessage(Event.Create, subscription.RequestId, parseObject)); eventCallback.DidNotReceive().Invoke(query, Arg.Any <ParseObject>()); }
private void ValidateReceivedEqualObjects <T>(Event objEvent, Func <T> objInitFunction, ErrorCallback <T> errorCallback = null) where T : ParseObject { T expectedObj = objInitFunction(); expectedObj.ObjectId = "testId"; ParseQuery <T> query = new ParseQuery <T>(expectedObj.ClassName); T actualObj = null; EventCallback <T> eventCallback = Substitute.For <EventCallback <T> >(); EventsCallback <T> eventsCallback = Substitute.For <EventsCallback <T> >(); eventCallback.Invoke(query, Arg.Do <T>(obj => actualObj = obj)); Subscription <T> subscription = Subscribe(query).HandleEvent(objEvent, eventCallback).HandleEvents(eventsCallback); if (errorCallback != null) { subscription.HandleError(errorCallback); } _webSocketClientCallback.OnMessage(MockObjectEventMessage(objEvent, subscription.RequestId, expectedObj)); eventCallback.Received().Invoke(query, actualObj); eventsCallback.Received().Invoke(query, objEvent, actualObj); Assert.AreEqual(expectedObj.ClassName, actualObj.ClassName); Assert.AreEqual(expectedObj.ObjectId, actualObj.ObjectId); }
public static IEnumerator AddFriend(string userName) { ParseQuery <ParseUser> mainQuery = new ParseQuery <ParseUser> ("_User").WhereEqualTo("username", userName); var findUser = mainQuery.FindAsync(); while (!findUser.IsCompleted) { yield return(null); } IEnumerable <ParseUser> results = findUser.Result; foreach (ParseUser user in results) { ParseObject newFR = new ParseObject("FriendRelationship"); newFR["player"] = ParseUser.CurrentUser; newFR["friend"] = user; var addFriend = newFR.SaveAsync(); while (!addFriend.IsCompleted) { yield return(null); } if (!addFriend.IsCanceled && !addFriend.IsFaulted) { Debug.Log("successfully added " + userName + " as a friend"); } else { Debug.Log("something went wrong adding + " + userName + " as a friend"); } } }
// Update is called once per frame IEnumerator Getlabel() { ArrayList label_list = new ArrayList(); ParseQuery <ParseObject> query = new ParseQuery <ParseObject> ("POST").OrderByDescending("createdAt"); query = query.Limit(limit); var queryTask = query.FindAsync(); while (!queryTask.IsCompleted) { yield return(null); } IEnumerable <ParseObject> post = queryTask.Result; label_list.Clear(); foreach (var obj in post) { string text = obj ["postfield"].ToString(); Debug.Log("資料庫傳回:" + text); string o = "Q_list" + i; Label_post = GameObject.Find(o); UILabel label = Label_post.GetComponentInChildren <UILabel> (); label.text = text; i++; label_list.Add(text); } }
public static Task <IEnumerable <TabType> > GetTabTypes() { if (tcs != null) { return(tcs.Task); } tcs = new TaskCompletionSource <IEnumerable <TabType> > (); var query = new ParseQuery("TabType"); query.SetCachePolicy(ParseQuery.CachePolicy.CacheElseNetwork); query.MaxCacheAge = (long)TimeSpan.FromDays(7).TotalMilliseconds; query.FindInBackground(new TabFindCallback((ls, e) => { if (e == null) { var types = ls.Select(TabType.FromParse).ToArray(); tcs.SetResult(types); } else { Log.Error("TabTypes", e.ToString()); tcs.SetException(e); } })); return(tcs.Task); }
// Use this for initialization public void retrievePlayerData() { ParseQuery <ParseObject> query = ParseObject.GetQuery("Usuario").WhereEqualTo("idFacebook", playerName); query.FindAsync().ContinueWith(t => { IEnumerable <ParseObject> results = t.Result; foreach (ParseObject parseObject in results) { nameFromParse = parseObject.Get <string>("idFacebook"); Debug.Log(nameFromParse); } }); /* * var query = ParseObject.GetQuery("Maintenances") * .WhereEqualTo("z", "b"); * IEnumerable<ParseObject> results = await query.FindAsync(); * * * * foreach (var record in results) * { * Console.WriteLine("in for each"); * var docket = record.Get<String>("Docket"); * Console.WriteLine(docket); * } */ }
public async Task <List <Tuple <string, string, string> > > PopulateModels() { var modelsList = new List <Tuple <string, string, string> >(); try { //@TODO add callback function to check if teh records will exceed 1000, parse limits query result to 1000 for each call ParseQuery <ParseObject> makeQuery = ParseObject.GetQuery("Model").Limit(1000); var models = await makeQuery.FindAsync(); modelsList.AddRange( models.Select( model => new Tuple <string, string, string>( model.Get <string>("make"), model.Get <string>("model"), model.ObjectId )) ); return(modelsList); } catch (Exception ex) { Console.WriteLine("Error inserting models to table " + ex.Message + ex.Message); return(null); } }
// Use this for initialization void Start() { double result = Convert.ToDouble(geo_x); double result2 = Convert.ToDouble(geo_y); var point = new ParseGeoPoint(result2, result); ParseQuery <ParseObject> query = ParseObject.GetQuery("POST") .WhereWithinDistance("Post_Geo", point, ParseGeoDistance.FromKilometers(2.5)); query.FindAsync().ContinueWith(t => { IEnumerable <ParseObject> nearbyLocations = t.Result; foreach (var obj in nearbyLocations) { string text = obj ["postfield"].ToString(); string place = obj["geo_place"].ToString(); //string post = obj ["postfield"].ToString (); //labeltext.Add(post); Debug.Log(text); Debug.Log("資料庫傳回:" + place); } // nearbyLocations contains PlaceObjects within 5 miles of the user's location }); }
/// <summary> /// Initiates a parse object, which is the current user /// only then we can update the user's score. /// </summary> /// <returns></returns> private async Task saveScore() { try{ // Query to get the current user. var query1 = from currentUser in ParseObject.GetQuery("Users") where currentUser.Get <string>("Email") == MainActivity.player.Email select currentUser; // Activate query. IEnumerable <ParseObject> resultsCurrent = await query1.FindAsync(); // Take the value. var userVar = resultsCurrent.ElementAt(0); // By object id, we can receive the parse object, // and then update its score. string s = userVar.ObjectId; ParseQuery <ParseObject> query = ParseObject.GetQuery("Users"); // Get the parse object - for current user. ParseObject parseUser = await query.GetAsync(s); // Update the score. parseUser["Score"] = Int32.Parse(score.Text); // Save changes. await parseUser.SaveAsync(); }catch (Exception) { showMessage("Error while trying to finish and update the score."); } }
public async Task <IEnumerable <ParseObject> > GetIndividualVehicleProfile(string objectId, bool imageMissing = false) { try { var vehicle = new ParseQuery <ParseObject>("VehicleProfile").WhereEqualTo("objectId", objectId); var vehicleProfileQuery = ParseObject.GetQuery("Images") .Include("vehicle") .WhereMatchesQuery("vehicle", vehicle); var profileData = await vehicleProfileQuery.FindAsync(); if (imageMissing) { profileData = await vehicle.FindAsync(); } //if the car has no image let us query the old way return(profileData); } catch (Exception ex) { Console.Write("Error getting individual vehicle profile " + ex.Message + ex.StackTrace); } return(null); }
private async void retrieveParseSponsors() { parseSponsors = from sponsor in new ParseQuery <Sponsor>() orderby sponsor.Level descending select sponsor; //parseSponsors = parseSponsors.Include("companyImage"); //parseSponsors.g SponsorList.ItemsSource = await parseSponsors.FindAsync(); }
public ActionResult GetByReview(Guid reviewId, [FromBody] NullableGuidDeserializer nullableUserId = null) { Guid?userId = nullableUserId.Property; List <Comment> records; List <Filter> filters = ParseQuery.ParseFilters("ReivewId", reviewId.ToString()); try { records = db.LoadRecords <Comment>(COMMENT_TABLE, filters, null, null); } catch (Exception e) { Failure failure = FailureFact.Default(e, userId); db.InsertRecord(FAILURE_TABLE, failure); return(StatusCode(500, failure)); } if (records == null) { Failure failure = FailureFact.NoRecordsFound(null, userId, null, filters, null); db.InsertRecord(FAILURE_TABLE, failure); return(NotFound(failure)); } Success success = SuccessFact.CommentsByReviewRetrieved(reviewId, userId); db.InsertRecord(SUCCESS_TABLE, success); return(new OkObjectResult(records)); }
public override void OnEnter() { if (!PlayMakerParseProxy.IsPropertyKeyValid(propertyKey.Value)) { LogError("Property Key name invalid"); Fsm.Event(errorEvent); Finish(); } ParseQuery <ParseObject> _query = PlayMakerParseProxy.GetParseObjectQuery(queryId.Value); if (_query == null) { LogError("retrieving query failed"); Fsm.Event(errorEvent); Finish(); } if (where == ParseExistsClauses.Exists) { _query = _query.WhereExists(propertyKey.Value); } else if (where == ParseExistsClauses.DoesNotExist) { _query = _query.WhereDoesNotExist(propertyKey.Value); } PlayMakerParseProxy.CacheParseObjectQuery(queryId.Value, _query); Fsm.Event(successEvent); Finish(); }
public static async Task <ParseObject> GetMyRequest(string objectId) { ParseQuery <ParseObject> query = ParseObject.GetQuery("Questions").Include("topics").Include("acceptedHelpers").Include("requestedHelpers"); ParseObject question = await query.GetAsync(objectId); return(question); }
async void UpdateTeamList() { busyIcon.IsVisible = true; busyIcon.IsRunning = true; ParseQuery <ParseObject> query = ParseObject.GetQuery("TeamData"); ParseQuery <ParseObject> sorted = query.OrderBy("teamNumber"); var allTeams = await sorted.FindAsync(); teamStack.Children.Clear(); foreach (ParseObject obj in allTeams) { await obj.FetchAsync(); TeamListCell cell = new TeamListCell(); cell.teamName.Text = "Team " + obj ["teamNumber"]; teamStack.Children.Add(cell); TapGestureRecognizer tap = new TapGestureRecognizer(); //teamObj [i] = obj; tap.Tapped += (object sender, EventArgs e) => { Navigation.PushModalAsync(new RobotInfoViewPage(obj)); //nextPage(teamObj[i]); }; cell.GestureRecognizers.Add(tap); i++; } busyIcon.IsVisible = false; busyIcon.IsRunning = false; }
public async Task <ParseObject> UsuarioById(string id) { ParseQuery <ParseObject> query = ParseObject.GetQuery("Usuario"); ParseObject usuario = await query.GetAsync(id); return(usuario); }
private IEnumerator FetchLevelsCoroutine() { ParseQuery <ParseObject> query = ParseObject.GetQuery("Levels"); //We find all the levels in our levels class //We currently load all levels, both name and world. In the final version we should load only the names and after the click load only the selected level Task <IEnumerable <ParseObject> > fetchLevelsTask = query.FindAsync(); while (!fetchLevelsTask.IsCompleted) { yield return(null); } if (fetchLevelsTask.IsFaulted || fetchLevelsTask.IsCanceled) { Debug.LogWarning(fetchLevelsTask.Exception.ToString()); } else { Debug.Log("Fetch Success"); //The result contains all the levels in our database List <ParseObject> levels = new List <ParseObject>(fetchLevelsTask.Result); if (onFetchedLevelsSuccess != null) { onFetchedLevelsSuccess(levels); } } }
public async Task <ObservableCollection <Trabajador> > getAllTrabajador(string idSemanaNoti) { ObservableCollection <Trabajador> listTrabajador = new ObservableCollection <Trabajador>(); ParseQuery <ParseObject> query = ParseObject.GetQuery(CLASS).WhereEqualTo(C_IDSEMANA, idSemanaNoti); IEnumerable <ParseObject> results = await query.FindAsync(); ParseObject listObject; Trabajador trabajador; int sizeResult = results.Count(); for (int i = 0; i < sizeResult; i++) { listObject = results.ElementAt <ParseObject>(i); trabajador = new Trabajador { IdTrabajador = listObject.ObjectId, NombreTrabajador = listObject.Get <string>(C_NAME_TRA), Klu = listObject.Get <int>(C_KLU), Kma = listObject.Get <int>(C_KMA), Kmi = listObject.Get <int>(C_KMI), Kju = listObject.Get <int>(C_KJU), Kvi = listObject.Get <int>(C_KVI), Ksa = listObject.Get <int>(C_KSA), Kdo = listObject.Get <int>(C_KDOM) }; listTrabajador.Add(trabajador); } return(listTrabajador); }
public async void AddQueueOrders() { loadingOverlay = new LoadingOverlay(UIScreen.MainScreen.Bounds); View.Add(loadingOverlay); ActiveOrdersList.Clear(); ParseQuery <ParseObject> query = from ordersTB in ParseObject.GetQuery("Orders") where ordersTB.Get <bool>("IsOrderDone") == false select ordersTB; IEnumerable <ParseObject> column = await query.FindAsync(); loadingOverlay.Hide(); foreach (ParseObject nameElements in column) { string nameOfCurrentUser = orderViewController.GetName; string namesColumn = nameElements.Get <string>("PersonOrdered"); string replacedName = namesColumn.Replace(nameOfCurrentUser, "You"); string time = nameElements.Get <string>("Time"); ActiveOrdersList.Add(replacedName + "#" + time); } PopulateTable(); }
public async Task BaseQuery() { ParseQuery <ParseObject> query = new ParseQuery <ParseObject>("Hello"); query.Limit(2); ReadOnlyCollection <ParseObject> list = await query.Find(); TestContext.WriteLine(list.Count); Assert.AreEqual(list.Count, 2); foreach (ParseObject item in list) { Assert.NotNull(item.ClassName); Assert.NotNull(item.ObjectId); Assert.NotNull(item.CreatedAt); Assert.NotNull(item.UpdatedAt); TestContext.WriteLine(item.ClassName); TestContext.WriteLine(item.ObjectId); TestContext.WriteLine(item.CreatedAt); TestContext.WriteLine(item.UpdatedAt); TestContext.WriteLine(item["intValue"]); TestContext.WriteLine(item["boolValue"]); TestContext.WriteLine(item["stringValue"]); } }
public async Task <ParseObject> FundacionById(string id) { ParseQuery <ParseObject> query = ParseObject.GetQuery("Fundacion"); ParseObject fundacion = await query.GetAsync(id); return(fundacion); }
public async Task First() { ParseQuery <ParseObject> query = new ParseQuery <ParseObject>("Account"); ParseObject account = await query.First(); Assert.NotNull(account.ObjectId); }
public async Task Geo() { ParseObject obj = new ParseObject("Todo"); ParseGeoPoint location = new ParseGeoPoint(39.9, 116.4); obj["location"] = location; await obj.Save(); // near ParseQuery <ParseObject> query = new ParseQuery <ParseObject>("Todo"); ParseGeoPoint point = new ParseGeoPoint(39.91, 116.41); query.WhereNear("location", point); ReadOnlyCollection <ParseObject> results = await query.Find(); Assert.Greater(results.Count, 0); // in box query = new ParseQuery <ParseObject>("Todo"); ParseGeoPoint southwest = new ParseGeoPoint(30, 115); ParseGeoPoint northeast = new ParseGeoPoint(40, 118); query.WhereWithinGeoBox("location", southwest, northeast); results = await query.Find(); Assert.Greater(results.Count, 0); }
public async void PopulateWindow() { try { var pendent = new ParseQuery <DocumentEntry>().Where(o => o.Status.Equals("pendiente")).OrderBy("receiptNum"); var result = await pendent.FindAsync(); var list = result.Select(p => new { Id = p.ObjectId, Suplidor = p.Supplier, Concepto = p.Concept, Factura = p.ReceiptNumber, Total = Utilities.ToDopCurrencyFormat(p.TotalAmount), Restante = Utilities.ToDopCurrencyFormat(p.Amount), Creado = p.CreatedAt, Ultimo = p.UpdatedAt }); var total = result.Sum(v => v.Amount); TotalLbl.Content = Utilities.ToDopCurrencyFormat(total); dataGrid.ItemsSource = list; dataGrid.Columns[7].Header = "Última abonación"; } catch (Exception) { dataGrid.Visibility = 0; } }
public IEnumerator YesDeleteClicked() { // Delete stuff GameObject.Find("Dialog Panel").GetComponent <dfPanel>().Disable(); if (Settings.Brain.Children != null) { foreach (Brain brain in Settings.Brain.Children) { RecurseDelete(brain); } } var query = new ParseQuery <Brain>().WhereEqualTo("originalBrain", Settings.Brain); query.FindAsync().ContinueWith(t => { foreach (Brain b in t.Result) { b.DeleteAsync(); } }); var task = Settings.Brain.DeleteAsync(); while (!task.IsCompleted) { yield return(null); } GameObject.Find("Panel").GetComponent <dfPanel>().Enable(); GameObject.Find("Dialog Panel").GetComponent <dfPanel>().Hide(); Application.LoadLevel("Bootcamp"); }
static async Task <IEnumerable <ParseObject> > HandleFileAsync() { ParseClient.Initialize(new ParseClient.Configuration { ApplicationId = "XW0rXBZxcGJcl3zkoWrh3w6bryBpkXnG36CvzOPV", WindowsKey = "C3O1Mn02ELUtYpKSBUbfUXf2dOh0snBHR8yoIbx6", Server = "https://parseapi.back4app.com/" } ); IEnumerable <ParseObject> cities = null; List <ParseObject> listOfCities = new List <ParseObject>(); ParseQuery <ParseObject> query = ParseObject.GetQuery("City") .Include("country"); int count = await query.CountAsync(); int limit = 1000; for (int i = 0; i < count;) { query = ParseObject.GetQuery("City") .Include("country").Skip(i).Limit(limit); cities = await query.FindAsync(); listOfCities.AddRange(cities.ToList <ParseObject>()); i += limit; } return(listOfCities); }
public async Task <ParseObject> EventoById(string id) { ParseQuery <ParseObject> query = ParseObject.GetQuery("Evento"); ParseObject evento = await query.GetAsync(id); return(evento); }
public async Task UserReadAndWrite() { await ParseUser.Login("hello", "world"); ParseObject account = new ParseObject("Account"); ParseUser currentUser = await ParseUser.GetCurrent(); ParseACL acl = ParseACL.CreateWithOwner(currentUser); account.ACL = acl; account["balance"] = 512; await account.Save(); Assert.IsTrue(acl.GetUserReadAccess(currentUser)); Assert.IsTrue(acl.GetUserWriteAccess(currentUser)); ParseQuery <ParseObject> query = new ParseQuery <ParseObject>("Account"); ParseObject result = await query.Get(account.ObjectId); TestContext.WriteLine(result.ObjectId); Assert.NotNull(result.ObjectId); await ParseUser.Logout(); result = await query.Get(account.ObjectId); Assert.IsNull(result); }
public void SyncUserNotesToParse(NotesActivity notesActivity, List<NoteScripture> notes) { if (!ConnectedToNetwork(context)) { return; } Parse.Initialize(context, "scBTJphDK8yVGGtNhcL9cYee89GbEKuRkygGYXKa", "wlXg6dWeJBCxD3uNbnoCTnnZlpSvvZWOdfyoeREZ"); List<ParseObject> parseItems = new List<ParseObject>(); List<NoteScripture> dbNotes = new List<NoteScripture>(); foreach (NoteScripture note in notes) { ParseQuery query = new ParseQuery("Note"); query.WhereEqualTo("objectId", note.NWTId); IEnumerable<ParseObject> existedObjects = query.Find(); // Does not exist in Parse if (existedObjects.Count() == 0) { ParseObject testObject = new ParseObject("Note"); testObject.Put("book", note.Book); testObject.Put("bookName", note.Book); testObject.Put("chapter", note.Chapter); testObject.Put("name", ParseUser.CurrentUser.Username); testObject.Put("title", note.NoteTitle); testObject.Put("note", note.NoteBody); testObject.Put("text", note.Scripture); testObject.Put("verse", note.Verses); testObject.Put("nwtId", note.NWTId); parseItems.Add(testObject); dbNotes.Add(note); } // Exists in Parse else if (existedObjects.Count() == 1) { query.GetInBackground(note.NWTId, new MyGetCallback(note, "update")); } } ParseObject.SaveAllInBackground(parseItems, new MySyncUploadSaveCallback(notesActivity, parseItems, dbNotes)); }
public async Task<bool> DeleteImageByPostAndInageId(string imageId, string postId) { try { var q = new ParseQuery<ImageParse>(); var post = await q.GetAsync(postId); await post.DeleteAsync(); return true; } catch (Exception ex) { var msg = ex.Message; return false; } }
public void DeleteNoteFromParse(NoteScripture note) { if (!ConnectedToNetwork(context)) { return; } // Initialize Parse Parse.Initialize(context, "scBTJphDK8yVGGtNhcL9cYee89GbEKuRkygGYXKa", "wlXg6dWeJBCxD3uNbnoCTnnZlpSvvZWOdfyoeREZ"); ParseQuery notes = new ParseQuery("Note"); notes.GetInBackground(note.NWTId, new MyGetCallback(note, "delete")); }
public void SyncUserNotesFromParse(NotesActivity notesActivity) { if (!ConnectedToNetwork(context)) { return; } Parse.Initialize(context, "scBTJphDK8yVGGtNhcL9cYee89GbEKuRkygGYXKa", "wlXg6dWeJBCxD3uNbnoCTnnZlpSvvZWOdfyoeREZ"); ParseQuery query = new ParseQuery("Note"); query.WhereEqualTo("name", ParseUser.CurrentUser.Username); query.FindInBackground(new MyFindCallback(notesActivity)); }
public void UpdateNoteToParse(long rowId, string noteTitle, string noteBody) { if (!ConnectedToNetwork(context)) { return; } NoteScripture n = GetNoteByParseId(rowId); // Initialize Parse Parse.Initialize(context, "scBTJphDK8yVGGtNhcL9cYee89GbEKuRkygGYXKa", "wlXg6dWeJBCxD3uNbnoCTnnZlpSvvZWOdfyoeREZ"); ParseQuery notes = new ParseQuery("Note"); notes.GetInBackground(n.NWTId, new MyGetCallback(n, "update")); }