public LotController(IUserService userService, ILotService lotService, IProfileService profileService, IBidService bidService)
{
this.userService = userService;
this.lotService = lotService;
this.profileService = profileService;
this.bidService = bidService;
}
public LotController(ILotService lotService, ICategoryService categoryService, IUserService userService)
{
this.userService = userService;
this.lotService = lotService;
this.categoryService = categoryService;
CheckLotsExpiration();
}
static Program()
{
resolver = new StandardKernel();
resolver.ConfigurateResolverConsole();
lotService = resolver.Get <ILotService>();
log = resolver.Get <ILog>();
}
public ApplyMaximumsTask(IRepository<AUMaxBidJobControlRecord> maxbidjobcontrolRepo,
IRepository<AUMaxBidRecord> maxbidRepo,
IRepository<AULotLastBidChangeRecord> lotlastbidchangeRepo,
ILogger logger,
IConsignorService consignorService,
ICustomerService customerService,
IQueuedEmailService queuedEmailService,
IEmailAccountService emailAccountService,
EmailAccountSettings emailAccountSettings,
IAUCatalogService AUcatalogService,
ILotService lotService)
{
//this._customerService = customerService;
this._logger = logger;
this._maxbidjobcontrolRepo = maxbidjobcontrolRepo;
this._maxbidRepo = maxbidRepo;
this._lotlastbidchangeRepo = lotlastbidchangeRepo;
this._consignorService = consignorService;
this._customerService = customerService;
this._queuedEmailService = queuedEmailService;
this._emailAccountService = emailAccountService;
this._emailAccountSettings = emailAccountSettings;
this._AUcatalogService = AUcatalogService;
this._lotService = lotService;
}
public AdminController(IUserService userService, ICategoryService categoryService, ILotService lotService, ICommentService commentService)
{
_userService = userService;
_categoryService = categoryService;
_lotService = lotService;
_commentService = commentService;
}
public UserController(IUserService userService, ILotService lotService, IPurchaseService purchaseService, IBidService bidService)
{
_userService = userService;
_lotService = lotService;
_purchaseService = purchaseService;
_bidService = bidService;
}
public AttributeNamesController(ILotService lotService)
{
if (lotService == null)
{
throw new ArgumentNullException("lotService");
}
_lotService = lotService;
}
public LotController(IMapper mapper, ILotService lotService, IBidService bidService, IRepository <Category> categoryRepository, ILotRepository lotRepository)
{
_lotRepository = lotRepository;
_categoryRepository = categoryRepository;
_bidService = bidService;
_maper = mapper;
_lotService = lotService;
}
public LotReportingService(ILotService lotService)
{
if (lotService == null)
{
throw new ArgumentNullException("lotService");
}
_lotService = lotService;
}
public UsersController(ICustomAuthentication authentication, IUserService userService,IBidService bidService,ILotService lotService)
:base(authentication)
{
_customAuthentication = authentication;
_userService = userService;
_bidService = bidService;
_lotService = lotService;
}
public LotController(IService<BllBid> bidService, ILotService lotService, IService<BllModerationStatus> moderationStatusService, IService<BllCategory> categoryService, IUserService userService)
{
this.bidService = bidService;
this.lotService = lotService;
this.moderationStatusService = moderationStatusService;
this.categoryService = categoryService;
this.userService = userService;
}
public DefectsController(ILotService lotService)
{
if (lotService == null)
{
throw new ArgumentNullException("lotService");
}
_lotService = lotService;
}
public UsersController(ICustomAuthentication authentication, IUserService userService, IBidService bidService, ILotService lotService)
: base(authentication)
{
_customAuthentication = authentication;
_userService = userService;
_bidService = bidService;
_lotService = lotService;
}
public LotController(ILotService lotService, ICommentService commentService, IBidService bidService,
ICategoryService categoryService, IUserService userService)
{
_lotService = lotService;
_commentService = commentService;
_bidService = bidService;
_categoryService = categoryService;
_userService = userService;
}
public LotManagerController(
ICRUDLotService crudLotService,
ICRUDUserService crudUserService,
ILotService lotService)
{
_crudLotService = crudLotService;
_crudUserService = crudUserService;
_lotService = lotService;
_lotManagerService = new LotManagerService(_crudLotService, _crudUserService);
}
public HomeController(UserManager <User> userManager,
ApplicationContext context,
ILotService lotService,
IDeleteService deleteService)
{
_context = context;
_userManager = userManager;
_lotService = lotService;
_deleteService = deleteService;
}
public ModeratorController(ISectionService sectionService,
ICategoryService categoryService, IRequestService requestService,
ILotImageService lotRequestService, ILotService lotService)
{
_sectionService = sectionService;
_categoryService = categoryService;
_requestService = requestService;
_lotRequestService = lotRequestService;
_lotService = lotService;
}
public ModeratorController(ISectionService sectionService,
ICategoryService categoryService, IRequestService requestService,
ILotImageService lotRequestService, ILotService lotService)
{
_sectionService = sectionService;
_categoryService = categoryService;
_requestService = requestService;
_lotRequestService = lotRequestService;
_lotService = lotService;
}
public CategoriesController(IMapper _mapper,
ICategoryService categoryService,
ILotService lotService,
IAuthorizationService authorizationService)
{
this._mapper = _mapper;
_categoryService = categoryService;
_lotService = lotService;
_authorizationService = authorizationService;
}
public LotController(ICategoryService categoryService, ISectionService sectionService,
ILotService lotService, IUserService userService, ILotImageService lotRequestService,
IBidService bidService)
{
_sectionService = sectionService;
_categoryService = categoryService;
_lotService = lotService;
_userService = userService;
_lotImageService = lotRequestService;
_bidService = bidService;
}
public LotController(ICategoryService categoryService, ISectionService sectionService,
ILotService lotService, IUserService userService, ILotImageService lotRequestService,
IBidService bidService)
{
_sectionService = sectionService;
_categoryService = categoryService;
_lotService = lotService;
_userService = userService;
_lotImageService = lotRequestService;
_bidService = bidService;
}
public MarketService(
ILotService lotService,
IOrderService orderService,
IOrderStateService orderStateService,
INotificationService notificationService,
IDispatcherService dispatcherService)
{
LotService = lotService;
OrderService = orderService;
OrderStateService = orderStateService;
NotificationService = notificationService;
DispatcherService = dispatcherService;
}
public LotsController(ILotService lotService, IUserIdentityProvider userIdentityProvider)
{
if (lotService == null)
{
throw new ArgumentNullException("lotService");
}
_lotService = lotService;
if (userIdentityProvider == null)
{
throw new ArgumentNullException("userIdentityProvider");
}
_userIdentityProvider = userIdentityProvider;
}
public LotController(
IChangeLotUpdateIntervalViewModelFactory changeLotUpdateIntervalViewModelFactory,
ILotViewModelFactory lotViewModelFactory,
ISchedulerService schedulerService,
ILotService lotService,
IFilterService filterService,
IUserService userService,
IFilterViewModelFactory filterViewModelFactory)
{
this.changeLotUpdateIntervalViewModelFactory = changeLotUpdateIntervalViewModelFactory ?? throw new ArgumentNullException(nameof(changeLotUpdateIntervalViewModelFactory));
this.lotViewModelFactory = lotViewModelFactory ?? throw new ArgumentException(nameof(lotViewModelFactory));
this.schedulerService = schedulerService ?? throw new ArgumentNullException(nameof(schedulerService));
this.lotService = lotService ?? throw new ArgumentNullException(nameof(lotService));
this.filterService = filterService ?? throw new ArgumentNullException(nameof(filterService));
this.filterViewModelFactory = filterViewModelFactory ?? throw new ArgumentNullException(nameof(filterViewModelFactory));
}
public void Init()
{
_mapper = new MappingProfile();
_mockUnitOfWork = new Mock <IUnitOfWork>();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(_mapper));
IMapper mapper = new Mapper(configuration);
_service = new LotService(_mockUnitOfWork.Object, mapper);
_bids = new List <Bid>()
{
new Bid()
{
Id = 1, LotId = 1, UserId = 1, UserName = "******", BidPrice = 10, BidDate = DateTime.Now.AddMinutes(1)
},
new Bid()
{
Id = 2, LotId = 1, UserId = 1, UserName = "******", BidPrice = 15, BidDate = DateTime.Now.AddMinutes(2)
},
new Bid()
{
Id = 3, LotId = 1, UserId = 1, UserName = "******", BidPrice = 20, BidDate = DateTime.Now.AddMinutes(3)
},
new Bid()
{
Id = 4, LotId = 1, UserId = 1, UserName = "******", BidPrice = 25, BidDate = DateTime.Now.AddMinutes(4)
},
new Bid()
{
Id = 5, LotId = 1, UserId = 1, UserName = "******", BidPrice = 30, BidDate = DateTime.Now.AddMinutes(5)
},
};
_lots = new List <Lot>()
{
new Lot()
{
Id = 1, InitialPrice = 1, Bids = new List <Bid>(_bids)
},
new Lot()
{
Id = 2, InitialPrice = 1, Bids = new List <Bid>()
},
new Lot()
{
Id = 3, InitialPrice = 1, Bids = new List <Bid>()
}
};
}
public LotsController(IMapper mapper,
ILotService lotService,
ICategoryService categoryService,
IAuthorizationService authorizationService,
IUserService userService,
IConfiguration configuration)
{
_mapper = mapper;
_lotService = lotService;
_categoryService = categoryService;
_authorizationService = authorizationService;
_userService = userService;
var cloudinaryConfiguration = configuration.GetSection("Cloudinary");
var account = new Account(
cloudinaryConfiguration.GetSection("cloud_name").Value,
cloudinaryConfiguration.GetSection("api_key").Value,
cloudinaryConfiguration.GetSection("api_secret").Value
);
_cloudinary = new Cloudinary(account);
}
//I think this is the method that uses dependancy injection to create the repos - as opposed to manual
//see:http://alexwolfthoughts.com/creating-a-generic-repository-with-entity-framework-and-mvc
public AULotController( IRepository<AULotRecord> lotRepo,
IRepository<AUFeesRecord> feesRepo,
IRepository<AUFinderFeesRecord> finderfeesRepo,
IRepository<AUBidHistoryRecord> bidhistoryRepo,
IRepository<AULotLastBidChangeRecord> lotlastbidchangeRepo,
IConsignorService consignorservice,
IAuthenticationService authenticationService,
IProductService productService,
ICopyProductService copyProductService,
ILotService lotService,
ISettingService settings,
IStoreService storeService,
IWorkContext workContext,
IAUSaleService ausaleService,
ILocalizationService localizationService
)
{
_lotRepo = lotRepo;
_feesRepo = feesRepo;
_finderfeesRepo = finderfeesRepo;
_bidhistoryRepo = bidhistoryRepo;
_consignorService = consignorservice;
_authenticationService = authenticationService;
_productService = productService;
_copyProductService = copyProductService;
_lotService = lotService;
_settings = settings;
_storeService = storeService;
_workContext = workContext;
_ausaleService = ausaleService;
_localizationService = localizationService;
_lotlastbidchangeRepo = lotlastbidchangeRepo;
}
public BidController(IService<BllBid> bidService, ILotService lotService, IUserService userService)
{
this.bidService = bidService;
this.lotService = lotService;
this.userService = userService;
}
public HomeController(ILotService lotService)
{
this.lotService = lotService;
}
public ParserService(ILotService lotService, IPhotoService photoService, IVehicleService vehicleService)
{
_lotService = lotService;
_photoService = photoService;
_vehicleService = vehicleService;
}
public LotsController(ILotService lotService)
{
_lotService = lotService;
}
public static IEnumerable<AUProductOverviewModel> 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,
ILotService lotService,
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<AUProductOverviewModel>();
foreach (var product in products)
{
var model = new AUProductOverviewModel
{
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 AUProductOverviewModel.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.DisableBuyButton = true;
priceModel.DisableWishlistButton = true;
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
priceModel.AvailableForPreOrder = false;
}
break;
default:
{
//we have at least one associated product
priceModel.DisableBuyButton = true;
priceModel.DisableWishlistButton = true;
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
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);
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
//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" attribute
pictureModel.Title = (picture != null && !string.IsNullOrEmpty(picture.TitleAttribute)) ?
picture.TitleAttribute :
string.Format(localizationService.GetResource("Media.Product.ImageLinkTitleFormat"), model.Name);
//"alt" attribute
pictureModel.AlternateText = (picture != null && !string.IsNullOrEmpty(picture.AltAttribute)) ?
picture.AltAttribute :
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
};
//TODO only get lot info if store contains lots and products is a lot
model.LotBidEntryModel = lotService.GetLotBidEntryModel(product.Id);
models.Add(model);
}
return models;
}
public AccountController(IUserService userService, ILotService lotService, IImageService imageService)
{
this.userService = userService;
this.lotService = lotService;
this.imageService = imageService;
}
public UserStatusJob()
{
_lotService = (ILotService)System.Web.Mvc.DependencyResolver.Current.GetService(typeof(ILotService));
}
public SearchController(ILotService lotService)
{
_lotService = lotService;
}
public AccountController(IUserService userService, ILotService lotService, IImageService imageService)
{
this.userService = userService;
this.lotService = lotService;
this.imageService = imageService;
}
/*public static List<string> ExtensionList = new List<string>
{
"jpg",
"jpeg",
"gif",
"png",
"bmp",
"tif",
"tiff"
};*/
public LotController()
{
_lotService = new LotService(new DatabaseUnitOfWork());
}
public LotController(ILotService serv) => lotService = serv;
//I think this is the method that uses dependancy injection to create the repos - as opposed to manual
//see:http://alexwolfthoughts.com/creating-a-generic-repository-with-entity-framework-and-mvc
public AUPublicController(IRepository<AUConsignorRecord> consignorRepo,
IRepository<AUConsignmentRecord> consignmentRepo,
IRepository<AUConsignorConsignmentRecord> consignorconsignmentRepo,
IRepository<AUConsignorList> consignorlistRepo,
IRepository<AUSaleRecord> saleRepo,
IRepository<AUSessionRecord> sessionRepo,
IRepository<AUIncrementRecord> incrementRepo,
IRepository<AUAddressRecord> addressRepo,
IRepository<AUCombAddress> combAddressRepo,
IRepository<AULotList> lotlistRepo,
IRepository<AUFeesRecord> feesRepo,
IRepository<AUBidHistoryRecord> bidhistoryRepo,
ICacheManager cacheManager,
IPictureService pictureService,
IConsignmentService consignmentservice,
ILotService lotService,
IForumService forumservice,
IConsignorService consignorservice,
IDateTimeHelper dateTimeHelper,
IAuthenticationService authenticationService,
ILocalizationService localizationService,
ICountryService countryService,
IStateProvinceService stateProvinceService,
IWorkContext workContext,
ICollectibleImportService collectibleimportService,
//IRepository<AUCombConsignorConsignment> combinedRepo,
ICategoryService categoryService,
IStoreService storeService,
IShippingService shippingService,
IPermissionService permissionService,
IEventPublisher eventPublisher,
ISettingService settings,
IProductService productService,
IDbContext dbContext,
IPhilatelicPdfService philatelicpdfService,
ICollectibleExportService collectibleexportService,
IAUSaleService ausaleService,
IAclService aclService,
IStoreMappingService storeMappingService,
CatalogSettings catalogSettings,
IWebHelper webHelper,
IPriceFormatter priceFormatter,
ICurrencyService currencyService,
IStoreContext storeContext,
MediaSettings mediaSettings,
IPriceCalculationService priceCalculationService,
ISpecificationAttributeService specificationAttributeService,
ITaxService taxService,
ICategoryTemplateService categoryTemplateService,
ICustomerActivityService customerActivityService,
ShoppingCartSettings shoppingCartSettings,
IAUCatalogService AUcatalogService,
IForumService forumService,
ICustomerService customerService,
ForumSettings forumSettings,
ILogger logger,
IRecentlyViewedProductsService recentlyViewedProductsService,
SeoSettings seoSettings,
IVendorService vendorService,
VendorSettings vendorSettings,
IProductTagService productTagService,
IProductTemplateService productTemplateService,
IProductAttributeParser productAttributeParser,
IManufacturerService manufacturerService,
IMeasureService measureService,
IProductAttributeService productAttributeService,
CustomerSettings customerSettings,
IGenericAttributeService genericAttributeService,
ISearchTermService searchTermService,
IShoppingCartService shoppingCartService,
IProductAttributeFormatter productAttributeFormatter)
{
_cacheManager = cacheManager;
_pictureService = pictureService;
_lotService = lotService;
_forumservice = forumservice;
_consignorRepo = consignorRepo;
_consignmentRepo = consignmentRepo;
_consignorconsignmentRepo = consignorconsignmentRepo;
_consignorService = consignorservice;
_consignmentService = consignmentservice;
_consignorlistRepo = consignorlistRepo;
_saleRepo = saleRepo;
_sessionRepo = sessionRepo;
_incrementRepo = incrementRepo;
_addressRepo = addressRepo;
_combAddressRepo = combAddressRepo;
_lotlistRepo = lotlistRepo;
_feesRepo = feesRepo;
_bidhistoryRepo = bidhistoryRepo;
_dateTimeHelper = dateTimeHelper;
_authenticationService = authenticationService;
_localizationService = localizationService;
_countryService = countryService;
_stateProvinceService = stateProvinceService;
_workContext = workContext;
_collectibleimportService = collectibleimportService;
_categoryService = categoryService;
_storeService = storeService;
_shippingService = shippingService;
_permissionService = permissionService;
_eventPublisher = eventPublisher;
_settings = settings;
_productService = productService;
_dbContext = dbContext;
_philatelicpdfService = philatelicpdfService;
_collectibleexportService = collectibleexportService;
_ausaleService = ausaleService;
_aclService = aclService;
_storeMappingService = storeMappingService;
_catalogSettings = catalogSettings;
_webHelper = webHelper;
_priceFormatter = priceFormatter;
_currencyService = currencyService;
_storeContext = storeContext;
_mediaSettings = mediaSettings;
_priceCalculationService = priceCalculationService;
_specificationAttributeService = specificationAttributeService;
_taxService = taxService;
_categoryTemplateService = categoryTemplateService;
_customerActivityService = customerActivityService;
_shoppingCartSettings = shoppingCartSettings;
_AUcatalogService = AUcatalogService;
_forumService = forumService;
_customerService = customerService;
_forumSettings = forumSettings;
_logger = logger;
_recentlyViewedProductsService = recentlyViewedProductsService;
_seoSettings = seoSettings;
_vendorService = vendorService;
_vendorSettings = vendorSettings;
_productTemplateService = productTemplateService;
_productTagService = productTagService;
_productAttributeParser = productAttributeParser;
_manufacturerService = manufacturerService;
_measureService = measureService;
_productAttributeService = productAttributeService;
_customerSettings = customerSettings;
_genericAttributeService = genericAttributeService;
_searchTermService = searchTermService;
_shoppingCartService = shoppingCartService;
_productAttributeFormatter = productAttributeFormatter;
}
public BiddingController(IUserService userService, ILotService lotService, IBidService bidService)
{
this.userService = userService;
this.lotService = lotService;
this.bidService = bidService;
}
public LotRequestService(ILotRequestRepository repository, ILotService lotService, IDispatcherService dispatcherService)
: base(repository)
{
LotService = lotService;
DispatcherService = dispatcherService;
}
public HomeController(ILotService service, ITagService srv, IUserService userService)
{
this.service = service;
this.srv = srv;
this.userService = userService;
}
public LotsController(ILotService lotService, IWebHostEnvironment environment)
{
_lotService = lotService;
_environment = environment;
}
public LotController(ILotService service)
{
Service = service;
}