public void GetDatasetMetadataAsync(string datasetName, AmazonCognitoSyncCallback <DatasetMetadata> callback, AsyncOptions options = null)
        {
            options = options ?? new AsyncOptions();

            DescribeDatasetRequest request = new DescribeDatasetRequest();

            request.IdentityPoolId = identityPoolId;
            request.IdentityId     = this.GetCurrentIdentityId();
            request.DatasetName    = datasetName;

            client.DescribeDatasetAsync(request, (responseObj) =>
            {
                Exception dataStorageException = null;
                DatasetMetadata metadata       = null;
                if (responseObj.Exception != null)
                {
                    dataStorageException = new DataStorageException("Failed to get metadata of dataset: "
                                                                    + datasetName, responseObj.Exception);
                }
                else
                {
                    metadata = ModelToDatasetMetadata(responseObj.Response.Dataset);
                }

                InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <DatasetMetadata>(metadata, dataStorageException, responseObj.state)), options);
            },
                                        options);
        }
Example #2
0
        /// <summary>
        /// Refreshes dataset metadata. Dataset metadata is pulled from remote
        /// storage and stored in local storage. Their record data isn't pulled down
        /// until you sync each dataset.
        /// </summary>
        /// <param name="callback">Callback once the refresh is complete</param>
        /// <param name="options">Options for asynchronous execution</param>
        /// <exception cref="Amazon.CognitoSync.SyncManager.DataStorageException">Thrown when fail to fresh dataset metadata</exception>
        public void RefreshDatasetMetadataAsync(AmazonCognitoSyncCallback <List <DatasetMetadata> > callback, AsyncOptions options = null)
        {
            options = options ?? new AsyncOptions();

            remote.GetDatasetMetadataAsync((cognitoResult) =>
            {
                Exception ex = cognitoResult.Exception;
                List <DatasetMetadata> res = cognitoResult.Response;
                if (ex != null)
                {
                    InternalSDKUtils.AsyncExecutor(() => callback(cognitoResult), options);
                }
                else
                {
                    Local.UpdateDatasetMetadata(GetIdentityId(), res);
                    InternalSDKUtils.AsyncExecutor(() => callback(cognitoResult), options);
                }
            }, options);
        }
 /// <summary>
 /// Refreshes dataset metadata. Dataset metadata is pulled from remote
 /// storage and stored in local storage. Their record data isn't pulled down
 /// until you sync each dataset.
 /// </summary>
 /// <param name="callback">Callback once the refresh is complete</param>
 /// <param name="options">Options for asynchronous execution</param>
 /// <exception cref="Amazon.CognitoSync.SyncManager.DataStorageException">Thrown when fail to fresh dataset metadata</exception>
 public void RefreshDatasetMetadataAsync(AmazonCognitoSyncCallback<List<DatasetMetadata>> callback, AsyncOptions options = null)
 {
     options = options ?? new AsyncOptions();
     AmazonCognitoSyncResult<List<DatasetMetadata>> cognitoResult = new AmazonCognitoSyncResult<List<DatasetMetadata>>(options.State);
     
     InternalSDKUtils.AsyncExecutor(() =>
     {
         try
         {
             var response = Remote.ListDatasetMetadata();
             Local.UpdateDatasetMetadata(IdentityId, response);
             cognitoResult.Response = response;
         }
         catch (Exception e)
         {
             cognitoResult.Exception = e;
         }
         callback(cognitoResult);
     }, options);
 }
        /// <summary>
        /// Refreshes dataset metadata. Dataset metadata is pulled from remote
        /// storage and stored in local storage. Their record data isn't pulled down
        /// until you sync each dataset.
        /// </summary>
        /// <param name="callback">Callback once the refresh is complete</param>
        /// <param name="options">Options for asynchronous execution</param>
        /// <exception cref="Amazon.CognitoSync.SyncManager.DataStorageException">Thrown when fail to fresh dataset metadata</exception>
        public void RefreshDatasetMetadataAsync(AmazonCognitoSyncCallback <List <DatasetMetadata> > callback, AsyncOptions options = null)
        {
            options = options ?? new AsyncOptions();
            AmazonCognitoSyncResult <List <DatasetMetadata> > cognitoResult = new AmazonCognitoSyncResult <List <DatasetMetadata> >(options.State);

            InternalSDKUtils.AsyncExecutor(() =>
            {
                try
                {
                    var response = Remote.ListDatasetMetadata();
                    Local.UpdateDatasetMetadata(IdentityId, response);
                    cognitoResult.Response = response;
                }
                catch (Exception e)
                {
                    cognitoResult.Exception = e;
                }
                callback(cognitoResult);
            }, options);
        }
        public void DeleteDatasetAsync(string datasetName, AmazonCognitoSyncCallback callback, AsyncOptions options = null)
        {
            options = options ?? new AsyncOptions();

            DeleteDatasetRequest request = new DeleteDatasetRequest();

            request.IdentityPoolId = identityPoolId;
            request.IdentityId     = this.GetCurrentIdentityId();
            request.DatasetName    = datasetName;

            client.DeleteDatasetAsync(request, (responseObj) =>
            {
                if (responseObj.Exception != null)
                {
                    InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult(HandleException(responseObj.Exception, "Failed to delete dataset: " + datasetName), responseObj.state)), options);
                }
                else
                {
                    InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult(null, responseObj.state)), options);
                }
            },
                                      options);
        }
        private void PopulateGetDatasetMetadataAsync(string nextToken, List<DatasetMetadata> datasets, AmazonCognitoSyncCallback<List<DatasetMetadata>> callback, AsyncOptions options)
        {

            ListDatasetsRequest request = new ListDatasetsRequest();
            // a large enough number to reduce # of requests
            request.MaxResults = 64;
            request.NextToken = nextToken;

            client.ListDatasetsAsync(request, (responseObj) =>
            {
                Exception ex = responseObj.Exception;
                ListDatasetsResponse response = responseObj.Response;
                object obj = responseObj.state;
                if (ex != null)
                {
                    InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult<List<DatasetMetadata>>(null, ex, obj)), options);
                }
                else
                {
                    foreach (Amazon.CognitoSync.Model.Dataset dataset in response.Datasets)
                    {
                        datasets.Add(ModelToDatasetMetadata(dataset));
                    }

                    nextToken = response.NextToken;

                    if (nextToken == null)
                    {
                        InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult<List<DatasetMetadata>>(datasets, null, obj)), options);
                        return;
                    }
                    PopulateGetDatasetMetadataAsync(nextToken, datasets, callback, options);
                }
            },
            options);
        }
Example #7
0
        /// <summary>
        /// Refreshes dataset metadata. Dataset metadata is pulled from remote
        /// storage and stored in local storage. Their record data isn't pulled down
        /// until you sync each dataset.
        /// </summary>
        /// <param name="callback">Callback once the refresh is complete</param>
        /// <param name="options">Options for asynchronous execution</param>
        /// <exception cref="Amazon.CognitoSync.SyncManager.DataStorageException">Thrown when fail to fresh dataset metadata</exception>
        public void RefreshDatasetMetadataAsync(AmazonCognitoSyncCallback<List<DatasetMetadata>> callback, AsyncOptions options = null)
        {
            options = options ?? new AsyncOptions();

            remote.GetDatasetMetadataAsync((cognitoResult) =>
            {
                Exception ex = cognitoResult.Exception;
                List<DatasetMetadata> res = cognitoResult.Response;
                if (ex != null)
                {
                    InternalSDKUtils.AsyncExecutor(() => callback(cognitoResult), options);
                }
                else
                {
                    Local.UpdateDatasetMetadata(GetIdentityId(), res);
                    InternalSDKUtils.AsyncExecutor(() => callback(cognitoResult), options);
                }
            }, options);
        }
        private void PopulateGetDatasetMetadataAsync(string nextToken, List <DatasetMetadata> datasets, AmazonCognitoSyncCallback <List <DatasetMetadata> > callback, AsyncOptions options)
        {
            ListDatasetsRequest request = new ListDatasetsRequest();

            // a large enough number to reduce # of requests
            request.MaxResults = 64;
            request.NextToken  = nextToken;

            client.ListDatasetsAsync(request, (responseObj) =>
            {
                Exception ex = responseObj.Exception;
                ListDatasetsResponse response = responseObj.Response;
                object obj = responseObj.state;
                if (ex != null)
                {
                    InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <List <DatasetMetadata> >(null, ex, obj)), options);
                }
                else
                {
                    foreach (Amazon.CognitoSync.Model.Dataset dataset in response.Datasets)
                    {
                        datasets.Add(ModelToDatasetMetadata(dataset));
                    }

                    nextToken = response.NextToken;

                    if (nextToken == null)
                    {
                        InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <List <DatasetMetadata> >(datasets, null, obj)), options);
                        return;
                    }
                    PopulateGetDatasetMetadataAsync(nextToken, datasets, callback, options);
                }
            },
                                     options);
        }
 /// <summary>
 /// Gets a list of <see cref="DatasetMetadata"/>
 /// </summary>
 /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes</param>
 /// <param name="state">A user-defined state object that is passed to the callback procedure. </param>
 /// <exception cref="DataStorageException"></exception>
 public void GetDatasetMetadataAsync(AmazonCognitoSyncCallback <List <DatasetMetadata> > callback, AsyncOptions options = null)
 {
     options = options ?? new AsyncOptions();
     PopulateGetDatasetMetadataAsync(null, new List <DatasetMetadata>(), callback, options);
 }
        private void PopulateListUpdatesAsync(string datasetName, long lastSyncCount, List<Record> records, string nextToken, AmazonCognitoSyncCallback<DatasetUpdates> callback, AsyncOptions options)
        {
            ListRecordsRequest request = new ListRecordsRequest();
            request.IdentityPoolId = identityPoolId;
            request.IdentityId = this.GetCurrentIdentityId();
            request.DatasetName = datasetName;
            request.LastSyncCount = lastSyncCount;
            // mark it large enough to reduce # of requests
            request.MaxResults = 1024;
            request.NextToken = nextToken;

            client.ListRecordsAsync(request, (responseObj) =>
            {
                ListRecordsResponse res = responseObj.Response;
                Exception ex = responseObj.Exception;
                object obj = responseObj.state;

                if (ex != null)
                {
                    InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult<DatasetUpdates>(null, ex, obj)), options); ;
                }
                else
                {
                    ListRecordsResponse listRecordsResponse = res;
                    foreach (Amazon.CognitoSync.Model.Record remoteRecord in listRecordsResponse.Records)
                    {
                        //builder.addRecord(modelToRecord(remoteRecord));
                        records.Add(this.ModelToRecord(remoteRecord));
                    }
                    if (listRecordsResponse.NextToken == null)
                    {
                        DatasetUpdates updates = new DatasetUpdates(
                            datasetName,
                            records,
                            listRecordsResponse.DatasetSyncCount,
                            listRecordsResponse.SyncSessionToken,
                            listRecordsResponse.DatasetExists,
                            listRecordsResponse.DatasetDeletedAfterRequestedSyncCount,
                            listRecordsResponse.MergedDatasetNames
                        );

                        InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult<DatasetUpdates>(updates, ex, obj)), options);

                        return;
                    }
                    // update last evaluated key
                    nextToken = listRecordsResponse.NextToken;

                    // emulating the while loop
                    PopulateListUpdatesAsync(datasetName, lastSyncCount, records, nextToken, callback, new AsyncOptions() { ExecuteCallbackOnMainThread = false, State = obj });
                }
            },
            options);

        }
        public void PutRecordsAsync(string datasetName, List <Record> records, string syncSessionToken, AmazonCognitoSyncCallback <List <Record> > callback, AsyncOptions options = null)
        {
            options = options ?? new AsyncOptions();
            UpdateRecordsRequest request = new UpdateRecordsRequest();

            request.DatasetName      = datasetName;
            request.IdentityPoolId   = identityPoolId;
            request.IdentityId       = this.GetCurrentIdentityId();
            request.SyncSessionToken = syncSessionToken;

            // create patches
            List <RecordPatch> patches = new List <RecordPatch>();

            foreach (Record record in records)
            {
                patches.Add(this.RecordToPatch(record));
            }
            request.RecordPatches = patches;

            List <Record> updatedRecords = new List <Record>();

            client.UpdateRecordsAsync(request, (responseObj) =>
            {
                Exception ex = responseObj.Exception;
                UpdateRecordsResponse updateRecordsResponse = responseObj.Response;
                Exception putRecordsException = null;
                object obj = responseObj.state;
                if (ex != null)
                {
                    putRecordsException = HandleException(ex, "Failed to update records in dataset: " + datasetName);
                }
                else
                {
                    foreach (Amazon.CognitoSync.Model.Record remoteRecord in updateRecordsResponse.Records)
                    {
                        updatedRecords.Add(ModelToRecord(remoteRecord));
                    }
                }

                InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <List <Record> >(updatedRecords, putRecordsException, obj)), options);
            },
                                      options);
        }
        private void PopulateListUpdatesAsync(string datasetName, long lastSyncCount, List <Record> records, string nextToken, AmazonCognitoSyncCallback <DatasetUpdates> callback, AsyncOptions options)
        {
            ListRecordsRequest request = new ListRecordsRequest();

            request.IdentityPoolId = identityPoolId;
            request.IdentityId     = this.GetCurrentIdentityId();
            request.DatasetName    = datasetName;
            request.LastSyncCount  = lastSyncCount;
            // mark it large enough to reduce # of requests
            request.MaxResults = 1024;
            request.NextToken  = nextToken;

            client.ListRecordsAsync(request, (responseObj) =>
            {
                ListRecordsResponse res = responseObj.Response;
                Exception ex            = responseObj.Exception;
                object obj = responseObj.state;

                if (ex != null)
                {
                    InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <DatasetUpdates>(null, ex, obj)), options);;
                }
                else
                {
                    ListRecordsResponse listRecordsResponse = res;
                    foreach (Amazon.CognitoSync.Model.Record remoteRecord in listRecordsResponse.Records)
                    {
                        //builder.addRecord(modelToRecord(remoteRecord));
                        records.Add(this.ModelToRecord(remoteRecord));
                    }
                    if (listRecordsResponse.NextToken == null)
                    {
                        DatasetUpdates updates = new DatasetUpdates(
                            datasetName,
                            records,
                            listRecordsResponse.DatasetSyncCount,
                            listRecordsResponse.SyncSessionToken,
                            listRecordsResponse.DatasetExists,
                            listRecordsResponse.DatasetDeletedAfterRequestedSyncCount,
                            listRecordsResponse.MergedDatasetNames
                            );

                        InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <DatasetUpdates>(updates, ex, obj)), options);

                        return;
                    }
                    // update last evaluated key
                    nextToken = listRecordsResponse.NextToken;

                    // emulating the while loop
                    PopulateListUpdatesAsync(datasetName, lastSyncCount, records, nextToken, callback, new AsyncOptions()
                    {
                        ExecuteCallbackOnMainThread = false, State = obj
                    });
                }
            },
                                    options);
        }
 public void ListUpdatesAsync(string datasetName, long lastSyncCount, AmazonCognitoSyncCallback <DatasetUpdates> callback, AsyncOptions options = null)
 {
     options = options ?? new AsyncOptions();
     PopulateListUpdatesAsync(datasetName, lastSyncCount, new List <Record>(), null, callback, options);
 }
 public void ListUpdatesAsync(string datasetName, long lastSyncCount, AmazonCognitoSyncCallback<DatasetUpdates> callback, AsyncOptions options = null)
 {
     options = options ?? new AsyncOptions();
     PopulateListUpdatesAsync(datasetName, lastSyncCount, new List<Record>(), null, callback, options);
 }
 /// <summary>
 /// Gets a list of <see cref="DatasetMetadata"/>
 /// </summary>
 /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes</param>
 /// <param name="state">A user-defined state object that is passed to the callback procedure. </param>
 /// <exception cref="DataStorageException"></exception>
 public void GetDatasetMetadataAsync(AmazonCognitoSyncCallback<List<DatasetMetadata>> callback, AsyncOptions options = null)
 {
     options = options ?? new AsyncOptions();
     PopulateGetDatasetMetadataAsync(null, new List<DatasetMetadata>(), callback, options);
 }
        public void GetDatasetMetadataAsync(string datasetName, AmazonCognitoSyncCallback<DatasetMetadata> callback, AsyncOptions options = null)
        {
            options = options ?? new AsyncOptions();

            DescribeDatasetRequest request = new DescribeDatasetRequest();
            request.IdentityPoolId = identityPoolId;
            request.IdentityId = this.GetCurrentIdentityId();
            request.DatasetName = datasetName;

            client.DescribeDatasetAsync(request, (responseObj) =>
            {
                Exception dataStorageException = null;
                DatasetMetadata metadata = null;
                if (responseObj.Exception != null)
                {
                    dataStorageException = new DataStorageException("Failed to get metadata of dataset: "
                                                                        + datasetName, responseObj.Exception);
                }
                else
                {
                    metadata = ModelToDatasetMetadata(responseObj.Response.Dataset);
                }

                InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult<DatasetMetadata>(metadata, dataStorageException, responseObj.state)), options);
            },
            options);
        }
        public void DeleteDatasetAsync(string datasetName, AmazonCognitoSyncCallback callback, AsyncOptions options = null)
        {
            options = options ?? new AsyncOptions();

            DeleteDatasetRequest request = new DeleteDatasetRequest();
            request.IdentityPoolId = identityPoolId;
            request.IdentityId = this.GetCurrentIdentityId();
            request.DatasetName = datasetName;

            client.DeleteDatasetAsync(request, (responseObj) =>
            {
                if (responseObj.Exception != null)
                {
                    InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult(HandleException(responseObj.Exception, "Failed to delete dataset: " + datasetName), responseObj.state)), options);
                }
                else
                {
                    InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult(null, responseObj.state)), options);
                }
            },
            options);
        }
        public void PutRecordsAsync(string datasetName, List<Record> records, string syncSessionToken, AmazonCognitoSyncCallback<List<Record>> callback, AsyncOptions options = null)
        {
            options = options ?? new AsyncOptions();
            UpdateRecordsRequest request = new UpdateRecordsRequest();
            request.DatasetName = datasetName;
            request.IdentityPoolId = identityPoolId;
            request.IdentityId = this.GetCurrentIdentityId();
            request.SyncSessionToken = syncSessionToken;

            // create patches
            List<RecordPatch> patches = new List<RecordPatch>();
            foreach (Record record in records)
            {
                patches.Add(this.RecordToPatch(record));
            }
            request.RecordPatches = patches;

            List<Record> updatedRecords = new List<Record>();

            client.UpdateRecordsAsync(request, (responseObj) =>
            {
                Exception ex = responseObj.Exception;
                UpdateRecordsResponse updateRecordsResponse = responseObj.Response;
                Exception putRecordsException = null;
                object obj = responseObj.state;
                if (ex != null)
                {
                    putRecordsException = HandleException(ex, "Failed to update records in dataset: " + datasetName);
                }
                else
                {
                    foreach (Amazon.CognitoSync.Model.Record remoteRecord in updateRecordsResponse.Records)
                    {
                        updatedRecords.Add(ModelToRecord(remoteRecord));
                    }
                }

                InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult<List<Record>>(updatedRecords, putRecordsException, obj)), options);

            },
            options);
        }