/// <summary>
/// Updates the details of the specified contact group and optionally populates the contact group object with the response's body through the use of the entity view query parameter.
/// </summary>
/// <param name="group">The contact group to update.</param>
/// <param name="populate">Indicates if the contact group object should be populated with the response's body through the use of the entity view query parameter.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public Task UpdateGroupAsync(ContactGroup group, bool populate, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(group, nameof(group));
Preconditions.NotNullOrEmpty(group.Id, $"{nameof(group)}.{nameof(group.Id)}");
return(PatchPopulateDirtyAsync(group.Id, JsonStreamContent.Create(group), nameof(UpdateGroupAsync), group.Id, group, populate, cancellationToken));
}
public Task UpdateAttachmentAsync(LoanAttachment attachment, bool populate, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(attachment, nameof(attachment));
Preconditions.NotNullOrEmpty(attachment.AttachmentId, $"{nameof(attachment)}{nameof(attachment.AttachmentId)}");
return(PatchPopulateDirtyAsync(attachment.AttachmentId, JsonStreamContent.Create(attachment), nameof(UpdateAttachmentAsync), attachment.AttachmentId, attachment, populate, cancellationToken));
}
/// <summary>
/// Updates the specified custom data object. This call adds the data provided in the body to the end of the dataObject. Optionally populates the custom data object with the response's body through the use of the entity view query parameter.
/// </summary>
/// <param name="cdo">The custom data object to update.</param>
/// <param name="populate">Indicates if the custom data object should be populated with the response's body through the use of the entity view query parameter.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public Task AppendToCustomDataObjectAsync(CustomDataObject cdo, bool populate, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(cdo, nameof(cdo));
Preconditions.NotNullOrEmpty(cdo.Name, $"{nameof(cdo)}.{nameof(cdo.Name)}");
return(PatchPopulateDirtyAsync(cdo.Name, JsonStreamContent.Create(cdo), nameof(AppendToCustomDataObjectAsync), cdo.Name, cdo, populate, cancellationToken));
}
/// <summary>
/// Submits an order for a service and creates a transaction object and returns the transaction id.
/// </summary>
/// <param name="partnerId">Ellie Mae's unique identifier for the Partner service provider.</param>
/// <param name="parameters">The parameters for ordering a service.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public Task <string> OrderServiceAsync(string partnerId, OrderServiceParameters parameters, CancellationToken cancellationToken = default)
{
Preconditions.NotNullOrEmpty(partnerId, nameof(partnerId));
Preconditions.NotNull(parameters, nameof(parameters));
return(PostAsync($"{partnerId}/transactions", null, JsonStreamContent.Create(parameters), nameof(OrderServiceAsync), partnerId, cancellationToken, ReadLocationFunc));
}
private Task UpdateNoteAsync(ContactNote note, bool populate, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(note, nameof(note));
Preconditions.NotNullOrEmpty(note.NoteId, $"{nameof(note)}.{nameof(note.NoteId)}");
return(PatchPopulateDirtyAsync(note.NoteId, JsonStreamContent.Create(note), nameof(UpdateNoteAsync), note.NoteId, note, populate, cancellationToken));
}
internal Task UpdateCustomFieldAsync(CustomFieldDefinition customField, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(customField, nameof(customField));
Preconditions.NotNullOrEmpty(customField.Id, $"{nameof(customField)}.{nameof(customField.Id)}");
return(PatchAsync(customField.Id, null, JsonStreamContent.Create(customField), nameof(UpdateCustomFieldAsync), customField.Id, cancellationToken));
}
public Task UpdateDocumentAsync(LoanDocument document, bool populate, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(document, nameof(document));
Preconditions.NotNullOrEmpty(document.DocumentId, $"{nameof(document)}.{nameof(document.DocumentId)}");
return(PatchPopulateDirtyAsync(document.DocumentId, JsonStreamContent.Create(document), nameof(UpdateDocumentAsync), document.DocumentId, document, populate, cancellationToken));
}
internal Task UpdateCustomFieldRawAsync(string fieldId, string customField, string queryString = null, CancellationToken cancellationToken = default)
{
Preconditions.NotNullOrEmpty(fieldId, nameof(fieldId));
Preconditions.NotNull(customField, nameof(customField));
return(PatchAsync(fieldId, queryString, JsonStreamContent.Create(customField), nameof(UpdateCustomFieldRawAsync), fieldId, cancellationToken));
}
public Task AssignAssociateAsync(string logId, AssignAssociateParameters parameters, CancellationToken cancellationToken = default)
{
Preconditions.NotNullOrEmpty(logId, nameof(logId));
Preconditions.NotNull(parameters, nameof(parameters));
return(PutAsync(logId, null, JsonStreamContent.Create(parameters), nameof(AssignAssociateAsync), logId, cancellationToken));
}
/// <inheritdoc/>
public Task <MediaUrlObject> GetUploadAttachmentUrlAsync(LoanAttachment attachment, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(attachment, nameof(attachment));
Preconditions.NullOrEmpty(attachment.AttachmentId, $"{nameof(attachment)}.{nameof(attachment.AttachmentId)}");
return(GetUploadAttachmentUrlInternalAsync(null, JsonStreamContent.Create(attachment), nameof(GetUploadAttachmentUrlAsync), cancellationToken, FuncCache <MediaUrlObject> .ReadAsFunc));
}
/// <inheritdoc/>
public Task UpdateMilestoneFreeRoleAsync(LoanMilestoneFreeRole milestoneFreeRole, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(milestoneFreeRole, nameof(milestoneFreeRole));
Preconditions.NotNullOrEmpty(milestoneFreeRole.Id, $"{nameof(milestoneFreeRole)}.{nameof(milestoneFreeRole.Id)}");
return(PatchAsync(milestoneFreeRole.Id, null, JsonStreamContent.Create(milestoneFreeRole), nameof(UpdateMilestoneFreeRoleAsync), milestoneFreeRole.Id, cancellationToken));
}
/// <summary>
/// Creates or replaces a custom data object.
/// </summary>
/// <param name="cdo">The custom data object to create or replace.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public Task CreateOrReplaceCustomDataObjectAsync(CustomDataObject cdo, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(cdo, nameof(cdo));
Preconditions.NotNullOrEmpty(cdo.Name, $"{nameof(cdo)}.{nameof(cdo.Name)}");
return(PutAsync(cdo.Name, null, JsonStreamContent.Create(cdo), nameof(CreateOrReplaceCustomDataObjectAsync), cdo.Name, cancellationToken));
}
public Task <LoanPipelineCursor> CreateCursorAsync(PipelineParameters parameters, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(parameters, nameof(parameters));
var queryParameters = new QueryParameters(
new QueryParameter("limit", "1"),
new QueryParameter("cursorType", "randomAccess"));
return(PostAsync(null, queryParameters.ToString(), JsonStreamContent.Create(parameters), nameof(CreateCursorAsync), null, cancellationToken, async response =>
{
var headers = response.Headers;
const string countHeaderName = "x-total-count";
if (!headers.TryGetValues(countHeaderName, out var counts))
{
throw await EncompassRestException.CreateAsync($"{nameof(CreateCursorAsync)} missing {countHeaderName} header", response).ConfigureAwait(false);
}
var countString = counts.First();
if (!int.TryParse(countString, out var count) || count < 0)
{
throw await EncompassRestException.CreateAsync($"{nameof(CreateCursorAsync)} invalid {countHeaderName} header value", response).ConfigureAwait(false);
}
if (count == 0)
{
return null;
}
const string cursorIdHeaderName = "x-cursor";
if (!headers.TryGetValues(cursorIdHeaderName, out var cursorIds))
{
throw await EncompassRestException.CreateAsync($"{nameof(CreateCursorAsync)} missing {cursorIdHeaderName} header", response).ConfigureAwait(false);
}
var cursorId = cursorIds.First();
return new LoanPipelineCursor(Client, cursorId, count, parameters.Fields);
}));
}
/// <inheritdoc/>
public Task <string> ConfirmRateLockRequestRawAsync(string requestId, string lockRequest, string?queryString = null, CancellationToken cancellationToken = default)
{
Preconditions.NotNullOrEmpty(requestId, nameof(requestId));
Preconditions.NotNullOrEmpty(lockRequest, nameof(lockRequest));
return(PutRawAsync($"{requestId}/confirmation", queryString, JsonStreamContent.Create(lockRequest), nameof(ConfirmRateLockRequestRawAsync), requestId, cancellationToken));
}
/// <inheritdoc/>
public Task UpdateRateLockRequestAsync(RateLockRequest lockRequest, bool populate, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(lockRequest, nameof(lockRequest));
Preconditions.NotNullOrEmpty(lockRequest.Id, nameof(lockRequest.Id));
return(PatchPopulateDirtyAsync(lockRequest.Id, JsonStreamContent.Create(lockRequest), nameof(UpdateRateLockRequestAsync), lockRequest.Id, lockRequest, populate, cancellationToken));
}
/// <summary>
/// Preview calculations for a loan. This API calculates fields similar to the calculations performed in Update Loan, however, the transient calculations provide a preview and do not save to the loan file.
/// </summary>
/// <param name="loan">The loan to recalculate.</param>
/// <param name="entities">The list of loan entities to populate for the loan.</param>
/// <param name="calcAllOnly">Indicates whether calculations will be executed for all fields. The default is <c>true</c>.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public Task CalculateLoanAsync(Loan loan, IEnumerable <string> entities, bool?calcAllOnly, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(loan, nameof(loan));
Preconditions.NotNullOrEmpty(loan.EncompassId, $"{nameof(loan)}.{nameof(loan.EncompassId)}");
var queryParameters = new QueryParameters();
if (calcAllOnly.HasValue)
{
queryParameters.Add(nameof(calcAllOnly), calcAllOnly.ToString().ToLower());
}
var body = new CalculateLoanBody {
LoanData = loan, Entities = entities
};
loan.Initialize(Client, loan.EncompassId);
return(PostAsync("loan", queryParameters.ToString(), JsonStreamContent.Create(body), nameof(CalculateLoanAsync), loan.EncompassId, cancellationToken, async(HttpResponseMessage response) =>
{
var loanAsJson = loan.ToString(SerializationOptions.Dirty);
await response.Content.PopulateAsync(loan).ConfigureAwait(false);
loan.Dirty = false;
// Repopulate with original dirty loan to maintain loan dirtiness.
// This may overwrite calculated values but they shouldn't have been dirty to begin with if they're calculated values.
JsonHelper.PopulateFromJson(loanAsJson, loan);
return string.Empty;
}));
}
private Task UpdateNoteAsync(ContactNote note, bool populate, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(note, nameof(note));
Preconditions.NotNullOrEmpty(note.NoteId, $"{nameof(note)}.{nameof(note.NoteId)}");
note.Dirty = true; // To be removed if Ellie Mae updates API to only update provided properties.
return(PatchPopulateDirtyAsync(note.NoteId, JsonStreamContent.Create(note), nameof(UpdateNoteAsync), note.NoteId, note, populate, cancellationToken));
}
private Task UpdateContactAsync(TContact contact, bool populate, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(contact, nameof(contact));
Preconditions.NotNullOrEmpty(contact.Id, $"{nameof(contact)}.{nameof(contact.Id)}");
contact.Initialize(Client, contact.Id);
return(PatchPopulateDirtyAsync(contact.Id, JsonStreamContent.Create(contact), nameof(UpdateContactAsync), contact.Id, contact, populate, cancellationToken));
}
/// <inheritdoc/>
public Task AssignAssociateAsync(string logId, LoanAssociate associate, CancellationToken cancellationToken = default)
{
Preconditions.NotNullOrEmpty(logId, nameof(logId));
Preconditions.NotNull(associate, nameof(associate));
Preconditions.NotNullOrEmpty(associate.Id, $"{nameof(associate)}.{nameof(associate.Id)}");
Preconditions.NotNullOrEmpty(associate.LoanAssociateType.Value, $"{nameof(associate)}.{nameof(associate.LoanAssociateType)}");
return(PutAsync(logId, null, JsonStreamContent.Create(associate), nameof(AssignAssociateAsync), logId, cancellationToken));
}
private Task UpdateContactAsync(TContact contact, bool populate, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(contact, nameof(contact));
Preconditions.NotNullOrEmpty(contact.Id, $"{nameof(contact)}.{nameof(contact.Id)}");
contact.Initialize(Client, contact.Id);
contact.Dirty = true; // To be removed if Ellie Mae updates API to only update provided properties.
return(PatchPopulateDirtyAsync(contact.Id, JsonStreamContent.Create(contact), nameof(UpdateContactAsync), contact.Id, contact, populate, cancellationToken));
}
/// <summary>
/// Adds or removes contacts in a contact group.
/// </summary>
/// <param name="groupId">The unique identifier of the contact group to update.</param>
/// <param name="action">Whether to add or remove the contact.</param>
/// <param name="contacts">The contacts to add or remove.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public Task AssignGroupContactsAsync(string groupId, string action, IEnumerable <EntityReference> contacts, CancellationToken cancellationToken = default)
{
Preconditions.NotNullOrEmpty(groupId, nameof(groupId));
Preconditions.NotNullOrEmpty(action, nameof(action));
Preconditions.NotNullOrEmpty(contacts, nameof(contacts));
var queryParameters = new QueryParameters(new QueryParameter(nameof(action), action));
return(PatchAsync($"{groupId}/contacts", queryParameters.ToString(), JsonStreamContent.Create(contacts), nameof(AssignGroupContactsAsync), groupId, cancellationToken));
}
/// <inheritdoc/>
public Task <RateLockRequest> DenyRateLockRequestAsync(string requestId, RateLockCancelDenyOptions?denialOptions = null, CancellationToken cancellationToken = default)
{
Preconditions.NotNullOrEmpty(requestId, nameof(requestId));
denialOptions = denialOptions ?? new RateLockCancelDenyOptions();
var queryParameters = new QueryParameters();
queryParameters.Add("view", "entity");
return(PutAsync($"{requestId}/denial", queryParameters.ToString(), JsonStreamContent.Create(denialOptions), nameof(DenyRateLockRequestAsync), requestId, cancellationToken, FuncCache <RateLockRequest> .ReadAsFunc));
}
/// <inheritdoc/>
public Task UpdateMilestoneAsync(LoanMilestone milestone, string?action, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(milestone, nameof(milestone));
Preconditions.NotNullOrEmpty(milestone.Id, $"{nameof(milestone)}.{nameof(milestone.Id)}");
var queryParameters = new QueryParameters();
if (!string.IsNullOrEmpty(action))
{
queryParameters.Add("action", action);
}
return(PatchAsync(milestone.Id, queryParameters.ToString(), JsonStreamContent.Create(milestone), nameof(UpdateMilestoneAsync), milestone.Id, cancellationToken));
}
/// <summary>
/// Updates an existing loan by modifying the values of the loan data elements passed with the optionally specified <paramref name="updateLoanOptions"/>.
/// </summary>
/// <param name="loan">The loan to update.</param>
/// <param name="updateLoanOptions">The loan update options.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public async Task UpdateLoanAsync(Loan loan, UpdateLoanOptions updateLoanOptions, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(loan, nameof(loan));
Preconditions.NotNullOrEmpty(loan.EncompassId, $"{nameof(loan)}.{nameof(loan.EncompassId)}");
loan.Initialize(Client, loan.EncompassId);
HttpContent content;
if (updateLoanOptions?.Persistent == false)
{
var body = loan.ToJson();
content = new JsonStringContent(body);
}
else
{
var transientLoanUpdates = loan.TransientLoanUpdates;
if (transientLoanUpdates?.Count > 0)
{
foreach (var transientLoanUpdate in transientLoanUpdates)
{
await PatchAsync(loan.EncompassId, transientLoanUpdate.QueryString, new JsonStringContent(transientLoanUpdate.Body), nameof(UpdateLoanAsync), loan.EncompassId, cancellationToken).ConfigureAwait(false);
}
transientLoanUpdates.Clear();
}
content = JsonStreamContent.Create(loan);
}
await PatchAsync(loan.EncompassId, updateLoanOptions?.ToQueryParameters().ToString(), content, nameof(UpdateLoanAsync), loan.EncompassId, cancellationToken, async (HttpResponseMessage response) =>
{
if (updateLoanOptions?.Populate == true)
{
await response.Content.PopulateAsync(loan).ConfigureAwait(false);
}
loan.Dirty = false;
if (updateLoanOptions?.Persistent == false)
{
var transientLoanUpdates = loan.TransientLoanUpdates;
if (transientLoanUpdates == null)
{
transientLoanUpdates = new List <Loan.TransientLoanUpdate>();
loan.TransientLoanUpdates = transientLoanUpdates;
}
transientLoanUpdates.Add(new Loan.TransientLoanUpdate {
Body = ((JsonStringContent)content).Json, QueryString = updateLoanOptions.ToQueryParameters(true).ToString()
});
}
return(string.Empty);
}).ConfigureAwait(false);
}
/// <summary>
/// Retrieves the contact IDs and specified fields for the contacts specified.
/// </summary>
/// <param name="parameters">The contact list parameters used to specify the contacts and fields to include.</param>
/// <param name="start">Starting index or record number from which to retrieve the contacts. The default is 1.</param>
/// <param name="limit">The maximum number of records to return in a page. Response size is limited to 6 MB and is recalculated if the response exceeds 6 MB. The default value is 1000. The maximum value is limited to 10000.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public Task <List <ContactData> > GetContactListAsync(ContactListParameters parameters, int?start = null, int?limit = null, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(parameters, nameof(parameters));
var queryParameters = new QueryParameters();
if (start.HasValue)
{
queryParameters.Add("start", start.ToString());
}
if (limit.HasValue)
{
queryParameters.Add("limit", limit.ToString());
}
return(PostAsync <List <ContactData> >(null, queryParameters.ToString(), JsonStreamContent.Create(parameters), nameof(GetContactListAsync), null, cancellationToken));
}
/// <inheritdoc/>
public Task <string> GetItemsRawAsync(int start, int?limit, IEnumerable <string>?fields, CancellationToken cancellationToken = default)
{
Preconditions.GreaterThanOrEquals(start, nameof(start), 0);
Preconditions.LessThan(start, nameof(start), Count, nameof(Count));
if (limit.HasValue)
{
Preconditions.GreaterThan(limit.GetValueOrDefault(), nameof(limit), 0);
}
var queryParameters = new QueryParameters(
new QueryParameter("cursor", CursorId),
new QueryParameter("start", start.ToString()));
if (limit.HasValue)
{
queryParameters.Add("limit", limit.ToString());
}
var content = JsonStreamContent.Create(new { Fields = fields ?? Fields });
return(_apiObject.PostRawAsync(null, queryParameters.ToString(), content, nameof(GetItemsRawAsync), null, cancellationToken));
}
/// <summary>
/// Updates an existing loan by modifying the values of the loan data elements passed with the optionally specified <paramref name="updateLoanOptions"/>.
/// </summary>
/// <param name="loan">The loan to update.</param>
/// <param name="updateLoanOptions">The loan update options.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public Task UpdateLoanAsync(Loan loan, UpdateLoanOptions updateLoanOptions, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(loan, nameof(loan));
Preconditions.NotNullOrEmpty(loan.EncompassId, $"{nameof(loan)}.{nameof(loan.EncompassId)}");
loan.Initialize(Client, loan.EncompassId);
return(PatchPopulateDirtyAsync(loan.EncompassId, updateLoanOptions?.ToQueryParameters().ToString(), JsonStreamContent.Create(loan), nameof(UpdateLoanAsync), loan.EncompassId, loan, updateLoanOptions?.Populate == true, cancellationToken));
}
/// <summary>
/// Submits a batch request to the server to update multiple loans and returns the batch update request id.
/// </summary>
/// <param name="parameters">The batch update parameters.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public Task <string> UpdateLoansAsync(BatchUpdateParameters parameters, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(parameters, nameof(parameters));
return(PostAsync(null, null, JsonStreamContent.Create(parameters), nameof(UpdateLoansAsync), null, cancellationToken, ReadLocationFunc));
}
public Task <List <LoanPipelineData> > ViewPipelineAsync(PipelineParameters parameters, int?limit, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(parameters, nameof(parameters));
if (limit.HasValue)
{
Preconditions.GreaterThan(limit.GetValueOrDefault(), nameof(limit), 0);
}
var queryParameters = new QueryParameters();
if (limit.HasValue)
{
queryParameters.Add(new QueryParameter("limit", limit.GetValueOrDefault().ToString()));
}
return(PostAsync <List <LoanPipelineData> >(null, queryParameters.ToString(), JsonStreamContent.Create(parameters), nameof(ViewPipelineAsync), null, cancellationToken));
}
/// <summary>
/// Sends an HTTP PUT request to the specified <paramref name="uri"/> with the specified json serializable <paramref name="content"/> and returns the response body as a <typeparamref name="TResponse"/>.
/// </summary>
/// <typeparam name="TResponse">The anonymous type to return. This can't be specified traditionally and must be inferred from the anonymous type passed as a parameter.</typeparam>
/// <param name="uri">The request uri including any query parameters.</param>
/// <param name="content">The json serializable content to send.</param>
/// <param name="anonymousTypeObject">The anonymous type object.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
#pragma warning disable IDE0060 // Remove unused parameter
public Task <TResponse> PutAnonymousTypeAsync <TResponse>(string uri, object content, TResponse anonymousTypeObject, CancellationToken cancellationToken = default) => PutAsync(uri, null, JsonStreamContent.Create(content), nameof(PutAnonymousTypeAsync), null, cancellationToken, FuncCache <TResponse> .ReadAsFunc);
