public async Task <IActionResult> CreateCategoriesAndDebits([FromRoute] int id)
{
try
{
var responseCsv = CSVParserService.ReadCsvFileReturnDebit_Invoice_Amount(Request.Form.Files[0]);
var debit = new DebitRequestModel()
{
CompanyId = id
};
var invoice = new InvoiceRequestModel()
{
CompanyId = id
};
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await _invoiceService.CreateAmountInvoice(responseCsv.AmountInvoices, invoice);
await _debitService.CreateAmountDebits(responseCsv.AmountDebits, debit);
scope.Complete();
}
return(Ok());
}
catch (Exception ex)
{
return(HandleControllerErrors(ex));
}
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
List <InvoiceRequestModel> models = context.ActionArguments.Values.OfType <InvoiceRequestModel>().ToList();
if (models.Count > 1)
{
throw new ArgumentException($"Controller action can't have more than one {nameof(InvoiceRequestModel)} parameter.");
}
InvoiceRequestModel model = models.FirstOrDefault();
if (model == null)
{
await next();
return;
}
List <RequestOrderItem> orderItems = model.OrderItems.ToList();
foreach (RequestOrderItem requestOrderItem in model.OrderItems)
{
// For demonstration purposes we just remove invalid equipment items, but
// it's better to send a response with invalid items.
if (!_equipmentRepository.DoesEquipmentExist(requestOrderItem.EquipmentName))
{
Log.Warn($"Invalid equipment name {requestOrderItem.EquipmentName}.");
orderItems.Remove(requestOrderItem);
}
}
model.OrderItems = orderItems;
await next();
}
/// <summary>
/// Create Invoice with full params
/// </summary>
/// <param name="invoiceRequest"></param>
/// <returns></returns>
public async Task <InvoiceResponseModel> CreateInvoice(InvoiceRequestModel invoiceRequest)
{
string url = GetUrl();
var content = await BaseClient.PostEntities(url, JsonConvert.SerializeObject(invoiceRequest), this._secretKey);
return(JsonConvert.DeserializeObject <InvoiceResponseModel>(content));
}
public async Task <InvoiceResponseModel> Create(InvoiceRequestModel invoiceRequest)
{
var invoice = InvoiceMap.InvoiceRequestToInvoice(invoiceRequest);
if (!invoice.IsValid())
{
AddErrors(invoice.GetErrors());
}
HandlerErrors();
var company = await _companyRepository.GetById(invoice.CompanyId);
if (company == null)
{
AddError("Company not found");
}
HandlerErrors();
await _invoiceRepository.Create(invoice);
company.CalculateReliability();
await _invoiceRepository.Save();
return(InvoiceMap.InvoiceToInvoiceResponse(invoice));
}
public APIResult InvoiceRequest([FromBody] InvoiceRequestModel input)
{
var memberId = GetMemberId();
//var memberId = 87;
var isOK = db.MemberInvoiceRequest.Count(m =>
m.MemberId.Equals(memberId) &&
m.ShopOrderId.Equals(input.ShopOrderId) &&
!m.IsDel
) > 0;
if (isOK)
{
return(Error("已经请求过发票了"));
}
MemberInvoiceRequest invoiceRequest = new MemberInvoiceRequest();
invoiceRequest.ShopOrderId = input.ShopOrderId;
invoiceRequest.MemberInvoiceTitleId = input.MemberInvoiceTitleId;
invoiceRequest.ShopId = input.ShopId;
//var invoiceRequest = _mapper.Map<MemberInvoiceRequest>(input);
invoiceRequest.MemberId = memberId;
invoiceRequest.CreateTime = DateTime.Now;
invoiceRequest.State = ProcessState.待处理发票;
db.MemberInvoiceRequest.Add(invoiceRequest);
db.SaveChanges();
return(Success(invoiceRequest));
}
public async Task ShouldCreateInvoice()
{
var expectedInvoice = new Invoice(1);
var InvoiceRequest = new InvoiceRequestModel()
{
CompanyId = 1,
};
var company = new Company("SERASA");
_companyRepository.GetById(1).Returns(company);
var response = await _invoiceService.Create(InvoiceRequest);
await _companyRepository
.Received(1)
.GetById(Arg.Is <int>(x =>
x == 1));
await _invoiceRepository
.Received(1)
.Create(Arg.Is <Invoice>(x => x.CompanyId == 1));
expectedInvoice.Should().BeEquivalentTo(response);
}
public IActionResult GetInvoiceAmount([FromBody] InvoiceRequestModel invoiceRequestModel)
{
var response = new BaseAPIResponse <InvoiceResponseModel>();
try
{
if (ModelState.IsValid)
{
var result = invoiceService.ComputeInvoiceAmount(invoiceRequestModel.Items, invoiceRequestModel.CustomerId);
response.ResponseCode = ResponseConstants.SuccessCode;
response.ResponseMessage = ResponseConstants.SuccessMessage;
response.Result = new InvoiceResponseModel
{
InvoiceAmount = result
};
return(Ok(response));
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
log.LogError("GetInvoiceAmount Error: {ex}", ex);
response.ResponseCode = ResponseConstants.ErrorCode;
response.ResponseMessage = ResponseConstants.ErrorMessage;
return(Ok(response));
}
}
public async Task <bool> CreateAmountInvoice(int amount, InvoiceRequestModel invoiceRequest)
{
var sucess = false;
for (int i = 0; i < amount; i++)
{
await Create(invoiceRequest);
}
sucess = true;
return(sucess);
}
public async Task <IActionResult> GetInvoiceAsync([FromBody] InvoiceRequestModel invoiceRequestModel)
{
var getInvoiceCommand = new GetInvoiceCommand
{
// ClientId or userId should be retrieved from JWT token once authentication is implemented.
// But it's out of scope. So here is just stub.
ClientId = "test_client_Id",
OrderItems = invoiceRequestModel.OrderItems
};
await _endpointInstance.Send(getInvoiceCommand).ConfigureAwait(false);
return(Accepted());
}
public async Task ShouldReturnErrorBecausseNotFoundCompanyAtCreateInvoice()
{
var InvoiceRequest = new InvoiceRequestModel()
{
CompanyId = 1,
};
var expectedErrors = new HashSet <string>();
expectedErrors.Add("Company not found");
var ex = await Record.ExceptionAsync(() => _invoiceService.Create(InvoiceRequest)) as BadRequestException;
expectedErrors.Should().BeEquivalentTo(ex.Errors);
}
public IActionResult Post([FromBody] InvoiceRequestModel invoice)
{
var userContext = _userHandler.GetUserContext();
var taxes = _taxService.SearchTaxesAsync(userContext.ClinicCountryId, userContext.ClinicRegionId, false);
var taxRate = taxes.Sum(p => p.TaxRate);
var invoiceItemModels = invoice.InvoiceItems.Select(p => new InvoiceItemModel
{
ItemId = p.ItemId,
Price = p.Cost,
Quantity = p.Quantity,
TaxTotal = p.Cost * p.Quantity * taxRate,
Subtotal = p.Cost * p.Quantity,
Total = p.Cost * p.Quantity * (1 + taxRate)
}).ToList();
var ticks = DateTime.Now.Ticks;
var guid = Guid.NewGuid().ToString();
var uniqueId = ticks.ToString() + '-' + guid; //guid created by combining ticks and guid
var invoiceModel = new InvoiceModel
{
EncryptId = uniqueId,
AmountPaid = 0,
Note = "New Invoice",
InvoiceStatus = 1,
InvoiceItems = invoiceItemModels,
PatientId = invoice.PatientId,
PaymentStatus = 1,
InvoiceDate = DateTime.Now,
DoctorId = invoice.DoctorId,
ClinicId = userContext.ClinicId,
CreatedBy = userContext.SiteUserId,
DiscountTotal = 0,
ReOccouring = false,
Subtotal = invoiceItemModels.Sum(p => p.Subtotal),
TaxTotal = invoiceItemModels.Sum(p => p.TaxTotal),
Total = invoiceItemModels.Sum(p => p.Total),
UpdatedDateUTC = DateTime.UtcNow
};
var result = _invoiceService.CreateInvoiceAsync(invoiceModel);
return(Json(result));
}
public async Task ShouldReturnErrorAtCreateInvoice()
{
var InvoiceRequest = new InvoiceRequestModel()
{
CompanyId = -1,
};
var company = new Company("SERASA");
_companyRepository.GetById(1).Returns(company);
var expectedErrors = new HashSet <string>();
expectedErrors.Add("The company Id is invalid");
var ex = await Record.ExceptionAsync(() => _invoiceService.Create(InvoiceRequest)) as BadRequestException;
expectedErrors.Should().BeEquivalentTo(ex.Errors);
}
public static Invoice InvoiceRequestToInvoice(InvoiceRequestModel invoiceRequest)
{
return(AutoMapperFunc.ChangeValues <InvoiceRequestModel, Invoice>(invoiceRequest));
}
