public async Task <dynamic> CreateDocument(byte[] fileContent, string documentJson)
{
var document = JsonConvert.DeserializeObject <CreateDocumentRequest>(documentJson);
using (var client = SetApiKey())
{
var response = await client.CreateDocument(fileContent, documentJson);
if (!string.IsNullOrEmpty(response.Uuid))
{
var sendRequest = new SendDocumentRequest
{
Message = "Please sign this document",
Silent = document.DisableEmail
};
Thread.Sleep(3000);
var sendDocResponse = await client.SendDocument(response.Uuid, sendRequest);
var detailResponse = client.GetDocumentDetail(response.Uuid);
return(detailResponse);
}
else
{
return(null);
}
}
}
public async Task <PandaDocHttpResponse <GetDocumentResponse> > CreateDocument(byte[] fileContent, CreateDocumentRequest request)
{
var sharedDocuments = new List <ShareDocumentResponse>();
using (var client = SetApiKey())
{
if (request == null)
{
request = CreateDocumentRequest();
}
var response = await client.CreateDocument(fileContent, request);
if (!string.IsNullOrEmpty(response.Uuid))
{
var sendRequest = new SendDocumentRequest
{
Message = "Please sign this document"
};
var sendDocResponse = await client.SendDocument(response.Uuid, sendRequest);
var getDocResponse = await client.GetDocument(response.Uuid);
return(getDocResponse);
}
else
{
return(null);
}
}
}
public async Task SendDocumentAsync_Multiple()
{
var file1 = Path.Combine(TestContext.CurrentContext.WorkDirectory, "Resources", "word-2-pages.pdf");
await using var fileStream1 = new FileStream(file1, FileMode.Open, FileAccess.Read);
var file2 = Path.Combine(TestContext.CurrentContext.WorkDirectory, "Resources", "word-2-pages.pdf");
await TestJobRequestAsync(async jobId =>
{
await using var fileStream2 = new FileStream(file2, FileMode.Open, FileAccess.Read);
var request1 = new SendDocumentRequest
{
PrinterUri = Options.Value.PrinterUrl, JobId = jobId, Document = fileStream1
};
var request2 = new SendDocumentRequest
{
PrinterUri = Options.Value.PrinterUrl, JobId = jobId, Document = fileStream2
};
await TestRequestAsync(request1, (client, r) =>
{
r.JobId = jobId;
return(client.SendDocumentAsync(r));
});
return(await TestRequestAsync(request2, (client, r) =>
{
r.JobId = jobId;
return client.SendDocumentAsync(r);
}));
});
}
/// <summary>
/// Print-Job Request
/// https://tools.ietf.org/html/rfc2911#section-3.2.1.1
/// </summary>
/// <param name="request"></param>
public IppRequestMessage Construct(SendDocumentRequest request)
{
if (request.Document == null && !request.LastDocument)
{
throw new ArgumentException($"{nameof(request.Document)} must be set for non-last document");
}
return(ConstructIppRequest(request));
}
public async Task SendDocumentAsync_LastDocument()
{
await TestJobRequestAsync(async jobId =>
{
var request = new SendDocumentRequest
{
PrinterUri = Options.Value.PrinterUrl, JobId = jobId, LastDocument = true
};
return(await TestJobRequestAsync(request, (client, r) => client.SendDocumentAsync(r)));
});
}
public void SendDocumentAsync_Simple()
{
var file = Path.Combine(TestContext.CurrentContext.WorkDirectory, "Resources", "word-2-pages.pdf");
using var fileStream = new FileStream(file, FileMode.Open, FileAccess.Read);
var request = new SendDocumentRequest {
PrinterUri = PrinterUrl, JobId = JobId, Document = fileStream
};
var result = _protocol.Construct(request);
CheckResult(result);
}
public async Task <SendDocumentResponse> SendDocument(string uuid, SendDocumentRequest request)
{
HttpContent httpContent = new StringContent(JsonConvert.SerializeObject(request), UnicodeEncoding.UTF8, "application/json");
HttpResponseMessage httpResponse = await httpClient.PostAsync(ESignConfig.PandaDocApiUrl + "/public/v1/documents/" + uuid + "/send", httpContent);
//PandaDocHttpResponse<SendDocumentResponse> response = await httpResponse.ToPandaDocResponseAsync<SendDocumentResponse>();
var response = await httpResponse.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <SendDocumentResponse>(response));
}
public async Task SendDocumentAsync_Simple()
{
var file = Path.Combine(TestContext.CurrentContext.WorkDirectory, "Resources", "word-2-pages.pdf");
await using var fileStream = new FileStream(file, FileMode.Open, FileAccess.Read);
await TestJobRequestAsync(async jobId =>
{
var request = new SendDocumentRequest
{
PrinterUri = Options.Value.PrinterUrl, JobId = jobId, Document = fileStream
};
return(await TestJobRequestAsync(request, (client, r) => client.SendDocumentAsync(r)));
});
}
public async Task <PandaDocSignerHttpResponse <GetDocumentResponse> > CreateDocument(string filePath, CreateDocumentRequest request)
{
var sharedDocuments = new List <ShareDocumentResponse>();
using (var client = SetApiKey())
{
if (request == null)
{
request = CreateDocumentRequest();
}
var response = await client.CreateDocument(filePath, request);
if (!string.IsNullOrEmpty(response.Uuid))
{
var sendRequest = new SendDocumentRequest
{
Message = "Please sign this document"
};
var sendDocResponse = await client.SendDocument(response.Uuid, sendRequest);
var getDocResponse = await client.GetDocument(response.Uuid);
return(getDocResponse);
}
else
{
return(null);
}
//foreach (var recipient in request.Recipients)
//{
// var shareRequest = new ShareDocumentRequest
// {
// Recipient = recipient.Email,
// LifeTime = 90000
// };
// var shareDocResponse = await client.ShareDocument(response.Uuid, shareRequest);
// shareDocResponse.Value.Recipient = recipient.Email;
// sharedDocuments.Add(shareDocResponse.Value);
//}
}
// return sharedDocuments;
}
public async void SendDocument()
{
using (PandaDocHttpClient client = await EnsureLoggedIn())
{
var createRequest = CreateDocumentRequest();
var createResponse = await client.CreateDocument(createRequest);
Console.WriteLine("Document '{0}' was uploaded", createResponse.Value.Uuid);
// we have to wait for the document to move from document.uploaded to document.draft before you can send it.
var attempts = 0;
while (true)
{
var getResponse = await client.GetDocument(createResponse.Value.Uuid);
if (getResponse.Value.DocumentStatus == DocumentStatus.Draft)
{
Console.WriteLine("Document '{0}' has moved to draft", createResponse.Value.Uuid);
break;
}
await Task.Delay(1000);
attempts++;
if (attempts == 5)
{
Assert.Fail();
}
}
var sendRequest = new SendDocumentRequest
{
Message = "Please sign this document"
};
PandaDocHttpResponse <SendDocumentResponse> response = await client.SendDocument(createResponse.Value.Uuid, sendRequest);
response.AssertOk();
Console.WriteLine("Document '{0}' was sent", response.Value.Uuid);
}
}
public static async Task <Message> SendDocumentAsync(this Telegram telegram, SendDocumentRequest sendRequest, string file = null)
{
var result = new Message();
if (string.IsNullOrEmpty(file) &&
string.IsNullOrEmpty(sendRequest.Document))
{
return(null);
}
var url = telegram.GetFullPathUrl("sendDocument");
using (var form = new MultipartFormDataContent())
{
AddParametersToRequest(form, sendRequest);
using (var fileStream = new FileStream(file, FileMode.Open, FileAccess.Read))
{
if (!string.IsNullOrEmpty(file))
{
form.Add(new StreamContent(fileStream), "document", Path.GetFileName(file));
}
using (var client = new HttpClient())
{
var responseHendler = await client.PostAsync(url, form);
if (responseHendler != null)
{
var response = await responseHendler.Content.ReadAsStringAsync();
if (!string.IsNullOrEmpty(response))
{
result = Newtonsoft.Json.JsonConvert.DeserializeObject <ResponseAnswer <Message> >(response).Result;
}
}
}
}
}
return(result);
}
public void SendDocumentAsync_Full()
{
var file = Path.Combine(TestContext.CurrentContext.WorkDirectory, "Resources", "word-2-pages.pdf");
using var fileStream = new FileStream(file, FileMode.Open, FileAccess.Read);
var request = new SendDocumentRequest
{
PrinterUri = PrinterUrl,
JobId = JobId,
Document = fileStream,
DocumentAttributes = new DocumentAttributes
{
DocumentName = "Document Name",
DocumentFormat = "application/octet-stream",
DocumentNaturalLanguage = "en"
}
};
var result = _protocol.Construct(request);
CheckResult(result);
}
public async Task SendDocumentAsync_Full()
{
var file = Path.Combine(TestContext.CurrentContext.WorkDirectory, "Resources", "word-2-pages.pdf");
await using var fileStream = new FileStream(file, FileMode.Open, FileAccess.Read);
await TestJobRequestAsync(async jobId =>
{
var request = new SendDocumentRequest
{
PrinterUri = Options.Value.PrinterUrl,
JobId = jobId,
Document = fileStream,
DocumentAttributes = new DocumentAttributes
{
DocumentName = "Document Name",
DocumentFormat = "application/octet-stream",
DocumentNaturalLanguage = "en"
}
};
return(await TestJobRequestAsync(request, (client, r) => client.SendDocumentAsync(r)));
});
}
/// <summary>
/// Sends a single document to a citizen/company.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='subscriptionId'>
/// Id of LoGIC subscription
/// </param>
/// <param name='request'>
/// Request body
/// </param>
public static object SendDocument(this IInternalClient operations, System.Guid subscriptionId, SendDocumentRequest request = default(SendDocumentRequest))
{
return(operations.SendDocumentAsync(subscriptionId, request).GetAwaiter().GetResult());
}
public SendDocumentResponse SendDocument(SendDocumentRequest sendDocumentRequest)
{
return(SendDocumentResponse.Parse(ExecuteAction(sendDocumentRequest)));
}
public SendDocumentResponse SendDocument(SendDocumentRequest sendDocumentRequest)
{
Log.Info(nameof(SendDocument));
return(SendDocumentResponse.Parse(ExecuteAction(sendDocumentRequest)));
}
/// <summary>
/// Send-Document Operation
/// https://tools.ietf.org/html/rfc2911#section-3.3.1
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <SendDocumentResponse> SendDocumentAsync(SendDocumentRequest request)
{
return(await SendAsync(request.PrinterUri, () => _ippProtocol.Construct(request),
ippResponse => _ippProtocol.ConstructSendDocumentResponse(ippResponse)));
}
public async void SendDocument()
{
using (PandaDocHttpClient client = await EnsureLoggedIn())
{
var createRequest = CreateDocumentRequest();
var createResponse = await client.CreateDocument(createRequest);
Console.WriteLine("Document '{0}' was uploaded", createResponse.Value.Uuid);
// we have to wait for the document to move from document.uploaded to document.draft before you can send it.
var attempts = 0;
while (true)
{
var getResponse = await client.GetDocument(createResponse.Value.Uuid);
if (getResponse.Value.DocumentStatus == DocumentStatus.Draft)
{
Console.WriteLine("Document '{0}' has moved to draft", createResponse.Value.Uuid);
break;
}
await Task.Delay(1000);
attempts++;
if (attempts == 5)
{
Assert.Fail();
}
}
var sendRequest = new SendDocumentRequest
{
Message = "Please sign this document"
};
PandaDocHttpResponse<SendDocumentResponse> response = await client.SendDocument(createResponse.Value.Uuid, sendRequest);
response.AssertOk();
Console.WriteLine("Document '{0}' was sent", response.Value.Uuid);
}
}
/// <summary>
/// Sends a single document to a citizen/company.
/// </summary>
/// <param name='subscriptionId'>
/// Id of LoGIC subscription
/// </param>
/// <param name='request'>
/// Request body
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="HttpOperationException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <HttpOperationResponse <SendMessageResponse> > SendSingleDocumentWithHttpMessagesAsync(System.Guid subscriptionId, SendDocumentRequest request = default(SendDocumentRequest), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("subscriptionId", subscriptionId);
tracingParameters.Add("request", request);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "SendSingleDocument", tracingParameters);
}
// Construct URL
var _baseUrl = BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/digital-post/documents").ToString();
_url = _url.Replace("{subscriptionId}", System.Uri.EscapeDataString(SafeJsonConvert.SerializeObject(subscriptionId, SerializationSettings).Trim('"')));
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (request != null)
{
_requestContent = SafeJsonConvert.SerializeObject(request, SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json-patch+json; charset=utf-8");
}
// Set Credentials
if (Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200 && (int)_statusCode != 400 && (int)_statusCode != 401)
{
var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
if (_httpResponse.Content != null)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
}
else
{
_responseContent = string.Empty;
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse <SendMessageResponse>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <SendMessageResponse>(_responseContent, DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
/// <summary>
/// Sends a single document to a citizen/company.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='subscriptionId'>
/// Id of LoGIC subscription
/// </param>
/// <param name='request'>
/// Request body
/// </param>
public static SendMessageResponse SendSingleDocument(this IDigitalPostClient operations, System.Guid subscriptionId, SendDocumentRequest request = default(SendDocumentRequest))
{
return(operations.SendSingleDocumentAsync(subscriptionId, request).GetAwaiter().GetResult());
}
public async Task<PandaDocHttpResponse<SendDocumentResponse>> SendDocument(string uuid, SendDocumentRequest request)
{
HttpContent httpContent = new ObjectContent<SendDocumentRequest>(request, JsonFormatter);
HttpResponseMessage httpResponse = await httpClient.PostAsync(settings.ApiUri + "public/v1/documents/" + uuid + "/send", httpContent);
PandaDocHttpResponse<SendDocumentResponse> response = await httpResponse.ToPandaDocResponseAsync<SendDocumentResponse>();
return response;
}
/// <summary>
/// Sends a single document to a citizen/company.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='subscriptionId'>
/// Id of LoGIC subscription
/// </param>
/// <param name='request'>
/// Request body
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> SendDocumentAsync(this IInternalClient operations, System.Guid subscriptionId, SendDocumentRequest request = default(SendDocumentRequest), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.SendDocumentWithHttpMessagesAsync(subscriptionId, request, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public async Task <PandaDocHttpResponse <SendDocumentResponse> > SendDocument(string uuid, SendDocumentRequest request)
{
HttpContent httpContent = new ObjectContent <SendDocumentRequest>(request, JsonFormatter);
HttpResponseMessage httpResponse = await httpClient.PostAsync(settings.ApiUri + "public/v1/documents/" + uuid + "/send", httpContent);
PandaDocHttpResponse <SendDocumentResponse> response = await httpResponse.ToPandaDocResponseAsync <SendDocumentResponse>();
return(response);
}
public SendDocumentResponse SendDocument(SendDocumentRequest sendDocumentRequest)
{
return SendDocumentResponse.Parse(ExecuteAction(sendDocumentRequest));
}
