public ActionResult AddInvoice([FromBody] Invoice invoice)
{
try
{
_invoiceService.AddInvoice(invoice);
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.GetBaseException().Message));
}
}
public async Task <Invoice> AddInvoice(AddInvoiceDto dto)
{
Order order = await _orderRepository.GetAsync(o => o.OrderNo == dto.OrderNo.Trim());
Guard.Against.OrderNotFound(order, dto.OrderNo);
Guard.Against.OrderStatus <OrderNotNeedInvoiceException>(true, order.NeedInvoice);
return(await _invoiceService.AddInvoice(order.Id, dto.InvoiceCode, dto.InvoiceNo, dto.Drawer, dto.IsRed, dto.Remark));
}
public IActionResult InvoiceAdd([FromBody] IEnumerable <MvInvoice> invoice)
{
try
{
var data = _invoiceService.AddInvoice(invoice);
return(Ok(data));
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult AddInvoice([FromBody] MvInvoice invoice)
{
try
{
dynamic jsonString = _invoiceService.AddInvoice(invoice);
return(Ok(jsonString));
}
catch (Exception e)
{
throw e;
}
}
public IActionResult CreateInvoice(Invoice invoice)
{
var result = _invoiceService.AddInvoice(invoice);
if (result)
{
return(Ok());
}
else
{
return(BadRequest());
}
}
public IActionResult AddInvoice([FromBody] IEnumerable <MvInvoice> sales)
{
try
{
var added = _invoiceService.AddInvoice(sales);
if (!added)
{
return(BadRequest());
}
return(Ok());
}
catch (Exception e)
{
throw e;
}
}
public IActionResult AddInvoice([FromBody] MvInvoice invoice)
{
try
{
var added = _invoiceService.AddInvoice(invoice);
if (!added)
{
return(BadRequest());
}
return(Ok());
}
catch (Exception e)
{
throw e;
}
}
public IActionResult Create(InvoiceViewModel client)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
invoiceService.AddInvoice(InvoiceMapper.MapToDomainModel(client));
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public void Checkout()
{
var processvm = IoC.Get <ProcessViewModel>();
processvm.Content = "Processing...";
processvm.ProcessAction = () =>
{
var invoice = new Invoice
{
DateTime = DateTimeOffset.Now,
CustomerId = Customer.Id
};
var invoiceItems = new List <InvoiceItem>(Products
.Where(o => o.Quantity > 0)
.Select((o, i) => new InvoiceItem
{
ItemNumber = i + 1,
ProductId = o.Product.Id,
Quantity = o.Quantity,
Price = o.Product.Price,
Discount = o.Discount
}));
InvoiceService.AddInvoice(invoice, invoiceItems, IsCashAccount ? Total : 0.0m);
Customer.Balance = CustomerService.GetCustomer(Customer.Id).Balance;
};
processvm.CompleteAction = () =>
{
var message = IoC.Get <MessageBoxViewModel>();
message.Content = new CustomerTransactionInfo {
Customer = Customer, NewBalance = Customer.Balance
};
message.DismissAction = () => ScreenCoordinator.NavigateToHome();
message.DismissTimeout = 2500;
ScreenCoordinator.NavigateToScreen(message);
};
ScreenCoordinator.NavigateToScreen(processvm);
}
public IActionResult AddInvoice([FromBody] IEnumerable <MvTransaction> transactions)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
var added = _invoiceService.AddInvoice(transactions);
if (!added)
{
return(BadRequest());
}
return(Ok());
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> CreateInvoice(InvoiceViewModel model)
{
if (ModelState.IsValid)
{
try
{
//get user id from access token i.e authorized user
string Id = User.Claims.First(c => c.Type == "UserID").Value;
//if customer created by sub-admin then customer linked to parent admin (i.e bussiness)
string parentUserId = Id;
var user = await _userManager.FindByIdAsync(Id);
if (User.IsInRole(Constants.isSubAdmin))
{
parentUserId = user.ParentUserId;
}
var userstatus = user.UserStatus;
string invNo = string.Empty;
if (model.Type.ToUpper() == Constants.typeInvoice)
{
invNo = Constants.typeInvoice + CommonMethods.Generate15UniqueDigits();
}
else if (model.Type.ToUpper() == Constants.typeQuotation)
{
invNo = Constants.typeQuotation + CommonMethods.Generate15UniqueDigits();
}
else
{
return(Ok(new { status = StatusCodes.Status406NotAcceptable, success = false, message = ResponseMessages.msgInvoiceTypeInvalid, userstatus = false }));
}
//for isSent field (false:- draft, true:- sent)
bool isSent = false;
if (model.Status.ToUpper() == Constants.statusSent)
{
model.Status = Constants.statusUnpaidOrPending;
isSent = true;
}
else if (model.Status.ToUpper() == Constants.statusDrafted)
{
model.Status = Constants.statusDrafted;
}
else
{
return(Ok(new { status = StatusCodes.Status406NotAcceptable, success = false, message = ResponseMessages.msgInvoiceStatusInvalid, userstatus = false }));
}
var invoices = new Invoices()
{
Title = model.Title,
Description = model.Description,
InvoiceNumber = invNo,
PosoNumber = model.PosoNumber,
Date = DateTime.ParseExact(model.Date, "dd/MM/yyyy", CultureInfo.InvariantCulture),
DueDate = DateTime.ParseExact(model.DueDate, "dd/MM/yyyy", CultureInfo.InvariantCulture),
ItemList = JsonConvert.SerializeObject(model.ItemList),
Status = model.Status,
CurrencyId = model.CurrencyId,
Type = model.Type.ToUpper(),
Subtotal = model.Subtotal,
Tax = model.Tax,
Total = model.Total,
CustomerId = model.CustomerId,
IsSent = isSent,
UserId = parentUserId,
Notes = model.Notes,
TermsAndConditions = model.TermsAndConditions,
IsPaid = false,
CreatedBy = Id,
CreatedDate = DateTime.Now
};
var retId = await _invoiceService.AddInvoice(invoices);
if (retId > 0)
{
if (invoices.IsSent)
{
await _invoiceService.SendInvoiceMail(retId);
}
return(Ok(new { status = StatusCodes.Status200OK, success = true, message = "invoice" + ResponseMessages.msgCreationSuccess, userstatus }));
}
else
{
return(Ok(new { status = StatusCodes.Status404NotFound, success = false, message = ResponseMessages.msgDbConnectionError, userstatus = false }));
}
}
catch (Exception ex)
{
return(Ok(new { status = StatusCodes.Status500InternalServerError, success = false, message = ResponseMessages.msgSomethingWentWrong + ex.Message, userstatus = false }));
}
}
return(Ok(new { status = StatusCodes.Status406NotAcceptable, success = false, message = ResponseMessages.msgParametersNotCorrect, userstatus = false }));
}
public async Task Post(OrderHeaderDTO invoiceDto) => await _invoice.AddInvoice(invoiceDto);
//[HttpPost]
public ActionResult CreateInvoice()
{
List <InvoiceItem> listItem = (List <InvoiceItem>)Session["listItem"];
if (listItem == null)
{
return(RedirectToAction("CreateVendor"));
}
var role = Session["role"].ToString().ToLower();
var requestorId = Session["wwid"].ToString();
var requestorMail = Session["mail"].ToString();
var managerId = Session["ManagerWWID"].ToString();
Invoice inv = new Invoice();
inv.Note = requestorId + "|" + requestorMail + "|" + managerId;
inv.PaymentVoucher = 0;
inv.totalPayment = 0;
inv.PaymentAmount = 0;
inv.PaymentCreatedDate = DateTime.Now;
// inv.optionA = invoice.option.ToString();
inv.optionA = Session["option"].ToString();
if (role.Equals("accountant"))
{
inv.Description = Session["InvoiceID"].ToString();
}
_invoiceService.AddInvoice(inv);
UserInvoice userInv = new UserInvoice();
int userId = 0;
if (role.Equals("requestor"))
{
userInv.StatusId = _statusService.GetAllStatuses().Where(p => p.StatusName.ToString().ToLower().Equals("pending for approve")).FirstOrDefault().Id;
var roleID = _roleGroupService.GetAllRoleGroups().Where(p => p.GroupName.ToString().ToLower().Equals("requestor")).FirstOrDefault().Id;
userId = _userTableService.GetAllUsers().Where(p => p.RoleGroupId == int.Parse(roleID.ToString())).FirstOrDefault().Id;
}
else if (role.Equals("accountant"))
{
userInv.StatusId = _statusService.GetAllStatuses().Where(p => p.StatusName.ToString().ToLower().Equals("pending for signature")).FirstOrDefault().Id;
userId = _userTableService.GetAllUsers().Where(p => p.WWID == int.Parse(requestorId)).FirstOrDefault().Id;
}
var invoiceId = _invoiceService.GetAllInvoices().LastOrDefault().Id;
userInv.UserTableId = userId;
// userInv.StatusId = statusId;
userInv.InvoiceId = invoiceId;
userInv.isDelete = false;
_userInvoiceService.AddUserInvoice(userInv);
double totalPay = 0;
foreach (var item in listItem)
{
InvoiceItem it = new InvoiceItem();
it.ItemVendorId = item.ItemVendorId;
it.InvoiceId = invoiceId;
it.isDelete = false;
it.Quantity = item.Quantity;
it.totalPrice = item.totalPrice;
totalPay += item.totalPrice;
_invoiceItemService.AddInvoiceItem(it);
}
Invoice invo = _invoiceService.GetInvoiceById(invoiceId);
invo.totalPayment = totalPay;
_invoiceService.EditInvoice(invo);
Session["listItem"] = null;
Session["option"] = null;
Session["InvoiceID"] = null;
InvoiceViewModel invoice = new InvoiceViewModel();
invoice.Id = invoiceId;
invoice.Description = invo.Description;
invoice.requestID = invo.requestID;
invoice.URL = "";
//return RedirectToAction("Index");
return(View("Upload", invoice));
}
public async Task <IActionResult> CreateInvoice([FromBody] InvoiceCreate invoiceCreate, CancellationToken cancellationToken)
{
return(Resolve(await _invoiceService.AddInvoice(invoiceCreate, cancellationToken), HttpStatusCode.Created));
}
