Пример #1
0
            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());
            }
Пример #2
0
        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);
        }
Пример #3
0
            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>());
            }
Пример #4
0
        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);
        }
Пример #5
0
    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");
            }
        }
    }
Пример #6
0
    // 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);
        }
    }
Пример #7
0
        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);
        }
Пример #8
0
    // 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);
         * }
         */
    }
Пример #9
0
        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);
            }
        }
Пример #10
0
    // 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
        });
    }
Пример #11
0
        /// <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.");
            }
        }
Пример #12
0
        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));
        }
Пример #15
0
        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();
        }
Пример #16
0
        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;
        }
Пример #18
0
        public async Task <ParseObject> UsuarioById(string id)
        {
            ParseQuery <ParseObject> query = ParseObject.GetQuery("Usuario");
            ParseObject usuario            = await query.GetAsync(id);

            return(usuario);
        }
Пример #19
0
    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);
            }
        }
    }
Пример #20
0
        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);
        }
Пример #21
0
        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();
        }
Пример #22
0
        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"]);
            }
        }
Пример #23
0
        public async Task <ParseObject> FundacionById(string id)
        {
            ParseQuery <ParseObject> query = ParseObject.GetQuery("Fundacion");
            ParseObject fundacion          = await query.GetAsync(id);

            return(fundacion);
        }
Пример #24
0
        public async Task First()
        {
            ParseQuery <ParseObject> query = new ParseQuery <ParseObject>("Account");
            ParseObject account            = await query.First();

            Assert.NotNull(account.ObjectId);
        }
Пример #25
0
        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);
        }
Пример #26
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;
            }
        }
Пример #27
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");
    }
Пример #28
0
        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);
        }
Пример #29
0
        public async Task <ParseObject> EventoById(string id)
        {
            ParseQuery <ParseObject> query = ParseObject.GetQuery("Evento");
            ParseObject evento             = await query.GetAsync(id);

            return(evento);
        }
Пример #30
0
        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);
        }
Пример #31
0
        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;
            }
        }
Пример #33
0
        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"));
        }
Пример #34
0
        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));
        }
Пример #35
0
        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"));
        }