private void ResetRandomnessPage(SSCasino_DBContext dbCasino, Randomness model)
//================================================================================================================
// Reset the data for the randomness page
//
// Parameters
// dbCasino: Open connection to the database
// model: Reference to a randomness model
//================================================================================================================
{
// Reset the shuffing results
// Get default card packs
SiteHelpers.ClearCombinedShuffleResults();
model.ShuffledPackageFisher.CardPack = CreateCardPackModel(dbCasino, sampleSize: SiteHelpers.SampleSizes.FourCardSample);
model.ShuffledPackageNaive.CardPack = CreateCardPackModel(dbCasino, sampleSize: SiteHelpers.SampleSizes.FourCardSample);
}
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 ActionResult Randomness_RefreshResultsGraph()
//================================================================================================================
// This action is invoked when the shuffling results graph needs to be refreshed.
//
// Event Arguments
// arg_Action: Action to be performed
// arg_ResizeWidth: New size of the parent container
//
// Returns
// The sguffling results grasph
//================================================================================================================
{
// Retrieve the action to be performed
string action = !string.IsNullOrEmpty(Request.Params[ARG_ACTION]) ? Request.Params[ARG_ACTION] : "";
// Create the model
// Get the current size of the results graph
ShuffleResultsGraph model = new ShuffleResultsGraph();
if (Session[SiteHelpers.ResultsGraphWidth] != null)
{
model.ResizeWidth = (int)Session[SiteHelpers.ResultsGraphWidth];
model.ResizeHeight = (int)Session[SiteHelpers.ResultsGraphHeight];
}
// Retrieve the shuffling results
SSCasino_DBContext dbCasino = null;
try
{
// Perform the action
switch (action)
{
case ACT_RESIZE_CHART:
// Get the resize width and height
int resultsGridWidth = !string.IsNullOrEmpty(Request.Params[ARG_RESULTS_GRAPH_WIDTH]) ? int.Parse(Request.Params[ARG_RESULTS_GRAPH_WIDTH]) : 0;
int resultsGridHeight = !string.IsNullOrEmpty(Request.Params[ARG_RESULTS_GRAPH_HEIGHT]) ? int.Parse(Request.Params[ARG_RESULTS_GRAPH_HEIGHT]) : 0;
// Calculate the new width and height of the shuffling results graph
// Store these values in the sesssion object for use on refeshes
model.ResizeWidth = ((resultsGridWidth == 0) ? model.DeafultWidth : resultsGridWidth);
model.ResizeHeight = ((resultsGridHeight == 0) ? model.DefaultHeight : resultsGridHeight);
Session[SiteHelpers.ResultsGraphWidth] = model.ResizeWidth;
Session[SiteHelpers.ResultsGraphHeight] = model.ResizeHeight;
break;
case ACT_CHANGE_SAMPLE_SIZE:
// Reset the shuffing results
SiteHelpers.ClearCombinedShuffleResults();
break;
case ACT_RESET:
// Reset the shuffing results
SiteHelpers.ClearCombinedShuffleResults();
break;
}
// Always get the results
GetShuffleResults(model);
}
finally
{
if (dbCasino != null)
{
dbCasino.Dispose();
}
}
return(PartialView("_Randomness_ResultsGraph", model));
}
public ActionResult Randomness_PerformAction()
//================================================================================================================
// This action is invoked when the card display area is performing an action on the cards.
//
// Event Arguments
// arg_Action: Action to be performed
// arg_CardPackId: Unique id of a card pack
// arg_ShuffleCount: Number of time to shuffle
// arg_SampleSize: Sample size of cards to shuffle
//
// Returns
// The card display view
//================================================================================================================
{
// Retrieve the action to be performed and the event arguments
string action = !string.IsNullOrEmpty(Request.Params[ARG_ACTION]) ? Request.Params[ARG_ACTION] : "";
int cardPackId = !string.IsNullOrEmpty(Request.Params[ARG_CARD_PACK_ID]) ? int.Parse(Request.Params[ARG_CARD_PACK_ID]) : 0;
int shuffleCount = !string.IsNullOrEmpty(Request.Params[ARG_SHUFFLE_COUNT]) ? int.Parse(Request.Params[ARG_SHUFFLE_COUNT]) : 0;
int sampleSize = !string.IsNullOrEmpty(Request.Params[ARG_SAMPLE_SIZE]) ? int.Parse(Request.Params[ARG_SAMPLE_SIZE]) : 0;
// Create the model
Randomness model = new Randomness();
// Perform the action
SSCasino_DBContext dbCasino = null;
try
{
// Connect the the database
dbCasino = new SSCasino_DBContext();
// Perform the action
switch (action)
{
case ACT_SHUFFLE:
// Get card packs for the shuffler
model.ShuffledPackageFisher.CardPack = CreateCardPackModel(dbCasino, cardPackId, (SiteHelpers.SampleSizes)sampleSize);
model.ShuffledPackageNaive.CardPack = CreateCardPackModel(dbCasino, cardPackId, (SiteHelpers.SampleSizes)sampleSize);
// Shuffle the cards
model.ShuffledPackageFisher = SiteHelpers.ShuffleCards(model.ShuffledPackageFisher.CardPack, SiteHelpers.ShuffleTypes.FisherYates, shuffleCount, true);
model.ShuffledPackageNaive = SiteHelpers.ShuffleCards(model.ShuffledPackageNaive.CardPack, SiteHelpers.ShuffleTypes.Naive, shuffleCount, true);
// Merge the Fisher-Yates and Naive shuffle results
SiteHelpers.CombinedShuffleResults = (ICollection <ShuffleResult>)model.ShuffledPackageFisher.ShuffleResults.Concat <ShuffleResult>(model.ShuffledPackageNaive.ShuffleResults).ToList();
break;
case ACT_CHANGE_CARD_PACK:
// Get card packs for the shuffler
model.ShuffledPackageFisher.CardPack = CreateCardPackModel(dbCasino, cardPackId, (SiteHelpers.SampleSizes)sampleSize);
model.ShuffledPackageNaive.CardPack = CreateCardPackModel(dbCasino, cardPackId, (SiteHelpers.SampleSizes)sampleSize);
break;
case ACT_CHANGE_SAMPLE_SIZE:
// Reset the shuffing results
// Get card packs based on sample size
SiteHelpers.ClearCombinedShuffleResults();
model.ShuffledPackageFisher.CardPack = CreateCardPackModel(dbCasino, cardPackId, (SiteHelpers.SampleSizes)sampleSize);
model.ShuffledPackageNaive.CardPack = CreateCardPackModel(dbCasino, cardPackId, (SiteHelpers.SampleSizes)sampleSize);
break;
default:
// Get default data for the page
ResetRandomnessPage(dbCasino, model);
break;
}
// Always get the number of shuffles and the aggregated shuffle results
model.ShuffleResultsData.ResizeWidth = (int)Session[SiteHelpers.ResultsGraphWidth];
model.ShuffleResultsData.ResizeHeight = (int)Session[SiteHelpers.ResultsGraphHeight];
GetShuffleResults(model.ShuffleResultsData);
}
finally
{
if (dbCasino != null)
{
dbCasino.Dispose();
}
}
return(PartialView("_Randomness_DisplayCBP", model));
}
public ActionResult CardShuffler_PerformAction()
//================================================================================================================
// This action is invoked when the card display area is performing an action on the cards.
//
// Event Arguments
// arg_Action: Action to be performed
// arg_CardPackId: Unique id of a card pack
// arg_ShuffleCount: Number of time to shuffle
// arg_ShuffleType: Shuffle algorithm
//
// Returns
// The card display view
//================================================================================================================
{
CardPack cardPack = null;
// Retrieve the action to be performed and the assigned card pack
string action = !string.IsNullOrEmpty(Request.Params[ARG_ACTION]) ? Request.Params[ARG_ACTION] : "";
int cardPackId = !string.IsNullOrEmpty(Request.Params[ARG_CARD_PACK_ID]) ? int.Parse(Request.Params[ARG_CARD_PACK_ID]) : 0;
// Connect to the database and perform the action
SSCasino_DBContext dbCasino = null;
try
{
// Connect the the database
dbCasino = new SSCasino_DBContext();
// Perform the action
switch (action)
{
case ACT_SHUFFLE:
// Retrieve an unshuffled pack of cards
cardPack = CreateCardPackModel(dbCasino, cardPackId);
// Shuffle the cards
int shuffleType = !string.IsNullOrEmpty(Request.Params[ARG_SHUFFLE_TYPE]) ? int.Parse(Request.Params[ARG_SHUFFLE_TYPE]) : 1;
int shuffleCount = !string.IsNullOrEmpty(Request.Params[ARG_SHUFFLE_COUNT]) ? int.Parse(Request.Params[ARG_SHUFFLE_COUNT]) : 1;
ShuffledPackage shuffledPackage = SiteHelpers.ShuffleCards(cardPack, (SiteHelpers.ShuffleTypes)shuffleType, shuffleCount, false);
cardPack = shuffledPackage.CardPack;
break;
case ACT_CHANGE_CARD_PACK:
// Retrieve an unshuffled pack of cards
cardPack = CreateCardPackModel(dbCasino, cardPackId);
break;
default:
// Get the default card pack
cardPack = CreateCardPackModel(dbCasino);
break;
}
}
finally
{
if (dbCasino != null)
{
dbCasino.Dispose();
}
}
return(PartialView("_CardShuffler_DisplayCBP", cardPack.CardDeck));
}
