public void Update_Entity_Updated()
{
// Arrange
const int id = 840;
const string alphabeticCode = "USD";
var mockRepository = new Mock <IRepository <CurrencyEntity, int> >(MockBehavior.Strict);
mockRepository.Setup(x => x.Update(new CurrencyEntity {
Id = id, AlphabeticCode = alphabeticCode
}, false)).Returns(new CurrencyEntity()).Verifiable();
var mockUnitOfWork = new Mock <ICurrencyUnitOfWork>(MockBehavior.Strict);
mockUnitOfWork.SetupGet(x => x.CurrencyRepository).Returns(mockRepository.Object);
mockUnitOfWork.Setup(x => x.Commit()).Returns(1).Verifiable();
var service = new CurrencyService(mockUnitOfWork.Object);
var item = new CurrencyDto
{
Id = id,
AlphabeticCode = alphabeticCode
};
// Act
service.Update(item);
// Assert
mockRepository.Verify();
mockUnitOfWork.Verify();
}
public void UpdateComponent(Component component, CompositionData compositionData)
{
MaterialRepository materialRepository = new MaterialRepository();
MaterialDto material = materialRepository.GetByName(component.Name);
component.Density = material.Density;
component.IsSemiProduct = material.IsIntermediate;
component.SemiProductNrD = material.IntermediateNrD;
component.PriceKg = (double)material.Price;
component.VocPercent = material.VOC;
component.SemiStatus = "";
if (material.Id > 0)
{
CurrencyRepository currencyRepository = new CurrencyRepository();
CurrencyDto currency = currencyRepository.GetById(material.CurrencyId, CurrencyRepository.GetByIdQuery);
component.Rate = (double)currency.Rate;
UpdatePriceAndVoc(component, material.VOC);
}
CompositionSubRecipeDto recipeDto = new CompositionSubRecipeDto(component.Id, component.Level, component.SemiProductNrD, component.Operation, component.Amount, component.Mass, component.ParentsId);
component.SemiRecipe = component.IsSemiProduct ? GetSemiRecipe(recipeDto) : new List <Component>();
}
public CurrencyDto EditCurrency(CurrencyDto CurrencyDto, int userId, int tenantId)
{
var CurrencyObj = _CurrencyService.Query(x => x.CurrencyId == CurrencyDto.CurrencyId && x.TenantId == tenantId).Select().FirstOrDefault();
if (CurrencyObj == null)
{
throw new NotFoundException(ErrorCodes.ProductNotFound);
}
ValidateCurrency(CurrencyDto, tenantId);
foreach (var CurrencyName in CurrencyDto.TitleDictionary)
{
var CurrencyTranslation = CurrencyObj.CurrencyTranslations.FirstOrDefault(x => x.Language.ToLower() == CurrencyName.Key.ToLower() &&
x.CurrencyId == CurrencyDto.CurrencyId);
if (CurrencyTranslation == null)
{
CurrencyObj.CurrencyTranslations.Add(new CurrencyTranslation
{
Title = CurrencyName.Value,
Language = CurrencyName.Key
});
}
else
{
CurrencyTranslation.Title = CurrencyName.Value;
}
}
CurrencyObj.LastModificationTime = Strings.CurrentDateTime;
CurrencyObj.LastModifierUserId = userId;
CurrencyObj.IsDeleted = CurrencyDto.IsDeleted;
_CurrencyService.Update(CurrencyObj);
SaveChanges();
return(CurrencyDto);
}
public CurrencyDto CreateCurrency(CurrencyDto CurrencyDto, int userId, int tenantId)
{
if (GetCurrency(CurrencyDto.CurrencyId, tenantId) != null)
{
return(EditCurrency(CurrencyDto, userId, tenantId));
}
ValidateCurrency(CurrencyDto, tenantId);
var CurrencyObj = Mapper.Map <Currency>(CurrencyDto);
foreach (var CurrencyName in CurrencyDto.TitleDictionary)
{
CurrencyObj.CurrencyTranslations.Add(new CurrencyTranslation
{
Title = CurrencyName.Value,
Language = CurrencyName.Key,
});
}
CurrencyObj.CreationTime = Strings.CurrentDateTime;
CurrencyObj.CreatorUserId = userId;
CurrencyObj.TenantId = tenantId;
_typeTranslationService.InsertRange(CurrencyObj.CurrencyTranslations);
_CurrencyService.Insert(CurrencyObj);
SaveChanges();
return(CurrencyDto);
}
/// <summary>
/// Binds the currencies list.
/// </summary>
private void BindCurrenciesList()
{
CurrencyDto dto = CatalogContext.Current.GetCurrencyDto();
CurrencyFilter.DataSource = dto.Currency;
CurrencyFilter.DataBind();
}
private void BindCurrencyFilter()
{
CurrencyDto.CurrencyDataTable currencyDataTable = new CurrencyDto.CurrencyDataTable();
CurrencyDto currencyDto = CatalogContext.Current.GetCurrencyDto();
if (string.IsNullOrEmpty(this.MarketFilter.SelectedValue))
{
this.CurrencyFilter.DataSource = (object)currencyDto.Currency;
}
else
{
foreach (Mediachase.Commerce.Currency currency in ServiceLocator.Current.GetInstance <IMarketService>().GetMarket(new MarketId(this.MarketFilter.SelectedValue)).Currencies)
{
foreach (DataRow dataRow in (InternalDataCollectionBase)currencyDto.Currency.Rows)
{
if (currency.CurrencyCode.Equals(dataRow["CurrencyCode"].ToString(), StringComparison.OrdinalIgnoreCase))
{
DataRow row = currencyDataTable.NewRow();
row.ItemArray = dataRow.ItemArray;
currencyDataTable.Rows.Add(row);
}
}
}
this.CurrencyFilter.DataSource = (object)currencyDataTable;
}
this.CurrencyFilter.DataBind();
}
public void given_string_when_create_currency_then_return_correct_currency()
{
const string value = "123.23";
var currency = new CurrencyDto(value);
Assert.AreEqual("123.23", currency.ToString());
}
/// <summary>
/// Saves the changes.
/// </summary>
/// <param name="context">The context.</param>
public void SaveChanges(IDictionary context)
{
CurrencyDto dto = (CurrencyDto)context[_CurrencyDtoContextString];
CurrencyDto.CurrencyRow currencyRow = null;
if (dto == null)
{
// dto must be created in base control that holds tabs
return;
}
currencyRow = dto.Currency.FindByCurrencyId(CurrencyId);
if (currencyRow == null)
{
currencyRow = dto.Currency.NewCurrencyRow();
currencyRow.ApplicationId = CatalogConfiguration.Instance.ApplicationId;
}
currencyRow.Name = tbCurrencyName.Text;
currencyRow.CurrencyCode = CodeText.Text;
currencyRow.ModifiedDate = DateTime.UtcNow;
if (currencyRow.RowState == DataRowState.Detached)
{
dto.Currency.Rows.Add(currencyRow);
}
}
/// <summary>
/// Loads the context.
/// </summary>
private void LoadContext()
{
CurrencyDto currency = null;
if (!this.IsPostBack && (!this.Request.QueryString.ToString().Contains("Callback=yes"))) // load fresh on initial load
{
currency = LoadFresh();
}
else // load from session
{
currency = (CurrencyDto)Session[_CurrencyDtoEditSessionKey];
if (currency == null)
{
currency = LoadFresh();
}
}
// Put a dictionary key that can be used by other tabs
IDictionary dic = new ListDictionary();
dic.Add(_CurrencyDtoContextString, currency);
dic.Add(_CurrencyIdContextString, CurrencyId);
// Call tabs load context
ViewControl.LoadContext(dic);
}
/// <summary>
/// Gets the currency dto.
/// </summary>
/// <returns></returns>
public static CurrencyDto GetCurrencyDto()
{
// Assign new cache key, specific for site guid and response groups requested
string cacheKey = CatalogCache.CreateCacheKey("catalog-currency", CatalogConfiguration.Instance.ApplicationId.ToString());
CurrencyDto dto = null;
// check cache first
object cachedObject = CatalogCache.Get(cacheKey);
if (cachedObject != null)
{
dto = (CurrencyDto)cachedObject;
}
// Load the object
if (dto == null)
{
CurrencyAdmin admin = new CurrencyAdmin();
admin.Load();
dto = admin.CurrentDto;
// Insert to the cache collection
CatalogCache.Insert(cacheKey, dto, CatalogConfiguration.Instance.Cache.CatalogSchemaTimeout);
}
dto.AcceptChanges();
return(dto);
}
protected UpdateCartResult ProcessCreditCardTransaction(IUnitOfWork unitOfWork, CustomerOrder cart, UpdateCartParameter parameter, UpdateCartResult result)
{
AddPaymentTransactionParameter parameter1 = new AddPaymentTransactionParameter();
if (parameter.Properties.Count() > 0 && parameter.Properties.ContainsKey("AddNewCard") && parameter.Status.EqualsIgnoreCase("SaveNewCard"))
{
parameter1.ReferenceNumber = string.Empty;
parameter1.Amount = 0;
CurrencyDto currency = SiteContext.Current.CurrencyDto;
string str = (currency != null ? currency.CurrencyCode : (string)null) ?? string.Empty;
parameter1.CurrencyCode = str;
}
parameter1.TransactionType = this.paymentSettings.SubmitSaleTransaction ? TransactionType.Sale : TransactionType.Authorization;
parameter1.CreditCard = parameter.CreditCard;
string paymentProfileId = parameter.PaymentProfileId;
parameter1.PaymentProfileId = paymentProfileId;
AddPaymentTransactionResult transactionResult = this.paymentService.Value.AddPaymentTransaction(parameter1);
if (transactionResult.CreditCardTransaction != null)
{
if (parameter.Properties.Count() > 0 && parameter.Properties.ContainsKey("AddNewCard"))
{
transactionResult.CreditCardTransaction.CustomerOrderId = null;
}
else
{
transactionResult.CreditCardTransaction.CustomerOrderId = new Guid?(cart.Id);
}
}
if (transactionResult.ResultCode != ResultCode.Success)
{
return(this.CreateErrorServiceResult <UpdateCartResult>(result, transactionResult.SubCode, transactionResult.Message));
}
if (parameter.StorePaymentProfile)
{
if (parameter.Properties.Count() > 0 && parameter.Properties.ContainsKey("AddNewCard"))
{
this.paymentService.Value.AddPaymentProfile(new AddPaymentProfileParameter()
{
CurrencyCode = parameter1.CurrencyCode,
BillToId = SiteContext.Current.BillTo.Id,
CreditCard = parameter.CreditCard
});
}
else
{
this.paymentService.Value.AddPaymentProfile(new AddPaymentProfileParameter()
{
CurrencyCode = cart.Currency.CurrencyCode,
BillToId = new Guid?(cart.Customer.Id),
CreditCard = parameter.CreditCard
});
}
}
return(result);
}
public MemoDetailDto(int id, string documentNo, DateTimeOffset date, CurrencyDto currency)
{
Id = id;
DocumentNo = documentNo;
Date = date;
Currency = currency;
}
public List <CurrencyDto> Currencies()
{
var currencies = new List <CurrencyDto>();
CultureInfo
.GetCultures(CultureTypes.AllCultures)
.Where(c => !c.IsNeutralCulture).ToList()
.ForEach(
culture =>
{
try
{
var regionInfo = new RegionInfo(culture.Name);
var dto = new CurrencyDto(
regionInfo.Name,
regionInfo.CurrencyEnglishName);
if (!currencies.Contains(dto))
{
currencies.Add(dto);
}
}
catch (System.Exception)
{
// ignored
}
});
return(currencies.OrderBy(x => x.Name).ToList());
}
public async Task <ActionResult <CurrencyDto> > PutCurrency(int id, CurrencyInputDto input)
{
var currency = await _context.Currencies.FindAsync(id);
currency.Name = input.Name;
currency.ForeignName = input.ForeignName;
currency.IsActive = input.IsActive;
currency.Symbol = input.Symbol;
currency.UpdatedUserId = input.UserId;
currency.UpdatedDate = DateTime.Now;
if (currency.IsActive)
{
var currencies = await _context.Currencies.Where(x => !x.VirtualDeleted && x.Id != id).ToListAsync();
foreach (var item in currencies)
{
item.IsActive = false;
_context.Entry(item).State = EntityState.Modified;
}
}
_context.Entry(currency).State = EntityState.Modified;
var user = await _context.Users.FirstOrDefaultAsync(x => x.Id == input.UserId);
var log = new Log()
{
DateTime = DateTime.Now,
TypeFullName = typeof(Currency).FullName,
Content = "@userName@updateAction@objTitle",
TypeId = currency.Id,
UserId = user.Id
};
_context.Logs.Add(log);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CurrencyExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
var result = new CurrencyDto()
{
Id = currency.Id,
Name = currency.Name,
ForeignName = currency.ForeignName,
IsActive = currency.IsActive,
Symbol = currency.Symbol,
};
return(result);
}
public AccountBankDto(int bankAccountId, string bankAccountingCode, string bankAccountNumber, string bankName, string currencyCode, int currencyId, double currencyRate)
{
BankName = bankName;
Id = bankAccountId;
BankCode = bankAccountingCode;
AccountNumber = bankAccountNumber;
Currency = new CurrencyDto(currencyCode, currencyId, currencyRate);
}
public async Task <IHttpActionResult> Create(CurrencyDto currency)
{
_repository.Add(currency.Map <Currency>());
await _unitOfWork.CompleteAsync();
return(Created(new Uri(Request.RequestUri + "/" + currency.Id), currency));
}
private static Currency Map(CurrencyDto currencyDto)
{
return(new Currency
{
Name = currencyDto.Name,
Code = currencyDto.Code,
});
}
public void AlphabeticCode_Get_Success()
{
// Arrange
var item = new CurrencyDto();
// Act & Assert
Assert.Null(item.AlphabeticCode);
}
public void Id_Get_Success()
{
// Arrange
var item = new CurrencyDto();
// Act & Assert
Assert.Equal(0, item.Id);
}
public async Task Modify(CurrencyDto currencyDto)
{
HashEntry[] hashEntries =
{
new HashEntry(currencyDto.CurrencyCode, currencyDto.CurrencyRate)
};
await _db.HashSetAsync(CurrencyKeyName, hashEntries);
}
/// <summary>
/// Gets the specified identifier.
/// </summary>
/// <param name="id">The identifier.</param>
/// <example><code>GET: api/Currency/5</code></example>
/// <returns>CurrencyDto</returns>
public CurrencyDto Get(String id)
{
var dtoEntity = new CurrencyDto()
{
CurrencyCode = id
};
return(_CurrencyBO.GetEntiyByPK(dtoEntity));
}
public Currency MapGetCurrencyDto(CurrencyDto entity)
{
return(new Currency
{
Id = entity.Id,
Name = entity.Name,
Code = entity.Code
});
}
public async Task UpdateCurrency(CurrencyDto currency)
{
using (var uow = UnitOfWorkProvider.Create())
{
await currencyService.Update(currency);
await uow.Commit();
}
}
public void Save()
{
// save current totalCoins to the dto and then store it in the save game
CurrencyDto dto = new CurrencyDto();
dto.TotalCoins = _totalCoins;
SaveManager.Put(SaveKeys.CurrencyDataKey, dto);
}
// DELETE: api/Currency/5
public void Delete(int id)
{
var entity = new CurrencyDto()
{
CurrencyCode = id
};
_CurrencyBO.DeleteWithAttachEntiy(entity);
}
/// <summary>
/// Binds the currency.
/// </summary>
private void BindCurrency()
{
CurrencyDto currencies = CatalogContext.Current.GetCurrencyDto();
foreach (CurrencyDto.CurrencyRow row in currencies.Currency)
{
ListItem item = new ListItem(row.Name, row.CurrencyCode);
ddlCurrency.Items.Add(item);
}
}
public async Task <int> CreateCurrency(CurrencyDto currency)
{
using (var uow = UnitOfWorkProvider.Create())
{
var created = currencyService.Create(currency);
await uow.Commit();
return(created.Id);
}
}
private void BindCurrenciesDropDown()
{
CurrencyDto dto = CurrencyManager.GetCurrencyDto();
CurrenciesList.DataValueField = "CurrencyCode";
CurrenciesList.DataTextField = "Name";
CurrenciesList.DataSource = dto.Currency;
CurrenciesList.DataBind();
}
public async Task <Currency> UpdateAsync(string code, CurrencyDto dto)
{
var currency = await GetAsync(code);
currency.Symbol = dto.Symbol;
currency.Scale = dto.Scale;
await _context.SaveChangesAsync();
return(currency);
}
/// <summary>
/// Saves the changes.
/// </summary>
/// <param name="context">The context.</param>
public void SaveChanges(IDictionary context)
{
CurrencyDto dto = (CurrencyDto)context[_CurrencyDtoContextString];
if (_Currency != null && dto != null)
{
ProcessTableEvents(_Currency);
dto.CurrencyRate.Merge(_Currency.CurrencyRate, false);
}
}
private void AddRates(CurrencyDto dto, CurrencyConversion from, IEnumerable<CurrencyConversion> toCurrencies)
{
var rates = dto.CurrencyRate;
foreach (var to in toCurrencies)
{
var rate = (double)(from.Factor / to.Factor);
var fromRow = GetCurrency(dto, from.Currency);
var toRow = GetCurrency(dto, to.Currency);
rates.AddCurrencyRateRow(rate, rate, DateTime.Now, fromRow, toRow, DateTime.Now);
}
}
private double ConvertToContentItemCurrency(CurrencyDto contentItemCurrency, double amountToConvert)
{
using (var repository = RepositoryFactory.GetInstance(Session))
{
var currencyRetriever = new CurrencyRetriver(HttpContext, Session, repository);
return CurrencyConverter.Convert(amountToConvert, currencyRetriever.GetCurrent(), contentItemCurrency);
}
}
private async Task GetCouponDiscountCalculations(
double price,
double supportPrice,
CurrencyDto contentItemCurrency,
CurrencyDto currentCurrency,
ParseUser teacher,
CreateCouponViewModel cuponViewModel)
{
cuponViewModel.TeacherData.TeacherId = teacher.ObjectId;
cuponViewModel.TeacherData.TeacherFullName = teacher.GetFullName(Language.CurrentLanguageCode);
var priceIncludingSupport = CurrencyConverter.Convert(price + supportPrice, contentItemCurrency, currentCurrency);
price = CurrencyConverter.Convert(price, contentItemCurrency, currentCurrency);
await GetTeacherCommission(cuponViewModel);
var teacherCommissionAmount = price * cuponViewModel.TeacherData.TeacherCommissionRate;
var teacherCommissionAmountWithSupport = priceIncludingSupport * cuponViewModel.TeacherData.TeacherCommissionRate;
cuponViewModel.ContentItemDetails.OriginalPrice = price;
cuponViewModel.ContentItemDetails.PriceIncludignSupport = priceIncludingSupport;
cuponViewModel.ContentItemDetails.FormattedOriginalPrice = price.ToCurrency(currentCurrency);
cuponViewModel.ContentItemDetails.FormattedSupportPrice = priceIncludingSupport.ToCurrency(currentCurrency);
cuponViewModel.ContentItemDetails.Currency = contentItemCurrency;
cuponViewModel.TeacherData.TeacherDiscountPrice = price - teacherCommissionAmount;
cuponViewModel.TeacherData.TeacherDiscountPriceWithSupport = priceIncludingSupport - teacherCommissionAmountWithSupport;
cuponViewModel.TeacherData.FormattedTeacherDiscountPrice = (price - teacherCommissionAmount).ToCurrency(currentCurrency);
cuponViewModel.TeacherData.FormattedTeacherDiscountPriceWithSupport = (priceIncludingSupport - teacherCommissionAmountWithSupport).ToCurrency(currentCurrency);
}
private double ConvertToNis(double amountToConvert, out CurrencyDto currentCurrency)
{
using (var repository = RepositoryFactory.GetInstance(Session))
{
var currencyRetriever = new CurrencyRetriver(HttpContext, Session, repository);
currentCurrency = currencyRetriever.GetCurrent();
var defaultCurrency = repository.FindDefaultCurrency();
return CurrencyConverter.Convert(amountToConvert, currentCurrency, defaultCurrency);
}
}
/// <summary>
/// Create new object for check the result of transacction process
/// </summary>
/// <param name="amount">Total value of the transaction</param>
/// <param name="transactionId">Unique identifier of the client's transaction</param>
/// <param name="token">Unique identifier of the transaction Payment Point</param>
public CheckTransactionRequestDto(decimal amount, ulong transactionId, string token)
{
TransactionId = transactionId;
Currency = new CurrencyDto(amount);
Token = token;
}
private void SetCoupons(Coupon[] userCoupons, Purchase[] userPurchases, CurrencyDto currencyDto, IMyMentorRepository repository, CheckoutViewModel model)
{
var coupnIdToContentId = userCoupons.ToDictionary(x => x.ObjectId, x => x.Bundle != null ? x.Bundle.ObjectId : x.Clip.ObjectId);
var unUsedCouponids = coupnIdToContentId
.Where(x => !userPurchases.Any(p => p.BundleKey != null ? p.BundleKey.ObjectId == x.Value : p.ClipKey.ObjectId == x.Value))
.Select(x => x.Key);
var unUsedCoupons = userCoupons.Where(x => unUsedCouponids.Contains(x.ObjectId)).Union(userCoupons.Where(x => x.State == CouponStates.UnUsed.ToString()));
var couponNameTemplate = MyMentorResources.checkoutCouponTitleTemplate;
foreach (var coupon in unUsedCoupons)
{
var lessonOrBundle = coupon.Bundle != null ? MyMentorResources.checkoutBundle : MyMentorResources.checkoutLesson;
var itemName = coupon.Bundle != null
? coupon.Bundle.GetLocalizedField("bundleName")
: coupon.Clip.GetLocalizedField("name");
var originalPrice = CurrencyConverter.ConvertFromNis(coupon.OriginalPriceNIS, currencyDto, repository).ToCurrency(currencyDto);
var yourPrice = CurrencyConverter.ConvertFromNis(coupon.SiteCouponFeeNIS + coupon.TeacherCouponFeeNIS, currencyDto, repository).ToCurrency(currencyDto);
var expiration = coupon.IssueDate.AddDays(10).ToString("dd/MM/yyyy");
model.CouponsForUser.Add(coupon.ObjectId, string.Format(couponNameTemplate, lessonOrBundle, itemName, originalPrice, yourPrice, expiration));
}
}
private void FixupCurrency1(CurrencyDto previousValue)
{
if (previousValue != null && previousValue.CurrencyRates1.Contains(this))
{
previousValue.CurrencyRates1.Remove(this);
}
if (Currency1 != null)
{
if (!Currency1.CurrencyRates1.Contains(this))
{
Currency1.CurrencyRates1.Add(this);
}
if (CurrencyIdReference != Currency1.Id)
{
CurrencyIdReference = Currency1.Id;
}
}
}
//public async Task FixRecords()
//{
// var results =
// (await new ParseQuery<AccountStatement>().WhereEqualTo("currency", ParseObject.CreateWithoutData<Currency>("PrOfDBWHGg")).FindAsync()).ToArray();
// foreach (var result in results)
// {
// result["currency"] = ParseObject.CreateWithoutData<Currency>("K67StSNEYs");
// await result.SaveAsync();
// }
//}
private void HandlePaymentRequiredRecovery(CreateCouponViewModel createCouponVm, EventDto eventsDto,
IMyMentorRepository repository, CurrencyRetriver currencyRetriever, CurrencyDto currentCurrency)
{
if (createCouponVm.PaymentRequired && string.IsNullOrEmpty(createCouponVm.PaymentData))
{
var coupon = ParseObject.CreateWithoutData<Coupon>(createCouponVm.CouponId);
coupon.CouponStatus = BL.Consts.CouponStatus.Pending;
coupon.SaveAsync();
UpdatePaymentNotRecieved(eventsDto, repository);
return;
}
var accountStatementBuilder = new AccountStatementBuilder(repository, currencyRetriever)
{
CouponId = createCouponVm.CouponId,
EventId = createCouponVm.EventId
};
var missingAccountStatements = GetMissingAccountStatements(createCouponVm, eventsDto);
var accountStatementsByUser = missingAccountStatements.GroupBy(x=>x.UserId);
var accountStatementsToUpdate = new List<AccountStatement>();
foreach (var accountStatementByUser in accountStatementsByUser)
{
var user = Task.Run(() =>
{
var userId = accountStatementByUser.Key;
return repository.FindUserWithAdminData(userId);
}).Result;
foreach (var accountStatement in accountStatementByUser)
{
var transactionCode = repository.FindTransactionTypesById(accountStatement.TransactionTypeId).TransactionCode;
var asCurrency = repository.FindAllCurrencies(accountStatement.CurrencyId);
var accountStatementDto = Task.Run(() => accountStatementBuilder.SetAccountStatement(user,
accountStatement.Credit,
accountStatement.Debit,
transactionCode,
accountStatement.DueDate,
asCurrency.Single(),
validationToken: accountStatement.ValidationToken)).Result;
accountStatementDto.Order = accountStatement.Order;
accountStatementsToUpdate.Add(accountStatementDto.ConvertToAccountStatementDomain());
}
}
UpdateCouponAccountStatementsAndEvent(createCouponVm, repository, accountStatementsToUpdate, eventsDto);
}
private double GetPriceWithCoupon(Purchase purchase, Coupon[] userCoupons, IMyMentorRepository repository, CurrencyDto userCurrency)
{
Coupon couponForItem = null;
var usedCoupons = userCoupons.Where(x => x.State != CouponStates.UnUsed.ToString());
if (purchase.ClipKey != null)
{
couponForItem = usedCoupons.FirstOrDefault(x => x.Clip != null && x.Clip.ObjectId == purchase.ClipKey.ObjectId);
}
else if (purchase.BundleKey != null)
{
couponForItem = usedCoupons.FirstOrDefault(x => x.Bundle != null && x.Bundle.ObjectId == purchase.BundleKey.ObjectId);
}
if (couponForItem != null)
{
var priceInNis = couponForItem.TeacherCouponFeeNIS + couponForItem.SiteCouponFeeNIS;
return CurrencyConverter.ConvertFromNis(priceInNis, userCurrency, repository);
}
return -1;
}
private double GetPrice(Purchase purchase, IMyMentorRepository repository, CurrencyDto userCurrency)
{
var price = purchase.Price + purchase.SupportPrice;
return CurrencyConverter.Convert(price, purchase.UserCurrency.ConvertToCurrencyDto(), userCurrency);
}
private void SetPurchases(CheckoutViewModel model, Purchase[] userPurchases, Coupon[] userCoupons, IMyMentorRepository repository, CurrencyDto currencyDto)
{
model.PurchasesForUser = userPurchases.Select(purchase => new CheckoutPurchaseViewModel
{
Id = purchase.ObjectId,
ContentTitlePart1 = GetTitle1(purchase),
ContentTitlePart2 = GetTitle2(purchase),
ContentName_he_il = GetName_he_il(purchase),
ContentName_en_us = GetName_en_us(purchase),
HasUnUsedCouopn = CheckUnUsedCouponsForPurchase(purchase, userCoupons),
IncludingSupport = purchase.IncludingSupport,
RegularPrice = GetPrice(purchase, repository, currencyDto),
RegularPriceString = GetPrice(purchase, repository, currencyDto).ToCurrency(model.UserCurrency),
PriceWithCoupon = GetPriceWithCoupon(purchase, userCoupons, repository, currencyDto),
PriceWithCouponString = GetPriceWithCoupon(purchase, userCoupons, repository, currencyDto).ToCurrency(model.UserCurrency),
IsLesson = purchase.ClipKey != null,
ContentId = purchase.ClipKey != null ? purchase.ClipKey.ObjectId : purchase.BundleKey.ObjectId,
CurrencyId = purchase.UserCurrency.ObjectId,
Coupon = CheckCouponForPurchase(purchase, userCoupons),
TeacherInfo = new TeacherInfo
{
Teacher = GetTeacher(purchase),
Agent = GetAgent(purchase).ConvertToParseUserDto(),
TeacherAdminData = GetTeacherAdminData(purchase),
AgentAdminData = GetAgetAdminData(purchase)
},
}).ToArray();
}
private static void SetClipViewModelInBunde(BundleUpdateViewModel model, Clip clipDetails, CurrencyDto sourceCurrency, CurrencyDto targetCurrency)
{
model.BundleClips.Add(new ClipMinimalData
{
Id = clipDetails.ObjectId,
ClipNamePart1 = clipDetails.GetLocalizedField("portalNamePart1"),
ClipNamePart2 = clipDetails.GetLocalizedField("portalNamePart2"),
Price = CurrencyConverter.Convert(clipDetails.Price, sourceCurrency, targetCurrency).ToString("0.00"),
Status = clipDetails.Status.GetLocalizedField("status"),
Category3 = clipDetails.Category3.GetLocalizedField("value"),
Currency = clipDetails.Currency.ConvertToCurrencyDto()
});
}
private void FixupCurrency(CurrencyDto previousValue)
{
if (previousValue != null && previousValue.CurrencyRates.Contains(this))
{
previousValue.CurrencyRates.Remove(this);
}
if (Currency != null)
{
if (!Currency.CurrencyRates.Contains(this))
{
Currency.CurrencyRates.Add(this);
}
if (CurrencyId != Currency.Id)
{
CurrencyId = Currency.Id;
}
}
}
private CurrencyDto.CurrencyRow GetCurrency(CurrencyDto dto, string currencyCode)
{
return (CurrencyDto.CurrencyRow)dto.Currency.Select("CurrencyCode = '" + currencyCode + "'").SingleOrDefault();
}
private void SetTotals(CheckoutViewModel model, IMyMentorRepository repository, CurrencyDto currencyDto)
{
var loggedInUser = Session.GetLoggedInUser();
var userAdminData = Task.Run(() => loggedInUser.GetPointerObject<UserAdminData>("adminData")).Result;
var currentBalance = userAdminData.Balance;
var minimumTransaction = repository.FindGlobalTeacherCommission().MinimumTransaction;
var basketPrice = model.PurchasesForUser.Sum(x => x.RegularPrice);
var basketPriceWithCoupon = model.PurchasesForUser.Sum(x =>
{
if (x.HasCoupon)
return x.PriceWithCoupon;
return x.RegularPrice;
});
var paymentTransactionWithCoupon = currentBalance < 0
? basketPriceWithCoupon - currentBalance
: basketPriceWithCoupon >= currentBalance ? basketPriceWithCoupon - currentBalance : 0;
var paymentTransactionNis = CurrencyConverter.ConvertToNis(paymentTransactionWithCoupon,currencyDto,repository);
paymentTransactionWithCoupon = paymentTransactionNis < minimumTransaction ? 0 : paymentTransactionWithCoupon;
var reduceFromBalance = basketPriceWithCoupon == 0 || paymentTransactionWithCoupon > basketPriceWithCoupon || currentBalance <= 0 ? 0 : basketPriceWithCoupon - paymentTransactionWithCoupon;
model.BasketPrice = basketPrice.ToCurrency(currencyDto);
model.BasketPriceWithCouopn = basketPriceWithCoupon.Equals(basketPrice) ? string.Empty : basketPriceWithCoupon.ToCurrency(currencyDto);
model.BasketPriceWithCouopnForCalc = basketPriceWithCoupon;
model.Balance = currentBalance.ToCurrency(currencyDto);
model.BalanceForCalc = currentBalance;
model.ReduceFromBalance = reduceFromBalance.ToCurrency(currencyDto);
model.PaymentTransaction = paymentTransactionWithCoupon.ToCurrency(currencyDto);
model.PaymentTransactionForCalc = paymentTransactionWithCoupon;
model.RequiresPayment = paymentTransactionWithCoupon > 0;
}
