Esempio n. 1
0
        public async Task GetRecordsByApp()
        {
            var getRequest  = new GetRecordsByAppRequest(_appIdWithRecords);
            var getResponse = await _apiClient.GetRecordsForAppAsync(getRequest);

            AssertHelper.AssertSuccess(getResponse);
        }
Esempio n. 2
0
        public async Task CrudAsync()
        {
            // Prepare initial record.
            var record = TestDataFactory.GetFullyFilledOutRecord(_appIdWithRecords, default);

            // Insert
            var insertResponse = await _apiClient.SaveRecordAsync(record);       // Used for single delete

            var secondInsertResponse = await _apiClient.SaveRecordAsync(record); // Used for batch delete

            AssertHelper.AssertSuccess(insertResponse);

            // Update
            record.RecordId = insertResponse.Value.Id;
            UpdateRecordFields(record);

            var updateResponse = await _apiClient.SaveRecordAsync(record);

            AssertHelper.AssertSuccess(updateResponse);

            // Reads
            // Get by ID
            var getRequest = new GetRecordRequest(_appIdWithRecords, insertResponse.Value.Id)
            {
                FieldIds = { _fieldId },
            };
            var getResponse = await _apiClient.GetRecordAsync(getRequest);

            AssertHelper.AssertSuccess(getResponse);
            AssertHelper.AssertCasting(getResponse.Value);

            // Get batch
            var getBatchRequest = new GetRecordsRequest
            {
                AppId     = _appIdWithRecords,
                RecordIds = { insertResponse.Value.Id, secondInsertResponse.Value.Id },
                FieldIds  = { _fieldId },
            };
            var batchGetResponse = await _apiClient.GetRecordsAsync(getBatchRequest);

            AssertHelper.AssertSuccess(batchGetResponse);
            AssertHelper.AssertCasting(batchGetResponse.Value.Items);

            // Get by app
            var pagingRequest   = new PagingRequest(1, 10);
            var getByAppRequest = new GetRecordsByAppRequest(_appIdWithRecords, pagingRequest)
            {
                FieldIds = { _fieldId },
            };
            var getByAppResponse = await _apiClient.GetRecordsForAppAsync(getByAppRequest);

            AssertHelper.AssertSuccess(getByAppResponse);
            AssertHelper.AssertCasting(getByAppResponse.Value.Items);

            // Query
            var queryRequest = new QueryRecordsRequest
            {
                AppId = _appIdWithRecords,
            };
            var queryResponse = await _apiClient.QueryRecordsAsync(queryRequest);

            AssertHelper.AssertSuccess(queryResponse);
            AssertHelper.AssertCasting(queryResponse.Value.Items);

            // Delete
            // Single delete
            var deleteResponse = await _apiClient.DeleteRecordAsync(_appIdWithRecords, insertResponse.Value.Id);

            AssertHelper.AssertSuccess(deleteResponse);

            // Batch delete
            var batchDeleteRequest  = new DeleteRecordsRequest(_appIdWithRecords, new[] { secondInsertResponse.Value.Id });
            var batchDeleteResponse = await _apiClient.DeleteRecordsAsync(batchDeleteRequest);

            AssertHelper.AssertSuccess(batchDeleteResponse);
        }
        // ------------------------------------ Records ------------------------------------

        #region Records

        /// <summary>
        /// Gets the records associated to an app.
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task <ApiResponse <GetPagedRecordsResponse> > GetRecordsForAppAsync(GetRecordsByAppRequest request)
        {
            Arg.IsNotNull(request, nameof(request));

            var path        = UrlHelper.GetRecordsByAppIdPath(request.AppId, request.FieldIds, request.DataFormat, request.PagingRequest);
            var apiResponse = await GetAsync <GetPagedRecordsResponse>(path);

            return(apiResponse);
        }