LargeDataSubResource.cs

Go to the documentation of this file.

using System.Collections.Generic;
using RestSharp;
 
namespace AnalyzeRe.APITypes
{
    public class LargeDataSubResource : DataSubResource
    {
        #region Private Fields
        private CommandSubResource _commit;
        private SubResource<LargeDataUpload.StatusResponse> _status;
        #endregion Private Fields
 
        #region Public SubResources
        public CommandSubResource commit => _commit ?? (_commit = new CommandSubResource(this, "commit"));
 
        public SubResource<LargeDataUpload.StatusResponse> status => _status ??
            (_status = new SubResource<LargeDataUpload.StatusResponse>(this, "status"));
        #endregion Public SubResources
 
        #region Constructors
        public LargeDataSubResource(IAPIResource_WithDataEndpoint owner) : base(owner, "data") { }
        #endregion Constructors
 
        #region REST Methods
        public void UploadString(string data, LargeDataUpload.Parameters parameters = null)
        {
            ValidateOwnerHasId();
            this.LargeStreamUpload(
                LargeDataUpload.Utilities.GetStringStream(data), parameters, data.Length);
        }
 
        public void Post(long? totalSizeBytes, int? timeout = null)
        {
            ValidateOwnerHasId();
            IEnumerable<Parameter> header = totalSizeBytes.HasValue ?
                API.Parameters.DataEntityLength(totalSizeBytes.Value) : null;
            API.RequestAndParse<string>(Path, Method.POST, header, timeout ?? DefaultTimeout);
        }
 
        public void Patch(string data, long bytesOffset, int? timeout = null,
            IEnumerable<Parameter> requestParameters = null)
        {
            ValidateOwnerHasId();
            IEnumerable<Parameter> patchParameters = API.Parameters.DataPatchChunk(bytesOffset, data)
                .AddParameters(requestParameters);
            PatchHelper(patchParameters, timeout);
        }
 
        public void Patch(byte[] data, int count, long bytesOffset, int? timeout = null,
            IEnumerable<Parameter> requestParameters = null)
        {
            ValidateOwnerHasId();
            IEnumerable<Parameter> patchParameters =
                API.Parameters.DataPatchChunk(bytesOffset, data, count)
                .AddParameters(requestParameters);
            PatchHelper(patchParameters, timeout);
        }
 
        // Helper method for the two PATCH variations
        private void PatchHelper(IEnumerable<Parameter> patchParameters, int? timeout)
        {
            API.RequestAndParse<string>(Path, Method.PATCH, patchParameters, timeout ?? DefaultTimeout);
        }
 
        public IRestResponse Head(int? timeout = null)
        {
            ValidateOwnerHasId();
            return API.ExecuteRestRequest(Path, Method.HEAD, timeout: timeout ?? DefaultTimeout);
        }
 
        public void Delete(int? timeout = null, IEnumerable<Parameter> requestParameters = null)
        {
            ValidateOwnerHasId();
            API.RequestAndParse<string>(Path, Method.DELETE, requestParameters, timeout ?? DefaultTimeout);
        }
        #endregion REST Methods
    }
}