public ListModule(ILibraryListRepository lists, IRepository documents, IImageRepository images, IEnvironmentPathProvider pathProvider)
: base("/lists")
{
_documents = documents;
Get["/"] = _ =>
{
var results = lists.GetAll().Select(doc => DtoMaps.Map(doc));
return Response.AsJson(results).AsCacheable(DateTime.Now.AddDays(1)); // f***s up CORS... ?
};
Get["/{id}"] = args =>
{
LibrarylistDto dto = DtoMaps.Map(lists.Get(args.id), _documents);
return Response.AsJson(dto).AsCacheable(DateTime.Now.AddDays(1));
};
Get["/{id}/thumbnail"] = args =>
{
LibraryList list = lists.Get(args.id);
foreach (var docNo in list.DocumentNumbers.Keys)
{
var img = images.GetDocumentImage(docNo);
if (String.IsNullOrEmpty(img)) continue;
return Response.AsFile(Path.Combine(pathProvider.GetImageCachePath(), img));
}
return TextResponse.NoBody; // todo: placeholder img
};
}
public NewsService(INewsArticleRepository newsArticleRepository, INewsContentRepository newsContentRepository, IUserRepository userRepository, IImageRepository imageRepository)
{
_newsArticleRepository = newsArticleRepository;
_newsContentRepository = newsContentRepository;
_userRepository = userRepository;
_imageRepository = imageRepository;
}
public AlbumsController(ICategoryRepository categoryRepository, IAlbumRepository albumRepository, ImageRepository imageRepository)
{
this.categoryRepository = categoryRepository;
this.albumRepository = albumRepository;
this.imageRepository = imageRepository;
}
public ActionResult Illustration()
{
imageRepository = new ImageRepository();
albumRepository = new AlbumRepository();
return View(albumRepository.AllIncluding(m => m.Images).OrderBy(m => m.OrderNumber));
}
public IdeaController(IIdeaRepository ideas, IUserRepository users, ISettingsRepository settings, IImageRepository imageRepository, IFeatureRepository features)
{
_ideas = ideas;
_users = users;
_settings = settings;
_features = features;
}
public SlideshowManager (IFavorites favorites, IImageRepository imageRepository)
{
_favorites = favorites;
_imageRepository = imageRepository;
Settings = new Settings (false, false, true, 5000, AnimationType.Second);
}
public ApartmentController(IApartmentRepository aRepo, ILocationRepository lRepo, IContext con, IImageRepository img)
{
AptRepo = aRepo;
LocRepo = lRepo;
context = con;
imageRepo = img;
}
public ImageService(IWebsite website, IImageStorage imageStorage, IImageRepository imageRepository, ITransactionManager transactionManager)
{
this._website = website;
this._imageStorage = imageStorage;
this._imageRepository = imageRepository;
this._transactionManager = transactionManager;
}
public ImageController(IImageDataProvider imageDataProvider, IImageFactory imageFactory, IImageRepository imageRespository, IImageUrlProvider imageUrlProvider)
{
_imageDataProvider = imageDataProvider;
_imageFactory = imageFactory;
_imageRespository = imageRespository;
_imageUrlProvider = imageUrlProvider;
}
public MainService(IUnitOfWork uow, ILotRepository lotrepository, ICathegoryRepository cathegoryRepository, IImageRepository imageRepository)
{
this.uow = uow;
this.lotRepository = lotrepository;
this.cathegoryRepository = cathegoryRepository;
this.imageRepository = imageRepository;
}
public UnitOfWork(MessageBoardContext context,ITopicRepository topics,ICompanyRepository companies,IImageRepository images)
{
_context = context;
_topics = topics;
_companies = companies;
_images = images;
}
public CompositionsViewModelProvider(
IImageRepository imageRepository,
IMappingEngine mappingEngine)
{
_imageRepository = imageRepository;
_mappingEngine = mappingEngine;
}
public UserImagesController(IImageRepository imageRepository, IBinaryRepository binaryRepository)
{
ActionInvoker = new ActionInvokers.ActionInvoker();
ImageRepository = imageRepository;
BinaryRepository = binaryRepository;
}
public unsafe MphotoToplevel (IImageRepository _repo, string[] args, params object[] props)
: base ("Mphoto", "0.0", Modules.UI, args, props)
{
cwh = new Glade.XMLCustomWidgetHandler (GladeCustomWidgetHandler);
Glade.XML.SetCustomHandler (cwh);
gxml = new Glade.XML (null, "mphoto.glade", null, null);
Console.WriteLine ("Autoconnect");
gxml.Autoconnect (this);
// CreateCustomWidget ("browser_icon_list");
// CreateCustomWidget ("collections_tree_view");
// CreateCustomWidget ("imageinfo_tree_view");
// CreateCustomWidget ("eog_image_view");
// CreateCustomWidget ("keywords_widget");
this.leftside_notebook = (Gtk.Notebook) gxml["browser_left_notebook"];
this.top_level_notebook = (Gtk.Notebook) gxml["top_level_notebook"];
this.toplevel = gxml["mphoto_browser"];
this.label_zoom_value = (Gtk.Label) gxml["label_zoom_value"];
this.search_dialog = (Gtk.Window) gxml["search_dialog"];
this.Repository = _repo;
// initialize the tree views to the side
imageinfo_tree_view.IconList = icon_list;
keywords_widget.IconList = icon_list;
collections_tree_view.RowActivated += new RowActivatedHandler (CollectionsTreeViewActivateHandler);
icon_list.Activated += new EventHandler (IconlistActivated);
GlobalMphotoToplevel = this;
}
public DocumentController(IRepository documentRepository, ISuggestionDictionary suggestionRepository, IImageRepository imageRepository, IRatingRepository ratingRepository, IReviewRepository reviewRepository)
{
_documentRepository = documentRepository;
_suggestionRepository = suggestionRepository;
_imageRepository = imageRepository;
_ratingRepository = ratingRepository;
_reviewRepository = reviewRepository;
}
public AccountService(IAccountRepository accountRepository,
ISubmissionRepository submissionRepository,
IImageRepository imageRepository)
{
_accountRepository = accountRepository;
_submissionRepository = submissionRepository;
_imageRepository = imageRepository;
}
public LibraryListDynamicRepository(IRepository documentRepository, IImageRepository imageRepository, IEnvironmentPathProvider environment)
{
this._documentRepository = documentRepository;
this._imageRepository = imageRepository;
var xmlFilePath = environment.GetXmlFilePath();
_xmlFolderPath = string.IsNullOrEmpty(xmlFilePath) ? StdFolderPath : xmlFilePath;
}
public LibraryListXmlRepository(IRepository repository, IImageRepository imageRepository, IEnvironmentPathProvider environment)
{
_repository = repository;
_imageRepository = imageRepository;
var folderPath = environment.GetXmlListPath();
_folderPath = string.IsNullOrEmpty(folderPath) ? StdFolderPath : folderPath;
}
public TemplateViewModelProvider(
IImageRepository imageDataProvider,
IMappingEngine mappingEngine
)
{
_imageDataProvider = imageDataProvider;
_mappingEngine = mappingEngine;
}
public IImageRepository<Image> GetImageRepository()
{
if(imageRepo == null)
{
imageRepo = new ImageRepository();
}
return imageRepo;
}
public DocumentModule(IRepository documents, IImageRepository images, IRatingRepository ratings, IReviewRepository reviews, IFavoritesRepository favorites, IEnvironmentPathProvider pathProvider)
: base("/documents")
{
Get["/{id}/thumbnail"] = args =>
{
var doc = documents.GetDocument(args.id, true);
string img = images.GetDocumentImage(args.id);
if (String.IsNullOrEmpty(img))
{
return ResolvePlaceHolderImageForDocumentType(pathProvider, doc);
}
return Response.AsFile(Path.Combine(pathProvider.GetImageCachePath(), img));
};
Get["/{id}"] = args =>
{
Document document = documents.GetDocument(args.id, false);
return Response.AsJson(DtoMaps.Map(document, favorites, Context.GetUserInfo()));
};
Get["/{id}/rating"] = args =>
{
try
{
DocumentRating rating = ratings.GetDocumentRating(args.id);
return Response.AsJson(new DocumentRatingDto
{
MaxScore = rating.MaxScore,
Score = rating.Score,
Source = rating.Source,
SourceUrl = rating.SourceUrl,
HasRating = true
}).AsCacheable(DateTime.Now.AddDays(1));
}
catch
{
return new DocumentRatingDto {Success = true, HasRating = false};
}
};
Get["/{id}/review"] = args =>
{
string review = reviews.GetDocumentReview(args.id);
return Response.AsJson(new DocumentReviewDto{ Review = review, Url = "" }).AsCacheable(DateTime.Now.AddDays(1));
};
Get["/search"] = _ =>
{
string query = Request.Query.query.HasValue ? Request.Query.query : null;
if (null == query) throw new InvalidOperationException("Ingenting å søke etter.");
return Response.AsJson(documents.Search(query).Select(doc => DtoMaps.Map(doc, favorites, Context.GetUserInfo())).ToArray()).AsCacheable(DateTime.Now.AddHours(12));
};
}
public ScannedRecipeEditorController(
IRecipeRepository recipeRepo,
IImageRepository imageRepo,
IOcrService ocrService)
{
_recipeRepo = recipeRepo;
_imageRepo = imageRepo;
_ocrService = ocrService;
}
public HomeController(IPageRepository PageRepo, IHomeRepository HomeRepo, IImageRepository ImageRepo, IFormRepository FormRepo, IFAQRepository FAQRepo, IBlogPostRepository BlogPostRepo)
{
PageRepository = PageRepo;
HomeRepository = HomeRepo;
ImageRepository = ImageRepo;
FormRepository = FormRepo;
FAQRepository = FAQRepo;
BlogPostRepository = BlogPostRepo;
}
public PageController(IPageRepository PageRepo, IJSONRepository JSONRepo, IFormRepository FormRepo, IFAQRepository FAQRepo, IBlogPostRepository BlogPostRepo, IImageRepository ImageRepo)
{
PageRepository = PageRepo;
JSONRepository = JSONRepo;
FormRepository = FormRepo;
FAQRepository = FAQRepo;
BlogPostRepository = BlogPostRepo;
ImageRepository = ImageRepo;
}
public IdeaModule(IIdeaRepository ideas, IUserRepository users, ISettingsRepository settings, IImageRepository imageRepository)
: base("/idea")
{
_ideas = ideas;
_settings = settings;
_users = users;
Get["/{id}"] = parameters =>
{
int id = parameters.id;
var idea = _ideas.Get(id);
if (idea == null)
return View["404"];
User user = Context.GetCurrentUser(_users);
if (user != null)
{
if (idea.Votes.Any(u => u.UserId == user.Id))
idea.UserHasVoted = true;
}
var viewModel = new IdeaViewModel(idea);
var model = Context.Model(string.Format("{0} - {1}", idea.Title, _settings.Title));
model.Idea = viewModel;
return View["Idea/Index", model];
};
Get["/image/{id}"] = parameters =>
{
var id = (string)parameters.id;
if (id.Contains("."))
{
id = id.Substring(0, id.IndexOf(".")); //string .jpg in case it was send in
}
var image = imageRepository.Get(int.Parse(id));
// TODO: format should be adaptive based on backing source?
return Response.FromStream(new MemoryStream(image.ImageBits), "image/jpeg");
};
Get[@"/imagethumb/{id}/{width}"] = parameters =>
{
var image = (Image)imageRepository.Get(parameters.id);
using (var memoryStream = new MemoryStream(image.ImageBits))
{
var drawingImage = System.Drawing.Image.FromStream(memoryStream);
var thumb = drawingImage.ToThumbnail((int)parameters.width);
using (var thumbnailStream = new MemoryStream())
{
// TODO: format should be adaptive based on backing source?
thumb.Save(thumbnailStream, ImageFormat.Jpeg);
return Response.FromStream(new MemoryStream(thumbnailStream.GetBuffer()), "image/jpeg"); //massive WTF? If I just use thumnailStream, it doesn't work...
}
}
};
}
public LocationController(ILandlordRepository ll, IApartmentRepository a,
ILocationRepository lo, ITenantRepository t, IContext con, IImageRepository img)
{
TRepo = t;
AptRepo = a;
LocRepo = lo;
LLRepo = ll;
context = con;
imageRepo = img;
}
public LocalAssetManager(IUserActionRepository userActionRepository, IItemRepository itemRepository, IFileRepository fileRepository, ICryptographyProvider cryptographyProvider, ILogger logger, IUserRepository userRepository, IImageRepository iImageRepository)
{
_userActionRepository = userActionRepository;
_itemRepository = itemRepository;
_fileRepository = fileRepository;
_cryptographyProvider = cryptographyProvider;
_logger = logger;
_userRepository = userRepository;
_imageRepository = iImageRepository;
}
public ImageProcessorsController(
IImageRepository imageRepository,
IImageProcessorsService imageProcessorService,
IImageFactory imageFactory,
IImageUrlProvider imageUrlProvider)
{
_imageRepository = imageRepository;
_imageProcessorService = imageProcessorService;
_imageFactory = imageFactory;
_imageUrlProvider = imageUrlProvider;
}
public CabinetService(IUnitOfWork uow, ILotRepository lotRepository, IUserRepository userRepository, IProfileRepository profileRepository, ICountryRepository countryRepository, IImageRepository imageRepository, ICathegoryRepository cathegoryRepository)
{
this.uow = uow;
this.lotRepository = lotRepository;
this.userRepository = userRepository;
this.profileRepository = profileRepository;
this.profileRepository = profileRepository;
this.countryRepository = countryRepository;
this.imageRepository = imageRepository;
this.cathegoryRepository = cathegoryRepository;
}
public CarNumberController(
IImageFactory imageFactory,
ICarNumerIdentifyService identifyService,
IImageRepository imageRepository,
IImageUrlProvider imageUrlProvider)
{
_imageFactory = imageFactory;
_identifyService = identifyService;
_imageRepository = imageRepository;
_imageUrlProvider = imageUrlProvider;
}
public PrototypeService(ICategoryRepository categoryRepository,
IContractorRepository contractorRepository, IContractRepository contractRepository,
IImageRepository imageRepository, IInventoryRepository inventoryRepository,
IOrderItemRepository orderItemRepository, IOrderRepository orderRepository,
IShoppingCartItemRepository shoppingCartItemRepository, IShoppingCartRepository shoppingCartRepository,
IUserRepository userRepository)
{
this.categoryRepository = categoryRepository;
this.contractorRepository = contractorRepository;
this.contractRepository = contractRepository;
this.imageRepository = imageRepository;
this.inventoryRepository = inventoryRepository;
this.orderItemRepository = orderItemRepository;
this.orderRepository = orderRepository;
this.shoppingCartItemRepository = shoppingCartItemRepository;
this.shoppingCartRepository = shoppingCartRepository;
this.userRepository = userRepository;
}
public ImageService(
IImageRepository imageRepo,
ICategoryRepository categoryRepo,
IMapper mapper,
IHostingEnvironment env,
IConfiguration config,
IOptions <AzureStorageConfig> azureStorageConfig,
UploadImageHelper imageHelper)
{
_imageRepo = imageRepo;
_categoryRepo = categoryRepo;
_mapper = mapper;
_env = env;
_config = config;
_imageHelper = imageHelper;
_azureStorageConfig = azureStorageConfig.Value;
_env = env;
}
public UnitOfWork(IAdRepository adRepository, ICommentRepository commentRepository,
IFavoriteRepository favoriteRepository, IForCompareRepository forCompareRepository,
IImageRepository imageRepository, ITagRepository tagRepository, IUserRepository userRepository
/*,UserManager<User> userManager,RoleManager<IdentityRole> roleManager,SignInManager<User> signInManager*/)
{
UserRepository = userRepository;
AdRepository = adRepository;
CommentRepository = commentRepository;
FavoriteRepository = favoriteRepository;
ForCompareRepository = forCompareRepository;
ImageRepository = imageRepository;
TagRepository = tagRepository;
UserRepository = userRepository;
/*UserManager = userManager;
* RoleManager = roleManager;
* SignInManager = signInManager;*/
}
public WallrApplicationTests()
{
_setup = A.Fake <ISetup>();
_quickUseOptions = new[] { A.Fake <IQuickUseOption>(), A.Fake <IQuickUseOption>(), A.Fake <IQuickUseOption>() };
_imageQueue = A.Fake <IObservableImageQueue>();
_imageRepository = A.Fake <IImageRepository>();
_imageSourceConfigurations = A.Fake <IImageSourceConfigurations>();
var imageSaver = A.Fake <IImageSaver>();
var imageSources = A.Fake <IImageSources>();
_savedImages = A.Fake <IObservable <ISavedImage> >();
A.CallTo(() => imageSaver.StartSavingImages(imageSources)).Returns(_savedImages);
_wallpaperUpdater = A.Fake <IWallpaperUpdater>();
var testingSources = A.Fake <TestingSources>();
_wallrApplication = new WallrApplication(_setup, A.Fake <ILogger>(), _quickUseOptions, _imageQueue,
_imageRepository, _imageSourceConfigurations, imageSaver, imageSources, _wallpaperUpdater, testingSources);
}
public ClientController(
IWebHostEnvironment environment,
IClientRepository clientRepository,
IPerformerRepository performerRepository,
ICustomerRepository customerRepository,
IRoleRepository roleRepository,
IImageRepository imageRepository,
IImageService imageService,
IMapper mapper)
{
_environment = environment;
_clientRepository = clientRepository;
_performerRepository = performerRepository;
_customerRepository = customerRepository;
_roleRepository = roleRepository;
_imageRepository = imageRepository;
_imageService = imageService;
_mapper = mapper;
}
public FinanceController(IMapper mapper,
IEinnahmenAusgabenRepository einnahmeAusgabenRepository,
ITagsRepository tagsRepository,
IUserRepository userRepository,
IImageRepository imageRepository,
UserManager <FinanceAppUser> userManager,
IHostingEnvironment hostingEnvironment,
ICreateZufallsDateinamenService createZufallsDateinamenService,
ICheckDateiGleichBildService checkDateiGleichBildService)
{
_Mapper = mapper;
_EinnahmeAusgabenRepository = einnahmeAusgabenRepository;
_TagsRepository = tagsRepository;
_UserManager = userManager;
_ImageRepository = imageRepository;
_HostingEnvironment = hostingEnvironment;
_CreateZufallsDateinamenService = createZufallsDateinamenService;
_CheckDateiGleichBildService = checkDateiGleichBildService;
}
public static async Task UploadImage(IImageRepository _imageRepository, Base64Image image)
{
byte[] data = System.Convert.FromBase64String(image.Base64Picture.Split(',')[1]);
var imageInfo = new ImageInfo
{
Date = image.Date,
Id = image.Id,
Name = image.Name
};
var imageStorage = new ImageStorage
{
ImageInfoId = image.Id,
Picture = data,
};
await _imageRepository.UploadImage(imageInfo, imageStorage);
}
public WallrApplication(ISetup setup, ILogger logger,
IEnumerable <IQuickUseOption> quickUseOptions,
IObservableImageQueue imageQueue, IImageRepository imageRepository,
IImageSourceConfigurations imageSourceConfigurations,
IImageSaver saver, IImageSources imageSources,
IWallpaperUpdater wallpaperUpdater,
TestingSources testingSources)
{
_setup = setup;
_logger = logger;
_quickUseOptions = quickUseOptions;
_imageQueue = imageQueue;
_imageRepository = imageRepository;
_imageSourceConfigurations = imageSourceConfigurations;
_saver = saver;
_imageSources = imageSources;
_wallpaperUpdater = wallpaperUpdater;
_testingSources = testingSources;
}
public override IController CreateController(RequestContext requestContext, string controllerName)
{
if (ctx == null)
{
ctx = new MyOrganizationEntities();
}
if (repuser == null)
{
repuser = new UserRepository(ctx);
}
if (repOrg == null)
{
repOrg = new OrganizationRepository(ctx);
}
if (repImg == null)
{
repImg = new ImageRepository(ctx);
}
if (orgImagerep == null)
{
orgImagerep = new OrgImageRepository(ctx);
}
if (orgUserRepository == null)
{
orgUserRepository = new OrgUserRepository(ctx);
}
//if (controllerName == "Home")
//{
// return new HomeController(repuser,repOrg,orgImagerep);
//}
//if (controllerName == "Organization")
//{
// return new OrganizationController(repOrg, repImg, repuser, orgUserRepository, orgImagerep,new testRepository());
//}
return(base.CreateController(requestContext, controllerName));
}
public static async Task <string> SaveLogoAndGetUrl(IHostingEnvironment env, IImageRepository img_repo, Images img, string resource_id)
{
bool result = true;
DataProvider.DbResult dbResult = null;
string igdb = "https://images.igdb.com/igdb/image/upload/";
string fileName = string.Format("{0}.jpg", Guid.NewGuid().ToString());
img.ImageType = Constant.ImageType.Small;
img.Url = string.Format("/{0}/{1}/{2}/{3}", Constant.Resources, img.ImageOf, img.ImageType, fileName);
result = await SaveImageAndGetUrl(env, string.Format("{0}/{1}/{2}.jpg", igdb, Constant.ImageType.IGdb.Logo, resource_id), img.ImageType, img.ImageOf, fileName);
if (result)
{
dbResult = await img_repo.Add_New_ImageAsync(img);
}
return(fileName);
}
public ApiCommentController(
ICommentRepository commentRepo,
IProfileRepository profileRepo,
IImageRepository imageRepo,
IFriendRepository friendRepo,
ILikeRepository likeRepo,
IPostRepository postRepo,
SessionResults sessionResults,
CurrentProfile currentProfile)
{
this.commentRepo = commentRepo;
this.profileRepo = profileRepo;
this.imageRepo = imageRepo;
this.friendRepo = friendRepo;
this.likeRepo = likeRepo;
this.postRepo = postRepo;
this.sessionResults = sessionResults;
this.currentProfile = currentProfile;
}
public ImageSaverTests()
{
_imageSources = A.Fake <IImageSources>();
_imageFromSources = new[]
{
CreateImageFromSource("foo"),
CreateImageFromSource("bar"),
CreateImageFromSource("baz")
};
_testScheduler = new TestScheduler();
_imagesFromSourcesObservable = _testScheduler.CreateHotObservable(
_imageFromSources
.Select(
(image, i) => new Recorded <Notification <IImageFromSource> >(i + 2, // start events emitting after 2 ticks to allow for subscription
Notification.CreateOnNext(image)))
.ToArray());
A.CallTo(() => _imageSources.ImagesFromAllSources).Returns(_imagesFromSourcesObservable);
_imageRepository = A.Fake <IImageRepository>();
_sut = new ImageSaver(_imageRepository, A.Fake <ILogger>());
}
private void Dispose(bool dispose)
{
if (dispose)
{
if (_departmentRepository != null)
{
//_connection.Dispose();
_departmentRepository = null;
}
if (_archiveRepository != null)
{
//_connection.Dispose();
_archiveRepository = null;
}
if (_eventRepository != null)
{
_eventRepository = null;
}
if (_imageRepository != null)
{
_imageRepository = null;
}
if (_imgPhotoGalleryRepository != null)
{
_imgPhotoGalleryRepository = null;
}
if (_photoGalleryRepository != null)
{
_photoGalleryRepository = null;
}
if (_videoRepository != null)
{
_videoRepository = null;
}
if (_instance != null)
{
_instance = null;
}
}
}
public ProductService(IShopRepository _shopRepo, IBusinessRepository _businessRepo, IImageRepository _imgRepo,
IPictureWareHouse _dbBase, IProductRepository _prodRepo, IUnitRepository _unitRepo, IPriceRepository _priceRepo,
ICostRepository _costRepo, IStockRepository _stockRepo, IOrdersRepository ordersRepository,
IStrategy _strategy, IFoldersDataService _foldersDataService)
{
this._shopRepo = _shopRepo;
this._businessRepo = _businessRepo;
this._imgRepo = _imgRepo;
this._prodRepo = _prodRepo;
this._unitRepo = _unitRepo;
this._priceRepo = _priceRepo;
this._costRepo = _costRepo;
this._stockRepo = _stockRepo;
_ordersRepo = ordersRepository;
this._strategy = _strategy;
this._dbBase = _dbBase;
this._foldersDataService = _foldersDataService;
this._dbBase.GeneratedAuthenticationURL();
this._dbBase.GenerateAccessToken();
_productDataService = new ProductDataService(this._dbBase);
}
private readonly IHostingEnvironment env; // Used to deal with server files.
public ApiImageController(
IImageRepository imageRepo,
IPostRepository postRepo,
ICommentRepository commentRepo,
IProfileRepository profileRepo,
ILikeRepository likeRepo,
IFriendRepository friendRepo,
SessionResults sessionResults,
CurrentProfile currentProfile,
IHostingEnvironment env)
{
this.imageRepo = imageRepo;
this.postRepo = postRepo;
this.commentRepo = commentRepo;
this.profileRepo = profileRepo;
this.likeRepo = likeRepo;
this.friendRepo = friendRepo;
this.sessionResults = sessionResults;
this.currentProfile = currentProfile;
this.env = env;
}
public TImageService(IImageRepository imageRepository, IValidationService validationService,
ITinyImageService tinyImageService, ISettingsService settingsService, IHistoryService historyService,
IStatisticService statisticService, IStateService stateService, IFileSystem fileSystem,
IImageHistoryService imageHistoryService, IMediaService mediaService, ITinyPNGConnector tinyPngConnectorService,
IMediaHistoryRepository mediaHistoryRepository, IUmbracoDbRepository umbracoDbRepository, IUmbracoContextFactory context)
{
_imageRepository = imageRepository;
_validationService = validationService;
_tinyImageService = tinyImageService;
_settingsService = settingsService;
_historyService = historyService;
_statisticService = statisticService;
_stateService = stateService;
_fileSystem = fileSystem;
_imageHistoryService = imageHistoryService;
_mediaService = mediaService;
_tinyPngConnectorService = tinyPngConnectorService;
_mediaHistoryRepository = mediaHistoryRepository;
_umbracoDbRepository = umbracoDbRepository;
_context = context;
}
private void Dispose(bool dispose)
{
if (dispose)
{
if (_userRepository != null)
{
_userRepository = null;
}
if (_categoryRepository != null)
{
_categoryRepository = null;
}
if (_imageRepository != null)
{
_imageRepository = null;
}
if (_orderedProductRepository != null)
{
_orderedProductRepository = null;
}
if (_orderRepository != null)
{
_orderRepository = null;
}
if (_productRepository != null)
{
_productRepository = null;
}
if (_shoppingCartRepository != null)
{
_shoppingCartRepository = null;
}
}
}
public HomeController(
IEventRepository eventRepository,
IEventCategoryRepository eventCategoryRepository,
IEventSubCategoryRepository eventSubCategoryRepository,
IVenueRepository venueRepository,
IRsvpRepository rsvpRepository,
ICommentRepository commentRepository,
IStatusRepository statusRepository,
IImageRepository imageRepository,
IRatingRepository ratingRepository
)
{
_eventRepository = eventRepository;
_eventCategoryRepository = eventCategoryRepository;
_eventSubCategoryRepository = eventSubCategoryRepository;
_venueRepository = venueRepository;
_rsvpRepository = rsvpRepository;
_commentRepository = commentRepository;
_statusRepository = statusRepository;
_imageRepository = imageRepository;
_ratingRepository = ratingRepository;
}
public ScrapeRepositories(IGlobalSettings globalSettings)
{
GlobalSettings = globalSettings;
//setup the download queue
Queue = new Queue <ImageDetail>();
switch (GlobalSettings.Database.DatabaseType.ToLower())
{
case "sqlserver":
//add repositories
var keywordRepo = new KeywordRepository(globalSettings.Database);
ImageRepository = new ImageRepository(keywordRepo, globalSettings.Database);
ImageScrapeRepository = new ImageScrapeRepository(globalSettings.Database);
break;
}
//setup httpClient
ServicePointManager.DefaultConnectionLimit = 10000;
ServicePointManager.ReusePort = true;
var cookieContainer = new CookieContainer();
cookieContainer.Add(new Uri(@"https://www.reddit.com"), new Cookie("over18", "1"));
//set the httpclient to auto-decompress gzup and deflate encodings
var httpClientHandler = new ScraperHttpHandler
{
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,
CookieContainer = cookieContainer,
AllowAutoRedirect = true
};
Client = new HttpClient(httpClientHandler);
Client.DefaultRequestHeaders.Add("User-Agent",
"Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.1.7) Gecko/20091221 Firefox/3.5.7 (.NET CLR 3.5.30729)");
}
public TImageService(IImageRepository imageRepository, IValidationService validationService,
ITinyImageService tinyImageService, ISettingsService settingsService, IHistoryService historyService,
IStatisticService statisticService, IStateService stateService,
IImageHistoryService imageHistoryService, IMediaService mediaService, ITinyPNGConnector tinyPngConnectorService,
IMediaHistoryRepository mediaHistoryRepository, IUmbracoDbRepository umbracoDbRepository, IFileSystemRegistrationService fileSystemRegistrationService)
{
_imageRepository = imageRepository;
_validationService = validationService;
_tinyImageService = tinyImageService;
_settingsService = settingsService;
_historyService = historyService;
_statisticService = statisticService;
_stateService = stateService;
_fileSystemRegistrationService = fileSystemRegistrationService;
_fileSystem = _fileSystemRegistrationService.GetFileSystem();
_imageHistoryService = imageHistoryService;
_mediaService = mediaService;
_tinyPngConnectorService = tinyPngConnectorService;
_mediaHistoryRepository = mediaHistoryRepository;
_umbracoDbRepository = umbracoDbRepository;
}
public PlaygroundController(UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IAuthorizationService authorizationService,
IUserRepository userRepository,
IImageRepository imageRepository,
IPlaygroundReservationRepository reservationRepository,
IReviewRepository reviewRepository,
IMessageRepository messageRepository,
IPlaygroundPriceRepository playgroundPriceRepository,
IConnectedUsersRepository connectedUsersRepository,
IHubContext <ChatHub> hubContext)
{
_userManager = userManager;
_signInManager = signInManager;
_authorizationService = authorizationService;
_userRepository = userRepository;
_imageRepository = imageRepository;
_reservationRepository = reservationRepository;
_reviewRepository = reviewRepository;
_messageRepository = messageRepository;
_playgroundPriceRepository = playgroundPriceRepository;
_connectedUsersRepository = connectedUsersRepository;
_hubContext = hubContext;
}
public CommonCardService(IUnitOfWork unitOfWork,
ICardRepository cardRepository,
IButtonLinkRepository buttonLinkRepository,
IButtonPostbackRepository buttonPostbackRepository,
IImageRepository imageRepository,
ITemplateGenericGroupRepository templateGenericGroupRepository,
ITemplateGenericItemRepository templateGenericItemRepository,
ITemplateTextRepository templateTextRepository,
IQuickReplyRepository quickReplyRepository,
IButtonModuleRepository buttonModuleRepository,
IModuleFollowCardRepository mdFollowCardRepository)
{
_unitOfWork = unitOfWork;
_cardRepository = cardRepository;
_buttonLinkRepository = buttonLinkRepository;
_buttonPostbackRepository = buttonPostbackRepository;
_imageRepository = imageRepository;
_templateGenericGroupRepository = templateGenericGroupRepository;
_templateGenericItemRepository = templateGenericItemRepository;
_templateTextRepository = templateTextRepository;
_quickReplyRepository = quickReplyRepository;
_buttonModuleRepository = buttonModuleRepository;
_mdFollowCardRepository = mdFollowCardRepository;
}
public PostController(IPostRepository postRepo, ICategoryRepository catRepo, IImageRepository imgRepo)
{
_postRepository = postRepo;
_categoryRepository = catRepo;
_imageRepository = imgRepo;
}
public ImageService(IImageRepository imageRepository)
{
_imageRepository = imageRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="HomeController"/> class.
/// </summary>
public ErrorController(IOptions <AppSettings> appSettings, ILogger <ErrorController> logger)
{
this.logger = logger;
this.appSettings = appSettings.Value;
this.imageRepository = new AzureImageRepository(this.appSettings.AzureStorageConnectionString, this.appSettings.AzureStorageCustomDomain, ContainerName);
}
public ImageService(IImageRepository repository, AspPostgreSQLContext context, IMapper mapper)
{
_repository = repository;
_context = context;
_mapper = mapper;
}
//
public ImageService(IImageRepository iRepo, IUnitOfWork uow) : base(iRepo, uow)
{
this.logPrefix = "Image";
}
public NasaImageManager(IImageRepository imageRepository, IMarsRoverApiClient marsRoverApiClient)
{
_imageRepository = imageRepository ?? throw new ArgumentNullException(nameof(imageRepository));
_marsRoverApiClient = marsRoverApiClient ?? throw new ArgumentNullException(nameof(marsRoverApiClient));
}
public ImageController(Context context)
{
this.imageRepository = new ImageRepository(context);
}
public AppController(IMailService mailService, IImageRepository repository)
{
_mailService = mailService;
_repository = repository;
}
