public IActionResult ConsentEditor(int consentGroupId, int consentId)
{
var consent = consentId > 0
? _consentService.Get(consentId)
: new Consent()
{
ConsentGroup = new ConsentGroup()
{
Id = consentGroupId
},
ConsentGroupId = consentGroupId
};
if (consent == null || consent.ConsentGroupId != consentGroupId)
{
return(NotFound());
}
var model = _gdprModelFactory.Create(consent);
//get available groups
var consentGroups = _consentGroupService.Get(x => true).OrderBy(x => x.Name).ToList();
var consentGroupsSelectList = SelectListHelper.GetSelectItemList(consentGroups, x => x.Id, x => x.Name);
return(R.Success.With("consent", model).With("consentGroups", consentGroupsSelectList).Result);
}
public IActionResult CategoryEditor(int categoryId)
{
//get the category tree
var categoryTree = _categoryService.GetFullCategoryTree();
var category = categoryId > 0 ? categoryTree.FirstOrDefault(x => x.Id == categoryId) : new Category();
if (category == null)
{
return(NotFound());
}
var categoryModel = _modelMapper.Map <CategoryModel>(category);
var availableParentCategoryModels = categoryTree.Where(x => x.Id != categoryId && !category.IsAnyChild(x.Id))
.Select(x =>
{
var model = _modelMapper.Map <CategoryModel>(x);
model.FullCategoryPath = categoryTree.First(y => y.Id == x.Id).GetNameBreadCrumb();
return(model);
})
.OrderBy(x => x.FullCategoryPath)
.ToList();
var apcAsSelectList =
SelectListHelper.GetSelectItemList(availableParentCategoryModels, x => x.Id, x => x.FullCategoryPath);
return(R.Success.With("category", categoryModel).With("availableParents", apcAsSelectList).Result);
}
public IActionResult Suggestions(string q = null)
{
var tags = _entityTagService.GetDistinctTags(q);
var suggestions = SelectListHelper.GetSelectItemList(tags, x => x, x => x).OrderBy(x => x.Text).ToList();
return(R.Success.With("suggestions", suggestions).Result);
}
public IActionResult Settings()
{
var upsModel = new SettingsModel()
{
ShipperNumber = _upsSettings.ShipperNumber,
LicenseNumber = _upsSettings.LicenseNumber,
UserId = _upsSettings.UserId,
Password = _upsSettings.Password,
AdditionalFee = _upsSettings.AdditionalFee,
CustomerClassificationType = _upsSettings.CustomerClassificationType,
DebugMode = _upsSettings.DebugMode,
DefaultPackagingType = _upsSettings.DefaultPackagingType,
PickupType = _upsSettings.PickupType,
ActiveServices = _upsSettings.ActiveServices
};
var pickupTypes = SelectListHelper.GetSelectItemList <PickupType>();
var packagingTypes = SelectListHelper.GetSelectItemList <PackagingType>();
var classificationTypes = SelectListHelper.GetSelectItemList <CustomerClassificationType>();
var availableServices = UPSProviderConfig.AvailableServices.Select(x => new SelectListItem(x.Key, x.Value)).ToList();
return(R.Success.With("settings", upsModel).With("availableUPSPickupTypes", pickupTypes)
.With("availableUPSPackagingTypes", packagingTypes)
.With("availableUPSCustomerClassificationTypes", classificationTypes)
.With("availableUPSServices", availableServices).Result);
}
public IActionResult CancelOrder(string orderGuid)
{
var order = _orderService.GetByGuid(orderGuid);
if (order == null || order.UserId != CurrentUser.Id)
{
return(NotFound());
}
if (!CanCancelOrder(order))
{
return(R.Fail.With("error", T("Unable to cancel the order")).Result);
}
var orderModel = _orderModelFactory.Create(order);
//set breadcrumb nodes
SetBreadcrumbToRoute("Account", RouteNames.AccountProfile);
SetBreadcrumbToRoute("Orders", RouteNames.AccountOrders);
SetBreadcrumbToRoute(order.OrderNumber, RouteNames.SingleOrder, new { orderGuid }, localize: false);
SetBreadcrumbToRoute("Cancellation Request", RouteNames.CancelOrder);
var cancellationReasons = _customLabelService.GetCustomLabels(CancellationReasonLabel, out _).ToList();
var selectList = SelectListHelper.GetSelectItemList(cancellationReasons, x => x.Id, x => x.Text);
return(R.Success.With("availableReasons", selectList).With("order", orderModel).With("orderGuid", orderGuid).Result);
}
public object GetViewObject(object settings)
{
var widgetSettings = settings as RawHtmlWidgetSettings;
//get consents
var consents = _consentService.Get(x => true).ToList();
var consentsSelector = SelectListHelper.GetSelectItemList(consents, x => x.Id, x => x.Title);
return(new {
content = widgetSettings?.Content,
acceptedConsentId = widgetSettings?.AcceptedConsentId ?? 0,
availableConsents = consentsSelector
});
}
public object GetViewObject(object settings)
{
var widgetSettings = settings as MenuWidgetSettings;
var menus = _menuService.Get(x => true).ToList();
var menusSelectList = SelectListHelper.GetSelectItemList(menus, x => x.Id, x => x.Name);
return(new
{
title = widgetSettings?.Title,
menuId = widgetSettings?.MenuId,
availableMenus = menusSelectList
});
}
public IActionResult ReturnOrder(string orderGuid)
{
var order = _orderService.GetByGuid(orderGuid);
if (order == null || order.UserId != CurrentUser.Id)
{
return(NotFound());
}
if (!CanReturnOrder(order, out var returnableOrderItems, out var lastReturnDate))
{
return(R.Fail.With("error", T("The order is not eligible for returns")).Result);
}
var models = returnableOrderItems.Select(x =>
{
var returnItemModel = new ReturnItemModel()
{
OrderItem = _orderModelFactory.Create(x),
MinimumQuantityToReturn = x.Product.MinimumPurchaseQuantity
};
if (returnItemModel.MinimumQuantityToReturn == 0)
{
returnItemModel.MinimumQuantityToReturn = 1;
}
return(returnItemModel);
}).ToList();
order.OrderItems = null;
var orderModel = _orderModelFactory.Create(order);
//get the actions and reasons
var customLabels =
_customLabelService.Get(
new List <string>()
{
ReturnActionLabel, ReturnReasonLabel
}, out _).ToList();
var actions = customLabels.Where(x => x.Type == ReturnActionLabel).ToList();
var reasons = customLabels.Where(x => x.Type == ReturnReasonLabel).ToList();
var reasonsAsSelectList = SelectListHelper.GetSelectItemList(reasons, x => x.Id, x => x.Text);
var actionsAsSelectList = SelectListHelper.GetSelectItemList(actions, x => x.Id, x => x.Text);
//set breadcrumb nodes
SetBreadcrumbToRoute("Account", RouteNames.AccountProfile);
SetBreadcrumbToRoute("Orders", RouteNames.AccountOrders);
SetBreadcrumbToRoute(order.OrderNumber, RouteNames.SingleOrder, new { orderGuid }, localize: false);
SetBreadcrumbToRoute("Return Request", RouteNames.ReturnOrder);
return(R.Success.With("returnItems", models).With("availableReasons", reasonsAsSelectList)
.With("availableActions", actionsAsSelectList).With("order", orderModel)
.With("lastReturnDate", lastReturnDate).Result);
}
public IActionResult VendorEditor(int vendorId)
{
var vendor = vendorId > 0 ? _vendorService.Get(vendorId) : new Vendor();
if (vendor == null)
{
return(NotFound());
}
var vendorModel = _modelMapper.Map <VendorModel>(vendor);
var availableVendorStatus = SelectListHelper.GetSelectItemList <VendorStatus>();
return(R.Success.With("vendor", vendorModel).WithAvailableCountries()
.With("vendorId", vendorId)
.With("availableVendorStatus", availableVendorStatus).Result);
}
public IActionResult RoleEditor(int roleId)
{
var role = roleId > 0 ? _roleService.Get(roleId) : new Role();
if (role == null)
{
return(NotFound());
}
var roleModel = _roleModelFactory.Create(role);
roleModel.Capabilities = role.Capabilities?.Select(x => x.Id.ToString()).ToList();
var availableCapabilities = _capabilityService.Get(x => true).OrderBy(x => x.Name).ToList();
var availableCapabilitiesModel =
SelectListHelper.GetSelectItemList(availableCapabilities, x => x.Id, x => x.Name);
return(R.Success.With("role", roleModel).With("availableCapabilities", availableCapabilitiesModel).Result);
}
public IActionResult EmailTemplateEditor(int emailTemplateId)
{
var emailTemplate = emailTemplateId > 0 ? _emailTemplateService.Get(emailTemplateId) : new EmailTemplate();
if (emailTemplate == null)
{
return(NotFound());
}
var model = _modelMapper.Map <EmailTemplateModel>(emailTemplate);
if (emailTemplate.ParentEmailTemplate != null)
{
model.ParentEmailTemplate = _modelMapper.Map <EmailTemplateModel>(emailTemplate.ParentEmailTemplate);
}
model.EmailAccount = _modelMapper.Map <EmailAccountModel>(emailTemplate.EmailAccount);
//available email accounts
var emailAccounts = _emailAccountService.Get(x => true).OrderBy(x => x.Email).ToList();
var availableEmailAccounts = SelectListHelper.GetSelectItemList(emailAccounts, x => x.Id, x => x.Email);
//available master templates
var masterTemplates = _emailTemplateService.Get(x => x.IsMaster).OrderBy(x => x.TemplateName).ToList();
var availableMasterTemplates =
SelectListHelper.GetSelectItemList(masterTemplates, x => x.Id, x => x.TemplateName);
var isAdminEmailRequired = emailTemplate.TemplateSystemName != null &&
((emailTemplate.TemplateSystemName.EndsWith(EmailTemplateNames.AdminSuffix) && emailTemplate.IsSystem) ||
(emailTemplate.TemplateSystemName.EndsWith(EmailTemplateNames.AdminSuffix)));
//available tokens
var tokens = _emailTemplateService.GetTemplateTokens(emailTemplate.TemplateSystemName).OrderBy(x => x);
return(R.Success.With("emailTemplate", model)
.With("availableEmailAccounts", availableEmailAccounts)
.With("availableMasterTemplates", availableMasterTemplates)
.With("availableTokens", tokens)
.With("adminEmailRequired", isAdminEmailRequired)
.Result);
}
public IActionResult CatalogEditor(int catalogId)
{
var catalog = catalogId > 0 ? _catalogService.Get(catalogId) : new Catalog();
if (catalog == null)
{
return(NotFound());
}
var catalogModel = _catalogModelFactory.Create(catalog);
var stores = _storeService.Get(x => true).ToList();
var catalogStoreIds = catalog.Stores?.Select(x => x.Id).ToList() ?? new List <int>();
var availableStores = SelectListHelper.GetSelectItemList(stores, x => x.Id, x => x.Name)
.Select(x =>
{
if (catalogStoreIds.Any(y => y.ToString() == x.Value))
{
x.Selected = true;
}
return(x);
}).ToList();
return(R.Success.With("catalog", catalogModel).With("availableStores", availableStores).Result);
}
private IActionResult GetSettingResult(string settingType)
{
SettingsModel model = null;
ISettingGroup settings = null;
var result = R.Success;
switch (settingType)
{
case "general":
settings = DependencyResolver.Resolve <GeneralSettings>();
model = _modelMapper.Map <GeneralSettingsModel>(settings);
var menuService = DependencyResolver.Resolve <IMenuService>();
var menus = menuService.Get(x => true).ToList();
var menuSelectList = SelectListHelper.GetSelectItemList(menus, x => x.Id, x => x.Name);
result.WithTimezones();
result.With("availableMenus", menuSelectList);
//get themes
var themes = _themeProvider.GetAvailableThemes()
.Select(x => new ThemeInfoModel()
{
DirectoryName = x.DirectoryName,
Name = x.Name,
ThumbnailUrl = x.ThumbnailUrl,
PendingRestart = x.PendingRestart
}).ToList();
result.With("availableThemes", themes);
break;
case "order":
settings = DependencyResolver.Resolve <OrderSettings>();
result.WithAvailableOrderStatusTypes();
model = _modelMapper.Map <OrderSettingsModel>(settings);
break;
case "user":
settings = DependencyResolver.Resolve <UserSettings>();
model = _modelMapper.Map <UserSettingsModel>(settings);
result.WithRegistrationModes();
break;
case "url":
settings = DependencyResolver.Resolve <UrlSettings>();
model = _modelMapper.Map <UrlSettingsModel>(settings);
break;
case "media":
settings = DependencyResolver.Resolve <MediaSettings>();
model = _modelMapper.Map <MediaSettingsModel>(settings);
break;
case "tax":
settings = DependencyResolver.Resolve <TaxSettings>();
var taxService = DependencyResolver.Resolve <ITaxService>();
var taxes = taxService.Get(x => true).ToList();
var taxesSelectList = SelectListHelper.GetSelectItemList(taxes, x => x.Id, x => x.Name);
model = _modelMapper.Map <TaxSettingsModel>(settings);
result.With("availableTaxes", taxesSelectList);
break;
case "email":
settings = DependencyResolver.Resolve <EmailSenderSettings>();
model = _modelMapper.Map <EmailSettingsModel>(settings);
result.WithEmailAccounts();
break;
case "catalog":
settings = DependencyResolver.Resolve <CatalogSettings>();
model = _modelMapper.Map <CatalogSettingsModel>(settings);
result.WithCatalogPaginationTypes();
break;
case "localization":
settings = DependencyResolver.Resolve <LocalizationSettings>();
model = _modelMapper.Map <LocalizationSettingsModel>(settings);
var currencyService = DependencyResolver.Resolve <ICurrencyService>();
var currencies = currencyService.Get(x => x.Published).ToList();
var currenciesSelectList = SelectListHelper.GetSelectItemListWithAction(currencies, x => x.Id, x => $"{x.Name} ({x.IsoCode})");
result.With("availableCurrencies", currenciesSelectList);
result.WithCatalogPaginationTypes();
break;
case "gdpr":
settings = DependencyResolver.Resolve <GdprSettings>();
model = _modelMapper.Map <GdprSettingsModel>(settings);
var consentGroupService = DependencyResolver.Resolve <IConsentGroupService>();
var consentGroups = consentGroupService.Get(x => true).ToList();
var groupSelectList = SelectListHelper.GetSelectItemList(consentGroups, x => x.Id, x => x.Name);
result.With("availableConsentGroups", groupSelectList);
break;
case "security":
settings = DependencyResolver.Resolve <SecuritySettings>();
model = _modelMapper.Map <SecuritySettingsModel>(settings);
break;
case "affiliate":
settings = DependencyResolver.Resolve <AffiliateSettings>();
model = _modelMapper.Map <AffiliateSettingsModel>(settings);
break;
}
return(result.With("settings", model).With("settingType", settingType).Result);
}
public static CustomResponse WithRegistrationModes(this CustomResponse customResponse)
{
return(customResponse.With("registrationModes", SelectListHelper.GetSelectItemList <RegistrationMode>()));
}
public IActionResult DiscountEditor(int discountId)
{
var discount = discountId > 0 ? _discountCouponService.Get(discountId) : new DiscountCoupon();
if (discount == null)
{
return(NotFound());
}
var discountModel = _modelMapper.Map <DiscountModel>(discount);
var availableCalculationTypes = SelectListHelper.GetSelectItemList <CalculationType>();
var availableRestrictionTypes = SelectListHelper.GetSelectItemList <RestrictionType>();
//fetch the additional data if it's an existing discount
if (discount.Id > 0)
{
switch (discount.RestrictionType)
{
case RestrictionType.Products:
var productIds = discount.RestrictionIds();
if (!productIds.Any())
{
break;
}
var products = _productService.Get(x => productIds.Contains(x.Id));
discountModel.RestrictionValues = products.Select(x => new RestrictionValueModel()
{
Name = x.Name,
RestrictionIdentifier = x.Id.ToString()
})
.ToList();
break;
case RestrictionType.Categories:
var categoryIds = discount.RestrictionIds();
if (!categoryIds.Any())
{
break;
}
var allCategories = _categoryService.GetFullCategoryTree()
.Where(x => categoryIds.Contains(x.Id));
discountModel.RestrictionValues = allCategories.Select(x => new RestrictionValueModel()
{
Name = _categoryAccountant.GetFullBreadcrumb(x),
RestrictionIdentifier = x.Id.ToString()
})
.ToList();
break;
case RestrictionType.Users:
var userIds = discount.RestrictionIds();
if (!userIds.Any())
{
break;
}
var users = _userService.Get(x => userIds.Contains(x.Id));
discountModel.RestrictionValues = users.Select(x => new RestrictionValueModel()
{
Name = $"{x.Name} ({x.Email})",
RestrictionIdentifier = x.Id.ToString()
})
.ToList();
break;
case RestrictionType.UserGroups:
break;
case RestrictionType.Roles:
var roleIds = discount.RestrictionIds();
if (!roleIds.Any())
{
break;
}
var roles = _roleService.Get(x => roleIds.Contains(x.Id));
discountModel.RestrictionValues = roles.Select(x => new RestrictionValueModel()
{
Name = $"{x.Name}",
RestrictionIdentifier = x.Id.ToString()
})
.ToList();
break;
case RestrictionType.Vendors:
var vendorIds = discount.RestrictionIds();
if (!vendorIds.Any())
{
break;
}
var vendors = _vendorService.Get(x => vendorIds.Contains(x.Id));
discountModel.RestrictionValues = vendors.Select(x => new RestrictionValueModel()
{
Name = $"{x.Name}",
RestrictionIdentifier = x.Id.ToString()
})
.ToList();
break;
case RestrictionType.Manufacturers:
var manufacturerIds = discount.RestrictionIds();
if (!manufacturerIds.Any())
{
break;
}
var manufacturers = _vendorService.Get(x => manufacturerIds.Contains(x.Id));
discountModel.RestrictionValues = manufacturers.Select(x => new RestrictionValueModel()
{
Name = $"{x.Name}",
RestrictionIdentifier = x.Id.ToString()
})
.ToList();
break;
case RestrictionType.PaymentMethods:
break;
case RestrictionType.ShippingMethods:
break;
case RestrictionType.OrderTotal:
break;
case RestrictionType.OrderSubTotal:
break;
}
}
return(R.Success.With("discount", discountModel)
.With("availableCalculationTypes", availableCalculationTypes)
.With("availableRestrictionTypes", availableRestrictionTypes)
.Result);
}
public static CustomResponse WithRoundingTypes(this CustomResponse customResponse)
{
return(customResponse.With("roundingTypes", SelectListHelper.GetSelectItemList <Rounding>()));
}
public static CustomResponse WithCatalogPaginationTypes(this CustomResponse customResponse)
{
return(customResponse.With("catalogPaginationTypes", SelectListHelper.GetSelectItemList <CatalogPaginationType>()));
}
public static CustomResponse WithLengthUnits(this CustomResponse customResponse)
{
return(customResponse.With("lengthUnits", SelectListHelper.GetSelectItemList <LengthUnit>()));
}
public override object GetObject()
{
var generalSettings = DependencyResolver.Resolve <GeneralSettings>();
var catalogSettings = DependencyResolver.Resolve <CatalogSettings>();
var orderSettings = DependencyResolver.Resolve <OrderSettings>();
var urlSettings = DependencyResolver.Resolve <UrlSettings>();
var gdprSettings = DependencyResolver.Resolve <GdprSettings>();
var localizationSettings = DependencyResolver.Resolve <LocalizationSettings>();
var securitySettings = DependencyResolver.Resolve <SecuritySettings>();
var vendorSettings = DependencyResolver.Resolve <VendorSettings>();
var affiliateSettings = DependencyResolver.Resolve <AffiliateSettings>();
var mediaAccountant = DependencyResolver.Resolve <IMediaAccountant>();
var categoryService = DependencyResolver.Resolve <ICategoryService>();
var antiforgery = DependencyResolver.Resolve <IAntiforgery>();
var currencyService = DependencyResolver.Resolve <ICurrencyService>();
var categories = categoryService.Get(x => x.ParentId == 0).ToList();
var logoUrl = generalSettings.LogoId > 0
? mediaAccountant.GetPictureUrl(generalSettings.LogoId)
: ApplicationEngine.MapUrl(ApplicationConfig.DefaultLogoUrl, true);
var faviconUrl = generalSettings.LogoId > 0
? mediaAccountant.GetPictureUrl(generalSettings.FaviconId)
: ApplicationEngine.MapUrl(ApplicationConfig.DefaultFaviconUrl, true);
var categoryDefaultName =
LocalizationHelper.Localize("All Categories", ApplicationEngine.CurrentLanguageCultureCode);
var store = new StoreImplementation()
{
Url = WebHelper.GetUrlFromPath("/", generalSettings.StoreDomain, urlSettings.GetUrlProtocol()),
Name = generalSettings.StoreName,
Theme = new ThemeImplementation()
{
Name = generalSettings.ActiveTheme,
Url = WebHelper.GetUrlFromPath("/default", generalSettings.StoreDomain, urlSettings.GetUrlProtocol()),
},
LogoUrl = logoUrl,
FaviconUrl = faviconUrl,
CurrentPage = ApplicationEngine.GetActiveRouteName(),
CurrentUrl = ApplicationEngine.CurrentHttpContext.Request.GetDisplayUrl(),
Categories = SelectListHelper.GetSelectItemList(categories, x => x.Id, x => x.Name, categoryDefaultName),
WishlistEnabled = orderSettings.EnableWishlist,
RepeatOrdersEnabled = orderSettings.AllowReorder,
ReviewsEnabled = catalogSettings.EnableReviews,
ReviewModificationAllowed = catalogSettings.AllowReviewModification,
ActiveCurrencyCode = ApplicationEngine.CurrentCurrency.IsoCode,
PrimaryCurrencyCode = currencyService.Get(localizationSettings.BaseCurrencyId)?.IsoCode,
ActiveCurrencySymbol = ApplicationEngine.CurrentCurrency.GetSymbol(),
XsrfToken = antiforgery.GetToken(),
SoftwareVersion = AppVersionEvaluator.Version,
SoftwareTitle = ApplicationConfig.AppName,
HoneypotFieldName = securitySettings.HoneypotFieldName,
VendorSignupEnabled = vendorSettings.EnableVendorSignup,
VendorsEnabled = vendorSettings.EnableVendorSignup
};
var currentUser = ApplicationEngine.CurrentUser;
if (affiliateSettings.EnableAffiliates && currentUser.IsActiveAffiliate())
{
store.AffiliateUrl = store.CurrentPage == RouteNames.SingleProduct ? currentUser.GetAffiliateUrl(store.CurrentUrl) : currentUser.GetAffiliateUrl();
}
if (!ApplicationEngine.CurrentHttpContext.IsTokenAuthenticated() && gdprSettings.ShowCookiePopup && !currentUser.IsAdministrator())
{
store.CookiePopupText = gdprSettings.CookiePopupText;
store.UseConsentGroup = gdprSettings.UseConsentGroup;
//if there was no consent provided, we show the popup
store.ShowCookieConsent = CookieHelper.GetRequestCookie(ApplicationConfig.ConsentCookieName).IsNullEmptyOrWhiteSpace();
if (gdprSettings.ConsentGroupId > 0 && gdprSettings.UseConsentGroup)
{
var consentGroupService = DependencyResolver.Resolve <IConsentGroupService>();
var gdprService = DependencyResolver.Resolve <IGdprService>();
var consentGroup = consentGroupService.GetWithConsents(gdprSettings.ConsentGroupId);
if (consentGroup != null)
{
//has user already consented?
var consented = currentUser != null && gdprService.AreConsentsActedUpon(currentUser.Id,
consentGroup.Consents.Select(x => x.Id).ToArray());
store.ShowCookieConsent = store.ShowCookieConsent && !consented;
if (store.ShowCookieConsent)
{
store.ConsentGroup = new ConsentGroupImplementation()
{
Name = consentGroup.Name,
Description = consentGroup.Description,
Consents = new List <ConsentImplementation>()
};
foreach (var consent in consentGroup.Consents)
{
store.ConsentGroup.Consents.Add(new ConsentImplementation()
{
Description = consent.Description,
Title = consent.Title,
IsRequired = consent.IsRequired,
Id = consent.Id
});
}
}
}
else
{
//no need to use consent group..it's null anyways
store.UseConsentGroup = false;
}
}
}
return(store);
}
public static CustomResponse WithWeightUnits(this CustomResponse customResponse)
{
return(customResponse.With("weightUnits", SelectListHelper.GetSelectItemList <WeightUnit>()));
}
public static CustomResponse WithTimeCycles(this CustomResponse customResponse)
{
return(customResponse.With("timeCycles", SelectListHelper.GetSelectItemList <TimeCycle>()));
}
public static CustomResponse WithProductTypes(this CustomResponse customResponse)
{
return(customResponse.With("productTypes", SelectListHelper.GetSelectItemList <ProductType>()));
}
