예제 #1
0
    private void UpdateOrder()
    {
        Order order = DataAccessContext.OrderRepository.GetOne(CurrentOrderID);

        order.OrderDate = GetOrderDate(GetCalendarDate("uxOrderDateCalendarPopup"));
        order.UserName  = GetText("uxUserNameText");
        order.Billing   = new Address(GetText("uxFirstNameText"), GetText("uxLastNameText"),
                                      GetText("uxCompanyText"), GetText("uxAddress1Text"), GetText("uxAddress2Text"),
                                      GetText("uxCityText"), GetStateList("uxStateList"), GetText("uxZipText"),
                                      GetCountryList("uxCountryList"), GetText("uxPhoneText"), GetText("uxFaxText"));
        order.Email    = GetText("uxEmailText");
        order.Shipping = new ShippingAddress(
            new Address(GetText("uxShippingFirstNameText"), GetText("uxShippingLastNameText"),
                        GetText("uxShippingCompanyText"), GetText("uxShippingAddress1Text"),
                        GetText("uxShippingAddress2Text"), GetText("uxShippingCityText"),
                        GetStateList("StateListShipping"), GetText("uxShippingZipText"),
                        GetCountryList("CountryListShipping"), GetText("uxShippingPhoneText"),
                        GetText("uxShippingFaxText")),
            false);
        order.PaymentMethod       = GetText("uxPaymentMethodText");
        order.ShippingMethod      = GetText("uxShippingMethodText");
        order.PaymentComplete     = GetCheck("uxPaymentCompleteCheck");
        order.Processed           = GetCheck("uxProcessedCheck");
        order.Status              = GetDrop("uxStatusDrop");
        order.Cancelled           = GetCheck("uxCancelledCheck");
        order.IPAddress           = GetText("uxIPAddressText");
        order.Subtotal            = DataAccessContext.OrderItemRepository.GetSubtotal(CurrentOrderID);
        order.Tax                 = ConvertUtilities.ToDecimal(GetText("uxTaxText"));
        order.ShippingCost        = ConvertUtilities.ToDecimal(GetText("uxShippingCostText"));
        order.CouponID            = GetText("uxCouponIDText");
        order.CouponDiscount      = ConvertUtilities.ToDecimal(GetText("uxCouponDiscountText"));
        order.CustomerComments    = GetText("uxCommentText");
        order.BaseCurrencyCode    = GetText("uxBaseCodeText");
        order.UserCurrencyCode    = GetText("uxUserCurrencyCodeText");
        order.UserConversionRate  = ConvertUtilities.ToDouble(GetText("uxConversionRateText"));
        order.InvoiceNotes        = GetText("uxInvoiceNotesText");
        order.GiftCertificateCode = GetText("uxGiftCertificateCodeText");
        order.GiftCertificate     = ConvertUtilities.ToDecimal((GetText("uxGiftCertificateText")));
        order.TrackingNumber      = GetText("uxTrackingNumerText");
        order.TrackingMethod      = GetDrop("uxTrackingMethodDrop");
        order.HandlingFee         = ConvertUtilities.ToDecimal(GetText("uxHandlingFeeText"));
        order.ContainsRecurring   = IsOrderContainRecurring();
        order.AvsAddrStatus       = ((DropDownList)uxFormView.Row.FindControl("uxAvsAddrDrop")).SelectedValue;
        order.AvsZipStatus        = ((DropDownList)uxFormView.Row.FindControl("uxAvsZipDrop")).SelectedValue;
        order.CvvStatus           = ((DropDownList)uxFormView.Row.FindControl("uxCvvDrop")).SelectedValue;
        order.PONumber            = GetText("uxPONumberText");

        if (IsSaleTaxExemptVisible(true) && !String.IsNullOrEmpty(GetText("uxTaxExepmtIDText")))
        {
            order.IsTaxExempt      = true;
            order.TaxExemptID      = GetText("uxTaxExepmtIDText");
            order.TaxExemptCountry = GetCountryList("uxTaxExemptCountryList");
            order.TaxExemptState   = GetStateList("uxTaxExemptStateList");
        }
        else
        {
            order.IsTaxExempt      = false;
            order.TaxExemptID      = String.Empty;
            order.TaxExemptCountry = String.Empty;
            order.TaxExemptState   = String.Empty;
        }

        DataAccessContext.OrderRepository.Save(order);
        if (order.PaymentComplete)
        {
            CustomerRewardPoint.UpdateRewardPoint(order);

            if (!order.IsSubscriptionApplied)
            {
                OrderNotifyService orderNotifyService = new OrderNotifyService(order.OrderID);
                orderNotifyService.UpdateCustomerSubscription(order);
                order.IsSubscriptionApplied = true;
                DataAccessContext.OrderRepository.Save(order);
            }
        }
    }
예제 #2
0
 protected void uxVevoPayPADSSModeDrop_SelectedIndexChanged(object sender, EventArgs e)
 {
     uxVevoPayConfigPanel.Visible = ConvertUtilities.ToBoolean(uxVevoPayPADSSModeDrop.SelectedValue);
 }
예제 #3
0
        public override System.Web.Security.MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
        {
            global::SoftFluent.Samples.GED.Security.User user = new global::SoftFluent.Samples.GED.Security.User();
            if (providerUserKey != null)
            {
                if (providerUserKey is System.Guid)
                {
                    user.Id = (System.Guid)providerUserKey;
                }
                else
                {
                    status = MembershipCreateStatus.InvalidProviderUserKey;
                    return(null);
                }
            }

            email = ConvertUtilities.Nullify(email, true);
            if ((email != null) && (email.Length > 256))
            {
                status = MembershipCreateStatus.InvalidEmail;
                return(null);
            }

            if ((email == null) && RequiresUniqueEmail)
            {
                status = MembershipCreateStatus.InvalidEmail;
                return(null);
            }
            user.Email = email;

            password = ConvertUtilities.Nullify(password, true);

            user.PasswordSalt = GenerateSalt();
            string encodedPassword = EncodePassword(password, user.PasswordSalt);

            if ((password == null) || (password.Length > 256))
            {
                status = MembershipCreateStatus.InvalidPassword;
                return(null);
            }
            user.Password = encodedPassword;

            username = ConvertUtilities.Nullify(username, true);
            if ((username == null) || (username.Length > 256))
            {
                status = MembershipCreateStatus.InvalidUserName;
                return(null);
            }
            user.UserName = username;

            DateTime time = DateTime.UtcNow; time = new DateTime(time.Year, time.Month, time.Day, time.Hour, time.Minute, time.Second);


            user.IsLockedOut = false;

            user.LastLoginDate          = time;
            user.LastActivityDate       = time;
            user.LastPasswordChangeDate = time;
            user.LastLockoutDate        = DateTime.MinValue;



            if (password.Length < MinRequiredPasswordLength)
            {
                status = MembershipCreateStatus.InvalidPassword;
                return(null);
            }

            int min = 0;

            for (int i = 0; i < password.Length; i++)
            {
                if (!char.IsLetterOrDigit(password, i))
                {
                    min++;
                }
            }
            if (min < MinRequiredNonAlphanumericCharacters)
            {
                status = MembershipCreateStatus.InvalidPassword;
                return(null);
            }

            if ((!string.IsNullOrEmpty(PasswordStrengthRegularExpression)) &&
                (!Regex.IsMatch(password, PasswordStrengthRegularExpression)))
            {
                status = MembershipCreateStatus.InvalidPassword;
                return(null);
            }

            ValidatePasswordEventArgs e = new ValidatePasswordEventArgs(username, password, true);

            OnValidatingPassword(e);
            if (e.Cancel)
            {
                status = MembershipCreateStatus.InvalidPassword;
                return(null);
            }

            try
            {
                user.Save();
            }
            catch (CodeFluent.Runtime.CodeFluentDuplicateException)
            {
                status = MembershipCreateStatus.DuplicateProviderUserKey;
                return(null);
            }

            status = MembershipCreateStatus.Success;
            return(MembershipUserFromUser(user));
        }
        private async void ButtonGenerate_OnClick(object sender, RoutedEventArgs e)
        {
            if (ConnectionStringObject == null)
            {
                return;
            }

            Database database = Database.Get(SelectedDatabaseSystem.ToString(), ConnectionStringObject.ToString(true));

            if (!database.Exists)
            {
                MessageBox.Show("Cannot connect to the database");
                return;
            }

            // Update Recent configurations
            Settings.Current.AddRecentConnectionString(SelectedDatabaseSystem, database);
            Settings.Current.SerializeToConfiguration();

            // Generate
            try
            {
                CircularProgressBar.Visibility = Visibility.Visible;
                Exception exception = null;
                var       count     = ConvertUtilities.ChangeType(TextBoxRows.Text, 100);
                var       nullCount = ConvertUtilities.ChangeType(TextBoxNullRows.Text, 5);

                await Task.Run(() =>
                {
                    Project project             = new Project(database);
                    project.BatchStatementCount = 1;
                    project.InitializeDefaultGenerator();
                    SqlScriptExecutor sqlScriptExecutor = new SqlScriptExecutor();

                    if (Debugger.IsAttached)
                    {
                        project.Generate(sqlScriptExecutor, count, nullCount);
                    }
                    else
                    {
                        try
                        {
                            project.Generate(sqlScriptExecutor, count, nullCount);
                        }
                        catch (Exception ex)
                        {
                            exception = ex;
                        }
                    }
                });

                if (exception == null)
                {
                    MessageBox.Show("Done");
                }
                else
                {
                    MessageBox.Show(exception.ToString(), "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(), "Error", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                CircularProgressBar.Visibility = Visibility.Collapsed;
            }
        }
예제 #5
0
    private int GetRewardPoint()
    {
        OrderAmount     orderAmount = StoreContext.GetOrderAmount();
        OrderCalculator calculator  = new OrderCalculator();

        return(calculator.GetPointFromPrice((orderAmount.Subtotal - orderAmount.Discount), ConvertUtilities.ToDecimal(DataAccessContext.Configurations.GetValue("RewardPoints", StoreContext.CurrentStore))));
    }
 public bool IsShowRecurringPeriod()
 {
     return(ConvertUtilities.ToBoolean(CurrentProduct.IsRecurring) &&
            !CatalogUtilities.IsOutOfStock(CurrentProduct.SumStock, CurrentProduct.UseInventory));
 }
예제 #7
0
    protected string GetDisplayText(object groupName)
    {
        if (groupName.ToString().ToLower() == "price")
        {
            if (String.IsNullOrEmpty(MaxPrice))
            {
                return(StoreContext.Currency.FormatPrice(ConvertUtilities.ToDecimal(MinPrice)) + GetLanguageText("andabove"));
            }

            return(StoreContext.Currency.FormatPrice(ConvertUtilities.ToDecimal(MinPrice)) + " - " + StoreContext.Currency.FormatPrice(ConvertUtilities.ToDecimal(MaxPrice)));
        }
        else if (groupName.ToString() == "[$Category]")
        {
            Category category = DataAccessContext.CategoryRepository.GetOne(StoreContext.Culture, Request.QueryString["cat"]);
            return(category.Name);
        }
        else if (groupName.ToString() == "[$Department]")
        {
            Department department = DataAccessContext.DepartmentRepository.GetOne(StoreContext.Culture, Request.QueryString["dep"]);
            return(department.Name);
        }
        else if (groupName.ToString() == "[$Manufacturer]")
        {
            Manufacturer manufacturer = DataAccessContext.ManufacturerRepository.GetOne(StoreContext.Culture, Request.QueryString["manu"]);
            return(manufacturer.Name);
        }
        else
        {
            SpecificationItem      specItem  = DataAccessContext.SpecificationItemRepository.GetOneByName(StoreContext.Culture, groupName.ToString());
            SpecificationItemValue specValue = DataAccessContext.SpecificationItemValueRepository.GetOneBySpecItemIDAndValue(StoreContext.Culture, specItem.SpecificationItemID, Request.QueryString[groupName.ToString()]);
            return(specValue.DisplayValue);
        }
    }
예제 #8
0
    public static IList <Product> GetProductList(
        Culture culture,
        string sortBy,
        int startIndex,
        int endIndex,
        object[] userDefined,
        out int howManyItems)
    {
        string categoryID   = userDefined[0].ToString();
        string departmentID = userDefined[1].ToString();
        bool   isFacet      = ConvertUtilities.ToBoolean(userDefined[6]);

        IList <string> list = new List <string>();

        IList <string> categoryids = DataAccessContext.CategoryRepository.GetLeafFromCategoryID(categoryID, list);

        List <string> categoryCollection = new List <string>();

        foreach (string categoryItem in categoryids)
        {
            categoryCollection.Add(categoryItem);
        }

        IList <string> departmentIDs = new List <string>();

        if (!String.IsNullOrEmpty(departmentID))
        {
            IList <string> depList = new List <string>();
            departmentIDs = DataAccessContext.DepartmentRepository.GetLeafFromDepartmentID(departmentID, depList);
        }
        List <string> departmentCollection = new List <string>();

        foreach (string departmentItem in departmentIDs)
        {
            departmentCollection.Add(departmentItem);
        }

        if (isFacet)
        {
            return(DataAccessContext.ProductRepository.GetFacetResultByCategoryID(
                       culture,
                       categoryCollection.ToArray(),
                       departmentCollection.ToArray(),
                       userDefined[2].ToString(),
                       userDefined[3].ToString(),
                       userDefined[4].ToString(),
                       (IList <SpecificationItemValue>)userDefined[5],
                       sortBy,
                       startIndex,
                       endIndex,
                       BoolFilter.ShowTrue,
                       out howManyItems,
                       new StoreRetriever().GetCurrentStoreID()
                       ));
        }
        else
        {
            return(DataAccessContext.ProductRepository.GetByCategoryID(
                       culture,
                       userDefined[0].ToString(),
                       sortBy,
                       startIndex,
                       endIndex,
                       BoolFilter.ShowTrue,
                       out howManyItems,
                       new StoreRetriever().GetCurrentStoreID()
                       ));
        }
    }
예제 #9
0
 protected void uxNegotiatedRatesIndicatorDrop_SelectedIndexChanged(object sender, EventArgs e)
 {
     uxShipperNumberDiv.Visible = ConvertUtilities.ToBoolean(uxNegotiatedRatesIndicatorDrop.SelectedValue);
 }
예제 #10
0
    private void Update()
    {
        try
        {
            if (Page.IsValid)
            {
                if (uxProductInfo.ConvertToCategoryIDs().Length > 0)
                {
                    if (!uxProductAttributes.VerifyInputListOption())
                    {
                        DisplayErrorOption();
                        return;
                    }

                    string  price;
                    string  retailPrice;
                    string  wholeSalePrice;
                    string  wholeSalePrice2;
                    string  wholeSalePrice3;
                    decimal giftAmount;
                    if (uxProductAttributes.IsFixPrice(
                            uxGiftCertificate.IsFixedPrice, uxGiftCertificate.IsGiftCertificate, uxRecurring.IsRecurring, uxProductAttributes.IsCallForPrice))
                    {
                        price           = uxProductAttributes.Price;
                        retailPrice     = uxProductAttributes.RetailPrice;
                        wholeSalePrice  = uxProductAttributes.WholeSalePrice;
                        wholeSalePrice2 = uxProductAttributes.WholeSalePrice2;
                        wholeSalePrice3 = uxProductAttributes.WholeSalePrice3;

                        giftAmount = ConvertUtilities.ToDecimal(uxGiftCertificate.GiftAmount);
                    }
                    else
                    {
                        price           = "0";
                        retailPrice     = "0";
                        wholeSalePrice  = "0";
                        wholeSalePrice2 = "0";
                        wholeSalePrice3 = "0";
                        giftAmount      = 0m;
                    }
                    string  storeID = new StoreRetriever().GetCurrentStoreID();
                    Product product = DataAccessContext.ProductRepository.GetOne(uxLanguageControl.CurrentCulture, CurrentID, storeID);
                    product = SetUpProduct(product);

                    product = DataAccessContext.ProductRepository.Save(product);

                    uxMessage.DisplayMessage(Resources.ProductMessages.UpdateSuccess);

                    AdminUtilities.ClearSiteMapCache();

                    PopulateControls();
                }
                else
                {
                    uxMessage.DisplayError(Resources.ProductMessages.AddErrorCategoryEmpty);
                    return;
                }
            }
        }
        catch (Exception ex)
        {
            uxMessage.DisplayException(ex);
        }
    }
예제 #11
0
    private bool SetShippingCouponGiftDetails()
    {
        string errMsg;
        bool   isValid;

        if (!SetCoupon())
        {
            return(false);
        }

        string giftCode = uxCouponGiftDetails.GetGiftCertificateCode(out isValid);

        if (!isValid)
        {
            return(false);
        }


        StoreContext.CheckoutDetails.SetGiftCertificate(giftCode);

        if (DataAccessContext.Configurations.GetBoolValue("PointSystemEnabled", CurrentStore))
        {
            string rewardPoint = uxCouponGiftDetails.GetRewardPointValue(out isValid);
            if (!isValid)
            {
                return(false);
            }

            StoreContext.CheckoutDetails.RedeemPrice = uxCouponGiftDetails.GetPriceFromPoint(ConvertUtilities.ToDecimal(rewardPoint));
            StoreContext.CheckoutDetails.RedeemPoint = ConvertUtilities.ToInt32(rewardPoint);
        }

        SetBillingAddress();
        SetShippingAddress();

        if (!SetShippingMethod(out errMsg))
        {
            return(false);
        }

        return(true);
    }
예제 #12
0
 private decimal GetPriceFromPoint(decimal point)
 {
     return(point * ConvertUtilities.ToDecimal(DataAccessContext.Configurations.GetValue("PointValue", StoreContext.CurrentStore)));
 }
예제 #13
0
 public String getText()
 {
     return(ConvertUtilities.replaceOut(richTextBox1.Text));
 }
예제 #14
0
 public void setText(String t)
 {
     richTextBox1.Text = ConvertUtilities.replaceIn(t);
 }
예제 #15
0
    protected bool IsReferenceLinkVisible(object rewardPointID)
    {
        string pointID = ConvertUtilities.ToString(rewardPointID);

        return(!IsPointReferenceLabelVisible(pointID));
    }
예제 #16
0
    protected string GetTextName(object item)
    {
        DataRowView data      = ( DataRowView )item;
        DateTime    time      = new DateTime(ConvertUtilities.ToInt32(data.Row["CreateYear"]), ConvertUtilities.ToInt32(data.Row["CreateMonth"]), 1);
        string      monthName = time.ToString("MMMM");

        return(monthName + " " + data.Row["CreateYear"]);
    }
예제 #17
0
        /// <summary>
        /// Update data and create change log
        /// </summary>
        /// <param name="pageLog"></param>
        /// <param name="pageLogModel"></param>
        /// <returns></returns>
        private string ChangeLog(PageLog pageLog, PageLogManageModel pageLogModel)
        {
            var          changeLog = new StringBuilder();
            const string format    = "- Update field: {0}\n";

            if (!ConvertUtilities.Compare(pageLog.Title, pageLogModel.Title))
            {
                changeLog.AppendFormat(format, "Title");
                pageLog.Title = pageLogModel.Title;
            }
            if (!ConvertUtilities.Compare(pageLog.FriendlyUrl, pageLogModel.FriendlyUrl))
            {
                changeLog.AppendFormat(format, "FriendlyUrl");
                pageLog.FriendlyUrl = pageLogModel.FriendlyUrl;
            }
            if (!ConvertUtilities.Compare(pageLog.Content, pageLogModel.Content))
            {
                changeLog.AppendFormat(format, "Content");
                pageLog.Content = pageLogModel.Content;
            }
            if (!ConvertUtilities.Compare(pageLog.ContentWorking, pageLogModel.ContentWorking))
            {
                changeLog.AppendFormat(format, "ContentWorking");
                pageLog.ContentWorking = pageLogModel.ContentWorking;
            }
            if (!ConvertUtilities.Compare(pageLog.Caption, pageLogModel.Caption))
            {
                changeLog.AppendFormat(format, "Caption");
                pageLog.Caption = pageLogModel.Caption;
            }
            if (!ConvertUtilities.Compare(pageLog.CaptionWorking, pageLogModel.CaptionWorking))
            {
                changeLog.AppendFormat(format, "CaptionWorking");
                pageLog.CaptionWorking = pageLogModel.CaptionWorking;
            }
            if (!ConvertUtilities.Compare(pageLog.Status, pageLogModel.Status))
            {
                changeLog.AppendFormat(format, "Status");
                pageLog.Status = pageLogModel.Status;
            }
            if (!ConvertUtilities.Compare(pageLog.Keywords, pageLogModel.Keywords))
            {
                changeLog.AppendFormat(format, "Keywords");
                pageLog.Keywords = pageLogModel.Keywords;
            }
            if (!ConvertUtilities.Compare(pageLog.FileTemplateId, pageLogModel.FileTemplateId))
            {
                changeLog.AppendFormat(format, "FileTemplateId");
                pageLog.FileTemplateId = pageLogModel.FileTemplateId;
            }
            if (!ConvertUtilities.Compare(pageLog.PageTemplateId, pageLogModel.PageTemplateId))
            {
                changeLog.AppendFormat(format, "PageTemplateId");
                pageLog.PageTemplateId = pageLogModel.PageTemplateId;
            }
            if (!ConvertUtilities.Compare(pageLog.ParentId, pageLogModel.ParentId))
            {
                changeLog.AppendFormat(format, "ParentId");
                pageLog.ParentId = pageLogModel.ParentId;
            }
            if (!ConvertUtilities.Compare(pageLog.IncludeInSiteNavigation, pageLogModel.IncludeInSiteNavigation))
            {
                changeLog.AppendFormat(format, "IncludeInSiteNavigation");
                pageLog.IncludeInSiteNavigation = pageLogModel.IncludeInSiteNavigation;
            }
            if (!ConvertUtilities.Compare(pageLog.StartPublishingDate, pageLogModel.StartPublishingDate))
            {
                changeLog.AppendFormat(format, "StartPublishingDate");
                pageLog.StartPublishingDate = pageLogModel.StartPublishingDate;
            }
            if (!ConvertUtilities.Compare(pageLog.EndPublishingDate, pageLogModel.EndPublishingDate))
            {
                changeLog.AppendFormat(format, "EndPublishingDate");
                pageLog.EndPublishingDate = pageLogModel.EndPublishingDate;
            }

            if (!string.IsNullOrEmpty(changeLog.ToString()))
            {
                changeLog.Insert(0, string.Format("** Update Page **\n"));
            }

            return(changeLog.ToString());
        }
예제 #18
0
        private Cell AppendCell(Row row, uint rowIndex, uint columnIndex, TableColumn <T> column, T value)
        {
            if (value == null)
            {
                return(null);
            }

            var displayValue = column.GetValue(value);

            if (displayValue == null)
            {
                return(null);
            }

            Cell cell = new Cell();

            cell.CellReference = GetColumnIndex(columnIndex) + rowIndex;

            CellValues datatype;

            if (column.DataType == null)
            {
                datatype = GetDataType(displayValue.GetType());
            }
            else
            {
                datatype = GetDataType(column.DataType);
            }

            switch (datatype)
            {
            case CellValues.Boolean:
                bool boolean;
                if (!ConvertUtilities.TryChangeType(displayValue, column.Culture, out boolean))
                {
                    return(null);
                }

                cell.DataType  = CellValues.Boolean;
                cell.CellValue = new CellValue(BooleanValue.FromBoolean(boolean));
                break;

            case CellValues.Number:
                string number;
                if (!ConvertUtilities.TryChangeType(displayValue, CultureInfo.InvariantCulture, out number))
                {
                    return(null);
                }

                cell.DataType  = CellValues.Number;
                cell.CellValue = new CellValue(number);
                break;

            case CellValues.String:
                string formula;
                if (!ConvertUtilities.TryChangeType(displayValue, column.Culture, out formula))
                {
                    return(null);
                }

                cell.DataType    = CellValues.InlineString;
                cell.CellFormula = new CellFormula(formula);
                break;

            case CellValues.InlineString:
                string text;
                if (!ConvertUtilities.TryChangeType(displayValue, column.Culture, out text))
                {
                    return(null);
                }

                cell.DataType = CellValues.InlineString;
                cell.AppendChild(new InlineString(new Text(text)));
                break;

            case CellValues.Date:
                DateTime datetime;
                if (!ConvertUtilities.TryChangeType(displayValue, column.Culture, out datetime))
                {
                    return(null);
                }

                //cell.DataType = CellValues.Date;
                cell.CellValue  = new CellValue(datetime.ToOADate().ToString(CultureInfo.InvariantCulture));
                cell.StyleIndex = 1;
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            if (column.Format != null)
            {
                cell.StyleIndex = GetStyleIndex(column);
            }

            row.AppendChild(cell);
            return(cell);
        }
 public bool IsShowFreeTrialPeriodMore()
 {
     return(IsShowRecurringPeriod() &&
            (ConvertUtilities.ToInt32(CurrentProduct.ProductRecurring.RecurringNumberOfTrialCycles) == 1) &&
            (ConvertUtilities.ToDecimal(CurrentProduct.ProductRecurring.RecurringTrialAmount) == 0m));
 }
예제 #20
0
        public string FormatNumber(object obj)
        {
            decimal number = ConvertUtilities.ToDecimal(obj);

            return(String.Format("{0:n2}", number));
        }
예제 #21
0
 protected decimal GetPrice(object price)
 {
     return(ConvertUtilities.ToDecimal(price));
 }
예제 #22
0
    private string ConvertNumberToMonth(string month)
    {
        DateTime date = new DateTime(2000, ConvertUtilities.ToInt32(month), 1);

        return(date.ToString("MMMM"));
    }
예제 #23
0
 protected string GetShortDate(object createDate)
 {
     return(ConvertUtilities.ToDateTime(createDate).ToShortDateString());
 }
예제 #24
0
    protected bool IsShowSeeMore(object shortDesc)
    {
        string shortDescription = ConvertUtilities.ToString(shortDesc);

        return(shortDescription.Length > 119);
    }
예제 #25
0
 private void PopulateSiteMapConfig()
 {
     uxSiteMapTypeTR.Visible         = ConvertUtilities.ToBoolean(uxSiteMapEnabledDrop.SelectedValue);
     uxSiteMapTypeDrop.SelectedValue = DataAccessContext.Configurations.GetValue("SiteMapDisplayType");
 }
예제 #26
0
    private Boolean CheckCondition(string templateID, string[] productIDList)
    {
        Boolean conditionPass = true;

        EBayAccess          access       = new EBayAccess(UrlPath.StorefrontUrl);
        EBayTemplate        eBayTemplate = DataAccessContextDeluxe.EBayTemplateRepository.GetOne(templateID);
        EBayCategory        category     = access.GetCategoriesDetailsByID(eBayTemplate.PrimaryeBayCategoryID, eBayTemplate.EBayListSite);
        EBayCategoryFeature feature      = access.GetCategoryFeatureDetail(category.PimaryCategoryID, category.CategoryLevel, eBayTemplate.EBayListSite);

        ShowMessageByCondition(feature, category);

        if (feature.IsReturnPolicyEnabled)
        {
            if (!eBayTemplate.IsAcceptReturn)
            {
                lcMessage.Text = "Return Policy is required for listing. Please check your listing template.";
                return(false);
            }
        }

        foreach (string productID in productIDList)
        {
            if (productID.Equals(""))
            {
                break;
            }

            Product product = GetProductByProductID(productID);

            double productPrice = 0.0;
            foreach (ProductPrice price in product.ProductPrices)
            {
                if (price.StoreID.Equals("0"))      //use defalut price
                {
                    productPrice = (double)price.Price;
                    break;
                }
            }

            if (eBayTemplate.DomesticShippingType == "Calculate" || eBayTemplate.InternationalShippingType == "Calculate")
            {
                if (product.Weight <= 0)
                {
                    lcMessage.Text = "Cannot list to eBay because some product does not have weight.";
                    return(false);
                }
            }

            if (String.IsNullOrEmpty(product.ShortDescription))
            {
                lcMessage.Text = "Cannot list to eBay because some product does not have short description.";
                return(false);
            }

            if (product.IsCustomPrice)
            {
                lcMessage.Text = "Cannot list to eBay because some product(s) enabled custom price.";
                return(false);
            }

            if (product.IsCallForPrice)
            {
                lcMessage.Text = "Cannot list to eBay because some product(s) enabled call for price.";
                return(false);
            }

            IList <ProductOptionGroup> optionGroupList = product.ProductOptionGroups;
            if (optionGroupList.Count > 0)
            {
                lcMessage.Text = "Cannot list to eBay because some product(s) has option.";
                return(false);
            }

            if (product.IsRecurring)
            {
                lcMessage.Text = "Cannot list to eBay because some product(s) enabled recurring option.";
                return(false);
            }

            double eBayTemplateReservePrice  = 0.0;
            double eBayTemplateStartingPrice = 0.0;
            double eBayTemplateBuyItNowPrice = 0.0;

            if (eBayTemplate.SellingMethod.Equals("Online Auction"))
            {
                if (eBayTemplate.UseReservePrice)
                {
                    switch (eBayTemplate.ReservePriceType)
                    {
                    case "ProductPrice":
                        eBayTemplateReservePrice = productPrice;
                        break;

                    case "PricePlusAmount":
                        eBayTemplateReservePrice = productPrice + ConvertUtilities.ToDouble(eBayTemplate.ReservePriceValue);
                        break;

                    case "PricePlusPercentage":
                        eBayTemplateReservePrice = productPrice + (productPrice * (ConvertUtilities.ToDouble(eBayTemplate.ReservePriceValue) / 100));
                        break;

                    case "CustomPrice":
                        eBayTemplateReservePrice = ConvertUtilities.ToDouble(eBayTemplate.ReservePriceValue);
                        break;

                    default:
                        eBayTemplateReservePrice = productPrice;
                        break;
                    }
                }

                if (eBayTemplate.UseBuyItNowPrice)
                {
                    switch (eBayTemplate.BuyItNowPriceType)
                    {
                    case "ProductPrice":
                        eBayTemplateBuyItNowPrice = productPrice;
                        break;

                    case "PricePlusAmount":
                        eBayTemplateBuyItNowPrice = productPrice + ConvertUtilities.ToDouble(eBayTemplate.BuyItNowPriceValue);
                        break;

                    case "PricePlusPercentage":
                        eBayTemplateBuyItNowPrice = productPrice + (productPrice * (ConvertUtilities.ToDouble(eBayTemplate.BuyItNowPriceValue) / 100));
                        break;

                    case "CustomPrice":
                        eBayTemplateBuyItNowPrice = ConvertUtilities.ToDouble(eBayTemplate.BuyItNowPriceValue);
                        break;

                    default:
                        eBayTemplateBuyItNowPrice = productPrice;
                        break;
                    }
                }

                switch (eBayTemplate.StartingPriceType)
                {
                case "ProductPrice":
                    eBayTemplateStartingPrice = productPrice;
                    break;

                case "PricePlusAmount":
                    eBayTemplateStartingPrice = productPrice + ConvertUtilities.ToDouble(eBayTemplate.StartingPriceValue);
                    break;

                case "PricePlusPercentage":
                    eBayTemplateStartingPrice = productPrice + (productPrice * (ConvertUtilities.ToDouble(eBayTemplate.StartingPriceValue) / 100));
                    break;

                case "CustomPrice":
                    eBayTemplateStartingPrice = ConvertUtilities.ToDouble(eBayTemplate.StartingPriceValue);
                    break;

                default:
                    eBayTemplateStartingPrice = productPrice;
                    break;
                }

                if (eBayTemplate.UseReservePrice)
                {
                    if (eBayTemplateReservePrice < feature.MinimumReservePrice)
                    {
                        lcMessage.Text = "Reserve Price in template is less than eBay minimun reserve price. Please check your template.";
                        return(false);
                    }

                    if (eBayTemplateReservePrice <= eBayTemplateStartingPrice)
                    {
                        lcMessage.Text = "The starting price must be less than the reserve price. Please check your template.";
                        return(false);
                    }
                }

                if (eBayTemplate.UseBuyItNowPrice)
                {
                    double eBayTemplateStartingPricePlusTenPercent = eBayTemplateStartingPrice + (eBayTemplateStartingPrice * 0.1);
                    if (eBayTemplateBuyItNowPrice <= eBayTemplateStartingPricePlusTenPercent)
                    {
                        lcMessage.Text = "Buy It Now price should be at least 10% more than your starting price. Please check your template.";
                        return(false);
                    }
                }
            }
        }

        access.VerifyAddItem(GetProductByProductID(productIDList[0]), eBayTemplate, category, false, DateTime.Now);
        if (access.HasError)
        {
            foreach (EBayErrorType error in access.ErrorTypeList)
            {
                lcMessage.Text += HttpUtility.HtmlEncode(error.ErrorLongMessage) + " (" + error.ErrorCode + ")<br/>";
            }

            lcMessage.ForeColor = System.Drawing.Color.Red;
            return(false);
        }
        return(conditionPass);
    }
예제 #27
0
        public override void Initialize(string name, System.Collections.Specialized.NameValueCollection config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            if (string.IsNullOrEmpty(name))
            {
                name = "SoftFluent.Samples.GEDMembershipProvider";
            }
            if (string.IsNullOrEmpty(config["description"]))
            {
                config.Remove("description");
                config.Add("description", SoftFluent.Samples.GED.Resources.Manager.GetStringWithDefault("MembershipProviderDescription", "SoftFluent.Samples.GED"));
            }
            base.Initialize(name, config);
            _enablePasswordRetrieval   = ConvertUtilities.ToBoolean(config["enablePasswordRetrieval"], false);
            _enablePasswordReset       = ConvertUtilities.ToBoolean(config["enablePasswordReset"], true);
            _requiresUniqueEmail       = true;       // cannot be changed here
            _requiresQuestionAndAnswer = ConvertUtilities.ToBoolean(config["requiresQuestionAndAnswer"], false);
            _updateLastActivity        = ConvertUtilities.ToBoolean(config["updateLastActivity"], true);


            if (_requiresQuestionAndAnswer)
            {
                throw new ProviderException(SoftFluent.Samples.GED.Resources.Manager.GetStringWithDefault("UnsupportedRequiresQuestionAndAnswer", "Membership provider only supports requiresQuestionAndAnswer set to false."));
            }


            _maxInvalidPasswordAttempts           = ConvertUtilities.ToInt32(config["maxInvalidPasswordAttempts"], 5);
            _passwordAttemptWindow                = ConvertUtilities.ToInt32(config["passwordAttemptWindow"], 10);
            _minRequiredPasswordLength            = ConvertUtilities.ToInt32(config["minRequiredPasswordLength"], 4);
            _minRequiredNonAlphanumericCharacters = ConvertUtilities.ToInt32(config["minRequiredNonalphanumericCharacters"], 0);
            _passwordStrengthRegularExpression    = ConvertUtilities.ToString(config["passwordStrengthRegularExpression"], "", true);
            if (_minRequiredNonAlphanumericCharacters > _minRequiredPasswordLength)
            {
                throw new ProviderException(SoftFluent.Samples.GED.Resources.Manager.GetStringWithDefault("MinNonAlphanMoreThanMinRequiredPassword", "MinRequiredNonalphanumericCharacters can not be more than MinRequiredPasswordLength."));
            }

            _applicationName = config["applicationName"];
            if (string.IsNullOrEmpty(_applicationName))
            {
                _applicationName = applicationName;
            }

            _passwordFormat = (MembershipPasswordFormat)ConvertUtilities.ToEnum(config["passwordFormat"], MembershipPasswordFormat.Hashed);
            if ((_passwordFormat == MembershipPasswordFormat.Hashed) && (_enablePasswordRetrieval))
            {
                throw new ProviderException(SoftFluent.Samples.GED.Resources.Manager.GetStringWithDefault("CannotRetrieveHash", "Membership provider can not retrieve hashed passwords."));
            }

            config.Remove("enablePasswordRetrieval");
            config.Remove("enablePasswordReset");
            config.Remove("requiresQuestionAndAnswer");
            config.Remove("applicationName");
            config.Remove("requiresUniqueEmail");
            config.Remove("maxInvalidPasswordAttempts");
            config.Remove("passwordAttemptWindow");
            config.Remove("passwordFormat");
            config.Remove("name");
            config.Remove("minRequiredPasswordLength");
            config.Remove("minRequiredNonalphanumericCharacters");
            config.Remove("passwordStrengthRegularExpression");
            config.Remove("updateLastActivity");
        }
예제 #28
0
 private int TotalPoint()
 {
     return(ConvertUtilities.ToInt32(
                DataAccessContextDeluxe.CustomerRewardPointRepository.SumCustomerIDAndStoreID(
                    CurrentID, uxStoreList.SelectedValue)));
 }
예제 #29
0
    public bool AddItemToShoppingCart(bool isSubscriptionable, out string errMsg)
    {
        errMsg = String.Empty;

        if (!VerifyValidInput(out errMsg))
        {
            DisplayErrorMessage(errMsg);
            return(false);
        }

        if (!IsMatchQuantity())
        {
            return(false);
        }

        OptionItemValueCollection selectedOptions = uxProductOptionGroupDetails.GetSelectedOptions();
        CartItemGiftDetails       giftDetails     = CreateGiftDetails();

        Currency currency   = DataAccessContext.CurrencyRepository.GetOne(CurrencyCode);
        decimal  enterPrice = ConvertUtilities.ToDecimal(currency.FormatPriceWithOutSymbolInvert(ConvertUtilities.ToDecimal(uxEnterAmountText.Text)));

        if (enterPrice == CurrentProduct.GetProductPrice(StoreID).Price)
        {
            enterPrice = 0;
        }

        decimal customPrice = 0;

        if (CurrentProduct.IsCustomPrice)
        {
            customPrice = ConvertUtilities.ToDecimal(currency.FormatPriceWithOutSymbolInvert(ConvertUtilities.ToDecimal(uxEnterAmountText.Text)));
        }


        CartAddItemService addToCartService = new CartAddItemService(
            StoreContext.Culture, StoreContext.ShoppingCart);

        int    currentStock;
        string errorOptionName;
        bool   stockOK = addToCartService.AddToCartByAdmin(
            CurrentProduct,
            selectedOptions,
            ConvertUtilities.ToInt32(uxQuantityText.Text),
            giftDetails,
            customPrice,
            enterPrice,
            StoreID,
            out errorOptionName,
            out currentStock,
            isSubscriptionable);


        if (stockOK)
        {
            return(true);
        }
        else
        {
            errMsg = DisplayOutOfStockError(currentStock, errorOptionName);
            uxMessage.DisplayError(errMsg);
            return(false);
        }
    }
예제 #30
0
        private void buttonOk_Click(object sender, EventArgs e)
        {
            Entity userEntity = CreateUserEntity();
            Entity roleEntity = null;
            //Entity userRoleEntity = null;
            Entity loginsEntity    = null;
            Entity claimsEntity    = null;
            Entity roleClaimEntity = null;

            if (checkBoxRole.Checked)
            {
                roleEntity = CreateRoleEntity();
            }

            //if (checkBoxUserRole.Checked)
            //{
            //    userRoleEntity = CreateUserRoleEntity();
            //    AddRelation(userEntity, PropertyType.Roles, userRoleEntity, PropertyType.User, RelationType.ManyToOne);
            //    AddRelation(roleEntity, PropertyType.RoleUsers, userRoleEntity, PropertyType.Role, RelationType.ManyToOne);
            //}
            //else
            //{
            AddRelation(userEntity, PropertyType.UserRoles, roleEntity, PropertyType.RoleUsers, RelationType.ManyToMany);
            //}

            if (checkBoxClaims.Checked)
            {
                claimsEntity = CreateUserClaimsEntity();
                AddRelation(userEntity, PropertyType.UserClaims, claimsEntity, PropertyType.UserClaimUser, RelationType.ManyToOne);
            }

            if (checkBoxExternalLogins.Checked)
            {
                loginsEntity = CreateUserLoginsEntity();
                AddRelation(userEntity, PropertyType.UserLogins, loginsEntity, PropertyType.UserLoginUser, RelationType.ManyToOne);
            }

            if (checkBoxRoleClaim.Checked)
            {
                roleClaimEntity = CreateRoleClaimEntity();
                AddRelation(roleEntity, PropertyType.RoleClaims, roleClaimEntity, PropertyType.RoleClaimRole, RelationType.ManyToOne);
            }

            CreateUserMethods(userEntity, loginsEntity);

            SetCollectionMode(userEntity);
            SetCollectionMode(roleEntity);
            //SetCollectionMode(userRoleEntity);
            SetCollectionMode(loginsEntity);
            SetCollectionMode(claimsEntity);
            SetCollectionMode(roleClaimEntity);

            if (_aspNetIdentityProducer.MustCreateMessages)
            {
                ProjectMessages messages = new ProjectMessages(_project);
                if (messages.RoleNotFoundMessage == null)
                {
                    var message = new Message
                    {
                        EditorName  = "RoleNotFound",
                        Class       = MessageClass._default.ToString(),
                        CultureName = ConvertUtilities.ToCultureInfo(_aspNetIdentityProducer.MessagesCulture, _project.Culture).Name,
                        Value       = IdentityRole.RoleNotFoundMessage,
                        AddToRuntimeResourceFile = true
                    };
                    message.SetAttributeValue("", "messageType", Constants.NamespaceUri, ProjectMessageType.RoleNotFound);
                    _project.Messages.Add(message);
                }
            }

            this.Close();
        }