public PostAppService()
{
this.postValidation = ValidationFactory.GetPostValidation();
this.postService = ServiceFactory.GetPostService(RepositoryFactory.GetPostRepository(), this.postValidation);
this.commentService = ServiceFactory.GetCommentService(RepositoryFactory.GetCommentRepository(), null);
this.categoryService = ServiceFactory.GetCategoryService(RepositoryFactory.GetCategoryRepository(), null);
}
public FroogleService(IScheduleTaskService scheduleTaskService,
IGoogleService googleService,
IProductService productService,
ICategoryService categoryService,
IManufacturerService manufacturerService,
IPictureService pictureService,
ICurrencyService currencyService,
IWebHelper webHelper,
ISettingService settingService,
IWorkContext workContext,
IMeasureService measureService,
MeasureSettings measureSettings,
StoreInformationSettings storeInformationSettings,
FroogleSettings froogleSettings,
CurrencySettings currencySettings,
GoogleProductObjectContext objectContext)
{
this._scheduleTaskService = scheduleTaskService;
this._googleService = googleService;
this._productService = productService;
this._categoryService = categoryService;
this._manufacturerService = manufacturerService;
this._pictureService = pictureService;
this._currencyService = currencyService;
this._webHelper = webHelper;
this._settingService = settingService;
this._workContext = workContext;
this._measureService = measureService;
this._measureSettings = measureSettings;
this._storeInformationSettings = storeInformationSettings;
this._froogleSettings = froogleSettings;
this._currencySettings = currencySettings;
this._objectContext = objectContext;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="settingsService"> </param>
/// <param name="emailService"> </param>
/// <param name="localizationService"> </param>
/// <param name="activityService"> </param>
/// <param name="privateMessageService"> </param>
/// <param name="membershipUserPointsService"> </param>
/// <param name="topicNotificationService"> </param>
/// <param name="voteService"> </param>
/// <param name="badgeService"> </param>
/// <param name="categoryNotificationService"> </param>
/// <param name="loggingService"></param>
/// <param name="uploadedFileService"></param>
/// <param name="postService"></param>
/// <param name="pollVoteService"></param>
/// <param name="pollAnswerService"></param>
/// <param name="pollService"></param>
/// <param name="topicService"></param>
/// <param name="favouriteService"></param>
/// <param name="categoryService"></param>
public MembershipService(IMVCForumContext context, ISettingsService settingsService,
IEmailService emailService, ILocalizationService localizationService, IActivityService activityService,
IPrivateMessageService privateMessageService, IMembershipUserPointsService membershipUserPointsService,
ITopicNotificationService topicNotificationService, IVoteService voteService, IBadgeService badgeService,
ICategoryNotificationService categoryNotificationService, ILoggingService loggingService, IUploadedFileService uploadedFileService,
IPostService postService, IPollVoteService pollVoteService, IPollAnswerService pollAnswerService,
IPollService pollService, ITopicService topicService, IFavouriteService favouriteService,
ICategoryService categoryService, IPostEditService postEditService)
{
_settingsService = settingsService;
_emailService = emailService;
_localizationService = localizationService;
_activityService = activityService;
_privateMessageService = privateMessageService;
_membershipUserPointsService = membershipUserPointsService;
_topicNotificationService = topicNotificationService;
_voteService = voteService;
_badgeService = badgeService;
_categoryNotificationService = categoryNotificationService;
_loggingService = loggingService;
_uploadedFileService = uploadedFileService;
_postService = postService;
_pollVoteService = pollVoteService;
_pollAnswerService = pollAnswerService;
_pollService = pollService;
_topicService = topicService;
_favouriteService = favouriteService;
_categoryService = categoryService;
_postEditService = postEditService;
_context = context as MVCForumContext;
}
public void GivenTheFollowingTransaction(string category, string paymentMethod, Table data)
{
_paymentMethodService = new PaymentMethodService(new PaymentMethodRepository(context));
switch (_transactionType)
{
case TransactionTypes.Income:
_transaction = data.CreateInstance<Income>();
_transactionService = new IncomeService(new IncomeRepository(context));
_categoryService = new IncomeCategoryService(new IncomeCategoryRepository(context));
break;
case TransactionTypes.Expense:
_transaction = data.CreateInstance<Expense>();
_transactionService = new ExpenseService(new ExpenseRepository(context));
_categoryService = new ExpenseCategoryService(new ExpenseCategoryRepository(context));
break;
}
if (!string.IsNullOrWhiteSpace(paymentMethod))
{
_paymentMethod = new PaymentMethod(0, paymentMethod);
_transaction.Method = _paymentMethod;
}
if (!string.IsNullOrWhiteSpace(category))
{
_category = new DataClasses.Category(0, category);
_transaction.Category = _category;
}
if (_transaction.Date.Equals(default(DateTime)))
{
_transaction.Date = DateTime.Today;
}
}
public MiscFacebookShopController(IAclService aclService,
ICacheManager cacheManager,
CatalogSettings catalogSettings,
ICategoryService categoryService,
ICurrencyService currencyService,
ILocalizationService localizationService,
IPermissionService permissionService,
IPictureService pictureService,
IPriceCalculationService priceCalculationService,
IPriceFormatter priceFormatter,
IProductService productService,
IStoreContext storeContext,
IStoreMappingService storeMappingService,
ITaxService taxService,
IWorkContext workContext)
{
this._aclService = aclService;
this._cacheManager = cacheManager;
this._catalogSettings = catalogSettings;
this._categoryService = categoryService;
this._currencyService = currencyService;
this._localizationService = localizationService;
this._permissionService = permissionService;
this._pictureService = pictureService;
this._priceCalculationService = priceCalculationService;
this._priceFormatter = priceFormatter;
this._productService = productService;
this._storeContext = storeContext;
this._storeMappingService = storeMappingService;
this._taxService = taxService;
this._workContext = workContext;
}
public BackwardCompatibility2XController(IProductService productService,
ICategoryService categoryService, IManufacturerService manufacturerService)
{
this._productService = productService;
this._categoryService = categoryService;
this._manufacturerService = manufacturerService;
}
public TagController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService, ITopicTagService topicTagService, ICategoryService categoryService, ICacheService cacheService)
: base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService)
{
_topicTagService = topicTagService;
_categoryService = categoryService;
_cacheService = cacheService;
}
public CategoryController(ICategoryService categoryService,
IUserProvider userProvider,
IPermissionService permissionService)
: base(userProvider, permissionService) {
this.categoryService = categoryService;
}
public PriceCalculationService(
IDiscountService discountService,
ICategoryService categoryService,
IProductAttributeParser productAttributeParser,
IProductService productService,
ShoppingCartSettings shoppingCartSettings,
CatalogSettings catalogSettings,
IProductAttributeService productAttributeService,
IDownloadService downloadService,
ICommonServices services,
HttpRequestBase httpRequestBase,
ITaxService taxService)
{
this._discountService = discountService;
this._categoryService = categoryService;
this._productAttributeParser = productAttributeParser;
this._productService = productService;
this._shoppingCartSettings = shoppingCartSettings;
this._catalogSettings = catalogSettings;
this._productAttributeService = productAttributeService;
this._downloadService = downloadService;
this._services = services;
this._httpRequestBase = httpRequestBase;
this._taxService = taxService;
}
public void SetUp()
{
_firstDbContextUoW = new Mock<IUnitOfWork<FirstDbContext>>();
_secondDbContextUoW = new Mock<IUnitOfWork<SecondDbContext>>();
_categoryService = new CategoryService(_firstDbContextUoW.Object);
_departmentService = new DepartmentService(_secondDbContextUoW.Object);
}
public ManufacturerController(ICategoryService categoryService, IManufacturerService manufacturerService,
IManufacturerTemplateService manufacturerTemplateService, IProductService productService,
ICustomerService customerService, IStoreService storeService,
IStoreMappingService storeMappingService,
IUrlRecordService urlRecordService, IPictureService pictureService,
ILanguageService languageService, ILocalizationService localizationService,
ILocalizedEntityService localizedEntityService, IExportManager exportManager,
ICustomerActivityService customerActivityService, IAclService aclService,
IPermissionService permissionService,
AdminAreaSettings adminAreaSettings, CatalogSettings catalogSettings)
{
this._categoryService = categoryService;
this._manufacturerTemplateService = manufacturerTemplateService;
this._manufacturerService = manufacturerService;
this._productService = productService;
this._customerService = customerService;
this._storeService = storeService;
this._storeMappingService = storeMappingService;
this._urlRecordService = urlRecordService;
this._pictureService = pictureService;
this._languageService = languageService;
this._localizationService = localizationService;
this._localizedEntityService = localizedEntityService;
this._exportManager = exportManager;
this._customerActivityService = customerActivityService;
this._aclService = aclService;
this._permissionService = permissionService;
this._adminAreaSettings = adminAreaSettings;
this._catalogSettings = catalogSettings;
}
public ManageController(
IUnitOfWorkAsync unitOfWorkAsync,
ISettingService settingService,
ICategoryService categoryService,
IItemService itemService,
IPictureService pictureService,
IItemPictureService itemPictureService,
IOrderService orderService,
ICustomFieldService customFieldService,
ICustomFieldCategoryService customFieldCategoryService,
ICustomFieldItemService customFieldItemService,
ISettingDictionaryService settingDictionaryService,
IItemStatService itemStatService,
DataCacheService dataCacheService,
SqlDbService sqlDbService)
{
_settingService = settingService;
_settingDictionaryService = settingDictionaryService;
_categoryService = categoryService;
_itemService = itemService;
_pictureService = pictureService;
_itemPictureService = itemPictureService;
_orderService = orderService;
_customFieldService = customFieldService;
_customFieldCategoryService = customFieldCategoryService;
_customFieldItemService = customFieldItemService;
_itemStatService = itemStatService;
_dataCacheService = dataCacheService;
_sqlDbService = sqlDbService;
_unitOfWorkAsync = unitOfWorkAsync;
}
public ExportManager(ICategoryService categoryService,
IManufacturerService manufacturerService,
IProductService productService,
IProductAttributeService productAttributeService,
IProductTemplateService productTemplateService,
IPictureService pictureService,
INewsLetterSubscriptionService newsLetterSubscriptionService,
ILanguageService languageService,
MediaSettings mediaSettings,
ICommonServices services,
IStoreMappingService storeMappingService)
{
_categoryService = categoryService;
_manufacturerService = manufacturerService;
_productService = productService;
_productAttributeService = productAttributeService;
_productTemplateService = productTemplateService;
_pictureService = pictureService;
_newsLetterSubscriptionService = newsLetterSubscriptionService;
_languageService = languageService;
_mediaSettings = mediaSettings;
_services = services;
_storeMappingService = storeMappingService;
Logger = NullLogger.Instance;
}
private void GetPostService(UnitOfWork uow, out ICategoryService categoryService, out IForumService forumService, out ITopicService topicService, out IPostService postService) {
ICategoryRepository cateRepo = new CategoryRepository(uow);
IForumRepository forumRepo = new ForumRepository(uow);
ITopicRepository topicRepo = new TopicRepository(uow);
IPostRepository postRepo = new PostRepository(uow);
IForumConfigurationRepository configRepo = new ForumConfigurationRepository(uow);
IState request = new DummyRequest();
ILogger logger = new ConsoleLogger();
IUserRepository userRepo = new UserRepository(uow);
User user = userRepo.Create(new User {
Name = "D. Ummy",
ProviderId = "12345678",
FullName = "Mr. Doh Ummy",
EmailAddress = "[email protected]",
Culture = "th-TH",
TimeZone = "GMT Standard Time"
});
List<IEventSubscriber> subscribers = new List<IEventSubscriber>();
IEventPublisher eventPublisher = new EventPublisher(subscribers, logger, request);
IUserProvider userProvider = new DummyUserProvider(user);
IPermissionService permService = new PermissionService();
IForumConfigurationService confService = new ForumConfigurationService(configRepo);
categoryService = new CategoryService(userProvider, cateRepo, eventPublisher, logger, permService);
forumService = new ForumService(userProvider, cateRepo, forumRepo, topicRepo, postRepo, eventPublisher, logger, permService);
topicService = new TopicService(userProvider, forumRepo, topicRepo, postRepo, eventPublisher, logger, permService, confService);
postService = new PostService(userProvider, forumRepo, topicRepo, postRepo, eventPublisher, logger, permService, confService);
}
public ImportManager(
IProductService productService,
ICategoryService categoryService,
IManufacturerService manufacturerService,
IPictureService pictureService,
IUrlRecordService urlRecordService,
SeoSettings seoSettings,
IEventPublisher eventPublisher,
IRepository<Product> rsProduct,
IRepository<ProductCategory> rsProductCategory,
IRepository<ProductManufacturer> rsProductManufacturer,
IRepository<Picture> rsPicture,
IRepository<ProductPicture> rsProductPicture,
IRepository<UrlRecord> rsUrlRecord,
ILanguageService languageService,
ILocalizedEntityService localizedEntityService,
IStoreMappingService storeMappingService)
{
this._productService = productService;
this._categoryService = categoryService;
this._manufacturerService = manufacturerService;
this._pictureService = pictureService;
this._urlRecordService = urlRecordService;
this._seoSettings = seoSettings;
this._eventPublisher = eventPublisher;
this._rsProduct = rsProduct;
this._rsProductCategory = rsProductCategory;
this._rsProductManufacturer = rsProductManufacturer;
this._rsProductPicture = rsProductPicture;
this._rsUrlRecord = rsUrlRecord;
this._rsPicture = rsPicture;
this._languageService = languageService;
this._localizedEntityService = localizedEntityService;
this._storeMappingService = storeMappingService;
}
public PostAdminController(ICategoryService categoryService, IPostService p, ITagService ts, IUserService us)
{
this.categoryService = categoryService;
this.postService = p;
this.tagService = ts;
this.userService = us;
}
public ProductController(IUnitOfWork unitOfWork, ICategoryService categoryService, IProductService productService, IUserService userService)
{
this._unitOfWork = unitOfWork;
this._categoryService = categoryService;
this._productService = productService;
this._userService = userService;
}
public DiscountController(IDiscountService discountService,
ILocalizationService localizationService,
ICurrencyService currencyService,
ICategoryService categoryService,
IProductService productService,
IWebHelper webHelper,
IDateTimeHelper dateTimeHelper,
ICustomerActivityService customerActivityService,
CurrencySettings currencySettings,
IPermissionService permissionService,
IWorkContext workContext,
IManufacturerService manufacturerService,
IStoreService storeService,
IVendorService vendorService,
IOrderService orderService,
IPriceFormatter priceFormatter)
{
this._discountService = discountService;
this._localizationService = localizationService;
this._currencyService = currencyService;
this._categoryService = categoryService;
this._productService = productService;
this._webHelper = webHelper;
this._dateTimeHelper = dateTimeHelper;
this._customerActivityService = customerActivityService;
this._currencySettings = currencySettings;
this._permissionService = permissionService;
this._workContext = workContext;
this._manufacturerService = manufacturerService;
this._storeService = storeService;
this._vendorService = vendorService;
this._orderService = orderService;
this._priceFormatter = priceFormatter;
}
public WidgetController(ILog logger, IConfigurationService configurationService, IPostService postService, ICategoryService categoryService, IPageService pageService)
: base(logger, configurationService)
{
this.postService = postService;
this.categoryService = categoryService;
this.pageService = pageService;
}
public static string GetCategoryNameWithPrefix(this Category category, ICategoryService categoryService, IDictionary<int, Category> mappedCategories = null)
{
string result = string.Empty;
while (category != null)
{
if (String.IsNullOrEmpty(result))
{
result = category.GetFullCategoryName();
}
else
{
result = "--" + result;
}
int parentId = category.ParentCategoryId;
if (mappedCategories == null)
{
category = categoryService.GetCategoryById(parentId);
}
else
{
category = mappedCategories.ContainsKey(parentId) ? mappedCategories[parentId] : categoryService.GetCategoryById(parentId);
}
}
return result;
}
public ProductController(IProductService productService,
IProductTemplateService productTemplateService,
ICategoryService categoryService, IManufacturerService manufacturerService,
IWorkContext workContext, ILanguageService languageService,
ILocalizationService localizationService, ILocalizedEntityService localizedEntityService,
ISpecificationAttributeService specificationAttributeService, IPictureService pictureService,
ITaxCategoryService taxCategoryService, IProductTagService productTagService,
ICopyProductService copyProductService, IPdfService pdfService,
IExportManager exportManager, IImportManager importManager,
ICustomerActivityService customerActivityService,
IPermissionService permissionService, AdminAreaSettings adminAreaSettings)
{
this._productService = productService;
this._productTemplateService = productTemplateService;
this._categoryService = categoryService;
this._manufacturerService = manufacturerService;
this._workContext = workContext;
this._languageService = languageService;
this._localizationService = localizationService;
this._localizedEntityService = localizedEntityService;
this._specificationAttributeService = specificationAttributeService;
this._pictureService = pictureService;
this._taxCategoryService = taxCategoryService;
this._productTagService = productTagService;
this._copyProductService = copyProductService;
this._pdfService = pdfService;
this._exportManager = exportManager;
this._importManager = importManager;
this._customerActivityService = customerActivityService;
this._permissionService = permissionService;
this._adminAreaSettings = adminAreaSettings;
}
public CategoryController(ICategoryService categoryService, ICategoryTemplateService categoryTemplateService,
IManufacturerService manufacturerService, IProductService productService,
ICustomerService customerService,
IUrlRecordService urlRecordService, IPictureService pictureService, ILanguageService languageService,
ILocalizationService localizationService, ILocalizedEntityService localizedEntityService,
IDiscountService discountService, IPermissionService permissionService,
IAclService aclService,
IExportManager exportManager, IWorkContext workContext,
ICustomerActivityService customerActivityService, AdminAreaSettings adminAreaSettings,
CatalogSettings catalogSettings)
{
this._categoryService = categoryService;
this._categoryTemplateService = categoryTemplateService;
this._manufacturerService = manufacturerService;
this._productService = productService;
this._customerService = customerService;
this._urlRecordService = urlRecordService;
this._pictureService = pictureService;
this._languageService = languageService;
this._localizationService = localizationService;
this._localizedEntityService = localizedEntityService;
this._discountService = discountService;
this._permissionService = permissionService;
this._aclService = aclService;
this._exportManager = exportManager;
this._workContext = workContext;
this._customerActivityService = customerActivityService;
this._adminAreaSettings = adminAreaSettings;
this._catalogSettings = catalogSettings;
}
public FroogleService(IGoogleService googleService,
IProductService productService,
ICategoryService categoryService,
IManufacturerService manufacturerService,
IPictureService pictureService,
ICurrencyService currencyService,
ISettingService settingService,
IWorkContext workContext,
IMeasureService measureService,
MeasureSettings measureSettings,
FroogleSettings froogleSettings,
CurrencySettings currencySettings,
GoogleProductObjectContext objectContext)
{
this._googleService = googleService;
this._productService = productService;
this._categoryService = categoryService;
this._manufacturerService = manufacturerService;
this._pictureService = pictureService;
this._currencyService = currencyService;
this._settingService = settingService;
this._workContext = workContext;
this._measureService = measureService;
this._measureSettings = measureSettings;
this._froogleSettings = froogleSettings;
this._currencySettings = currencySettings;
this._objectContext = objectContext;
}
/// <summary>
/// Get formatted category breadcrumb
/// Note: ACL and store mapping is ignored
/// </summary>
/// <param name="category">Category</param>
/// <param name="categoryService">Category service</param>
/// <param name="separator">Separator</param>
/// <param name="languageId">Language identifier for localization</param>
/// <returns>Formatted breadcrumb</returns>
public static string GetFormattedBreadCrumb(this Category category,
ICategoryService categoryService,
string separator = ">>", int languageId = 0)
{
if (category == null)
throw new ArgumentNullException("category");
string result = string.Empty;
//used to prevent circular references
var alreadyProcessedCategoryIds = new List<int>();
while (category != null && //not null
!category.Deleted && //not deleted
!alreadyProcessedCategoryIds.Contains(category.Id)) //prevent circular references
{
var categoryName = category.GetLocalized(x => x.Name, languageId);
if (String.IsNullOrEmpty(result))
{
result = categoryName;
}
else
{
result = string.Format("{0} {1} {2}", categoryName, separator, result);
}
alreadyProcessedCategoryIds.Add(category.Id);
category = categoryService.GetCategoryById(category.ParentCategoryId);
}
return result;
}
public CustomerRoleController(ICustomerService customerService,
ILocalizationService localizationService,
ICustomerActivityService customerActivityService,
IPermissionService permissionService,
IProductService productService,
ICategoryService categoryService,
IManufacturerService manufacturerService,
IStoreService storeService,
IVendorService vendorService,
IWorkContext workContext,
ILanguageService languageService,
ILocalizedEntityService localizedEntityService,
ICacheManager cacheManager)
{
this._customerService = customerService;
this._localizationService = localizationService;
this._customerActivityService = customerActivityService;
this._permissionService = permissionService;
this._productService = productService;
this._categoryService = categoryService;
this._manufacturerService = manufacturerService;
this._storeService = storeService;
this._vendorService = vendorService;
this._workContext = workContext;
this._languageService = languageService;
this._localizedEntityService = localizedEntityService;
this._cacheManager = cacheManager;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="topicService"></param>
/// <param name="categoryService"></param>
/// <param name="badgeService"></param>
public TopicTagService(IMVCForumContext context, ITopicService topicService, ICategoryService categoryService, IBadgeService badgeService)
{
_topicService = topicService;
_categoryService = categoryService;
_badgeService = badgeService;
_context = context as MVCForumContext;
}
/// <summary>
/// Get category breadcrumb
/// </summary>
/// <param name="category">Category</param>
/// <param name="categoryService">Category service</param>
/// <param name="aclService">ACL service</param>
/// <param name="storeMappingService">Store mapping service</param>
/// <param name="showHidden">A value indicating whether to load hidden records</param>
/// <returns>Category breadcrumb </returns>
public static IList<Category> GetCategoryBreadCrumb(this Category category,
ICategoryService categoryService,
IAclService aclService,
IStoreMappingService storeMappingService,
bool showHidden = false)
{
if (category == null)
throw new ArgumentNullException("category");
var result = new List<Category>();
//used to prevent circular references
var alreadyProcessedCategoryIds = new List<int>();
while (category != null && //not null
!category.Deleted && //not deleted
(showHidden || category.Published) && //published
(showHidden || aclService.Authorize(category)) && //ACL
(showHidden || storeMappingService.Authorize(category)) && //Store mapping
!alreadyProcessedCategoryIds.Contains(category.Id)) //prevent circular references
{
result.Add(category);
alreadyProcessedCategoryIds.Add(category.Id);
category = categoryService.GetCategoryById(category.ParentCategoryId);
}
result.Reverse();
return result;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="tagRepository"></param>
/// <param name="topicRepository"></param>
/// <param name="categoryService"></param>
public TopicTagService(ITopicTagRepository tagRepository, ITopicRepository topicRepository, ICategoryService categoryService, IBadgeService badgeService)
{
_tagRepository = tagRepository;
_topicRepository = topicRepository;
_categoryService = categoryService;
_badgeService = badgeService;
}
public CollectibleExportService(IProductService productService,
ICategoryService categoryService,
IManufacturerService manufacturerService,
IPictureService pictureService,
IUrlRecordService urlRecordService,
IStoreContext storeContext,
INewsLetterSubscriptionService newsLetterSubscriptionService,
ICountryService countryService, //not used
IStateProvinceService stateProvinceService,
IConsignorService consignorService,
IAuthenticationService authenticationService,
ILogger logger,
IRepository<AUCountryLotRecord> countrylotRepo,
IRepository<AUStateProvinceLotRecord> stateprovincelotRepo
)
{
this._productService = productService;
this._categoryService = categoryService;
this._manufacturerService = manufacturerService;
this._pictureService = pictureService;
this._urlRecordService = urlRecordService;
this._storeContext = storeContext;
this._newsLetterSubscriptionService = newsLetterSubscriptionService;
this._countryService = countryService;
this._stateProvinceService = stateProvinceService;
this._consignorService = consignorService;
this._authenticationService = authenticationService;
this._logger = logger; //NJM: AUConsignor
this._countrylotRepo = countrylotRepo;
this._stateprovincelotRepo = stateprovincelotRepo;
}
public CopyProductService(IProductService productService,
IProductAttributeService productAttributeService,
ILanguageService languageService,
ILocalizedEntityService localizedEntityService,
IPictureService pictureService,
ICategoryService categoryService,
IManufacturerService manufacturerService,
ISpecificationAttributeService specificationAttributeService,
IDownloadService downloadService,
IProductAttributeParser productAttributeParser,
IUrlRecordService urlRecordService,
IStoreMappingService storeMappingService)
{
this._productService = productService;
this._productAttributeService = productAttributeService;
this._languageService = languageService;
this._localizedEntityService = localizedEntityService;
this._pictureService = pictureService;
this._categoryService = categoryService;
this._manufacturerService = manufacturerService;
this._specificationAttributeService = specificationAttributeService;
this._downloadService = downloadService;
this._productAttributeParser = productAttributeParser;
this._urlRecordService = urlRecordService;
this._storeMappingService = storeMappingService;
}
public CategoryImagesController(ICategoryService categoryService)
{
this.categoryService = categoryService;
}
public static IEnumerable <ProductOverviewModel> PrepareProductOverviewModels(this Controller controller,
IWorkContext workContext,
IStoreContext storeContext,
ICategoryService categoryService,
IProductService productService,
ISpecificationAttributeService specificationAttributeService,
IPriceCalculationService priceCalculationService,
IPriceFormatter priceFormatter,
IPermissionService permissionService,
ILocalizationService localizationService,
ITaxService taxService,
ICurrencyService currencyService,
IPictureService pictureService,
IWebHelper webHelper,
ICacheManager cacheManager,
CatalogSettings catalogSettings,
MediaSettings mediaSettings,
IEnumerable <Product> products,
bool preparePriceModel = true, bool preparePictureModel = true,
int?productThumbPictureSize = null, bool prepareSpecificationAttributes = false,
bool forceRedirectionAfterAddingToCart = false)
{
if (products == null)
{
throw new ArgumentNullException("products");
}
var models = new List <ProductOverviewModel>();
foreach (var product in products)
{
var model = new ProductOverviewModel
{
Id = product.Id,
Name = product.GetLocalized(x => x.Name),
ShortDescription = product.GetLocalized(x => x.ShortDescription),
FullDescription = product.GetLocalized(x => x.FullDescription),
SeName = product.GetSeName(),
};
//price
if (preparePriceModel)
{
#region Prepare product price
var priceModel = new ProductOverviewModel.ProductPriceModel
{
ForceRedirectionAfterAddingToCart = forceRedirectionAfterAddingToCart
};
switch (product.ProductType)
{
case ProductType.GroupedProduct:
{
#region Grouped product
var associatedProducts = productService.GetAssociatedProducts(product.Id, storeContext.CurrentStore.Id);
switch (associatedProducts.Count)
{
case 0:
{
//no associated products
priceModel.OldPrice = null;
priceModel.Price = null;
priceModel.DisableBuyButton = true;
priceModel.DisableWishlistButton = true;
priceModel.AvailableForPreOrder = false;
}
break;
default:
{
//we have at least one associated product
priceModel.DisableBuyButton = true;
priceModel.DisableWishlistButton = true;
priceModel.AvailableForPreOrder = false;
if (permissionService.Authorize(StandardPermissionProvider.DisplayPrices))
{
//find a minimum possible price
decimal?minPossiblePrice = null;
Product minPriceProduct = null;
foreach (var associatedProduct in associatedProducts)
{
//calculate for the maximum quantity (in case if we have tier prices)
var tmpPrice = priceCalculationService.GetFinalPrice(associatedProduct,
workContext.CurrentCustomer, decimal.Zero, true, int.MaxValue);
if (!minPossiblePrice.HasValue || tmpPrice < minPossiblePrice.Value)
{
minPriceProduct = associatedProduct;
minPossiblePrice = tmpPrice;
}
}
if (minPriceProduct != null && !minPriceProduct.CustomerEntersPrice)
{
if (minPriceProduct.CallForPrice)
{
priceModel.OldPrice = null;
priceModel.Price = localizationService.GetResource("Products.CallForPrice");
}
else if (minPossiblePrice.HasValue)
{
//calculate prices
decimal taxRate;
decimal finalPriceBase = taxService.GetProductPrice(minPriceProduct, minPossiblePrice.Value, out taxRate);
decimal finalPrice = currencyService.ConvertFromPrimaryStoreCurrency(finalPriceBase, workContext.WorkingCurrency);
priceModel.OldPrice = null;
priceModel.Price = String.Format(localizationService.GetResource("Products.PriceRangeFrom"), priceFormatter.FormatPrice(finalPrice));
}
else
{
//Actually it's not possible (we presume that minimalPrice always has a value)
//We never should get here
Debug.WriteLine("Cannot calculate minPrice for product #{0}", product.Id);
}
}
}
else
{
//hide prices
priceModel.OldPrice = null;
priceModel.Price = null;
}
}
break;
}
#endregion
}
break;
case ProductType.SimpleProduct:
default:
{
#region Simple product
//add to cart button
priceModel.DisableBuyButton = product.DisableBuyButton ||
!permissionService.Authorize(StandardPermissionProvider.EnableShoppingCart) ||
!permissionService.Authorize(StandardPermissionProvider.DisplayPrices);
//add to wishlist button
priceModel.DisableWishlistButton = product.DisableWishlistButton ||
!permissionService.Authorize(StandardPermissionProvider.EnableWishlist) ||
!permissionService.Authorize(StandardPermissionProvider.DisplayPrices);
//rental
priceModel.IsRental = product.IsRental;
//pre-order
if (product.AvailableForPreOrder)
{
priceModel.AvailableForPreOrder = !product.PreOrderAvailabilityStartDateTimeUtc.HasValue ||
product.PreOrderAvailabilityStartDateTimeUtc.Value >= DateTime.UtcNow;
priceModel.PreOrderAvailabilityStartDateTimeUtc = product.PreOrderAvailabilityStartDateTimeUtc;
}
//prices
if (permissionService.Authorize(StandardPermissionProvider.DisplayPrices))
{
if (!product.CustomerEntersPrice)
{
if (product.CallForPrice)
{
//call for price
priceModel.OldPrice = null;
priceModel.Price = localizationService.GetResource("Products.CallForPrice");
}
else
{
//prices
//calculate for the maximum quantity (in case if we have tier prices)
decimal minPossiblePrice = priceCalculationService.GetFinalPrice(product,
workContext.CurrentCustomer, decimal.Zero, true, int.MaxValue);
decimal taxRate;
decimal oldPriceBase = taxService.GetProductPrice(product, product.OldPrice, out taxRate);
decimal finalPriceBase = taxService.GetProductPrice(product, minPossiblePrice, out taxRate);
decimal oldPrice = currencyService.ConvertFromPrimaryStoreCurrency(oldPriceBase, workContext.WorkingCurrency);
decimal finalPrice = currencyService.ConvertFromPrimaryStoreCurrency(finalPriceBase, workContext.WorkingCurrency);
//do we have tier prices configured?
var tierPrices = new List <TierPrice>();
if (product.HasTierPrices)
{
tierPrices.AddRange(product.TierPrices
.OrderBy(tp => tp.Quantity)
.ToList()
.FilterByStore(storeContext.CurrentStore.Id)
.FilterForCustomer(workContext.CurrentCustomer)
.RemoveDuplicatedQuantities());
}
//When there is just one tier (with qty 1),
//there are no actual savings in the list.
bool displayFromMessage = tierPrices.Count > 0 &&
!(tierPrices.Count == 1 && tierPrices[0].Quantity <= 1);
if (displayFromMessage)
{
priceModel.OldPrice = null;
priceModel.Price = String.Format(localizationService.GetResource("Products.PriceRangeFrom"), priceFormatter.FormatPrice(finalPrice));
}
else
{
if (finalPriceBase != oldPriceBase && oldPriceBase != decimal.Zero)
{
priceModel.OldPrice = priceFormatter.FormatPrice(oldPrice);
priceModel.Price = priceFormatter.FormatPrice(finalPrice);
}
else
{
priceModel.OldPrice = null;
priceModel.Price = priceFormatter.FormatPrice(finalPrice);
}
}
if (product.IsRental)
{
//rental product
priceModel.OldPrice = priceFormatter.FormatRentalProductPeriod(product, priceModel.OldPrice);
priceModel.Price = priceFormatter.FormatRentalProductPeriod(product, priceModel.Price);
}
//property for German market
//we display tax/shipping info only with "shipping enabled" for this product
//we also ensure this it's not free shipping
priceModel.DisplayTaxShippingInfo = catalogSettings.DisplayTaxShippingInfoProductBoxes &&
product.IsShipEnabled &&
!product.IsFreeShipping;
}
}
}
else
{
//hide prices
priceModel.OldPrice = null;
priceModel.Price = null;
}
#endregion
}
break;
}
model.ProductPrice = priceModel;
#endregion
}
//picture
if (preparePictureModel)
{
#region Prepare product picture
//If a size has been set in the view, we use it in priority
int pictureSize = productThumbPictureSize.HasValue ? productThumbPictureSize.Value : mediaSettings.ProductThumbPictureSize;
//prepare picture model
var defaultProductPictureCacheKey = string.Format(ModelCacheEventConsumer.PRODUCT_DEFAULTPICTURE_MODEL_KEY, product.Id, pictureSize, true, workContext.WorkingLanguage.Id, webHelper.IsCurrentConnectionSecured(), storeContext.CurrentStore.Id);
model.DefaultPictureModel = cacheManager.Get(defaultProductPictureCacheKey, () =>
{
var picture = pictureService.GetPicturesByProductId(product.Id, 1).FirstOrDefault();
var pictureModel = new PictureModel
{
ImageUrl = pictureService.GetPictureUrl(picture, pictureSize),
FullSizeImageUrl = pictureService.GetPictureUrl(picture),
Title = string.Format(localizationService.GetResource("Media.Product.ImageLinkTitleFormat"), model.Name),
AlternateText = string.Format(localizationService.GetResource("Media.Product.ImageAlternateTextFormat"), model.Name)
};
return(pictureModel);
});
#endregion
}
//specs
if (prepareSpecificationAttributes)
{
model.SpecificationAttributeModels = PrepareProductSpecificationModel(controller, workContext,
specificationAttributeService, cacheManager, product);
}
//reviews
model.ReviewOverviewModel = new ProductReviewOverviewModel
{
ProductId = product.Id,
RatingSum = product.ApprovedRatingSum,
TotalReviews = product.ApprovedTotalReviews,
AllowCustomerReviews = product.AllowCustomerReviews
};
models.Add(model);
}
return(models);
}
public new void SetUp()
{
_workContext = null;
var pluginFinder = new PluginFinder(new AppDomainTypeFinder());
var cacheManager = new NopNullCache();
//price calculation service
_discountService = MockRepository.GenerateMock <IDiscountService>();
_categoryService = MockRepository.GenerateMock <ICategoryService>();
_productAttributeParser = MockRepository.GenerateMock <IProductAttributeParser>();
_shoppingCartSettings = new ShoppingCartSettings();
_catalogSettings = new CatalogSettings();
_priceCalcService = new PriceCalculationService(_workContext, _discountService,
_categoryService, _productAttributeParser, _shoppingCartSettings, _catalogSettings);
_eventPublisher = MockRepository.GenerateMock <IEventPublisher>();
_eventPublisher.Expect(x => x.Publish(Arg <object> .Is.Anything));
//shipping
_shippingSettings = new ShippingSettings();
_shippingSettings.ActiveShippingRateComputationMethodSystemNames = new List <string>();
_shippingSettings.ActiveShippingRateComputationMethodSystemNames.Add("FixedRateTestShippingRateComputationMethod");
_shippingMethodRepository = MockRepository.GenerateMock <IRepository <ShippingMethod> >();
_logger = new NullLogger();
_shippingService = new ShippingService(cacheManager,
_shippingMethodRepository,
_logger,
_productAttributeParser,
_checkoutAttributeParser,
_shippingSettings, pluginFinder, _eventPublisher);
_paymentService = MockRepository.GenerateMock <IPaymentService>();
_checkoutAttributeParser = MockRepository.GenerateMock <ICheckoutAttributeParser>();
_giftCardService = MockRepository.GenerateMock <IGiftCardService>();
_eventPublisher = MockRepository.GenerateMock <IEventPublisher>();
_eventPublisher.Expect(x => x.Publish(Arg <object> .Is.Anything));
//tax
_taxSettings = new TaxSettings();
_taxSettings.ShippingIsTaxable = true;
_taxSettings.PaymentMethodAdditionalFeeIsTaxable = true;
_taxSettings.DefaultTaxAddressId = 10;
_addressService = MockRepository.GenerateMock <IAddressService>();
_addressService.Expect(x => x.GetAddressById(_taxSettings.DefaultTaxAddressId)).Return(new Address()
{
Id = _taxSettings.DefaultTaxAddressId
});
_taxService = new TaxService(_addressService, _workContext, _taxSettings, pluginFinder, _eventPublisher);
_rewardPointsSettings = new RewardPointsSettings();
_orderTotalCalcService = new OrderTotalCalculationService(_workContext,
_priceCalcService, _taxService, _shippingService, _paymentService,
_checkoutAttributeParser, _discountService, _giftCardService,
_taxSettings, _rewardPointsSettings, _shippingSettings, _shoppingCartSettings, _catalogSettings);
}
public CategoryApiController(ICategoryService categoryService)
{
_CategoryService = categoryService;
}
public CategoriesController(ICategoryService categoryService, IMapper mapper)
{
_categoryService = categoryService;
_mapper = mapper;
}
public CategoryController(ICategoryService categoryService)
{
_categoryService = categoryService;
}
public CategoryController(ICategoryService categoryService, ILogger <BooksController> logger)
{
_categoryService = categoryService;
_logger = logger;
}
public CategoryController(ICategoryService categoryService, UserManager <User> userManager, IMapper mapper, IImageHelper imageHelper) : base(userManager, mapper, imageHelper)
{
_categoryService = categoryService;
}
public CategoryController(IMapper mapper, ICategoryService categoryService)
{
_mapper = mapper;
_categoryService = categoryService;
}
public CategoryController(ICategoryService categoryService, ICategory categorymodel)
{
_ICategoryService = categoryService;
_ICategory = categorymodel;
_category = new Category();
}
public ProductManager(IProductDal productDal, ICategoryService categoryService)
{
_productDal = productDal;
_categoryService = categoryService;
}
public CategoriesController(ICategoryService categoryService, IMapper mapper, IRdfService rdfService)
{
_categoryService = categoryService;
_mapper = mapper;
_rdfService = rdfService;
}
public CategoryController(ICategoryService serv)
{
_serv = serv;
}
public CategoryService_Test()
{
this.InitDb();
this._categoryService = _serviceProvider.GetRequiredService <ICategoryService>();
}
public CategoriesViewComponent(ICategoryService categoryService)
{
this._categoryService = categoryService;
}
public override void SetUp()
{
base.SetUp();
_categoryService = new CategoryService(_serviceContext, _currentUserService);
}
public CategoryListModelMVC(ICategoryService service)
{
categoryService = service;
Init();
}
static void Main(string[] args)
{
StandardKernel ninject = new StandardKernel(new BLL.Infrastructure.ServiceModule("StoreConnection"));
ISupplierService supplier = ninject.Get <ISupplierService>();
IGoodService good = ninject.Get <IGoodService>();
ICategoryService category = ninject.Get <ICategoryService>();
//#region First point "Get the list of goods of defined Category"
//Console.WriteLine("First point \"Get the list of goods of defined Category\"\n");
//Console.WriteLine("1.1 Get All Goods\n");
//var goodsFromCategories = category.GetAll();
//foreach (var categories in goodsFromCategories)
//{
// foreach (var item in categories.Goods)
// {
// Console.WriteLine(
// $"{item.Category.CategoryID}-{item.Category.Name}-{item.Brand}-{item.Model}");
// }
//}
//Console.WriteLine("\n");
//Console.WriteLine("1.2 Get goods by Id of Category\n");
//var goodFromCategory = category.GetById(2);//Clothes
//foreach (var item in goodFromCategory.Goods)
//{
// Console.WriteLine($"{item.Brand}-{item.Model}");
//}
//Console.WriteLine("\n");
//Console.WriteLine("1.3 Get goods by name of Category\n");
//var goodsFromCategory = good.GetGoodsFromCategory("Phone");
//foreach (var categories in goodsFromCategories)
//{
// foreach (var item in categories.Goods)
// {
// Console.WriteLine(
// $"{item.Category.CategoryID}-{item.Category.Name}-{item.Brand}-{item.Model}");
// }
//}
//Console.WriteLine("\n");
//#endregion
//#region Second point "Define all Suppliers of Category"
//Console.WriteLine("Second point \"Define all Suppliers of Category\"\n");
//Console.WriteLine("2.1 Get Suppliers from Category By Id \n");
//var categorySuppliers = category.GetById(1).Goods;
//foreach (var item in categorySuppliers)
//{
// Console.WriteLine($"{item.Supplier.Name}-{item.Supplier.City}");
//}
//Console.WriteLine("\n");
//Console.WriteLine("2.2 Get Suppliers from Category By categoru name (Registed of literals is not important)\n");
//Console.WriteLine("With upper");
//var category_Suppliers1 = supplier.GetSuppliersFromCategory("Phone");
//foreach (var item in category_Suppliers1)
//{
// Console.WriteLine($"{item.SupplierID} - {item.Name} - {item.City.CityName}");
//}
//Console.WriteLine("\n");
//OR
//Console.WriteLine("__________OR_________");
//Console.WriteLine("With all lower\n");
//var category_Suppliers2 = supplier.GetSuppliersFromCategory("phone");
//foreach (var item in category_Suppliers2)
//{
// Console.WriteLine($"{item.SupplierID} - {item.Name} - {item.City.CityName}");
//}
//Console.WriteLine("\n");
//#endregion
//#region Third point "Define all Goods of Supplier"
//Console.WriteLine("Third point \"Define all Goods of Supplier\"\n");
//Console.WriteLine("3.1 Get suppliers goods by his Id\n");
//var goodsOfSupplier = supplier.GetById(1).Goods;
//foreach (var item in goodsOfSupplier)
//{
// Console.WriteLine($"{item.Supplier.Name} - {item.Brand} - {item.Model}");
//}
//Console.WriteLine("\n");
//Console.WriteLine("3.2 Get suppliers goods by his name\n");
//var goodsofSupplier = good.GetGoodsFromSupplier("ClothSeller");
//foreach (var item in goodsofSupplier)
//{
// Console.WriteLine($"{item.Supplier.Name} - {item.Brand} - {item.Model}");
//}
//Console.WriteLine("\n");
//#endregion
//#region Second point "To Find some goods by criteria"
//Console.WriteLine("Second point \"To Find some goods by criteria\"\n");
//Console.WriteLine("4.1 MAX PRICE\n");
//var goodsMaxPrice = good.GetGoodsWithMaxPrice();
//foreach (var item in goodsMaxPrice)
//{
// Console.WriteLine($"Goods with max price - {item.Brand} - {item.Model} - {item.Price}");
//}
//Console.WriteLine("\n");
//Console.WriteLine("4.2 MIN PRICE\n");
//var goodsMinPrice = good.GetGoodsWithMinPrice();
//foreach (var item in goodsMinPrice)
//{
// Console.WriteLine($"Goods with min price - {item.Brand} - {item.Model} - {item.Price}");
//}
//Console.WriteLine("\n");
//Console.WriteLine("4.3 Goods from the City by id\n");
//var goodsFromCity = good.Find(x => x.Supplier.City.CiteID == 2);
//foreach (var item in goodsFromCity)
//{
// Console.WriteLine($"Goods From {item.Supplier.City.CityName} - {item.Brand} - {item.Model}");
//}
//#endregion
Console.ReadKey();
}
public ProductController(IProductService Ips, ICategoryService Ics, ILoggerService ILS)
{
IProductService = Ips;
ICategoryService = Ics;
ILoggerService = ILS;
}
public CategoryListViewModel(INavigationService navigation, IDialogService dialog, ICategoryService categoryService) : base(navigation, dialog)
{
CategoryService = categoryService;
Title = "Categories";
LoadCommand = new Command(async() => await Load());
}
public CategoriesController(ICategoryService categoryService, IMapper mapper)
{
this.categoryService = categoryService;
this.mapper = mapper;
}
public CategoryListModelMVC()
{
categoryService = new CategoryService();
Init();
}
public EditCategoryModel(ICategoryService categoryService) : base(categoryService)
{
}
public MangaViewPageViewModel(ICategoryService categoryService, IImageStoreService imageStoreService)
{
_categoryService = categoryService;
_imageStoreService = imageStoreService;
MangaPages = new ObservableCollection <PixivMangaImageViewModel>();
}
public CategoryMenuViewComponent(
ICategoryService categoryService)
{
_categoryService = categoryService;
}
public HomeController(ICategoryService categoryService, IGadgetService gadgetService)
{
this.categoryService = categoryService;
this.gadgetService = gadgetService;
}
public ProductCategoryValidator(IEnumerable <IValidatorConsumer <ProductCategoryDto> > validators, ILocalizationService localizationService, ICategoryService categoryService)
: base(validators)
{
RuleFor(x => x).MustAsync(async(x, y, context) =>
{
var category = await categoryService.GetCategoryById(x.CategoryId);
if (category == null)
{
return(false);
}
return(true);
}).WithMessage(localizationService.GetResource("Api.Catalog.ProductCategory.Fields.CategoryId.NotExists"));
}
public CategoryCustomList(ICategoryService service, IMapper mapper)
{
_service = service;
_mapper = mapper;
}
public SuperAdminController(IUserService UserService, IRoleService RoleService, IFormService FormService, IRoleDetailService RoleDetailService,
IUserRoleService UserRoleService, ICustomerService CustomerService, ICategoryService CategoryService, IAgencyIndividualService AgencyIndividualService)
: base(UserService, RoleService, FormService, RoleDetailService, UserRoleService)
{
this._CustomerService = CustomerService;
this._CategoryService = CategoryService;
this._AgencyIndividualService = AgencyIndividualService;
}
public CategoryNavigationViewComponent(ICategoryService categoryService)
{
_categoryService = categoryService;
}
