public PurchasePayment GetOne([FromBody] PurchasePayment input)
{
try
{
if (input != null)
{
Expression <Func <Purchase, object> >[] exp = new Expression <Func <Purchase, object> >[] { x => x.PurchasePayments, x => x.PurchaseDetails, x => x.Suplier };
var predicate = PredicateBuilder.True <Purchase>();
predicate = predicate.And(x => !x.IsDeleted);
if (!string.IsNullOrWhiteSpace(input.BillId))
{
predicate = predicate.And(x => x.PurchaseId.ToUpper().Trim() == input.BillId.ToUpper().Trim());
}
if (input.FK_PurchaseId > 0)
{
predicate = predicate.And(x => x.Id == input.FK_PurchaseId);
}
var result = _purchaseOpp.GetAllUsingExpression(out int totalCount, 1, 0, predicate, null, null, exp).FirstOrDefault();
if (result != null)
{
if (result.PurchasePayments != null)
{
foreach (var each in result.PurchasePayments)
{
result.TotalPaid = result.TotalPaid + each.Amount;
}
}
result.Due = Math.Round(result.RoundOffTotal - result.TotalPaid, 2);
//nullifying to avoid object chain
if (result.PurchasePayments != null)
{
result.PurchasePayments.ForEach(x => x.Purchase = null);
}
if (result.Suplier != null)
{
result.Suplier.Purchases = null;
}
if (result.PurchaseDetails != null)
{
result.PurchaseDetails.ForEach(x => x.Purchase = null);
}
input.Purchase = result;
}
}
}
catch (Exception ex)
{
input.IsFailure = true;
input.Msg = "";
}
return(input);
}
public List <PurchasePayment> GetPurchasePayment(int id, string connectionString)
{
List <PurchasePayment> payments = new List <PurchasePayment>();
SqlConnection connection = null;
try
{
using (connection = new SqlConnection(connectionString))
{
connection.Open();
using (SqlCommand command = connection.CreateCommand())
{
command.CommandText = "GetPurchasePayment";
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add(new SqlParameter("@id", id));
using (SqlDataReader rdr = command.ExecuteReader())
{
while (rdr.Read())
{
if (!string.IsNullOrEmpty(rdr["Id"].ToString()))
{
PurchasePayment r = new PurchasePayment();
r.Id = int.Parse(rdr["Id"].ToString());
if (!string.IsNullOrEmpty(rdr["PaymentMethod"].ToString()))
{
r.PaymentMethod = int.Parse(rdr["PaymentMethod"].ToString());
}
if (!string.IsNullOrEmpty(rdr["Sum"].ToString()))
{
r.Sum = decimal.Parse(rdr["Sum"].ToString());
}
payments.Add(r);
}
}
}
}
}
}
catch (SqlException sqlEx)
{
}
catch (Exception ex)
{
}
finally
{
if (connection != null && connection.State == ConnectionState.Open)
{
connection.Close();
}
}
return(payments);
}
public int InsertPurchasePayment(PurchasePayment purchasePayment, string connectionString)
{
int purchaseStatus = 0;
SqlConnection connection = null;
try
{
using (connection = new SqlConnection(connectionString))
{
connection.Open();
using (SqlCommand command = connection.CreateCommand())
{
command.CommandText = "InsertPurchasePayment";
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add(new SqlParameter("@purchaseId", purchasePayment.PurchaseId));
command.Parameters.Add(new SqlParameter("@paymentMethod", purchasePayment.PaymentMethod));
command.Parameters.Add(new SqlParameter("@sum", purchasePayment.Sum));
using (SqlDataReader rdr = command.ExecuteReader())
{
while (rdr.Read())
{
if (!string.IsNullOrEmpty(rdr["status"].ToString()))
{
purchaseStatus = int.Parse(rdr["status"].ToString());
}
}
}
}
}
}
catch (SqlException sqlEx)
{
}
catch (Exception ex)
{
}
finally
{
if (connection != null && connection.State == ConnectionState.Open)
{
connection.Close();
}
}
return(purchaseStatus);
}
public async Task <IActionResult> PostPurchasePayment([FromBody] PurchasePayment purchasePayment)
{
//validate
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_context.Purchase.Any(p => p.Id == purchasePayment.PurchaseId))
{
return(BadRequest("This Purchase doesn't exist"));
}
if (!_context.PaymentMethod.Any(p => p.Id == purchasePayment.PaymentMethod))
{
return(BadRequest("This Payment Method doesn't exist"));
}
Purchase purchase = _context.Purchase.AsNoTracking().SingleOrDefault(p => p.Id == purchasePayment.PurchaseId);
if (purchase.TotalSum - purchase.PaidAmount <= 0)
{
return(BadRequest("Already completed all payments for this purchase"));
}
if (purchase.TotalSum - purchase.PaidAmount < purchasePayment.Sum || purchasePayment.Sum <= 0)
{
purchasePayment.Sum = purchase.TotalSum - (decimal)purchase.PaidAmount;
}
// complete payment and receive the response
//if(!paymentApproved)
//return - payment declined.
//Insert Payment to DB
int purchaseStatus = Repository.Instance.InsertPurchasePayment(purchasePayment, _context.Database.GetDbConnection().ConnectionString);
//Retreive the Updated Purchase
Purchase updatedPurchase = Repository.Instance.GetPurchase(purchasePayment.PurchaseId, _context.Database.GetDbConnection().ConnectionString);
if (updatedPurchase == null)
{
return(NotFound());
}
return(Ok(updatedPurchase));
}
public PurchasePayment Payment([FromBody] PurchasePayment input)
{
try
{
if (input != null)
{
input.Purchase = null;
if (input.Id <= 0)
{
input.Id = 0;
_purchasePaymentOpp.Add(input);
}
input = GetOne(input);
}
}
catch (Exception ex)
{
input.Msg = "";
input.IsFailure = true;
}
return(input);
}
public async Task <DbResponse <int> > BillUpdated(PurchaseUpdatePostModel model, IUnitOfWork db, string userName)
{
var response = new DbResponse <int>();
try
{
var purchase = Context.Purchase
.Include(s => s.PurchaseList)
.FirstOrDefault(s => s.PurchaseId == model.PurchaseId);
if (purchase == null)
{
response.IsSuccess = false;
response.Message = "Not found";
return(response);
}
var registrationId = db.Registrations.GetRegID_ByUserName(userName);
var returnRecord = new PurchasePaymentReturnRecordModel
{
PrevReturnAmount = decimal.Round(purchase.PurchaseReturnAmount, 2),
CurrentReturnAmount = decimal.Round(model.PurchaseReturnAmount, 2),
AccountId = model.AccountId,
PurchaseId = purchase.PurchaseId,
RegistrationId = registrationId
};
purchase.PurchaseTotalPrice = decimal.Round(model.PurchaseTotalPrice, 2);
purchase.PurchaseDiscountAmount = decimal.Round(model.PurchaseDiscountAmount, 2);
purchase.PurchaseReturnAmount = decimal.Round(model.PurchaseReturnAmount, 2);
purchase.PurchasePaidAmount += decimal.Round(model.PaidAmount, 2);
var due = (purchase.PurchaseTotalPrice + purchase.PurchaseReturnAmount) - (purchase.PurchaseDiscountAmount + purchase.PurchasePaidAmount);
if (due < 0)
{
response.IsSuccess = false;
response.Message = "Due cannot be less than zero";
return(response);
}
if (model.RemovedProductStockIds != null)
{
if (model.RemovedProductStockIds.Any())
{
var removedStocks = Context.ProductStock
.Include(s => s.ProductLog)
.Include(s => s.Warranty)
.Where(s => model.RemovedProductStockIds.Contains(s.ProductStockId)).ToList();
if (removedStocks.Any(s => s.IsSold))
{
response.IsSuccess = false;
response.Message = "Sold product can not be return";
return(response);
}
if (removedStocks.Any())
{
Context.ProductStock.RemoveRange(removedStocks);
}
}
}
if (model.PurchaseList == null)
{
purchase.PurchaseList = null;
}
Context.Purchase.Update(purchase);
var existProduct = model.PurchaseList.Where(p => p.PurchaseListId != 0 && p.AddedProductCodes != null).ToList();
foreach (var pItem in existProduct)
{
var purchaseList = Context.PurchaseList.Find(pItem.PurchaseListId);
purchaseList.SellingPrice = pItem.SellingPrice;
purchaseList.PurchasePrice = pItem.PurchasePrice;
purchaseList.Description = pItem.Description;
purchaseList.Note = pItem.Note;
purchaseList.Warranty = pItem.Warranty;
purchaseList.ProductStock = pItem.AddedProductCodes.Select(s => new ProductStock
{
ProductId = pItem.ProductId,
ProductCode = s
}).ToList();
Context.PurchaseList.Update(purchaseList);
}
var newProduct = model.PurchaseList.Where(p => p.PurchaseListId == 0 && p.AddedProductCodes != null).ToList();
var newPurchaseList = newProduct.Select(p => new PurchaseList
{
PurchaseListId = p.PurchaseListId,
PurchaseId = model.PurchaseId,
ProductId = p.ProductId,
SellingPrice = p.SellingPrice,
PurchasePrice = p.PurchasePrice,
Description = p.Description,
Note = p.Note,
Warranty = p.Warranty,
ProductStock = p.AddedProductCodes.Select(s => new ProductStock
{
ProductId = p.ProductId,
ProductCode = s
}).ToList()
}).ToList();
Context.PurchaseList.AddRange(newPurchaseList);
if (model.PaidAmount > 0)
{
var newSellingPaymentSn = await db.PurchasePayments.GetNewSnAsync().ConfigureAwait(false);
var payment = new PurchasePayment
{
RegistrationId = registrationId,
VendorId = purchase.VendorId,
ReceiptSn = newSellingPaymentSn,
PaidAmount = model.PaidAmount,
AccountId = model.AccountId,
PaidDate = DateTime.Now.BdTime().Date,
PurchasePaymentList = new List <PurchasePaymentList>
{
new PurchasePaymentList
{
PurchasePaidAmount = model.PaidAmount,
PurchaseId = model.PurchaseId
}
}
};
await Context.PurchasePayment.AddAsync(payment);
}
//Account add balance
if (model.PaidAmount > 0 && model.AccountId != null)
{
db.Account.BalanceSubtract(model.AccountId.Value, model.PaidAmount);
}
await Context.SaveChangesAsync();
db.Vendors.UpdatePaidDue(purchase.VendorId);
//remove purchase list
var removedPurchaseList = Context.PurchaseList.Where(l => !l.ProductStock.Any()).ToList();
Context.RemoveRange(removedPurchaseList);
await Context.SaveChangesAsync();
//Product Logs
var codes = model.PurchaseList.SelectMany(l => l.AddedProductCodes).ToArray();
var stockList = Context
.ProductStock
.Include(p => p.PurchaseList)
.Where(s => s.PurchaseList.PurchaseId == model.PurchaseId && codes.Contains(s.ProductCode))
.ToList();
if (stockList.Any())
{
var productLogs = stockList.Select(c => new ProductLogAddModel
{
PurchaseId = model.PurchaseId,
ProductStockId = c.ProductStockId,
ActivityByRegistrationId = registrationId,
Details = $"Bill Updated: Product Buy at Receipt No: {purchase.PurchaseSn}",
LogStatus = ProductLogStatus.PurchaseUpdate
}).ToList();
//Product log
db.ProductLog.AddList(productLogs);
}
//Return amount account update
db.Account.PurchaseReturnRecordAdd(returnRecord);
}
catch (Exception e)
{
response.IsSuccess = false;
response.Message = e.Message;
return(response);
}
response.IsSuccess = true;
response.Message = "Success";
response.Data = model.PurchaseId;
return(response);
}
