public async Task <IActionResult> Edit(int id, [Bind("MembershipFeeID,Name,amount")] MembershipFee membershipFee)
{
if (id != membershipFee.MembershipFeeID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(membershipFee);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MembershipFeeExists(membershipFee.MembershipFeeID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(membershipFee));
}
public ActionResult DeleteConfirmed(int id)
{
MembershipFee membershipRegistration = db.MembershipFee.Find(id);
db.MembershipFee.Remove(membershipRegistration);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create([Bind("MembershipFeeID,Name,amount")] MembershipFee membershipFee)
{
if (ModelState.IsValid)
{
_context.Add(membershipFee);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(membershipFee));
}
public ActionResult Edit([Bind(Include = "MembershipFeeId,ActiveMemberId,ReferenceNo,OrderId,PaidFee,TotalAmount,Date,Status,PaymentStatus")] MembershipFee membershipRegistration)
{
if (ModelState.IsValid)
{
db.Entry(membershipRegistration).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ActiveMemberId = new SelectList(db.ActiveMember, "ActiveMemberId", "StateCode", membershipRegistration.ActiveMemberId);
return(View(membershipRegistration));
}
public async Task <ActionResult> Create(ConfirmPaymentVM model)
{
if (ModelState.IsValid)
{
var hasTransaction = await db.MembershipFee.AsNoTracking().Where(x => x.ActiveMemberId == model.ActiveMemberId &&
x.FeeCategory == model.FeeCategory)
.ToListAsync();
model.paymentType = model.RemitaPaymentType.ToString().Replace("_", " ").ToLower();
if (model.FeeCategory == PaymentType.MembershipRegistration)
{
model.serviceTypeId = RemitaConfigParam.MEMBERSHIPREGISTRATION;
}
else if (model.FeeCategory == PaymentType.MonthlyDues)
{
model.serviceTypeId = RemitaConfigParam.MONTHLYDUES;
}
if (string.IsNullOrEmpty(model.payerEmail))
{
model.payerEmail = $"{model.payerName.Trim()}@naccplateau.org";
}
var memberFee = new MembershipFee
{
OrderId = model.orderId,
FeeCategory = model.FeeCategory,
Date = DateTime.Now,
ActiveMemberId = model.ActiveMemberId,
PaidFee = model.TotalAmount,
TotalAmount = model.TotalAmount,
PaymentMode = model.PaymentMode
};
db.MembershipFee.Add(memberFee);
var log = new RemitaPaymentLog
{
OrderId = model.orderId,
PaymentName = model.FeeCategory,
PaymentDate = DateTime.Now,
Amount = model.TotalAmount.ToString(),
PayerName = model.MemberName
};
db.RemitaPaymentLog.Add(log);
await db.SaveChangesAsync();
model.hash = _query.HashRemitaRequest(model.merchantId, model.serviceTypeId, model.orderId, model.amt, model.responseurl, RemitaConfigParam.APIKEY);
return(RedirectToAction("SubmitRemita", model));
}
return(View(model));
}
// GET: MembershipRegistrations/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MembershipFee membershipFee = db.MembershipFee.Find(id);
if (membershipFee == null)
{
return(HttpNotFound());
}
return(View(membershipFee));
}
// GET: MembershipRegistrations/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MembershipFee membershipFee = db.MembershipFee.Find(id);
if (membershipFee == null)
{
return(HttpNotFound());
}
ViewBag.ActiveMemberId = new SelectList(db.ActiveMember, "ActiveMemberId", "FullName", membershipFee.ActiveMemberId);
return(View(membershipFee));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,AmountWithDiscount,CurrentState,FirstName,LastName,MiddleName,RealAmount,Start,End,LeftOver,Periodicity,ActivePrivilegeEnd,ActivePrivilegeStart,PrivilegeType,LicenseNumber")] MembershipFee membershipFee)
{
if (id != membershipFee.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var previousModel =
_context.MembershipFees.AsNoTracking().SingleOrDefault(m => m.Id == membershipFee.Id);
membershipFee.LicenseNumber = previousModel.LicenseNumber;
membershipFee.ActivePrivilegeEnd = previousModel.ActivePrivilegeEnd;
membershipFee.ActivePrivilegeStart = previousModel.ActivePrivilegeEnd;
membershipFee.LeftOver = previousModel.LeftOver;
membershipFee.PrivilegeType = previousModel.PrivilegeType;
membershipFee.Periodicity = previousModel.Periodicity;
membershipFee.MonthlyPay = previousModel.MonthlyPay;
if (Math.Abs(previousModel.RealAmount - membershipFee.RealAmount) > 10 && membershipFee.End < DateTime.Now)
{
if (HttpContext.User.Identity.Name != "*****@*****.**")
{
membershipFee.RealAmount = previousModel.RealAmount;
membershipFee.AmountWithDiscount = previousModel.AmountWithDiscount;
}
else
{
var privelegeModel =
await _context.PrivilegeModels.AsNoTracking()
.SingleOrDefaultAsync(p => p.MembershipFeeFoeignKey == membershipFee.Id);
if (privelegeModel == null)
{
membershipFee.AmountWithDiscount = membershipFee.RealAmount;
}
else
{
var privelege =
await
_context.Privileges.FirstOrDefaultAsync(
p =>
p.Type ==
privelegeModel.Type.Substring(0, privelegeModel.Type.IndexOf('(')));
var fullDays = (membershipFee.End - membershipFee.Start).TotalDays;
var discountDays = (privelegeModel.End - privelegeModel.Start).TotalDays;
double priceWithDiscount = membershipFee.RealAmount - (membershipFee.RealAmount * privelege.Discount / 100);
membershipFee.AmountWithDiscount = ((fullDays - discountDays) *
(membershipFee.RealAmount / fullDays)) +
(discountDays * priceWithDiscount / fullDays);
membershipFee.LeftOver = membershipFee.AmountWithDiscount;
var transfers = await _context.TransferPayments.Where(t => t.MembershipFeeId == privelegeModel.MembershipFeeFoeignKey).ToListAsync();
var cashs = await _context.CashModel.Where(c => c.MembershipFeeId == privelegeModel.MembershipFeeFoeignKey).ToListAsync();
foreach (var t in transfers)
{
membershipFee.LeftOver -= t.Amount;
}
foreach (var c in cashs)
{
membershipFee.LeftOver -= c.Amount;
}
}
var pendingPayments =
await
_context.Payments.Where(p => p.MembershipFeeForeignKey == membershipFee.Id && p.PaymentDeadline >= DateTime.Now)
.ToListAsync();
membershipFee.MonthlyPay = Math.Floor(membershipFee.AmountWithDiscount / 12);
double newLeftOver = 0;
foreach (var payment in pendingPayments)
{
if (payment.PaymentDeadline.Month == DateTime.Now.AddMonths(1).Month)
{
int days = DateTime.DaysInMonth(payment.PaymentDeadline.Year,
payment.PaymentDeadline.Month);
payment.Amount = ((previousModel.AmountWithDiscount / (12 * days)) * DateTime.Now.Day) +
(membershipFee.AmountWithDiscount / (12 * days) * (days - DateTime.Now.Day));
}
else
{
payment.Amount = membershipFee.MonthlyPay;
}
payment.DepositOrDebt = -payment.Amount;
newLeftOver += payment.Amount;
_context.Update(payment);
}
membershipFee.LeftOver = Math.Floor(newLeftOver);
var feeAmountChange = new FeeAmountChangeModel()
{
ChangeDate = DateTime.Now.Date,
MembershipFeeForeignKey = membershipFee.Id,
NewAmount = membershipFee.RealAmount,
OldAmount = previousModel.RealAmount
};
_context.Add(feeAmountChange);
}
}
if (membershipFee.CurrentState != previousModel.CurrentState)
{
var stateChangeModel = new FeeStateChangeModel()
{
MembershipFeeForeignKey = membershipFee.Id,
ChangeDate = DateTime.Now,
PreviousState = previousModel.CurrentState,
NewState = membershipFee.CurrentState
};
_context.Add(stateChangeModel);
if (membershipFee.CurrentState == FeeState.Pause)
{
membershipFee.Paused = DateTime.Now;
int howManyDays = (int)(membershipFee.Paused.Value - membershipFee.Start).TotalDays;
int fullDays = (int)(membershipFee.End - membershipFee.Start).TotalDays;
double paymentsSum = 0;
var cashPayments =
await
_context.CashModel.Where(c => c.MembershipFeeId == membershipFee.Id)
.ToListAsync();
var transferPayments =
await
_context.TransferPayments.Where(t => t.MembershipFeeId == membershipFee.Id)
.ToListAsync();
foreach (var cash in cashPayments)
{
paymentsSum += cash.Amount;
}
foreach (var transfer in transferPayments)
{
paymentsSum += transfer.Amount;
}
membershipFee.currentDebt = (membershipFee.AmountWithDiscount / fullDays) * howManyDays - paymentsSum;
int days = DateTime.DaysInMonth(membershipFee.Paused.Value.Year, membershipFee.Paused.Value.Month);
//var payment =
// await
// _context.Payments.SingleOrDefaultAsync(
// p =>
// p.MembershipFeeForeignKey == membershipFee.Id &&
// p.PaymentDeadline.Month == membershipFee.Paused.Value.AddMonths(1).Month);
var d = membershipFee.Paused.Value.AddMonths(1);
var nextPayDate = new DateTime(d.Year, d.Month, 14);
var payments =
await
_context.Payments.Where(
p =>
p.MembershipFeeForeignKey == membershipFee.Id &&
p.PaymentDeadline >= nextPayDate)
.OrderBy(p => p.PaymentDeadline)
.ToListAsync();
var payment =
payments.SingleOrDefault(
p => p.PaymentDeadline == nextPayDate.AddDays(1));
//double deposit = 0;
foreach (var p in payments)
{
if (p.Id == payment.Id)
{
p.Amount = Math.Floor((membershipFee.MonthlyPay / days) * (DateTime.Now.Day));
double difference = membershipFee.MonthlyPay - p.Amount;
p.DepositOrDebt += difference;
_context.Update(p);
}
else
{
if (p.Status == PaymentStatus.Payed)
{
p.DepositOrDebt = -p.Amount;
payment.DepositOrDebt += p.Amount;
_context.Update(payment);
}
else if (Math.Abs(p.DepositOrDebt.Value) < Math.Abs(p.Amount))
{
payment.DepositOrDebt += Math.Abs(p.Amount) - Math.Abs(p.DepositOrDebt.Value);
p.DepositOrDebt = -p.Amount;
_context.Update(payment);
}
p.Status = PaymentStatus.Paused;
}
_context.Update(p);
}
//_context.Update(payment);
}
else if (previousModel.CurrentState == FeeState.Pause && membershipFee.CurrentState == FeeState.Active)
{
membershipFee.Paused = previousModel.Paused;
membershipFee.Reactiveted = DateTime.Now;
membershipFee.TotalDaysPaused += (int)(DateTime.Now - previousModel.Paused.Value).TotalDays;
int days = DateTime.DaysInMonth(membershipFee.Reactiveted.Value.Year, membershipFee.Reactiveted.Value.Month);
int howManyDays = (int)(membershipFee.Paused.Value - membershipFee.Start).TotalDays;
int fullDays = (int)(membershipFee.End - membershipFee.Start).TotalDays;
//var d = membershipFee.Paused.Value.AddMonths(1);
//var nextPayDate = new DateTime(d.Year, d.Month, 14);
//var lostPayments =
// await
// _context.Payments.Where(
// p =>
// p.MembershipFeeForeignKey == membershipFee.Id &&
// p.PaymentDeadline > membershipFee.Paused.Value.AddMonths(1) &&
// p.PaymentDeadline <= membershipFee.Reactiveted.Value).ToListAsync();
var payments =
await
_context.Payments.Where(
p =>
p.MembershipFeeForeignKey == membershipFee.Id &&
p.PaymentDeadline > membershipFee.Reactiveted.Value &&
p.Status == PaymentStatus.Paused).ToListAsync();
foreach (var p in payments)
{
if (p.PaymentDeadline.Month == membershipFee.Reactiveted.Value.AddMonths(1).Month)
{
p.Amount = Math.Floor((membershipFee.MonthlyPay / days) * (days - DateTime.Now.Day));
membershipFee.LeftOver -= membershipFee.MonthlyPay - p.Amount;
}
p.Status = PaymentStatus.Pending;
_context.Update(p);
}
await _context.SaveChangesAsync();
var cashPayments =
await
_context.CashModel.Where(c => c.MembershipFeeId == membershipFee.Id)
.ToListAsync();
var transferPayments =
await
_context.TransferPayments.Where(t => t.MembershipFeeId == membershipFee.Id)
.ToListAsync();
foreach (var cash in cashPayments)
{
SiteHelpers.ReCountPayments(membershipFee.Id, cash, null, _context);
}
foreach (var transfer in transferPayments)
{
SiteHelpers.ReCountPayments(membershipFee.Id, null, transfer, _context);
}
}
else if (membershipFee.CurrentState == FeeState.Finish)
{
if (previousModel.End != DateTime.Now.Date)
{
membershipFee.End = DateTime.Now.Date;
int days = DateTime.DaysInMonth(membershipFee.End.Year, membershipFee.End.Month);
var pendingPayments = _context.Payments.Where(p => p.PaymentDeadline > DateTime.Now);
foreach (var payment in pendingPayments)
{
if (payment.PaymentDeadline.Month == DateTime.Now.Month + 1)
{
payment.Amount = Math.Floor((previousModel.MonthlyPay / days) * DateTime.Now.Day);
}
else
{
payment.Status = PaymentStatus.Cancelled;
}
_context.Update(payment);
}
}
}
}
try
{
_context.Update(membershipFee);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MembershipFeeExists(membershipFee.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(View(membershipFee));
}
public async Task <IActionResult> Create([Bind("AmountWithDiscount,FirstName,LastName,MiddleName,RealAmount,Start,Periodicity,ActivePrivilegeEnd,ActivePrivilegeStart,PrivilegeType,LicenseNumber")] MembershipFee membershipFee)
{
//var rand = new Random();
//var privileges = await _context.Privileges.ToListAsync();
//for (int i = 1; i < 500; i++)
//{
// var start = DateTime.Now.AddDays(rand.Next(1, 29)).AddMonths(rand.Next(1, 12));
// var fee = new MembershipFee()
// {
// Id = Guid.NewGuid().ToString(),
// RealAmount = i * 10000,
// AmountWithDiscount = i * 5000,
// CurrentState = rand.Next(2) == 1 ? FeeState.Active : FeeState.Pause,
// FirstName = "Firstname" + i,
// LastName = "LastName" + i,
// MiddleName = "MiddleName" + i,
// Start = start,
// End = start.AddMonths(12),
// LeftOver = i * 10000,
// MonthlyPay = i * 10000 / 12,
// Periodicity = FeePeriodicity.Year,
// PrivilegeType = rand.Next(0, 2) == 1 ? privileges[1].Type : privileges[0].Type,
// ActivePrivilegeStart = start,
// ActivePrivilegeEnd = start.AddMonths(12),
// ActivePrivilegeNo = rand.Next(),
// };
// _context.Add(fee);
//}
//for (int i = 0; i < 50; i++)
//{
// var start = DateTime.Now.AddDays(rand.Next(1, 29)).AddMonths(rand.Next(1, 12));
// var payments = new TransferPayment()
// {
// Id = Guid.NewGuid().ToString(),
// Amount = i * 5100,
// Date = DateTime.Now.AddDays(i * 3),
// FullName = "FirstName" + i * 10 + " LastName" + i * 10,
// Destination = "chem manum",
// PaymentNo = (i * 1000).ToString(),
// };
// _context.Add(payments);
//}
//for (int i = 0; i < 100; i++)
//{
// var cashes = new CashModel()
// {
// Id = Guid.NewGuid().ToString(),
// FullName = "FirstName" + i * 10 + " LastName" + i * 10,
// AccountingPass = (i * 123).ToString(),
// Amount = i * 4320,
// Date = DateTime.Now.AddDays(i * 2),
// Destination = "chem manum asi",
// OrdersNumber = (i * 10000 + i * 378).ToString(),
// Type = rand.Next(0, 2) == 1 ? BargainType.CashIn : BargainType.CashOut,
// //?ccount ="asfasfasfasfas"
// };
// _context.Add(cashes);
//}
//await _context.SaveChangesAsync();
if (ModelState.IsValid)
{
membershipFee.AmountWithDiscount = membershipFee.RealAmount;
membershipFee.LeftOver = membershipFee.AmountWithDiscount;
membershipFee.End = membershipFee.Periodicity == FeePeriodicity.Year
? membershipFee.Start.AddMonths(12)
: membershipFee.Start.AddMonths(1);
if (membershipFee.Periodicity != FeePeriodicity.Month)
{
membershipFee.MonthlyPay = Math.Floor(membershipFee.RealAmount / 12);
}
if (!string.IsNullOrEmpty(membershipFee.PrivilegeType) && membershipFee.ActivePrivilegeStart != null &&
membershipFee.ActivePrivilegeEnd > membershipFee.ActivePrivilegeStart)
{
var privilige = _context.Privileges.AsNoTracking().FirstOrDefault(p => p.Type == membershipFee.PrivilegeType);
var priviligeModel = new PrivilegeModel()
{
Start = membershipFee.ActivePrivilegeStart.Value,
End = membershipFee.ActivePrivilegeEnd.Value,
Type = membershipFee.PrivilegeType + $"({privilige.Discount})",
MembershipFeeFoeignKey = membershipFee.Id
};
_context.Add(priviligeModel);
var fullDays = (int)(membershipFee.End - membershipFee.Start).TotalDays;
var discountDays = (int)(priviligeModel.End - priviligeModel.Start).TotalDays;
double priceWithDiscount =
Math.Floor(membershipFee.RealAmount - (membershipFee.RealAmount * privilige.Discount / 100));
membershipFee.AmountWithDiscount =
Math.Floor(((fullDays - discountDays) * (membershipFee.RealAmount / fullDays)) +
(discountDays * priceWithDiscount / fullDays));
membershipFee.MonthlyPay = Math.Floor(membershipFee.AmountWithDiscount / 12);
membershipFee.LeftOver = membershipFee.AmountWithDiscount;
}
_context.Add(membershipFee);
await _context.SaveChangesAsync();
SiteHelpers.AddPaymentsForFee(membershipFee.Id, _context);
return(RedirectToAction("Index"));
}
return(View(membershipFee));
}
public MembershipFeeDto(MembershipFee membershipFee)
{
Id = membershipFee.Id;
Name = membershipFee.Name;
Amount = membershipFee.Amount;
}
public MembershipInformation()
{
MembershipPersonTypes = new List <string>();
MembershipFee = new MembershipFee();
MeetingOptions = new MeetingOptions(MeetingTypes.Members);
}
