public FileWriter(IAccountRepository accountRepository, IAccountTagRepository accountTagRepository, ITemplateRepository templateRepository, IJournalRepository journalRepository)
{
_accountRepository = accountRepository;
_accountTagRepository = accountTagRepository;
_templateRepository = templateRepository;
_journalRepository = journalRepository;
}
internal Archive(
IContentRepository contentRep,
IArchiveRepository archiveRep,
ILinkRepository linkRep,
IExtendFieldRepository extendRep,
ICategoryRepository categoryRep,
ITemplateRepository templateRep,
int id,
string strId,
int categoryId,
string title)
: base(
contentRep,
extendRep,
categoryRep,
templateRep,
linkRep,
id,
categoryId,
title
)
{
this.StrId = strId;
this._archiveRep = archiveRep;
this._templateRep = templateRep;
}
public HomeController()
{
viewclientService = new ViewclientRepository();
playlistService = new PlaylistRepository();
slideService = new SlideRepository();
templateService = new TemplateRepository();
}
public ContentRepository(
ITemplateRepository tempRep)
{
this._tempRep = tempRep;
siteContents = new Dictionary<int, IContentContainer>();
}
private void InitialiseRepositories()
{
//_accountTagRepository = new AccountTagRepository(AccountTagDataPath);
//_accountRepository = new AccountRepository(AccountDataPath, _accountTagRepository);
_journalRepository = new JournalRepository(JournalDataPath, _accountRepository);
_templateRepository = new TemplateRepository(TemplateDataPath, _accountRepository);
}
public PartialHelperHandler(ITerrificTemplateHandler handler, ISchemaProvider schemaProvider, ITemplateRepository templateRepository, IClientTemplateGenerator clientTemplateGenerator)
{
_handler = handler;
_schemaProvider = schemaProvider;
_templateRepository = templateRepository;
_clientTemplateGenerator = clientTemplateGenerator;
}
public IContentContainer CreateSiteContent(
IArchiveRepository archiveRep,
ITemplateRepository tempRep,
int siteId)
{
return new ContentContainer(archiveRep,tempRep,siteId);
}
public TerrificNetViewEngine(IViewEngineTerrific viewEngine, ITemplateRepository templateRepository, IModelTypeProvider modelTypeProvider, IModuleRepository moduleRepository)
{
_viewEngine = viewEngine;
_templateRepository = templateRepository;
_modelTypeProvider = modelTypeProvider;
_moduleRepository = moduleRepository;
}
public ValidTemplateRouteConstraint(ITemplateRepository templateRepository, IFileSystem fileSystem,
ITerrificNetConfig configuration)
{
_templateRepository = templateRepository;
_fileSystem = fileSystem;
_viewPathInfo = configuration.ViewPath;
}
public TemplateService(ITemplateRepository templateRepository, IReferenceGenerator referenceGenerator)
{
Check.If(templateRepository).IsNotNull();
Check.If(referenceGenerator).IsNotNull();
_templateRepository = templateRepository;
_referenceGenerator = referenceGenerator;
}
internal Category(ICategoryRepository rep,IExtendFieldRepository extendRep,ITemplateRepository tmpRep, int id,ISite site)
{
this.Site = site;
this._rep = rep;
this.Id = id;
this._extendRep = extendRep;
this._tempRep = tmpRep;
}
public StateController(
IStateRepository states,
ITemplateRepository templates,
IIdentityService identity)
{
_states = states;
_templates = templates;
_identity = identity;
}
public EmailTemplateController(
ITemplateRepository templates,
IEventEmailRecipient recipients,
IIdentityService identity)
{
_templates = templates;
_recipients = recipients;
_identity = identity;
}
/// <summary>
///
/// </summary>
/// <param name="categoryRep"></param>
/// <param name="extendRep"></param>
/// <param name="tempRep"></param>
/// <param name="categoryId"></param>
/// <param name="site"></param>
/// <returns></returns>
public ICategory CreateCategory(
ICategoryRepository categoryRep,
IExtendFieldRepository extendRep,
ITemplateRepository tempRep,
int categoryId,
ISite site)
{
return new Category(categoryRep, extendRep, tempRep,categoryId, site);
}
public DefaultTerrificTemplateHandler(IViewEngine viewEngine, IModelProvider modelProvider,
ITemplateRepository templateRepository, ILabelService labelService, IModuleRepository moduleRepository)
{
_viewEngine = viewEngine;
_modelProvider = modelProvider;
_templateRepository = templateRepository;
_labelService = labelService;
_moduleRepository = moduleRepository;
}
public SiteRepository(
IExtendFieldRepository extendFieldRepository,
ICategoryRepository categoryRepository,
ITemplateRepository tempRep
)
{
this._extendFieldRepository = extendFieldRepository;
this._categoryRep = categoryRepository;
this._tempRep = tempRep;
}
public PageController(IPageRepository repository, PageService pageService,
ITemplateRepository templateRepository, IPageTreeRepository pageTreeRepository,
IAuthorizer authorizer)
{
_repository = repository;
_pageService = pageService;
_templateRepository = templateRepository;
_pageTreeRepository = pageTreeRepository;
_authorizer = authorizer;
}
internal ContentContainer(
IArchiveRepository archiveRep,
ITemplateRepository tempRep,
int siteId)
{
this._archiveRep = archiveRep;
this._tempRep = tempRep;
this.SiteId = siteId;
}
public SchemaController(IModuleRepository moduleRepository,
ITemplateRepository templateRepository,
ISchemaProvider schemaProvider,
IModuleSchemaProvider moduleSchemaProvider)
{
_moduleRepository = moduleRepository;
_templateRepository = templateRepository;
_schemaProvider = schemaProvider;
_moduleSchemaProvider = moduleSchemaProvider;
}
public TemplateController(ITemplateRepository templateRepository, IUserRepository userRepository)
{
if (templateRepository == null)
throw new ArgumentNullException("templateRepository");
if (userRepository == null)
throw new ArgumentNullException("userRepository");
_templateRepository = templateRepository;
_userRepository = userRepository;
}
public SiteService(ISiteRepository resp,
ICategoryRepository categoryRep,
IExtendFieldRepository extendFieldPository,
ITemplateRepository tempRep)
{
this._resp = resp;
this._extendResp = extendFieldPository;
this._categoryRep = categoryRep;
this._tempRep = tempRep;
}
public TerrificViewDefinitionRepository(IFileSystem fileSystem,
ITerrificNetConfig configuration,
ITemplateRepository templateRepository,
IModelTypeProvider typeProvider)
{
_fileSystem = fileSystem;
_templateRepository = templateRepository;
_typeProvider = typeProvider;
_viewPathInfo = configuration.ViewPath;
}
public DefaultRenderingHelperHandlerFactory(
ITerrificTemplateHandlerFactory terrificTemplateHandlerFactory,
ITemplateRepository templateRepository,
ISchemaProviderFactory schemaProviderFactory,
IClientTemplateGeneratorFactory clientTemplateGeneratorFactory)
{
_terrificTemplateHandlerFactory = terrificTemplateHandlerFactory;
_templateRepository = templateRepository;
_schemaProviderFactory = schemaProviderFactory;
_clientTemplateGeneratorFactory = clientTemplateGeneratorFactory;
}
public AdminViewModel()
{
_productRepository = new ProductRepository();
_categoryRepository = new CategoryRepository();
_locationRepository = new LocationRepository();
_serviceRepository = new ServiceRepository();
_allergyRepository = new AllergyRepository();
_immunizationRepository = new ImmunizationRepository();
_medicationRepository = new MedicationRepository();
_templateRepository = new TemplateRepository();
}
public TemplateViewModel(ITemplateRepository templateRepository, IJournalRepository journalRepository, IAccountRepository accountRepository)
{
_templateRepository = templateRepository;
_journalRepository = journalRepository;
_accountRepository = accountRepository;
var journals = _templateRepository.GetTemplateJournals();
_template = templateRepository.GetAll().Single();
_journalVMs = new ObservableCollection<JournalViewModel>();
foreach (var journal in journals.OrderBy(x => x.Date))
AddJournalToInternalCollection(journal);
}
public ArchiveRepository(
IContentRepository contentRep,
IExtendFieldRepository extendRep,
ITemplateRepository templateRep,
ICategoryRepository categoryRep,
ILinkRepository linkRep
)
{
this._contentRep = contentRep;
this._extendRep = extendRep;
this._templateRep = templateRep;
this._categoryRep = categoryRep;
this._linkRep = linkRep;
}
internal Site(ISiteRepository siteRepository,
IExtendFieldRepository extendRepository,
ICategoryRepository categoryRep,
ITemplateRepository tempRep,
int siteId,
string name)
{
this.Id = siteId;
this.Name = name;
this._siteRepository = siteRepository;
this._categoryRep = categoryRep;
this._extendRepository = extendRepository;
this._tempRep = tempRep;
}
/// <summary>
///
/// </summary>
/// <param name="contentRep"></param>
/// <param name="archiveRep"></param>
/// <param name="extendRep"></param>
/// <param name="categoryRep"></param>
/// <param name="templateRep"></param>
/// <param name="linkRep"></param>
/// <param name="id"></param>
/// <param name="strId"></param>
/// <param name="categoryId"></param>
/// <param name="title"></param>
/// <returns></returns>
public IArchive CreateArchive(
IContentRepository contentRep,
IArchiveRepository archiveRep,
IExtendFieldRepository extendRep,
ICategoryRepository categoryRep,
ITemplateRepository templateRep,
ILinkRepository linkRep,
int id,
string strId,
int categoryId,
string title)
{
return new Archive(contentRep, archiveRep, linkRep, extendRep, categoryRep, templateRep, id, strId, categoryId, title);
}
public CategoryRepository(
//ISiteRepository siteRep,
ITemplateRepository tempRep,
IExtendFieldRepository extendRep)
{
//
//NOTE:会循环依赖
//
this._extendRep = extendRep;
this._tempRep = tempRep;
//this._siteRep = ObjectFactory.GetInstance<ISiteRepository>();
// GetCategoryDictionary();
}
public AccountController(
UserManager userManager,
SignInManager signInManager,
IAuthenticationManager authenticationManager,
ISampleGenerator sampleGenerator,
IProjectRepository projectRepository,
ITemplateRepository templateRepository
)
{
_userManager = userManager;
_signInManager = signInManager;
_authenticationManager = authenticationManager;
_sampleGenerator = sampleGenerator;
_projectRepository = projectRepository;
_templateRepository = templateRepository;
}
public ChannelRepository(ISettingsManager settingsManager, ITemplateRepository templateRepository)
{
_repository = new Repository <Channel>(settingsManager.Database, settingsManager.Redis);
_settingsManager = settingsManager;
_templateRepository = templateRepository;
}
public TemplateCreatedHandler(ITemplateRepository templateRepository)
{
_templateRepository = templateRepository;
}
private IEnumerable <ITemplate> CreateHierarchy(ITemplateRepository repository)
{
var parent = new Template("parent", "parent")
{
Content = @"<%@ Master Language=""C#"" %>"
};
var child1 = new Template("child1", "child1")
{
Content = @"<%@ Master Language=""C#"" %>"
};
var toddler1 = new Template("toddler1", "toddler1")
{
Content = @"<%@ Master Language=""C#"" %>"
};
var toddler2 = new Template("toddler2", "toddler2")
{
Content = @"<%@ Master Language=""C#"" %>"
};
var baby1 = new Template("baby1", "baby1")
{
Content = @"<%@ Master Language=""C#"" %>"
};
var child2 = new Template("child2", "child2")
{
Content = @"<%@ Master Language=""C#"" %>"
};
var toddler3 = new Template("toddler3", "toddler3")
{
Content = @"<%@ Master Language=""C#"" %>"
};
var toddler4 = new Template("toddler4", "toddler4")
{
Content = @"<%@ Master Language=""C#"" %>"
};
var baby2 = new Template("baby2", "baby2")
{
Content = @"<%@ Master Language=""C#"" %>"
};
child1.MasterTemplateAlias = parent.Alias;
child1.MasterTemplateId = new Lazy <int>(() => parent.Id);
child2.MasterTemplateAlias = parent.Alias;
child2.MasterTemplateId = new Lazy <int>(() => parent.Id);
toddler1.MasterTemplateAlias = child1.Alias;
toddler1.MasterTemplateId = new Lazy <int>(() => child1.Id);
toddler2.MasterTemplateAlias = child1.Alias;
toddler2.MasterTemplateId = new Lazy <int>(() => child1.Id);
toddler3.MasterTemplateAlias = child2.Alias;
toddler3.MasterTemplateId = new Lazy <int>(() => child2.Id);
toddler4.MasterTemplateAlias = child2.Alias;
toddler4.MasterTemplateId = new Lazy <int>(() => child2.Id);
baby1.MasterTemplateAlias = toddler2.Alias;
baby1.MasterTemplateId = new Lazy <int>(() => toddler2.Id);
baby2.MasterTemplateAlias = toddler4.Alias;
baby2.MasterTemplateId = new Lazy <int>(() => toddler4.Id);
repository.Save(parent);
repository.Save(child1);
repository.Save(child2);
repository.Save(toddler1);
repository.Save(toddler2);
repository.Save(toddler3);
repository.Save(toddler4);
repository.Save(baby1);
repository.Save(baby2);
return(new[] { parent, child1, child2, toddler1, toddler2, toddler3, toddler4, baby1, baby2 });
}
private void ParseNode(IFFFile.Node node, ITemplateRepository repo)
{
int offset = 0;
var name = node.Data.ReadAsciiString(ref offset);
switch (name)
{
case "gender":
Gender = TryParseAssign(node, ref offset, Gender);
break;
case "niche":
Niche = TryParseAssign(node, ref offset, Niche);
break;
case "species":
Species = TryParseAssign(node, ref offset, Species);
break;
case "race":
Race = TryParseAssign(node, ref offset, Race);
break;
case "acceleration":
Acceleration = TryParseAssign(node, ref offset, Acceleration);
break;
case "speed":
Speed = TryParseAssign(node, ref offset, Speed);
break;
case "turnRate":
TurnRate = TryParseAssign(node, ref offset, TurnRate);
break;
case "animationMapFilename":
AnimationMapFilename = TryParseAssign(node, ref offset, AnimationMapFilename);
break;
case "slopeModAngle":
SlopeModAngle = TryParseAssign(node, ref offset, SlopeModAngle);
break;
case "slopeModPercent":
SlopeModPercent = TryParseAssign(node, ref offset, SlopeModPercent);
break;
case "waterModPercent":
WaterModPercent = TryParseAssign(node, ref offset, WaterModPercent);
break;
case "stepHeight":
StepHeight = TryParseAssign(node, ref offset, StepHeight);
break;
case "collisionHeight":
CollisionHeight = TryParseAssign(node, ref offset, CollisionHeight);
break;
case "collisionRadius":
CollisionRadius = TryParseAssign(node, ref offset, CollisionRadius);
break;
case "movementDatatable":
MovementDatatable = TryParseAssign(node, ref offset, MovementDatatable);
break;
case "postureAlignToTerrain":
PostureAlignToTerrain = TryParseAssign(node, ref offset, PostureAlignToTerrain);
break;
case "swimHeight":
SwimHeight = TryParseAssign(node, ref offset, SwimHeight);
break;
case "warpTolerance":
WarpTolerance = TryParseAssign(node, ref offset, WarpTolerance);
break;
case "collisionOffsetX":
CollisionOffsetX = TryParseAssign(node, ref offset, CollisionOffsetX);
break;
case "collisionOffsetZ":
CollisionOffsetZ = TryParseAssign(node, ref offset, CollisionOffsetZ);
break;
case "collisionLength":
CollisionLength = TryParseAssign(node, ref offset, CollisionLength);
break;
case "cameraHeight":
CameraHeight = TryParseAssign(node, ref offset, CameraHeight);
break;
default:
break;
}
}
public TemplateRules(ITemplateRepository templateRepository)
{
_templateRepository = templateRepository;
}
public GenerateController(IJsonSchemaCodeGenerator generator, ISchemaProvider schemaProvider, ITemplateRepository templateRepository)
{
_generator = generator;
_schemaProvider = schemaProvider;
_templateRepository = templateRepository;
}
public FileService(ICoreScopeProvider uowProvider, ILoggerFactory loggerFactory, IEventMessagesFactory eventMessagesFactory,
IStylesheetRepository stylesheetRepository, IScriptRepository scriptRepository, ITemplateRepository templateRepository,
IPartialViewRepository partialViewRepository, IPartialViewMacroRepository partialViewMacroRepository,
IAuditRepository auditRepository, IShortStringHelper shortStringHelper, IOptions <GlobalSettings> globalSettings, IHostingEnvironment hostingEnvironment)
: base(uowProvider, loggerFactory, eventMessagesFactory)
{
_stylesheetRepository = stylesheetRepository;
_scriptRepository = scriptRepository;
_templateRepository = templateRepository;
_partialViewRepository = partialViewRepository;
_partialViewMacroRepository = partialViewMacroRepository;
_auditRepository = auditRepository;
_shortStringHelper = shortStringHelper;
_globalSettings = globalSettings.Value;
_hostingEnvironment = hostingEnvironment;
}
public HealthController(ITemplateRepository TemplateRepo, ILogger <HealthController> logger)
{
_logger = logger;
_TemplateRepo = TemplateRepo;
}
public TemplateService(ITemplateRepository templateRepository, ITemplateContentRepository templateContentRepository, ILogFactory logFactory)
{
_templateRepository = templateRepository;
_templateContentRepository = templateContentRepository;
_log = logFactory.CreateLog(this);
}
public IndexTemplateBaseService(ITemplateRepository templateRepository)
{
this.templateRepository = templateRepository;
}
public CreateTemplateHandler(ITemplateRepository templateRepository,
IValidator <CreateTemplate> validator)
{
_templateRepository = templateRepository;
_validator = validator;
}
public void ConstructWithNullFileRepository(TemplateRendererConverter converter, IFileRepository fileRepository, ITemplateRepository repository, ITemplateRenderer renderer, IApplicationModel model, ILogger logger, MigrationContext context, Exception e)
{
"Given a converter"
.x(() => converter.Should().BeNull());
"And a null file repository"
.x(() => fileRepository.Should().BeNull());
"And a repository"
.x(() => repository = _mockRepository.Object);
"And a renderer"
.x(() => renderer = _mockRenderer.Object);
"And a model"
.x(() => model = TestHelper.CreateDefaultModelForConverting());
"And a context"
.x(() => context = TestHelper.BuildContext());
"And a logger"
.x(() => logger = _mockLogger.Object);
"When constructing with a null file repository"
.x(() => e = Record.Exception(() => new TemplateRendererConverter(fileRepository, repository, renderer, model, context, logger)));
"Then the constructor should throw an exception"
.x(() => e.Should().NotBeNull().And.Subject.Should().BeOfType <ArgumentNullException>().Which.ParamName.Should().Be("fileRepository"));
}
public TemplateService(ITemplateRepository templateRepository, IMapper mapper)
{
_templateRepository = templateRepository;
_mapper = mapper;
}
public DatabaseManager(ISettingsManager settingsManager, IAccessTokenRepository accessTokenRepository, IAdministratorRepository administratorRepository, IAdministratorsInRolesRepository administratorsInRolesRepository, IChannelRepository channelRepository, IChannelGroupRepository channelGroupRepository, IConfigRepository configRepository, IContentCheckRepository contentCheckRepository, IContentGroupRepository contentGroupRepository, IContentRepository contentRepository, IContentTagRepository contentTagRepository, IDbCacheRepository dbCacheRepository, IErrorLogRepository errorLogRepository, ILogRepository logRepository, IMaterialArticleRepository materialArticleRepository, IMaterialAudioRepository materialAudioRepository, IMaterialFileRepository materialFileRepository, IMaterialGroupRepository materialGroupRepository, IMaterialImageRepository materialImageRepository, IMaterialMessageRepository materialMessageRepository, IMaterialMessageItemRepository materialMessageItemRepository, IMaterialVideoRepository materialVideoRepository, IPermissionsInRolesRepository permissionsInRolesRepository, IPluginConfigRepository pluginConfigRepository, IRelatedFieldItemRepository relatedFieldItemRepository, IRelatedFieldRepository relatedFieldRepository, IRoleRepository roleRepository, ISiteLogRepository siteLogRepository, ISitePermissionsRepository sitePermissionsRepository, ISiteRepository siteRepository, ISpecialRepository specialRepository, IStatRepository statRepository, ITableStyleRepository tableStyleRepository, ITemplateLogRepository templateLogRepository, ITemplateRepository templateRepository, ITranslateRepository translateRepository, IUserGroupRepository userGroupRepository, IUserMenuRepository userMenuRepository, IUserRepository userRepository, IWxAccountRepository wxAccountRepository, IWxChatRepository wxChatRepository, IWxMenuRepository wxMenuRepository, IWxReplyKeywordRepository wxReplyKeywordRepository, IWxReplyMessageRepository wxReplyMessageRepository, IWxReplyRuleRepository wxReplyRuleRepository, IWxUserRepository wxUserRepository)
{
_settingsManager = settingsManager;
AccessTokenRepository = accessTokenRepository;
AdministratorRepository = administratorRepository;
AdministratorsInRolesRepository = administratorsInRolesRepository;
ChannelRepository = channelRepository;
ChannelGroupRepository = channelGroupRepository;
ConfigRepository = configRepository;
ContentCheckRepository = contentCheckRepository;
ContentGroupRepository = contentGroupRepository;
ContentRepository = contentRepository;
ContentTagRepository = contentTagRepository;
DbCacheRepository = dbCacheRepository;
ErrorLogRepository = errorLogRepository;
LogRepository = logRepository;
MaterialArticleRepository = materialArticleRepository;
MaterialAudioRepository = materialAudioRepository;
MaterialFileRepository = materialFileRepository;
MaterialGroupRepository = materialGroupRepository;
MaterialImageRepository = materialImageRepository;
MaterialMessageRepository = materialMessageRepository;
MaterialMessageItemRepository = materialMessageItemRepository;
MaterialVideoRepository = materialVideoRepository;
PermissionsInRolesRepository = permissionsInRolesRepository;
PluginConfigRepository = pluginConfigRepository;
RelatedFieldItemRepository = relatedFieldItemRepository;
RelatedFieldRepository = relatedFieldRepository;
RoleRepository = roleRepository;
SiteLogRepository = siteLogRepository;
SitePermissionsRepository = sitePermissionsRepository;
SiteRepository = siteRepository;
SpecialRepository = specialRepository;
StatRepository = statRepository;
TableStyleRepository = tableStyleRepository;
TemplateLogRepository = templateLogRepository;
TemplateRepository = templateRepository;
TranslateRepository = translateRepository;
UserGroupRepository = userGroupRepository;
UserMenuRepository = userMenuRepository;
UserRepository = userRepository;
WxAccountRepository = wxAccountRepository;
WxChatRepository = wxChatRepository;
WxMenuRepository = wxMenuRepository;
WxReplyKeywordRepository = wxReplyKeywordRepository;
WxReplyMessageRepository = wxReplyMessageRepository;
WxReplyRuleRepository = wxReplyRuleRepository;
WxUserRepository = wxUserRepository;
}
private DocumentRepository CreateContentRepository(IScopeProvider provider, out IContentTypeRepository contentTypeRepository, out ITemplateRepository templateRepository)
{
var accessor = (IScopeAccessor)provider;
templateRepository = new TemplateRepository(accessor, AppCaches, Logger, TestObjects.GetFileSystemsMock());
var tagRepository = new TagRepository(accessor, AppCaches, Logger);
var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches);
var languageRepository = new LanguageRepository(accessor, AppCaches, Logger);
contentTypeRepository = new ContentTypeRepository(accessor, AppCaches, Logger, commonRepository, languageRepository);
var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Logger);
var entityRepository = new EntityRepository(accessor);
var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository, entityRepository);
var propertyEditors = new Lazy <PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty <IDataEditor>())));
var dataValueReferences = new DataValueReferenceFactoryCollection(Enumerable.Empty <IDataValueReferenceFactory>());
var repository = new DocumentRepository(accessor, AppCaches, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors, dataValueReferences);
return(repository);
}
public AutorizacaoAcessoService(IAutorizacaoAcessoRepository baseRepository, ILogRepository logRepository, IGrauParentescoRepository grauRepository, ITipoDocumentoRepository tdRepository, ITemplateRepository tpRepository, IConfiguracaoRepository conRepository) : base(baseRepository)
{
_baseRepository = baseRepository;
_logRepository = logRepository;
_grauRepository = grauRepository;
_tdRepository = tdRepository;
_tpRepository = tpRepository;
_conRepository = conRepository;
}
public TemplatesController()
{
this._repository = DependencyResolver.Current.GetService <ITemplateRepository>();
}
public CreatePageController(IAuthManager authManager, ICreateManager createManager, ISiteRepository siteRepository, IChannelRepository channelRepository, IContentRepository contentRepository, ITemplateRepository templateRepository)
{
_authManager = authManager;
_createManager = createManager;
_siteRepository = siteRepository;
_channelRepository = channelRepository;
_contentRepository = contentRepository;
_templateRepository = templateRepository;
}
public override void ReadFile(IFFFile File, ITemplateRepository repo)
{
ReadNode(File.Root, repo);
}
public TemplateService(IGeneralCache <Template> cache, ITemplateRepository templates, ICategoryRepository categories)
{
_cache = cache ?? throw new ArgumentNullException(nameof(cache));
_templates = templates ?? throw new ArgumentNullException(nameof(templates));
_categories = categories ?? throw new ArgumentNullException(nameof(categories));
}
public TemplateController(ITemplateRepository TemplateRepo, ILogger <TemplateController> logger, IOptions <NATSServer> msgServer)
{
_logger = logger;
_TemplateRepo = TemplateRepo;
_msgServer = msgServer.Value.connection;
}
public DefaultComponentRepository(ITemplateRepository templateRepository)
{
_templateRepository = templateRepository;
}
public UpdateTemplateDetailsHandler(ITemplateRepository templateRepository, IValidator <UpdateTemplateDetails> validator)
{
_templateRepository = templateRepository;
_validator = validator;
}
public TemplateCommandProvider(ITemplateCommandBuilder templateCommandBuilder, ITemplateRepository repository, IEntityFactory entityFactory, ITemplateFileGenerator templateFileGenerator, IUserInterface userInterface, IDeployService deployService, IEnumerable <IDeployStep> deploySteps, ExecutionContext executionContext)
{
this.templateCommandBuilder = templateCommandBuilder;
this.repository = repository;
this.entityFactory = entityFactory;
this.templateFileGenerator = templateFileGenerator;
this.userInterface = userInterface;
this.deployService = deployService;
this.deploySteps = deploySteps;
this.executionContext = executionContext;
}
public TypeContentProvider(ITemplateRepository templateRepository, ITemplateResolver resolver)
{
this.templateRepository = templateRepository;
this.resolver = resolver;
}
public ContentRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository)
: base(work, cache)
{
_contentTypeRepository = contentTypeRepository;
_templateRepository = templateRepository;
EnsureUniqueNaming = true;
}
public Query(ITemplateRepository <T> repo)
{
_repo = repo;
}
public CreateManager(IPathManager pathManager, IParseManager parseManager, ITaskManager taskManager, IChannelRepository channelRepository, IContentRepository contentRepository, ISiteRepository siteRepository, ISpecialRepository specialRepository, ITemplateRepository templateRepository)
{
_pathManager = pathManager;
_parseManager = parseManager;
_taskManager = taskManager;
_channelRepository = channelRepository;
_contentRepository = contentRepository;
_siteRepository = siteRepository;
_specialRepository = specialRepository;
_templateRepository = templateRepository;
}
public EmailNotificationSender(INotificationQueue notificationQueue, ITemplateRepository templateRepository)
{
_notificationQueue = notificationQueue;
_templateRepository = templateRepository;
_currentMailsToSend = new Dictionary <Guid, MailToSend>();
}
public CreateDocumentHandler(ITemplateRepository templateRepository, IDocumentService documentService)
{
_templateRepository = templateRepository;
_documentService = documentService;
}
