Example #1
0
        /// <summary>
        /// Executes the request asynchronously.
        /// </summary>
        /// <returns> The async task with the request result.</returns>
        public override async Task <KinveyDeleteResponse> ExecuteAsync()
        {
            var kdr = default(KinveyDeleteResponse);

            switch (Policy)
            {
            case WritePolicy.FORCE_LOCAL:
                // sync
                if (_query == null)
                {
                    // cache
                    kdr = Cache.DeleteByID(entityID);

                    var request = Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, entityID);

                    var pendingAction = PendingWriteAction.buildFromRequest(request);
                    SyncQueue.Enqueue(pendingAction);
                }
                else
                {
                    // cache
                    kdr = Cache.DeleteByQuery(_query);

                    foreach (var id in kdr.IDs)
                    {
                        var request       = Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, id);
                        var pendingAction = PendingWriteAction.buildFromRequest(request);
                        SyncQueue.Enqueue(pendingAction);
                    }
                }
                break;

            case WritePolicy.FORCE_NETWORK:
                // network
                if (_query == null)
                {
                    kdr = await Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, entityID).ExecuteAsync().ConfigureAwait(false);
                }
                else
                {
                    var mongoQuery = KinveyMongoQueryBuilder.GetQueryForRemoveOperation <T>(_query);
                    kdr = await Client.NetworkFactory.buildDeleteRequestWithQuery <KinveyDeleteResponse>(Collection, mongoQuery).ExecuteAsync().ConfigureAwait(false);
                }
                break;

            case WritePolicy.NETWORK_THEN_LOCAL:
                if (_query == null)
                {
                    // cache
                    kdr = Cache.DeleteByID(entityID);

                    // network
                    kdr = await Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, entityID).ExecuteAsync().ConfigureAwait(false);
                }
                else
                {
                    // cache
                    kdr = Cache.DeleteByQuery(_query);

                    // network
                    var mongoQuery = KinveyMongoQueryBuilder.GetQueryForRemoveOperation <T>(_query);
                    kdr = await Client.NetworkFactory.buildDeleteRequestWithQuery <KinveyDeleteResponse>(Collection, mongoQuery).ExecuteAsync().ConfigureAwait(false);
                }
                break;

            case WritePolicy.LOCAL_THEN_NETWORK:
                if (_query == null)
                {
                    // cache
                    kdr = Cache.DeleteByID(entityID);

                    var deleteRequest = Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, entityID);

                    KinveyException kinveyException = null;
                    Exception       exception       = null;
                    try
                    {
                        // network
                        kdr = await deleteRequest.ExecuteAsync().ConfigureAwait(false);
                    }
                    catch (KinveyException kinveyEx)
                    {
                        kinveyException = kinveyEx;
                    }
                    catch (Exception ex)
                    {
                        exception = ex;
                    }

                    if (kinveyException != null || exception != null)
                    {
                        var pendingAction = PendingWriteAction.buildFromRequest(deleteRequest);
                        SyncQueue.Enqueue(pendingAction);

                        if (kinveyException != null)
                        {
                            throw kinveyException;
                        }
                    }
                }
                else
                {
                    // cache
                    kdr = Cache.DeleteByQuery(_query);

                    // network
                    KinveyException kinveyException = null;
                    Exception       exception       = null;
                    try
                    {
                        var mongoQuery = KinveyMongoQueryBuilder.GetQueryForRemoveOperation <T>(_query);
                        kdr = await Client.NetworkFactory.buildDeleteRequestWithQuery <KinveyDeleteResponse>(Collection, mongoQuery).ExecuteAsync().ConfigureAwait(false);
                    }
                    catch (KinveyException kinveyEx)
                    {
                        kinveyException = kinveyEx;
                    }
                    catch (Exception ex)
                    {
                        exception = ex;
                    }

                    if (kinveyException != null || exception != null)
                    {
                        foreach (var id in kdr.IDs)
                        {
                            var request       = Client.NetworkFactory.buildDeleteRequest <KinveyDeleteResponse>(Collection, id);
                            var pendingAction = PendingWriteAction.buildFromRequest(request);
                            SyncQueue.Enqueue(pendingAction);
                        }

                        if (kinveyException != null)
                        {
                            throw kinveyException;
                        }
                    }
                }
                break;

            default:
                throw new KinveyException(EnumErrorCategory.ERROR_GENERAL, EnumErrorCode.ERROR_GENERAL, "Invalid write policy");
            }

            return(kdr);
        }