public async Task <IActionResult> Create(PaymentPlanViewModel view)
{
if (ModelState.IsValid)
{
try
{
if (await CheckBudget(view))
{
PaymentPlan paymentPlan = this.ToPaymentPlan(view);
paymentPlan.ID = 0;
context.Add(paymentPlan);
await context.SaveChangesAsync();
return(RedirectToAction(nameof(Details), new { paymentPlan.ID }));
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
}
}
FillData(ref view);
return(View(view));
}
public static void ExpirePaymentPlan(PaymentPlan paymentPlan)
{
if (_paymentPlanRegionTokenLookup.TryRemove(paymentPlan.Id, out var token))
{
token.Cancel();
}
}
private async Task CreatePaymentPlansAsync()
{
var paymentPlans = new List <PaymentPlan>();
var freePlan = new PaymentPlan("Free", 0);
freePlan.AddFeatures(Feature.Organizations(1), Feature.UsersInOrganizations(3),
Feature.Wardens(3), Feature.WardenSpawns(1), Feature.Watchers(3),
Feature.WardenChecks(30000), Feature.WardenChecksRetentionDays(1),
Feature.Metrics(3), Feature.ApiKeys(2));
var premiumPlan = new PaymentPlan("Premium", 10);
premiumPlan.AddFeatures(Feature.Organizations(3), Feature.UsersInOrganizations(10),
Feature.Wardens(5), Feature.WardenSpawns(3), Feature.Watchers(10),
Feature.WardenChecks(300000), Feature.WardenChecksRetentionDays(7),
Feature.Metrics(10), Feature.ApiKeys(5));
var enterprisePlan = new PaymentPlan("Enterprise", 30);
enterprisePlan.AddFeatures(Feature.Organizations(5), Feature.UsersInOrganizations(20),
Feature.Wardens(10), Feature.WardenSpawns(5), Feature.Watchers(20),
Feature.WardenChecks(3000000), Feature.WardenChecksRetentionDays(30),
Feature.Metrics(30), Feature.ApiKeys(10));
paymentPlans.Add(freePlan);
paymentPlans.Add(premiumPlan);
paymentPlans.Add(enterprisePlan);
await _database.PaymentPlans().InsertManyAsync(paymentPlans);
}
public string AddPaymentPlan(AddPaymentPlanViewModel model, string userId)
{
var message = this.IsHasNullData(model);
if (string.IsNullOrEmpty(message))
{
message = this.CheckDublicatePaymentAdd(model.Name, model.CountBook);
if (string.IsNullOrEmpty(message))
{
PaymentPlan paymentPlan = new PaymentPlan()
{
CountBook = model.CountBook,
Name = model.Name,
PriceOneYear = model.PriceOneYear,
PriceTwoYears = model.PriceTwoYears,
Text = model.Text,
};
this.context.PaymentPlans.Add(paymentPlan);
this.context.SaveChanges();
message = "Успешно добавен абонаментен план!";
this.messageService.AddNotificationAtDB(userId, message);
}
}
return(message);
}
internal static PaymentPlan SelectPaymentPlan(string planName)
{
PaymentPlan paymentPlan = null;
StringBuilder SqlStatement = new StringBuilder();
//SQL Statement =============================================================
SqlStatement.Append("Select * From PaymentPlans ");
SqlStatement.Append("Where PaymentPlanName='");
SqlStatement.Append(planName);
SqlStatement.Append("'");
//SqlCommand sqlCommand = new SqlCommand(SqlStatement.ToString(), Sahara.Core.Settings.Azure.Databases.DatabaseConnections.AccountsSqlConnection);
SqlCommand sqlCommand = Settings.Azure.Databases.DatabaseConnections.AccountsSqlConnection.CreateCommand();
sqlCommand.CommandText = SqlStatement.ToString();
sqlCommand.Connection.OpenWithRetry();
SqlDataReader reader = sqlCommand.ExecuteReaderWithRetry();
while (reader.Read())
{
paymentPlan = Transforms.Transforms.DataReader_to_PaymentPlan(reader);
}
sqlCommand.Connection.Close();
return(paymentPlan);
}
/// <summary>
/// Полная перезагрузка плановых платежей
/// </summary>
public void ReloadPaymentsPlannedFull()
{
PaymentsPlanned.Clear();
foreach (var condition in PaymentConditionsToDone)
{
var payment = new PaymentPlan {
SumAndVat = new SumAndVat {
Sum = CostSingle.Sum * condition.PartInPercent / 100, Vat = CostSingle.Vat
}
};
//дата платежа
if (condition.PaymentConditionPoint == PaymentConditionPoint.ProductionStart)
{
payment.Date = ProductionUnit.ProductionStartDateCalculated.AddDays(condition.DaysToPoint);
}
if (condition.PaymentConditionPoint == PaymentConditionPoint.ProductionEnd)
{
payment.Date = ProductionUnit.ProductionEndDateCalculated.AddDays(condition.DaysToPoint);
}
if (condition.PaymentConditionPoint == PaymentConditionPoint.Shipment)
{
payment.Date = ShipmentUnit.ShipmentDateCalculated.AddDays(condition.DaysToPoint);
}
if (condition.PaymentConditionPoint == PaymentConditionPoint.Delivery)
{
payment.Date = ShipmentUnit.DeliveryDateCalculated.AddDays(condition.DaysToPoint);
}
var paymentWrapper = new PaymentPlanWrapper(payment);
PaymentsPlanned.Add(paymentWrapper);
}
}
public void ComputeBalancesTest()
{
PaymentPlan target = new PaymentPlan(); // TODO: Initialize to an appropriate value
target.ComputeBalances();
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
public void ShouldReturnTrueTotalInstallementAmountEqualsTotalPurchaseAmount(decimal purchaseAmount)
{
var paymentPlan = new PaymentPlan(purchaseAmount);
var totalInstallmentAmount = paymentPlan.Installments.Sum(i => i.Amount);
Assert.Equal(paymentPlan.TotalAmountOwed, totalInstallmentAmount);
}
public ActionResult Change(string planId)
{
if (!Core.Configuration.SubscriptionsEnabled)
{
ConfirmationNotification("Errordite subscriptions are not currently enabled, you may continue using the free trial until subscriptions become active.");
return(RedirectToAction("index"));
}
var plans = _getAvailablePaymentPlansQuery.Invoke(new GetAvailablePaymentPlansRequest()).Plans;
var newPlan = plans.FirstOrDefault(p => p.FriendlyId == planId.GetFriendlyId());
if (newPlan == null)
{
ErrorNotification("Unrecognised payment plan id {0}, cannot change your subscription.".FormatWith(planId));
return(RedirectToAction("index"));
}
var model = new ChangeSubscriptionViewModel
{
CurrentPlan = Core.AppContext.CurrentUser.ActiveOrganisation.PaymentPlan,
NewPlan = newPlan,
NewPlanId = PaymentPlan.GetId(planId),
CurrentBillingPeriodEnd = Core.AppContext.CurrentUser.ActiveOrganisation.Subscription.CurrentPeriodEndDate,
Downgrading = newPlan.Rank < Core.AppContext.CurrentUser.ActiveOrganisation.PaymentPlan.Rank
};
model.NewPlanName = model.NewPlan.Name;
return(View(model));
}
[InlineData(500.00, 4, -10)] //test when the number of days between installment payments cannot be a negative value
public void ShouldThrowExceptionForInvalidParameters(decimal amount, int installmentCount, int installmentIntervalDays)
{
Assert.Throws <ArgumentException>(() =>
{
var paymentPlan = new PaymentPlan(amount, installmentCount, installmentIntervalDays);
});
}
public LoanCreatedEvent(DateTimeOffset createdOn, decimal amount, Duration term, PaymentPlan paymentPlan)
{
CreatedOn = createdOn;
Amount = amount;
Term = term;
PaymentPlan = paymentPlan;
}
public static PlanQuotas FromStats(Statistics stats, PaymentPlan plan)
{
return(new PlanQuotas
{
IssuesExceededBy = stats.TotalIssues - plan.MaximumIssues,
});
}
public void OrderSystem_PaymentPlan_CreateFromOrder_FirstPurchaseOrder()
{
Cart cart = OrderHelper.CreateCartSimple(Guid.NewGuid());
cart.OrderForms[0].Payments.Clear();
cart.OrderForms[0].Payments.Add(OrderHelper.CreateCreditCardPayment());
cart.AcceptChanges();
cart.RunWorkflow("CartValidate");
cart.RunWorkflow("CartPrepare");
cart.OrderForms[0].Payments[0].Amount = cart.Total;
//cart.RunWorkflow("CartCheckout");
cart.AcceptChanges();
// Create payment plan
PaymentPlan plan = cart.SaveAsPaymentPlan();
// Set some payment plan values
// Monthly subscription for a year
plan.CycleMode = PaymentPlanCycle.Months;
plan.CycleLength = 1;
plan.MaxCyclesCount = 12;
plan.StartDate = DateTime.UtcNow;
plan.EndDate = DateTime.UtcNow.AddMonths(13);
plan.LastTransactionDate = DateTime.UtcNow;
// Send emails
OrderHelper.SendEmail(plan, "order-paymentplan-confirm");
OrderHelper.SendEmail(plan, "order-paymentplan-notify");
// Now create first PO from the payment plan
PurchaseOrder po = plan.SaveAsPurchaseOrder();
// Validate
Assert.AreEqual(po.OrderForms[0].Payments.Count, 1);
}
public async Task <IActionResult> Edit(int id, PaymentPlanViewModel view)
{
if (id != view.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
PaymentPlan paymentPlan = this.ToPaymentPlan(view);
context.Update(paymentPlan);
await context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaymentPlanExists(view.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Details), new { id }));
}
FillData(ref view);
return(View(view));
}
public async Task GetByIdsAsync_GetThenSavePaymentPlan_ReturnCachedPaymentPlan()
{
//Arrange
var id = Guid.NewGuid().ToString();
var newPaymentPlan = new PaymentPlan {
Id = id
};
var newPaymentPlanEntity = AbstractTypeFactory <PaymentPlanEntity> .TryCreateInstance().FromModel(newPaymentPlan, new PrimaryKeyResolvingMap());
var service = GetPaymentPlanServiceWithPlatformMemoryCache();
_subscriptionRepositoryFactoryMock.Setup(x => x.Add(newPaymentPlanEntity))
.Callback(() =>
{
_subscriptionRepositoryFactoryMock.Setup(o => o.GetPaymentPlansByIdsAsync(new[] { id }))
.ReturnsAsync(new[] { newPaymentPlanEntity });
});
//Act
var nullPaymentPlan = await service.GetByIdsAsync(new [] { id }, null);
await service.SavePlansAsync(new[] { newPaymentPlan });
var paymentPlan = await service.GetByIdsAsync(new[] { id }, null);
//Assert
Assert.NotEqual(nullPaymentPlan, paymentPlan);
}
public virtual async Task <Subscription> TryCreateSubscriptionFromOrderAsync(CustomerOrder order)
{
Subscription retVal = null;
PaymentPlan paymentPlan = null;
if (!string.IsNullOrEmpty(order.ShoppingCartId))
{
//Retrieve payment plan with id as the same order original shopping cart id
paymentPlan = (await _paymentPlanService.GetByIdsAsync(new[] { order.ShoppingCartId })).FirstOrDefault();
}
if (paymentPlan == null)
{
//Try to create subscription if order line item with have defined PaymentPlan
//TODO: On the right must also be taken into account when the situation in the order contains items with several different plans
paymentPlan = (await _paymentPlanService.GetByIdsAsync(order.Items.Select(x => x.ProductId).ToArray())).FirstOrDefault();
}
//Generate numbers for new subscriptions
var store = await _storeService.GetByIdAsync(order.StoreId);
var numberTemplate = store.Settings.GetSettingValue("Subscription.SubscriptionNewNumberTemplate", "SU{0:yyMMdd}-{1:D5}");
if (paymentPlan != null)
{
var now = DateTime.UtcNow;
//There need to make "prototype" for future orders which will be created by subscription schedule information
retVal = AbstractTypeFactory <Subscription> .TryCreateInstance <Subscription>();
retVal.StoreId = order.StoreId;
retVal.Number = _uniqueNumberGenerator.GenerateNumber(numberTemplate);
retVal.CustomerOrderPrototype = CloneCustomerOrder(order);
//Need to prevent subscription creation for prototype order in CreateSubscriptionHandler
retVal.CustomerOrderPrototype.Number = retVal.Number;
retVal.CustomerOrderPrototype.IsPrototype = true;
retVal.CustomerId = order.CustomerId;
retVal.CustomerName = order.CustomerName;
retVal.Interval = paymentPlan.Interval;
retVal.IntervalCount = paymentPlan.IntervalCount;
retVal.StartDate = now;
retVal.CurrentPeriodStart = now;
retVal.TrialPeriodDays = paymentPlan.TrialPeriodDays;
retVal.SubscriptionStatus = SubscriptionStatus.Active;
retVal.CurrentPeriodEnd = GetPeriodEnd(now, paymentPlan.Interval, paymentPlan.IntervalCount);
if (retVal.TrialPeriodDays > 0)
{
retVal.TrialSart = now;
retVal.TrialEnd = GetPeriodEnd(now, PaymentInterval.Days, retVal.TrialPeriodDays);
//For trial need to shift start and end period
retVal.CurrentPeriodStart = retVal.TrialEnd;
retVal.CurrentPeriodEnd = GetPeriodEnd(retVal.TrialEnd.Value, paymentPlan.Interval, paymentPlan.IntervalCount);
}
retVal.CustomerOrders = new List <CustomerOrder>
{
order
};
}
return(retVal);
}
public void ShouldThrowExceptionWhenInstallmentNotFoundWhileMakingPayment()
{
var paymentPlan = new PaymentPlan(_userId, 100, ThirPartyPaymentAPIMock, 4);
var randomInstallmentId = Guid.NewGuid();
var exception = Assert.Throws <ArgumentException>(() => paymentPlan.MakePayment(25, randomInstallmentId));
exception.Message.Should().Be($"No Installment Found for Provided installmentId: {randomInstallmentId}{Environment.NewLine}Parameter name: installmentId");
}
public async Task UpdatePaymentPlanAsync(PaymentPlan plan)
{
var paymentPlanDto = plan.ToPaymentPlanDto();
await _subscriptionApi.UpdatePaymentPlanAsync(paymentPlanDto);
PaymentPlanCacheRegion.ExpireRegion();
}
public void SummariesTest()
{
PaymentPlan target = new PaymentPlan(); // TODO: Initialize to an appropriate value
List <PaymentPlanSummary> actual;
actual = target.Summaries;
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void ShouldRefundNothingIfNothingPaid()
{
var paymentPlan = new PaymentPlan(100, 4);
Refund refund = new Refund(Guid.NewGuid().ToString(), 100);
var cashRefund = paymentPlan.ApplyRefund(refund);
Assert.Equal(0, cashRefund);
}
public void InstallmentsTest()
{
PaymentPlan target = new PaymentPlan(); // TODO: Initialize to an appropriate value
IList <PaymentInstallment> actual;
actual = target.Installments;
Assert.Inconclusive("Verify the correctness of this test method.");
}
/// <summary>
/// Processes the create command.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="customer">The customer.</param>
/// <returns></returns>
void ProcessCreateCommand(int id, Guid customer)
{
PaymentPlan order = OrderContext.Current.GetPaymentPlan(customer, id);
if (order != null)
{
order.SaveAsPurchaseOrder();
}
}
public void ShouldCreateCorrectNumberOfInstallments(
decimal amount,
int installmentCount,
int installmentIntervalDays)
{
var paymentPlan = new PaymentPlan(_userId, amount, ThirPartyPaymentAPIMock, installmentCount, installmentIntervalDays);
paymentPlan.Installments.Count.Should().Be(installmentCount);
}
public void OutstandingBalanceShouldReflectDefaultedPayments()
{
var paymentPlan = new PaymentPlan(100, 4);
var firstInstallment = paymentPlan.FirstInstallment();
paymentPlan.MakePayment(25, firstInstallment.Id);
firstInstallment.SetDefaulted();
Assert.Equal(100, paymentPlan.OustandingBalance());
}
public void ShouldThrowExceptionWhenAmountDoesNotMatch(decimal paymentAmount)
{
SetupPaymentService();
var paymentPlan = new PaymentPlan(_userId, 100, ThirPartyPaymentAPIMock, 4);
var firstInstallment = paymentPlan.FirstInstallment();
var exception = Assert.Throws <ArgumentException>(() => paymentPlan.MakePayment(paymentAmount, firstInstallment.Id));
exception.Message.Should().Be($"Payment amount must match installment amount.{Environment.NewLine}Parameter name: amount");
}
public void PaymentAmountIncorrectShouldThrowArgumentException(int paymentAmount)
{
var paymentPlan = new PaymentPlan(100, 4);
var firstInstallment = paymentPlan.FirstInstallment();
Assert.Throws <ArgumentException>(() =>
{
paymentPlan.MakePayment(paymentAmount, firstInstallment.Id);
});
}
public virtual subscriptionDto.PaymentPlan ToPaymentPlanDto(PaymentPlan paymentPlan)
{
var result = new subscriptionDto.PaymentPlan();
result.Id = paymentPlan.Id;
result.Interval = paymentPlan.Interval.ToString();
result.IntervalCount = paymentPlan.IntervalCount;
result.TrialPeriodDays = paymentPlan.TrialPeriodDays;
return(result);
}
public void GetBalanceTest()
{
PaymentPlan target = new PaymentPlan(); // TODO: Initialize to an appropriate value
uint expected = 0; // TODO: Initialize to an appropriate value
uint actual;
actual = target.GetBalance();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public virtual PaymentPlan ToPaymentPlan(subscriptionDto.PaymentPlan paymentPlanDto)
{
var result = new PaymentPlan();
result.Id = paymentPlanDto.Id;
result.Interval = EnumUtility.SafeParse(paymentPlanDto.Interval, PaymentInterval.Months);
result.IntervalCount = paymentPlanDto.IntervalCount ?? 0;
result.TrialPeriodDays = paymentPlanDto.TrialPeriodDays ?? 0;
return(result);
}
public async Task <PaymentPlan> AddPaymentPlanAsync(PaymentPlan paymentPlan)
{
var result = await _context.AddAsync(paymentPlan);
if (await SaveAsync() > 0)
{
return(result.Entity);
}
return(null);
}
