public SearchTasks(
IAssertionRepository assertionRepository,
ITagRepository tagRepository)
{
this.assertionRepository = assertionRepository;
this.tagRepository = tagRepository;
}
public void SetUp()
{
linkConnection = connectionFactory.Create(connectionString);
linkConnection.Open();
linkRepository = new SQLiteLinkRepository(logger, linkConnection);
linkRepository.Initialize();
tagConnection = connectionFactory.Create(connectionString);
tagConnection.Open();
tagRepository = new SQLiteTagRepository(logger, tagTypeFactory, tagConnection);
tagRepository.Initialize();
mediaConnection = connectionFactory.Create(connectionString);
mediaConnection.Open();
mediaRepository = new SQLiteMediaRepository(logger, mediaFactory, mediaConnection);
mediaRepository.Initialize();
itemConnection = connectionFactory.Create(connectionString);
itemConnection.Open();
mediaItemRepository = new SQLiteMetadataRepository(logger, securityContext, mediaFactory, itemConnection);
mediaItemRepository.Initialize();
audioStreamFactory = new AudioStreamFactory();
spider = new CatalogSpider(logger, securityContext, mediaFactory, linkRepository, tagRepository, mediaRepository, mediaItemRepository, audioStreamFactory);
}
public AdminManager()
{
_postRepo = new Factory().PostRepository();
_pageRepo = new Factory().PageRepository();
_categoryRepo = new Factory().CategoryRepository();
_tagRepo = new Factory().TagRepository();
}
/// <summary>
/// Initializes a new instance of the <see cref="YearController"/> class.
/// </summary>
/// <param name="recentRepository">The recent repository.</param>
/// <param name="tagService">The tag service.</param>
/// <param name="tagRepository">The tag repository.</param>
/// <param name="persistentCollectionService">The persistent collection service.</param>
public YearController(IRecentRepository recentRepository, ITagService tagService, ITagRepository tagRepository, IPersistentCollectionService persistentCollectionService)
{
_recentRepository = recentRepository;
_persistentCollectionService = persistentCollectionService;
_tagRepository = tagRepository;
_tagService = tagService;
}
public AlbumService(IUsersRepository usersRepository, IAlbumRepository albumRepository, IPhotoRepository photoRepository, ITagRepository tagRepository)
{
this.mUserRepository = usersRepository;
this.mAlbumRepository = albumRepository;
this.mPhotoRepository = photoRepository;
this.mTagRepository = tagRepository;
}
public ThreadController()
{
var context = new DefaultDbConext();
_threadRepository = new ThreadRepository(context);
_tagRepository = new TagRepository(context);
_feedFactory = new FeedFactory();
}
public TagsController(ITagRepository tagRepository, ISettingsProvider settingsProvider)
{
_tagRepository = tagRepository;
_settingsProvider = settingsProvider;
PageSize = _settingsProvider.GetSettings().PageSize;
}
public StatusReportController(IStatusReportRepository repository, ITopicRepository topicRepository, IProjectRepository projectRepository, IResourceRepository resourceRepository, IStatusReportManager statusReportManager, ITagRepository tagRepository)
{
_repository = repository;
_topicRepository = topicRepository;
_projectRepository = projectRepository;
_resourceRepository = resourceRepository;
_tagRepository = tagRepository;
_statusReportManager = statusReportManager;
Mapper.CreateMap<StatusReport, StatusReportViewModel>()
.ForMember(m => m.NumberOfStatusItems, opt => opt.ResolveUsing<NumberOfStatusItemsFormatter>());
Mapper.CreateMap<StatusItem, StatusReportItemViewModel>()
.ForMember(m => m.TagsString, opt =>
{
opt.MapFrom(src =>
String.Join(",", (from tag in src.Tags
select tag.Name)));
opt.NullSubstitute(String.Empty);
}
);
Mapper.CreateMap<StatusReportItemViewModel, StatusItem>();
Mapper.CreateMap<Project, ProjectViewModel>();
Mapper.CreateMap<Tag, TagViewModel>();
//.ForMember(m => m.StatusReportId, opt => opt.M);
//.ForMember(dest => dest.ProjectLeadFullName, opt => opt.MapFrom(src => src.Project.Lead.FullName))
//.ForMember(dest => dest.ProjectTeamLeadFullName, opt => opt.MapFrom(src => src.Project.Team.Lead.FullName));
}
public ReportService(IRecordRepository repository, IReportConverter converter, IRecordValidator recordValidator, ITagRepository tagRepository)
{
_recordsRepository = repository;
_converter = converter;
_recordValidator = recordValidator;
_tagRepository = tagRepository;
}
public ConceptsService(
IConceptRepository conceptRepository,
ITagRepository tagRepository)
{
this.conceptRepository = conceptRepository;
this.tagRepository = tagRepository;
}
public ProductController(IBrandRepository brandRepository, ITagRepository tagRepository, IProductRepository productRepository, IStoreRepository storeRepository)
{
_productRepository = productRepository;
_storeRepository = storeRepository;
_brandRepository = brandRepository;
_tagRepository = tagRepository;
}
public SpiderFactory(ILogger logger, ISecurityContext securityContext, IMediaFactory mediaFactory, ILinkRepository linkRepository, ITagRepository tagRepository, IMediaRepository mediaRepository, IMetadataRepository mediaItemRepository, IAudioStreamFactory audioStreamFactory)
{
if (logger == null)
throw new ArgumentNullException("logger");
if (securityContext == null)
throw new ArgumentNullException("securityContext");
if (mediaFactory == null)
throw new ArgumentNullException("mediaFactory");
if (linkRepository == null)
throw new ArgumentNullException("linkRepository");
if (tagRepository == null)
throw new ArgumentNullException("tagRepository");
if (mediaRepository == null)
throw new ArgumentNullException("mediaRepository");
if (mediaItemRepository == null)
throw new ArgumentNullException("mediaItemRepository");
this.logger = logger;
this.securityContext = securityContext;
this.securityContext = securityContext;
this.mediaFactory = mediaFactory;
this.linkRepository = linkRepository;
this.tagRepository = tagRepository;
this.mediaRepository = mediaRepository;
this.mediaItemRepository = mediaItemRepository;
this.audioStreamFactory = audioStreamFactory;
}
public PropertyValueController(ITagRepository tagRepo,
ICategoryPropertyRepository tagpropertyRepo,
ICategoryPropertyValueRepository tagpropertyvalRepo)
{
_tagRepo = tagRepo;
_tagpropertyRepo = tagpropertyRepo;
_tagpropertyvalueRepo = tagpropertyvalRepo;
}
public QuestionsController()
{
questionRepository = new QuestionRepository();
userRepository = new UserRepository();
tagRepository = new TagRepository();
answerRepository = new AnswerRepository();
voteRepository = new VoteRepository();
}
public IncomingMessageProcessor(IMessageRepository messageRepository, ITagRepository tagRepository, IMessageParser messageParser, IValidMessageReceiver validMessageReceiver, IAllMessageReceiver allMessageReceiver)
{
_messageRepository = messageRepository;
_messageParser = messageParser;
_tagRepository = tagRepository;
_validMessageReceiver = validMessageReceiver;
_allMessageReceiver = allMessageReceiver;
}
public TagController(
ITagRepository tagRepository,
IArticleTagRepository atRepository
)
{
_tagRepository = tagRepository;
_atRepository = atRepository;
}
internal RefRepositoryTestMethods(ICommitRepository cmrepo, IStreamedBlobRepository blrepo, ITreeRepository trrepo, ITagRepository tgrepo, IRefRepository rfrepo)
{
this.cmrepo = cmrepo;
this.blrepo = blrepo;
this.trrepo = trrepo;
this.tgrepo = tgrepo;
this.rfrepo = rfrepo;
}
public QuestionsController(IRepositoryFactory repositoryFactory )
{
questionRepository = repositoryFactory.GetQuestionRepository();
userRepository = repositoryFactory.GetUserRepository();
tagRepository = repositoryFactory.GetTagRepository();
answerRepository = repositoryFactory.GetAnswerRepository();
voteRepository = repositoryFactory.GetVoteRepository();
}
public SearchController(IArticleService articleService, ITagRepository tagRepository,
IBlogService blogService, IUserService userService)
{
_articleService = articleService;
_tagRepository = tagRepository;
_blogService = blogService;
_userService = userService;
}
public PostsController(IPostRepository postRepository, ITagRepository tagRepository, ISettingsProvider settingsProvider)
{
_postRepository = postRepository;
_tagRepository = tagRepository;
_settingsProvider = settingsProvider;
PageSize = _settingsProvider.GetSettings().PageSize;
}
public HomeController(IBadgeRepository ibadgeRepository, IPostRepository ipostRepository
, ITagRepository itagRepository, IUserRepository iuserRepository)
{
this.ibadgeRepository = ibadgeRepository;
this.ipostRepository = ipostRepository;
this.itagRepository = itagRepository;
this.iuserRepository = iuserRepository;
}
public ContentService(IPostRepository postRepository, ICommentRepository commentRepository, ITagRepository tagRepository, ISiteSettingsService siteSettingsService, IMembershipService membershipService, HttpContextBase context)
{
_siteSettingsService = siteSettingsService;
PostRepository = postRepository;
CommentRepository = commentRepository;
TagRepository = tagRepository;
MembershipService = membershipService;
Context = context;
}
public ProfileTasks(
IProfileRepository profileRepository,
ITagRepository tagRepository,
ICategoryRepository categoryRepository)
{
this.profileRepository = profileRepository;
this.tagRepository = tagRepository;
this.categoryRepository = categoryRepository;
}
public PopulateSidebarView(IRecentRepository recentRepository,
ITagRepository tagRepository,
IAlbumRepository albumRepository,
IFriendRepository friendRepository)
{
_recentRepository = recentRepository;
_friendRepository = friendRepository;
_albumRepository = albumRepository;
_tagRepository = tagRepository;
}
public TagController(ILogger logger, ITagRepository tagRepository)
{
if (logger == null)
throw new ArgumentNullException("logger");
if (tagRepository == null)
throw new ArgumentNullException("tagRepository");
this.logger = logger;
this.tagRepository = tagRepository;
}
public ArticleController(
ICommandBus commandBus,
IArticleRepository articleRepository,
ICategoryRepository categoryRepository,
ITagRepository tagRepository)
{
this.commandBus = commandBus;
this.articleRepository = articleRepository;
this.categoryRepository = categoryRepository;
this.tagRepository = tagRepository;
}
public ContentServices(
IUnitOfWork unitOfWork,
IArticleRepository articleRepository,
ICategoryRepository categoryRepository,
ITagRepository tagRepository
)
{
_unitOfWork = unitOfWork;
_articleRepository = articleRepository;
_categoryRepository = categoryRepository;
_tagRepository = tagRepository;
}
public PromotionController(IPromotionRepository promotionRepository
,IStoreRepository storeRepository
,ITagRepository tagRepository
,IResourceService resourceService
,IUserAuthRepository authRepo)
{
this._promotionRepository = promotionRepository;
_storeRepository = storeRepository;
_tagRepository = tagRepository;
_resourceService = resourceService;
_authRepo = authRepo;
}
private static void Init()
{
tags = (new List<Tag>() {
new Tag("tag1"),
new Tag("taaag2"),
new Tag("tag3")
}).AsQueryable();
tagRepository = MockRepository.GenerateStub<ITagRepository>();
tagRepository.Stub(x => x.ListAll())
.WhenCalled(x => x.ReturnValue = tags);
}
protected BaseMappingManager()
{
_resourceRepository = ServiceLocator.Current.Resolve<IResourceRepository>();
_pprRepository = ServiceLocator.Current.Resolve<IPromotionProductRelationRepository>();
_stprRepository = ServiceLocator.Current.Resolve<ISpecialTopicProductRelationRepository>();
_storeRepository = ServiceLocator.Current.Resolve<IStoreRepository>();
_tagRepository = ServiceLocator.Current.Resolve<ITagRepository>();
_specialTopicRepository = ServiceLocator.Current.Resolve<ISpecialTopicRepository>();
_promotionRepository = ServiceLocator.Current.Resolve<IPromotionRepository>();
_brandRepository = ServiceLocator.Current.Resolve<IBrandRepository>();
_customerRepository = ServiceLocator.Current.Resolve<ICustomerRepository>();
_productRepository = ServiceLocator.Current.Resolve<IProductRepository>();
}
public TagService(
ILogger <ITagService> logger,
MediatR.IMediator mediator,
ITagRepository tagRepository,
IApiTagServerRequestModelValidator tagModelValidator,
IDALTagMapper dalTagMapper)
: base()
{
this.TagRepository = tagRepository;
this.TagModelValidator = tagModelValidator;
this.DalTagMapper = dalTagMapper;
this.logger = logger;
this.mediator = mediator;
}
public PerformanceDetailsServiceWp(
ITheaterScheduleUnitOfWork theaterScheduleUnitOfWork,
IPerformanceDetailsRepository performanceDetailsRepository,
ITagRepository tagRepository,
ICreativeTeamRepository creativeTeamRepository,
IIsCheckedPerformanceRepository isCheckedPerformanceRepository,
IMemoryCache memoryCache)
{
this.theaterScheduleUnitOfWork = theaterScheduleUnitOfWork;
this.performanceDetailsRepository = performanceDetailsRepository;
this.tagRepository = tagRepository;
this.creativeTeamRepository = creativeTeamRepository;
this.isCheckedPerformanceRepository = isCheckedPerformanceRepository;
this.memoryCache = memoryCache;
}
public Handler
(
IArticleRepository repository,
ICategoryRepository categoryRepository,
IBlogRepository blogRepository,
ITagRepository tagRepository,
IMediaObjectRepository mediaObjectRepository
)
{
this.repository = repository;
this.categoryRepository = categoryRepository;
this.blogRepository = blogRepository;
this.tagRepository = tagRepository;
this.mediaObjectRepository = mediaObjectRepository;
}
public TagStatisticsAppService(
ICommentTagRepository commentTagRepository,
ITagRepository tagRepository,
IDbUnitOfWork dbUnitOfWork,
IServiceRepository serviceRepository,
IServicerRepository servicerRepository,
IReservationRepository reservationRepository)
{
_tagRepository = tagRepository;
_commentTagRepository = commentTagRepository;
_dbUnitOfWork = dbUnitOfWork;
_serviceRepository = serviceRepository;
_servicerRepository = servicerRepository;
_reservationRepository = reservationRepository;
}
public ExperimentController(
IExperimentRepository experimentRepository,
IExperimentPreprocessRepository experimentPreprocessRepository,
IAquariumDataSetRepository aquariumDataSetRepository,
IDataSetRepository dataSetRepository,
IGitRepository gitRepository,
IRegistryRepository registryRepository,
ITrainingHistoryRepository trainingHistoryRepository,
ITemplateRepository templateRepository,
ITemplateVersionRepository templateVersionRepository,
ITenantRepository tenantRepository,
INodeRepository nodeRepository,
ITemplateLogic templateLogic,
ITagLogic tagLogic,
IGitLogic gitLogic,
IClusterManagementLogic clusterManagementLogic,
IDataSetLogic dataSetLogic,
IRegistryLogic registryLogic,
IUnitOfWork unitOfWork,
IInferenceHistoryRepository inferenceHistoryRepository,
ITensorBoardContainerRepository tensorBoardContainerRepository,
ITagRepository tagRepository,
IStorageLogic storageLogic,
IHttpContextAccessor accessor) : base(accessor)
{
this.trainingHistoryRepository = trainingHistoryRepository;
this.experimentRepository = experimentRepository;
this.experimentPreprocessRepository = experimentPreprocessRepository;
this.aquariumDataSetRepository = aquariumDataSetRepository;
this.dataSetRepository = dataSetRepository;
this.gitRepository = gitRepository;
this.registryRepository = registryRepository;
this.templateRepository = templateRepository;
this.templateVersionRepository = templateVersionRepository;
this.tenantRepository = tenantRepository;
this.nodeRepository = nodeRepository;
this.templateLogic = templateLogic;
this.tagLogic = tagLogic;
this.gitLogic = gitLogic;
this.clusterManagementLogic = clusterManagementLogic;
this.dataSetLogic = dataSetLogic;
this.registryLogic = registryLogic;
this.inferenceHistoryRepository = inferenceHistoryRepository;
this.tensorBoardContainerRepository = tensorBoardContainerRepository;
this.tagRepository = tagRepository;
this.storageLogic = storageLogic;
this.unitOfWork = unitOfWork;
}
protected override void Process(LinqExtender.Interface.IModify <Tag> items)
{
object tagList = Bucket.Instance.For.Item(TagColums.ListMode).Value;
TagListMode tagListMode = tagList == null ? TagListMode.Popular : (TagListMode)tagList;
if (tagListMode == TagListMode.Popular)
{
object tagsPeriod = Bucket.Instance.For.Item(TagColums.Period).Value;
TagPeriod period = tagsPeriod == null ? TagPeriod.Day : (TagPeriod)tagsPeriod;
int score = Convert.ToInt32(Bucket.Instance.For.Item(TagColums.Score).Value ?? "0");
int count = (int)Bucket.Instance.For.Item(TagColums.Count).Value;
if (count > 200)
{
throw new Exception("Tag count should be less than 200");
}
using (ITagRepository tagRepositoryRepo = repositoryFactory.CreateTagRepository())
{
IEnumerable <Tag> tags = tagRepositoryRepo.GetPopularTags(period, count);
// do the filter on score.
if (score > 0)
{
tags = tags.Where(tag => tag.Score == score).Select(tag => tag);
}
items.AddRange(tags, true);
}
}
else
{
object photoId = Bucket.Instance.For.Item(TagColums.PhotoId).Value;
if (photoId == null)
{
throw new Exception("Must provide a valid photoId");
}
using (ITagRepository tagRepositoryRepo = repositoryFactory.CreateTagRepository())
{
items.AddRange(tagRepositoryRepo.GetTagsForPhoto((string)photoId));
}
}
}
public PostAppService(
IPostRepository postRepository,
ITagRepository tagRepository,
ICommentRepository commentRepository,
IBlogUserLookupService userLookupService,
IDistributedCache <List <PostCacheItem> > postsCache,
ILocalEventBus localEventBus
)
{
UserLookupService = userLookupService;
_postRepository = postRepository;
_tagRepository = tagRepository;
_commentRepository = commentRepository;
_postsCache = postsCache;
_localEventBus = localEventBus;
}
public UnitOfWork(CmsEngineContext context, ICategoryRepository categoryRepository, IPageRepository pageRepository,
IPostRepository postRepository, ITagRepository tagRepository, IWebsiteRepository websiteRepository,
UserManager <ApplicationUser> userManager, IEmailRepository emailRepository)
{
_ctx = context;
Categories = categoryRepository;
Pages = pageRepository;
Posts = postRepository;
Tags = tagRepository;
Websites = websiteRepository;
Users = userManager;
Emails = emailRepository;
_disposed = false;
}
public ProductService(IProductRepository productRepository,
ITagRepository tagRepository,
IProductQuantityRepository productQuantityRepository,
IProductImageRepository productImageRepository,
IWholePriceRepository wholePriceRepository,
IUnitOfWork unitOfWork,
IProductTagRepository productTagRepository)
{
_productRepository = productRepository;
_tagRepository = tagRepository;
_productQuantityRepository = productQuantityRepository;
_productTagRepository = productTagRepository;
_wholePriceRepository = wholePriceRepository;
_productImageRepository = productImageRepository;
_unitOfWork = unitOfWork;
}
public RemarkProvider(IProviderClient provider,
IRemarkRepository remarkRepository,
IRemarkCategoryRepository categoryRepository,
IGroupRepository groupRepository,
ITagRepository tagRepository,
IReportRepository reportRepository,
IRemarkServiceClient serviceClient)
{
_provider = provider;
_remarkRepository = remarkRepository;
_categoryRepository = categoryRepository;
_groupRepository = groupRepository;
_tagRepository = tagRepository;
_reportRepository = reportRepository;
_serviceClient = serviceClient;
}
public ArticleService(IUnitOfWork uow,
IArticleRepository articleRepository,
IArticleTagRepository articleTagRepository,
IArticleTagService articleTagService,
IArticleCategoryService articleCategoryService,
ITagRepository tagRepository, IUrlHelper urlHelper)
: base(articleRepository)
{
_articleRepository = articleRepository;
_articleTagRepository = articleTagRepository;
_articleTagService = articleTagService;
_tagRepository = tagRepository;
_articleCategoryService = articleCategoryService;
_unitOfWork = uow;
_urlHelper = urlHelper;
}
public TagService(ITagRepository repo,
IEventAggregator eventAggregator,
IDelayProfileService delayProfileService,
IImportListFactory importListFactory,
INotificationFactory notificationFactory,
IReleaseProfileService releaseProfileService,
ISeriesService seriesService)
{
_repo = repo;
_eventAggregator = eventAggregator;
_delayProfileService = delayProfileService;
_importListFactory = importListFactory;
_notificationFactory = notificationFactory;
_releaseProfileService = releaseProfileService;
_seriesService = seriesService;
}
public PostController(IPostRepository PostRepository,
IPostServices PostServices,
IUserRepository userRepository,
ICategoryRepository categoryRepository,
ITagRepository tagRepository,
IFileSaveServices fileSaveServices,
IFileSaveRepository fileSaveRepository)
{
_postRepository = PostRepository;
_postServices = PostServices;
_userRepository = userRepository;
_categoryRepository = categoryRepository;
_tagRepository = tagRepository;
_fileSaveServices = fileSaveServices;
_fileSaveRepository = fileSaveRepository;
}
public BlogService(IBlogCacheService blogCacheService,
IPostRepository postRepository,
ICategoryRepository categoryRepository,
ITagRepository tagRepository,
IPostTagRepository postTagRepository,
IFriendLinkRepository friendLinksRepository,
IDistributedEventBus distributedEventBus)
{
_blogCacheService = blogCacheService;
_postRepository = postRepository;
_categoryRepository = categoryRepository;
_tagRepository = tagRepository;
_postTagRepository = postTagRepository;
_friendLinksRepository = friendLinksRepository;
_distributedEventBus = distributedEventBus;
}
public RemarkService(IRemarkRepository remarkRepository,
IUserRepository userRepository,
ICategoryRepository categoryRepository,
ITagRepository tagRepository,
IGroupRepository groupRepository,
IRemarkPhotoService remarkPhotoService,
GeneralSettings settings)
{
_remarkRepository = remarkRepository;
_userRepository = userRepository;
_categoryRepository = categoryRepository;
_tagRepository = tagRepository;
_groupRepository = groupRepository;
_remarkPhotoService = remarkPhotoService;
_settings = settings;
}
public BlogService(IBlogCacheService blogCacheService,
IPostRepository postRepository,
ICategoryRepository categoryRepository,
ITagRepository tagRepository,
IPostTagRepository postTagRepository,
IFriendLinkRepository friendLinksRepository,
IHotNewsRepository hotNewsRepository)
{
_blogCacheService = blogCacheService;
_postRepository = postRepository;
_categoryRepository = categoryRepository;
_tagRepository = tagRepository;
_postTagRepository = postTagRepository;
_friendLinksRepository = friendLinksRepository;
_hotNewsRepository = hotNewsRepository;
}
public TagService(ITagRepository repo,
IEventAggregator eventAggregator,
IDelayProfileService delayProfileService,
IImportListFactory importListFactory,
INotificationFactory notificationFactory,
IRestrictionService restrictionService,
IMovieService movieService)
{
_repo = repo;
_eventAggregator = eventAggregator;
_delayProfileService = delayProfileService;
_importListFactory = importListFactory;
_notificationFactory = notificationFactory;
_restrictionService = restrictionService;
_movieService = movieService;
}
public CmsKitDataSeedContributor(
IGuidGenerator guidGenerator,
ICmsUserRepository cmsUserRepository,
CmsKitTestData cmsKitTestData,
ICommentRepository commentRepository,
ReactionManager reactionManager,
IRatingRepository ratingRepository,
ICurrentTenant currentTenant,
TagManager tagManager,
ITagRepository tagRepository,
IEntityTagRepository entityTagRepository,
IPageRepository pageRepository,
IBlogRepository blogRepository,
IBlogPostRepository blogPostRepository,
BlogPostManager blogPostmanager,
IBlogFeatureRepository blogFeatureRepository,
EntityTagManager entityTagManager,
IOptions <CmsKitOptions> options,
IOptions <CmsKitTagOptions> tagOptions,
IMediaDescriptorRepository mediaDescriptorRepository,
IBlobContainer <MediaContainer> mediaBlobContainer,
BlogManager blogManager,
IOptions <CmsKitMediaOptions> cmsMediaOptions)
{
_guidGenerator = guidGenerator;
_cmsUserRepository = cmsUserRepository;
_cmsKitTestData = cmsKitTestData;
_commentRepository = commentRepository;
_reactionManager = reactionManager;
_ratingRepository = ratingRepository;
_currentTenant = currentTenant;
_tagManager = tagManager;
_tagRepository = tagRepository;
_entityTagManager = entityTagManager;
_entityTagRepository = entityTagRepository;
_pageRepository = pageRepository;
_blogRepository = blogRepository;
_blogPostRepository = blogPostRepository;
_blogPostManager = blogPostmanager;
_blogFeatureRepository = blogFeatureRepository;
_options = options;
_tagOptions = tagOptions;
_mediaDescriptorRepository = mediaDescriptorRepository;
_mediaBlobContainer = mediaBlobContainer;
_blogManager = blogManager;
_mediaOptions = cmsMediaOptions;
}
public AppUnitOfWork(
IValidationService validationService,
IDomainEventBus domainEventBus,
AppContext appContext,
IAuthorRepository authorRepository,
IBlogPostRepository blogPostRepository,
ICategoryRepository categoryRepository,
ILocationRepository locationRepository,
ITagRepository tagRepository,
ICarouselItemRepository carouselItemRepository,
IContentHtmlRepository contentHtmlRepository,
IContentTextRepository contentTextRepository,
IFaqRepository faqRepository,
IMailingListRepository mailingListRepository,
IProjectRepository projectRepository,
ITestimonialRepository testimonialRepository
)
: base(true, validationService, domainEventBus, appContext)
{
AuthorRepository = authorRepository;
BlogPostRepository = blogPostRepository;
CategoryRepository = categoryRepository;
LocationRepository = locationRepository;
TagRepository = tagRepository;
AddRepository(AuthorRepository);
AddRepository(BlogPostRepository);
AddRepository(CategoryRepository);
AddRepository(LocationRepository);
AddRepository(TagRepository);
CarouselItemRepository = carouselItemRepository;
ContentHtmlRepository = contentHtmlRepository;
ContentTextRepository = contentTextRepository;
FaqRepository = faqRepository;
MailingListRepository = mailingListRepository;
ProjectRepository = projectRepository;
TestimonialRepository = testimonialRepository;
AddRepository(CarouselItemRepository);
AddRepository(ContentHtmlRepository);
AddRepository(ContentTextRepository);
AddRepository(FaqRepository);
AddRepository(MailingListRepository);
AddRepository(ProjectRepository);
AddRepository(TestimonialRepository);
}
public ImageService(IHttpClientFactory clientFactory,
IConfiguration configuration,
ILogger <ImageService> logger,
IImageRepository imageRepository,
ITagRepository tagRepository)
{
this.logger = logger;
this.imageRepository = imageRepository;
this.tagRepository = tagRepository;
httpClient = clientFactory.CreateClient();
IConfigurationSection gallerySection = configuration.GetSection("Gallery");
httpClient.BaseAddress = new Uri(gallerySection["RemoteAPI"]);
apiKey = gallerySection["ApiKey"];
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
[Inject] ITagRepository tagRepository,
ILogger log)
{
string search = req.Query["tagName"];
var tags = await tagRepository.SearchTagsByName(search);
var response = tags.AsQueryable().Select(x => new CatalogTagViewModel
{
Id = x.Id,
Name = x.Name
}).ToList();
return(new OkObjectResult(response));
}
public PostApplicationService(
IUnitOfWork unitOfWork,
IPostRepository postRepository,
IPointRepository pointRepository,
IUserRepository userRepository,
ILikeRepository likesRepository,
ITagRepository tagRepository,
IPostTagRepository postTagRepository)
{
_unitOfWork = unitOfWork;
_postRepository = postRepository;
_pointRepository = pointRepository;
_userRepository = userRepository;
_likesRepository = likesRepository;
_tagRepository = tagRepository;
_postTagRepository = postTagRepository;
}
public async Task <IActionResult> AttachTag(long id, string tag, [FromServices] ITagRepository tagRepository)
{
//データの存在チェック
var data = await dataRepository.GetByIdAsync(id);
if (data == null)
{
return(JsonNotFound($"Data ID {id} is not found."));
}
await tagRepository.AddAsync(data.Id, tag);
//結果を取り直す
var result = await dataRepository.GetDataIncludeAllAsync(data.Id);
return(JsonOK(new DetailsOutputModel(result)));
}
public MediaRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, IContentSection contentSection)
: base(work, cache, logger, sqlSyntax, contentSection)
{
if (mediaTypeRepository == null)
{
throw new ArgumentNullException("mediaTypeRepository");
}
if (tagRepository == null)
{
throw new ArgumentNullException("tagRepository");
}
_mediaTypeRepository = mediaTypeRepository;
_tagRepository = tagRepository;
_contentXmlRepository = new ContentXmlRepository <IMedia>(work, CacheHelper.CreateDisabledCacheHelper(), logger, sqlSyntax);
_contentPreviewRepository = new ContentPreviewRepository <IMedia>(work, CacheHelper.CreateDisabledCacheHelper(), logger, sqlSyntax);
EnsureUniqueNaming = contentSection.EnsureUniqueNaming;
}
public async Task Add(MediaItem item)
{
await Task.Run(() =>
{
// begin transaction
IUnitOfWork uow = this._uowProvider.Get();
IMediaItemRepository itemRepo = this._repoProvider.Get(uow);
ITagRepository tagRepo = this._tagRepoProvider.Get(uow);
uow.Begin();
// insert Media table record
itemRepo.Create(item);
// handle tags
// get all tag Ids
List <int> tagIds = new List <int>();
foreach (var tag in item.Tags)
{
if (tagRepo.ExistsWithName(tag.Name))
{
// tag exists
// get the Id
int tagId = tagRepo.GetIdByName(tag.Name);
tagIds.Add(tagId);
}
else
{
// tag does not exist
// insert tag
tagRepo.Create(tag);
// get the Id
int tagId = tagRepo.GetIdByName(tag.Name);
tagIds.Add(tagId);
}
}
// insert record(s) in Media_Tag link table
int itemId = itemRepo.GetIdByTitle(item.Title);
foreach (int tagId in tagIds)
{
tagRepo.LinkMediaItem(itemId, tagId);
}
// commit transaction
uow.Commit();
});
}
public CmsWebHookController(
ILogger <CmsWebHookController> logger,
ICmsApiProxy cmsApiProxy,
IBusinessRepository businessRepository,
IConfiguration configuration,
ITagRepository tagRepository,
IRegionRepository regionRepository)
{
_logger = logger;
_cmsApiProxy = cmsApiProxy;
_businessRepository = businessRepository;
_configuration = configuration;
_tagRepository = tagRepository;
_regionRepository = regionRepository;
_wpImageBaseUrl = _configuration["web-cms:base-url"];
}
public BlogManagementController(
IBlogEntryPhotoRepository blogEntryPhotoRepository,
IBlogEntryTagRepository blogEntryTagRepository,
ITagRepository tagRepository,
IBlogEntryRepository blogEntryRepository,
ISiteFilesRepository siteFilesRepository,
IImageUploaderService imageUploaderService,
IMemoryCache memoryCache)
{
_blogEntryPhotoRepository = blogEntryPhotoRepository;
_blogEntryTagRepository = blogEntryTagRepository;
_tagRepository = tagRepository;
_blogEntryRepository = blogEntryRepository;
_siteFilesRepository = siteFilesRepository;
_imageUploaderService = imageUploaderService;
_memoryCache = memoryCache;
}
public UriRequestProcessor(
ILoggerFactory loggerFactory,
IMessageBroker <UriRequest> requests,
ZadolbaliClient client,
ITagRepository tagRepository,
IRepository <Article> articleRepository,
IRepository <ArticleTag> articleTagRepository)
{
this.logger = loggerFactory.CreateLogger(typeof(UriRequestProcessor).FullName + " " + client.Proxy);
this.requests = requests;
this.client = client;
this.tagRepository = tagRepository;
this.articleRepository = articleRepository;
this.articleTagRepository = articleTagRepository;
this.rootUri = new Uri(ZadolbaliClient.RootUriString, UriKind.Absolute);
this.countAttempt = ZadolbaliClient.CountAttempt;
}
public MemberRepository(IScopeUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository, IContentSection contentSection)
: base(work, cache, logger, sqlSyntax, contentSection)
{
if (memberTypeRepository == null)
{
throw new ArgumentNullException("memberTypeRepository");
}
if (tagRepository == null)
{
throw new ArgumentNullException("tagRepository");
}
_memberTypeRepository = memberTypeRepository;
_tagRepository = tagRepository;
_memberGroupRepository = memberGroupRepository;
_contentXmlRepository = new ContentXmlRepository <IMember>(work, CacheHelper.NoCache, logger, sqlSyntax);
_contentPreviewRepository = new ContentPreviewRepository <IMember>(work, CacheHelper.NoCache, logger, sqlSyntax);
}
public StoryController(ICategoryRepository categoryRepository, ITagRepository tagRepository, IStoryRepository storyRepository, IStoryService storyService, IContentService contentService, ISocialServiceRedirector[] socialServiceRedirectors)
{
Check.Argument.IsNotNull(categoryRepository, "categoryRepository");
Check.Argument.IsNotNull(tagRepository, "tagRepository");
Check.Argument.IsNotNull(storyRepository, "storyRepository");
Check.Argument.IsNotNull(storyService, "storyService");
Check.Argument.IsNotNull(contentService, "contentService");
Check.Argument.IsNotEmpty(socialServiceRedirectors, "socialServiceRedirectors");
_categoryRepository = categoryRepository;
_tagRepository = tagRepository;
_storyRepository = storyRepository;
_storyService = storyService;
_contentService = contentService;
_socialServiceRedirectors = socialServiceRedirectors;
}
