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; }