public async Task <IActionResult> GenerateFromDraftAsync([FromBody] UpdateInvoiceModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponse.Create("Invalid model.", ModelState)));
}
IInvoice invoice;
try
{
invoice = await _invoiceService.GenerateFromDraftAsync(Mapper.Map <Invoice>(model));
}
catch (InvoiceNotFoundException exception)
{
await _log.WriteErrorAsync(nameof(InvoiceController), nameof(GenerateFromDraftAsync),
model.ToContext(), exception);
return(NotFound(ErrorResponse.Create(exception.Message)));
}
catch (InvalidOperationException exception)
{
await _log.WriteErrorAsync(nameof(InvoiceController), nameof(GenerateFromDraftAsync),
model.ToContext(), exception);
return(BadRequest(ErrorResponse.Create(exception.Message)));
}
return(Ok(Mapper.Map <InvoiceModel>(invoice)));
}
public async Task <bool> UpdateStatusList(UpdateInvoiceModel model)
{
var response = await flurlClient.Request($"/v1/outboxinvoice/updatestatuslist")
.PutJsonAsync(model);
return(response.IsSuccessStatusCode);
}
public async Task <bool> SendOrRemoveArchive(UpdateInvoiceModel model)
{
var response = await flurlClient.Request($"/v1/inboxinvoice/sendorremovearchivelist")
.PutJsonAsync(model);
return(response.IsSuccessStatusCode);
}
public static UpdateInvoiceModel Sanitize(this UpdateInvoiceModel model)
{
model.ClientEmail = model.ClientEmail.SanitizeEmail();
model.ClientName = model.ClientName.Sanitize();
return(model);
}
public async Task <IActionResult> UpdateAsync([FromBody] UpdateInvoiceModel model)
{
try
{
model.ValidateDueDate();
var invoice = Mapper.Map <Invoice>(model);
await _invoiceService.UpdateDraftAsync(invoice);
return(NoContent());
}
catch (InvoiceDueDateException ex)
{
_log.WarningWithDetails(ex.Message, model.Sanitize());
return(BadRequest(ErrorResponse.Create(ex.Message)));
}
catch (InvoiceNotFoundException ex)
{
_log.WarningWithDetails(ex.Message, model.Sanitize());
return(NotFound(ErrorResponse.Create("Invoice with such Id and MerchantId not found")));
}
catch (InvalidOperationException ex)
{
_log.WarningWithDetails(ex.Message, model.Sanitize());
return(BadRequest(ErrorResponse.Create(ex.Message)));
}
}
public static string ToContext(this UpdateInvoiceModel model)
{
var context = Mapper.Map <UpdateInvoiceModel>(model);
context.ClientEmail = context.ClientEmail.SanitizeEmail();
return(context.ToJson());
}
public static UpdateInvoiceModel Sanitize(this UpdateInvoiceModel model)
{
var context = Mapper.Map <UpdateInvoiceModel>(model);
context.ClientEmail = context.ClientEmail?.SanitizeEmail();
context.ClientName = context.ClientName?.Sanitize();
return(context);
}
public Task <Result <InvoiceCoreModel> > Edit(UpdateInvoiceModel model)
=> Result <InvoiceCoreModel> .TryAsync(async() =>
{
var invoice = (await _repository.FirstOrDefaultAsync <Invoice>(i => i.Id == model.Id, i => i.UserSurvey))
.Data;
if (invoice == null)
{
return(Result <InvoiceCoreModel> .Failed(Error.WithData(1000, new[] { "invoice not found " })));
}
var profile =
await _membershipServiceApi.AuthAuthApiService.Profile(new BaseModel {
Id = invoice.UserId
});
if (model.Status != (InvoiceStatus)invoice.Status && model.Status == InvoiceStatus.Pending &&
model.Enabled)
{
_coreSmtpClient.SendInvoiceReady(profile.Data.Email, profile.Data.Firstname + " " + profile.Data.Lastname);
}
invoice.Amount = model.Amount + model.Amount * 5 / 100;
invoice.TaxAmount = model.Amount * 5 / 100;
invoice.Title = model.Title;
invoice.Description = model.Description;
invoice.Amount = model.Amount;
if (model.Status == InvoiceStatus.Paid)
{
invoice.IsPaid = true;
if (invoice.UserSurvey.Any())
{
_coreSmtpClient.SendPaysForInvoicesNotif("*****@*****.**",
profile.Data.Username,
DateTime.Now.ToString("F"));
}
}
invoice.Status = (byte)model.Status;
invoice.Enabled = model.Enabled;
await _repository.CommitAsync();
return(Result <InvoiceCoreModel> .Successful(_autoMapper.Map <InvoiceCoreModel>(invoice)));
});
public async Task UpdateAsync(UpdateInvoiceModel model, bool draft)
{
model.PaymentAssetId = _lykkeAssetsResolver.GetInvoiceCreationPair(model.SettlementAssetId);
try
{
await _payInvoiceClient.UpdateDraftInvoiceAsync(model);
if (!draft)
{
await _payInvoiceClient.CreateInvoiceAsync(model.Id);
}
}
catch (ErrorResponseException ex)
{
_log.ErrorWithDetails(ex, new { model = model.Sanitize(), draft });
throw new InvalidOperationException(ex.Message);
}
}
public async Task <InvoiceModel> GenerateInvoiceFromDraftAsync(UpdateInvoiceModel model)
{
return(await _runner.RunAsync(() => _invoiceApi.GenerateFromDraftAsync(model)));
}
public async Task <Result <InvoiceCoreModel> > Edit(UpdateInvoiceModel model) => await _invoiceBiz.Edit(model);
public async Task UpdateDraftInvoiceAsync(UpdateInvoiceModel model)
{
await _runner.RunAsync(() => _draftsApi.UpdateAsync(model));
}
