public async Task <Invoice> CreateInvoice(InvoiceRequest data)
{
var _invoice = new Invoice();
var _products = data.lines.ToArray();
foreach (Product p in _products)
{
if (p.currency.ToUpper() != "CRC")
{
return(null);//new BadRequestObjectResult("Only local currency");
}
p.invoice_id = _invoice.invoice_id;
var _subtotal = (p.price * p.quantity);
var _discount_total = (_subtotal * p.discount_rate / 100);
var _tax_total = ((_subtotal - _discount_total) * p.tax_rate / 100);
_invoice.subtotal = _invoice.subtotal + _subtotal;
_invoice.tax_total = _invoice.tax_total + _tax_total;
_invoice.discount_total = _invoice.discount_total + _discount_total;
_invoice.total = _invoice.balance + ((_subtotal - _discount_total) + _tax_total);
_invoice.balance = _invoice.total;
}
data.client.invoice_id = _invoice.invoice_id;
_context.Invoices.Add(_invoice);
_context.Products.AddRange(_products);
_context.Clients.Add(data.client);
await _context.SaveChangesAsync();
return(_invoice);
}
public async Task <InvoiceResponse> PushInvoiceToRDCBrains(InvoiceRequest request)
{
_handler = new MyHttpClientHandler.MyHandler();
Client = new HttpClient();
var byteArray = Encoding.ASCII.GetBytes("ADDA:test");
Client.BaseAddress = new Uri("http://35.185.72.232/");
Client.DefaultRequestHeaders.Accept.Clear();
//Client.DefaultRequestHeaders.Add("Content-Type", "application/json");
Client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json; charset=utf-8");
Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
Client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
var response = new InvoiceResponse();
var result = await Client.PostAsJsonAsync("RDCWebServices/RDCPush.jsp", request);
if (result.IsSuccessStatusCode)
{
var resultasstring = await result.Content.ReadAsStringAsync();
response = JsonConvert.DeserializeObject <InvoiceResponse>(resultasstring);
}
else
{
response = DummyResponse();
}
return(response);
}
public async Task <IHttpActionResult> Post(InvoiceRequest request)
{
try
{
if (request == null)
{
return(BadRequest());
}
InvoiceRepository _repository = new InvoiceRepository();
InvoiceResponse response = await _repository.PushInvoiceToRDCBrains(request);
if (response.statusCode == "0")
{
Dictionary <string, string> jsonresponse = new Dictionary <string, string>();
jsonresponse["Bill Number"] = response.Bill_Number;
jsonresponse["freeFormRSN"] = response.freeFormRSN;
jsonresponse["peopleRSN"] = response.peopleRSN;
jsonresponse["folderRSN"] = response.folderRSN;
jsonresponse["statusCode"] = response.statusCode;
jsonresponse["status"] = response.status;
return(Created(Request.RequestUri, jsonresponse));
}
return(BadRequest());
}
catch (Exception)
{
return(InternalServerError());
}
}
public IActionResult Post([FromBody] InvoiceRequest request)
{
try
{
var invoice = createManager.Create(
date: DateTime.Now,
expirationDate: request.ExpirationDate,
totalReceived: request.TotalReceived,
customerId: request.CustomerId,
productInputs: request.Products);
return(CreatedAtAction(
nameof(InvoicesGetController.GetById),
nameof(InvoicesGetController).Replace("Controller", ""),
new { invoiceId = invoice.Id },
invoice));
}
catch (ProductNotFound)
{
return(NotFound());
}
catch (CustomerNotFound)
{
return(NotFound());
}
}
public CreateResponse Create(InvoiceRequest request)
{
var invoice = _mapper.Map <Invoice>(request);
_invoiceRepository.Create(invoice);
return(new CreateResponse(invoice.Id));
}
private void do_report(bool report)
{
//if (invoice == InvoiceType.AlımFaturası || invoice == InvoiceType.SatisFaturasi)
//{
//}
//if (invoice == InvoiceType.SatisIrsaliye || invoice == InvoiceType.AlisIrsaliye)
//{
//}
var req = new InvoiceRequest
{
InvoiceType = (int)invoice,
BeginDate = dt_BeginDate.DateTime,
EndDate = new DateTime(dt_EndDate.DateTime.Year, dt_EndDate.DateTime.Month, dt_EndDate.DateTime.Day, 23, 59, 00),
DovizTuru = Convert.ToInt32(dt_Currencies.EditValue)
};
invoiceList = _repository.Run <ReportService, List <InvoiceOwnerDTO> >(x => x.GetList_Invoice(req));
if (invoiceList.Count > 0)
{
gridControl1.DataSource = invoiceList;
if (report)
{
}
}
else
{
XtraMessageBox.Show("Kayıt Bulunamadı...", "Uyarı", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public IHttpActionResult UpdateInvoice([FromBody] InvoiceRequest request)
{
IEnumerable <string> headerValues = null;
if (Request.Headers.TryGetValues(SECRET_KEY, out headerValues))
{
var value = headerValues.FirstOrDefault();
if (String.Compare(value, SECRET_KEY) == 0 && request != null)
{
var invoice = db.DbInvoice.FirstOrDefault(c => c.Id == request.Id);
if (invoice == null)
{
return(NotFound());
}
else
{
invoice.Name = request.Name;
invoice.Status = request.Status;
db.SaveChanges();
}
}
}
return(Ok());
}
public async Task <bool> PayInvoice(InvoiceRequest request)
{
string uri = _configuration["proxy:urlInvoicePago"];
var response = await _httpClient.PostAsync(uri, request);
response.EnsureSuccessStatusCode();
return(true);
}
public List <InvoiceOwnerDTO> GetList_Invoice(InvoiceRequest request)
{
using (var _db = new MspDbContext())
{
List <InvoiceOwnerDTO> result = new List <InvoiceOwnerDTO>();
result = base.Map <List <InvoiceOwner>, List <InvoiceOwnerDTO> >(_db.InvoiceOwner.Where(x => x.InvoiceType == request.InvoiceType && x.Deleted == false && x.FicDate >= request.BeginDate && x.FicDate <= request.EndDate && x.DovizTuru == request.DovizTuru).ToList());
return(result);
}
}
public bool Execute(Transaction request)
{
bool response = false;
//#1. Pòlitica de CircuiBraker
var circuitBrakerPolicy = Policy.Handle <Exception>()
.CircuitBreaker(3, TimeSpan.FromSeconds(15),
onBreak: (ex, timeSpan, context) =>
{
Console.Write("El circuito entro en estado de falla");
},
onReset: (context) =>
{
Console.Write("Circuito dejo estado de falla");
});
//#2 Pòlitica de reitentos
var retry = Policy.Handle <Exception>()
.WaitAndRetryForever(attemp => TimeSpan.FromMilliseconds(300))
.Wrap(circuitBrakerPolicy);//Se antepone esta Politica de CircuiBraker.
//#3 La ejecuciòn de Reitentos.
retry.Execute(() =>
{
if (circuitBrakerPolicy.CircuitState == CircuitState.Closed)
{
circuitBrakerPolicy.Execute(() =>
{
InvoiceRequest invoice = new InvoiceRequest()
{
IdInvoice = request.IdInvoice,
Amount = request.Amount
};
response = PayInvoice(invoice).Result;
Console.WriteLine("Solicitud realizada con èxito");
});
}//fin del IF
if (circuitBrakerPolicy.CircuitState != CircuitState.Closed)
{
Transaction transaction = new Transaction()
{
IdInvoice = request.IdInvoice,
Amount = request.Amount,
Date = DateTime.Now.ToString() + $" CANCELADO"
};
response = ReverseInvoice(transaction);
response = false;
Console.WriteLine("Solicitud cancelada con èxito");
}//fin del IF
});//Fin Retry
return(response);
}
public async Task <InvoiceResponse> PushInvoiceToRDCBrains(InvoiceRequest request)
{
_handler = new MyHttpClientHandler.MyHandler();
Client = new HttpClient();
var byteArray = Encoding.ASCII.GetBytes("ADDA:test");
Client.BaseAddress = new Uri("http://35.185.72.232/");
Client.DefaultRequestHeaders.Accept.Clear();
//Client.DefaultRequestHeaders.Add("Content-Type", "application/json");
// Client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json; charset=utf-8");
Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
Client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
var response = new InvoiceResponse();
var json = new JavaScriptSerializer().Serialize(request);
//HttpRequestMessage requestss = new HttpRequestMessage(HttpMethod.Post, "RDCWebServices/RDCPush.jsp");
//requestss.Content = new StringContent(json, Encoding.UTF8, "application/json");
//var sss = Client.SendAsync(requestss).Result;
//if (sss.IsSuccessStatusCode)
//{
// var stringsd = sss.Content.ReadAsStringAsync();
//}
//HttpContent _Body = new StringContent(json);
//// and add the header to this object instance
//// optional: add a formatter option to it as well
//_Body.Headers.ContentType = new MediaTypeHeaderValue("application/json");
//// synchronous request without the need for .ContinueWith() or await
//HttpResponseMessage asresponse = Client.PostAsync("RDCWebServices/RDCPush.jsp", _Body).Result;
//if (asresponse.IsSuccessStatusCode)
//{
// var resresultasstring = await asresponse.Content.ReadAsStringAsync();
//}
var result = await Client.PostAsJsonAsync("RDCWebServices/RDCPush.jsp", request);
if (result.IsSuccessStatusCode)
{
var resultasstring = await result.Content.ReadAsStringAsync();
//dynamic obj = JsonConvert.DeserializeObject<dynamic>(resultasstring);
// object objs = resultasstring;
//string responsestring = JsonConvert.DeserializeObject<string>(resultasstring);
JObject s = JObject.Parse(resultasstring);
response.Bill_Number = (string)s["Bill Number"];
response.folderRSN = (string)s["folderRSN"];
response.freeFormRSN = (string)s["freeFormRSN"];
response.peopleRSN = (string)s["peopleRSN"];
response.status = (string)s["status"];
response.statusCode = (string)s["statusCode"];
// response = JsonConvert.DeserializeObject<InvoiceResponse>(resultasstring);
}
else
{
response = DummyResponse();
}
return(response);
}
public async Task <IActionResult> SaveInvoice([FromBody] InvoiceRequest request)
{
var isValid = await ValidateRequest();
if ((isValid as OkResult)?.StatusCode != Ok().StatusCode)
{
return(isValid);
}
var entity = request?.CreateEntity();
if (entity == null)
{
return(BadRequest());
}
entity.RowKey = entity.InvoiceId;
entity.PartitionKey = MerchantId;
entity.MerchantId = MerchantId;
try
{
var resp = await _invoiceService.SaveInvoiceWithHttpMessagesAsync(entity);
var result = resp.Body ?? false;
if (!result)
{
throw new DataException("Can't save invoice in Lykke Pay API");
}
}
catch (Exception e)
{
await Log.WriteErrorAsync(nameof(InvoicesController), nameof(SaveInvoice), e);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
var context = new
{
entity.Transaction,
entity.StartDate,
entity.WalletAddress,
entity.Status,
entity.DueDate,
entity.ClientUserId,
entity.ClientId,
entity.Currency,
entity.Amount,
entity.InvoiceNumber,
entity.InvoiceId,
MerchantId
};
await Log.WriteInfoAsync(nameof(InvoicesController), nameof(SaveInvoice), context.ToJson(), "Save new Invoce in system");
return(Json(new InvoiceResponse(entity.Create(), _payApiSettings.LykkeInvoiceTemplate)));
}
public IList <InvoiceRequest> GenerateListInvoiceRequest(InvoiceRequest invoiceRequest, int number)
{
IList <InvoiceRequest> lstInvoice = new List <InvoiceRequest>();
for (int i = 0; i < number; i++)
{
lstInvoice.Add(invoiceRequest);
}
return(lstInvoice);
}
// id po to, żeby nie zmieniać id modelu przy mapowaniu
public async Task EditInvoice(InvoiceRequest invoiceRequest, long id)
{
var invoiceToEdit = await _dbContext.Set <Invoice>()
.Include(x => x.Items)
.Where(x => x.Id == id)
.FirstOrDefaultAsync();
_mapper.Map(invoiceRequest, invoiceToEdit);
await _dbContext.SaveChangesAsync();
}
public IActionResult InvoiceProducts([FromBody] InvoiceRequest invoiceRequest)
{
try
{
InvoiceProductsResponse response = productService.InvoiceProducts(invoiceRequest);
return(StatusCode(200, response));
}
catch (Exception)
{
return(StatusCode(500, Constants.REQUEST_ERROR_MESSAGE));
}
}
public VSDCRequestSubmitter()
{
InitializeComponent();
txtVSDCAddress.Text = Properties.Settings.Default.VSDCTargetAddress;
txtCertificateName.Text = Properties.Settings.Default.CertificateName;
invoiceRequest = JsonConvert.DeserializeObject <InvoiceRequest>("{ \"IT\": \"Normal\", \"TT\": \"Sale\", \"PaymentType\": \"Cash\", \"PAC\": \"REPLACE WITH PAC CODE RECEIVED WITH POS PFX FILE!!!!\", \"Items\": [{\"Name\": \"Network Cable\", \"Quantity\": 1,\"UnitPrice\":100.87, \"Labels\":[\"A\"], \"TotalAmount\": 100.87 }]}");
txtRequest.Text = JsonConvert.SerializeObject(invoiceRequest, Formatting.Indented);
}
public async Task <Guid> Create(InvoiceRequest request)
{
var invoice = InvoiceAggregate.Create(request.ContractId, request.DateEnd, request.DateStart);
var sheetsToInclude = await _invoiceAggregateRepo
.GetSheets(request.ContractId, request.DateStart, request.DateEnd);
invoice.IncludeSheets(sheetsToInclude);
await _invoiceRepo.Add(invoice);
return(invoice.Id);
}
public async Task CreateInvoice(InvoiceRequest invoiceRequest)
{
var invoice = _mapper.Map <Invoice>(invoiceRequest);
var countOfInvoices = (await GetInvoice(invoice.InvoiceDate.Month, invoice.InvoiceDate.Year)).Count;
invoice.InvoiceNo = $"{countOfInvoices + 1}/{invoice.InvoiceDate.Month}/{invoice.InvoiceDate.Year}";
await _dbContext.Set <Invoice>().AddAsync(invoice);
await _dbContext.SaveChangesAsync();
}
public ResultJson UpDateInvoice(InvoiceRequest request)
{
var InvoiceAddress = request.AddressInfo + request.AddressDetail;
#region 添加
if (request.Id == 0 && request.ListOrderId != null)
{
var resultAdd = ProducerinvoiceFunc.Instance.UpdateProducerInfo(request.ListOrderId, request.ProducerId, request.CompanyName, request.InvoiceNumber, request.InvoiceTime, request.InvoiceMoney, request.InvoiceIdentify, request.InvoicePhone, InvoiceAddress, request.InvoiceBank, request.InvoiceContext);
if (resultAdd)
{
return(new ResultJson {
HttpCode = 200, Message = "成功!"
});
}
else
{
return(new ResultJson {
HttpCode = 300, Message = "失败,请重试"
});
}
}
#endregion
#region 修改
else
{
var result = ProducerinvoiceOper.Instance.Update(new Producerinvoice
{
Id = request.Id,
ProducerId = request.ProducerId,
CompanyName = request.CompanyName,
InvoicePhone = request.InvoicePhone,
InvoiceAddress = InvoiceAddress,
InvoiceIdentify = request.InvoiceIdentify,
InvoiceMoney = request.InvoiceMoney,
InvoiceBank = request.InvoiceBank,
InvoiceContext = request.InvoiceContext
});
if (result)
{
return(new ResultJson {
HttpCode = 200, Message = "成功!"
});
}
else
{
return(new ResultJson {
HttpCode = 300, Message = "失败!"
});
}
}
#endregion
}
public async Task <IActionResult> Create([FromBody] InvoiceRequest invoiceRequest)
{
var isAllowedToCreate = await _contractManager.CheckContractIsActive(invoiceRequest.ContractId);
if (isAllowedToCreate != null && !(bool)isAllowedToCreate)
{
return(BadRequest($"Contract {invoiceRequest.ContractId} is not active or not found."));
}
var id = await _invoiceManager.Create(invoiceRequest);
return(Ok(id));
}
public InvoiceServiceTest()
{
_repository = A.Fake <IRepository>();
_invoiceService = new InvoiceService(_repository);
#region Mock DTOs properties
_clientRequest = Builder <ClientRequest> .CreateNew().Build();
_invoiceRequest = new InvoiceRequest(GenerateNewGuid(), _clientRequest, Domain.Enums.EInvoiceStatus.New);
#endregion
}
public async Task <IActionResult> Create([FromBody] InvoiceRequest invoiceRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = new InvoiceResponse()
{
ResponseResult = new ResponseResult(invoiceRequest.RequestHeader.RequestId)
};
try
{
InvoiceRequestDTO dto = GetInvoiceRequestDtoFromRequest(invoiceRequest);
result.Reference = new InvoiceReferenceResponse
{
InvoiceNumber = dto.Id,
InvoiceDate = dto.InvoiceDate
};
var command = new SubmitInvoiceCommand(dto,
JsonConvert.SerializeObject(invoiceRequest),
invoiceRequest.GetType().Name);
try
{
var confirmationCode = await _mediator.Send(command);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
catch (Exception e)
{
result.ResponseResult.Errors = new List <ErrorDetail>()
{
new ErrorDetail()
{
ErrorCode = "-1",
ErrorMessage = e.Message
}
};
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <IActionResult> InsertInvoiveAsync([FromForm] InvoiceRequest invoice)
{
DataRespond data = new DataRespond();
try
{
Invoices inv = new Invoices();
inv.namecustomer = invoice.namecustomer;
inv.gender = invoice.gender;
inv.phonenumber = invoice.phonenumber;
inv.email = invoice.email;
inv.province = invoice.province;
inv.district = invoice.district;
inv.adress = invoice.adress;
inv.adressdelviver = invoice.adressdelviver;
inv.timedeliver = invoice.timedeliver;
inv.typepay = invoice.typepay;
inv.totalmoney = invoice.totalmoney;
inv.money = invoice.money;
inv.codediscount = invoice.codediscount;
inv.usid = invoice.usid;
inv.codeinvoice = RandomString(20);
inv.status = 0; //don't acvite
inv.isread = 0; //don't view
inv.createday = DateTime.Now;
Invoices newinv = m_invoiceResponcitory.InsetInvoice(inv);
foreach (var i in invoice.invoiceproduct)
{
InvoiceProductRequest invprd = new InvoiceProductRequest(i);
InvoiceProduct invoicers = new InvoiceProduct();
invoicers.prid = invprd.prid;
invoicers.total = invprd.total;
invoicers.ivid = newinv.ivid;
m_invoiceResponcitory.InsertInvoiceProduct(invoicers);
}
var invsocket = m_invoiceResponcitory.GetFirstInvoice(newinv.codeinvoice);
await sendInvoidBySocket(invsocket);
sendEmail(invoice.email, inv.codeinvoice);
data.success = true;
data.data = newinv;
}
catch (Exception e)
{
data.success = false;
data.error = e;
}
return(Ok(new { data }));
}
public InvoiceRequest CreateInvoice(InvoiceRequest invoiceRequest)
{
using (var scope = _context.CreateScope())
{
var db = scope.ServiceProvider.GetRequiredService <InvoiceContext>();
//add customer
var newCustomer = new DataAccess.Models.Customer()
{
Name = invoiceRequest.CustomerDetails.CustomerName,
Streat = invoiceRequest.CustomerDetails.ShippingDetails.Streat,
State = invoiceRequest.CustomerDetails.ShippingDetails.State,
City = invoiceRequest.CustomerDetails.ShippingDetails.City,
Phone = invoiceRequest.CustomerDetails.ShippingDetails.Phone,
};
db.Customer.Add(newCustomer);
db.SaveChanges();
var randumNumber = new Random();
//add products
var invoice = new InvoiceDetails()
{
InvoiceNumber = invoiceRequest.CompanyID.ToString() + "-" + "DDYY" + randumNumber.Next().ToString(),
CompanyId = invoiceRequest.CompanyID,
Date = invoiceRequest.InvoiceDate,
CustomerId = newCustomer.Id,
};
db.InvoiceDetails.Add(invoice);
db.SaveChanges();
foreach (var product in invoiceRequest.ProductDetails)
{
var newProduct = new DataAccess.Models.Product()
{
price = product.Price,
Name = product.Name
};
db.Product.Add(newProduct);
db.SaveChanges();
var newOrder = new OrderDetails()
{
ProuductId = newProduct.Id,
InvoiceId = invoice.Id,
Quantity = product.Quantity
};
db.OrderDetails.Add(newOrder);
db.SaveChanges();
}
invoiceRequest.InvoiceId = invoice.Id;
return(invoiceRequest);
}
}
public ResultJson DelInvoice(InvoiceRequest request)
{
if (ProducerinvoiceOper.Instance.DeleteById(request.Id))
{
return(new ResultJson {
HttpCode = 200, Message = "成功!"
});
}
else
{
return(new ResultJson {
HttpCode = 300, Message = "失败!"
});
}
}
public SuccessResponse Update(int id, InvoiceRequest request)
{
var invoice = _invoiceRepository.GetBy(id);
var items = _itemRepository.GetBy(p => p.InvoiceId == id);
var itemsRequest = request.Items.ToList();
request.Items = null;
var invoiceModel = _mapper.Map <Invoice>(request);
_mapper.Map(invoiceModel, invoice);
_invoiceRepository.Update(invoice);
RemoveItems(items, itemsRequest);
CreateAndUpdateItmes(items, itemsRequest, id);
return(new SuccessResponse(true));
}
private Safe2Pay_Request(Config config)
{
this.config = config;
client = new Client(config);
Account = new AccountRequest(this.config);
Carnet = new CarnetRequest(this.config);
Invoice = new InvoiceRequest(this.config);
Marketplace = new MarketplaceRequest(this.config);
Payment = new CheckoutRequest(this.config);
//Plan = new PlanRequest(this.config);
//Subscription = new SubscriptionRequest(this.config);
Token = new TokenRequest(this.config);
Transfer = new TransferRequest(this.config);
Transaction = new TransactionRequest(this.config);
}
public ActionResult CreateInvoice([FromBody] InvoiceRequest invoice)
{
try
{
if (invoice.CompanyID < 0)
{
return(BadRequest("Company ID invalid"));
}
var invoiceDetail = _invoiceDetailsBL.CreateInvoice(invoice);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest("unable to create invoice"));
}
}
public new InvoiceRequest CreateRequest()
{
var result = new InvoiceRequest
{
Id = this.Id,
CreateAt = this.CreateAt,
Name = this.Name,
Description = this.Description,
Amount = this.Amount,
DueDate = this.DueDate,
Category = this.Category.Id,
Contacts = this.Contacts.Select(f => f.Id).ToArray()
};
return(result);
}
public void InvoiceController_HttpStatusCode_200()
{
InvoiceRequest invoiceRequest = new InvoiceRequest()
{
IdUser = 123,
Products = new List<ProductDto>() {
new ProductDto() { Cantidad = 1, Nombre = "CPU", Precio = 2800000 },
new ProductDto() { Cantidad = 3, Nombre = "Monitor", Precio = 500000 }
}
};
InvoiceController invoiceController = new InvoiceController(new ProductService());
var response = invoiceController.InvoiceProducts(invoiceRequest) as Microsoft.AspNetCore.Mvc.ObjectResult;
Assert.AreEqual(200, response.StatusCode);
}
public static InvoiceRequest CreateInvoiceRequest(InvoiceType invoice)
{
InvoiceRequest request = new InvoiceRequest() { Id = "test", Item = invoice };
HeaderType header = new HeaderType() { DateTime = Misc.FormatCurrentTime(), MessageID = Guid.NewGuid().ToString() };
request.Header = header;
return request;
}
