/// <summary>
/// Unregisters the given template into the static <see cref="TemplateProviderSelector"/>.
/// </summary>
/// <param name="templateProvider"></param>
public void UnregisterTemplateProvider(ITemplateProvider templateProvider)
{
if (templateProviderNames.Remove(templateProvider.Name))
{
templateProviders.Remove(templateProvider);
}
}
public void SetUp()
{
_templateBuilder = new Mock <ITemplateBuilder>();
_templateRepository = new Mock <ITemplateRepository>();
_target = new TemplateProvider(_templateBuilder.Object, _templateRepository.Object);
}
protected virtual RazorEngineCompiledTemplate GetCompiledTemplate(ITemplateProvider templateProvider, TemplateData data)
{
string template = templateProvider.ProvideTemplate(data.Language);
var razorEngine = new RazorEngine();
return(razorEngine.Compile(template));
}
public BookingMailService(
IBookingProvider bookingProvider,
ITemplateProvider templateProvider)
{
BookingProvider = bookingProvider;
TemplateProvider = templateProvider;
}
public PropertyValueModel(ITemplateProvider templateProvider, object parent, PropertyInfo propertyInfo, DataTemplateAttribute datatemplate = null)
{
_parent = parent;
_templateProvider = templateProvider;
_propertyInfo = propertyInfo;
_displayName = propertyInfo.Name;
_dataTemplateAttribute = _propertyInfo.GetCustomAttribute <DataTemplateAttribute>(true);
if (parent is INotifyPropertyChanged bindable)
{
bindable.PropertyChanged += Bindable_PropertyChanged;
}
if (_propertyInfo.PropertyType == typeof(Rect))
{
_rectangleWrapper = new RectangleWrapper((Rect)_propertyInfo.GetValue(_parent));
_rectangleWrapper.PropertyChanged += Wrapper_PropertyChanged;
}
else if (_propertyInfo.PropertyType == typeof(FontWeight))
{
_valueNames = typeof(FontWeights).GetProperties(BindingFlags.Static | BindingFlags.Public).Select <PropertyInfo, string>((x) => x.Name).ToArray();
}
else if (_propertyInfo.PropertyType.IsEnum)
{
_valueNames = Enum.GetNames(_propertyInfo.PropertyType);
}
}
public static async Task Handler(DiscordSocketClient client, ITemplateProvider templates, SocketGuildUser user)
{
if (user == null)
{
Log.Information("A user joined, but the data received was null!");
return;
}
if (user.Guild.Id == SpecialGuilds.CrystalExploratoryMissions)
{
await user.SendMessageAsync(embed : templates.Execute("cemjoin.md", new
{
GuildName = user.Guild.Name,
BotMention = client.CurrentUser.Mention,
ContentRolesChannelLink = "<#590757405927669769>",
HowDoesThisWorkChannelLink = "<#877659281481162803>",
RulesChannelLink = "<#550707138348187648>",
HelpChannelLink = "<#550777867173232661>",
OtherUsefulServersChannelLink = "<#569322805351415808>",
})
.ToEmbedBuilder()
.WithColor(Color.Orange)
.Build());
}
}
public MailBodyBuilder(ITemplateCompiler compiler, ITemplateProvider provider, ITemplateResolver resolver)
: this()
{
_compiler = compiler;
_provider = provider;
_resolver = resolver;
}
public ProjectViewModel(ISiteStorage siteStorage, IProjectProvider projectProvider, ITemplateProvider templateProvider, IComposer composer)
{
this.siteStorage = siteStorage;
this.projectProvider = projectProvider;
this.templateProvider = templateProvider;
this.composer = composer;
}
public BuildInvoice(ISalesOrderRepository salesOrderRepository, IInvoiceRepository invoiceRepository, IReportBuilderFactory reportBuilderFactory, ITemplateProvider templateProvider)
{
_salesOrderRepository = salesOrderRepository;
_invoiceRepository = invoiceRepository;
_reportBuilderFactory = reportBuilderFactory;
_templateProvider = templateProvider;
}
private string GetConvertDataResult(ConvertDataRequest convertRequest, ITemplateProvider templateProvider, CancellationToken cancellationToken)
{
var converter = _converterMap.GetValueOrDefault(convertRequest.InputDataType);
if (converter == null)
{
// This case should never happen.
_logger.LogInformation("Invalid input data type for conversion.");
throw new RequestNotValidException("Invalid input data type for conversion.");
}
try
{
return(converter.Convert(convertRequest.InputData, convertRequest.RootTemplate, templateProvider, cancellationToken));
}
catch (FhirConverterException convertException)
{
if (convertException.FhirConverterErrorCode == FhirConverterErrorCode.TimeoutError)
{
_logger.LogError(convertException.InnerException, "Convert data operation timed out.");
throw new ConvertDataTimeoutException(Resources.ConvertDataOperationTimeout, convertException.InnerException);
}
_logger.LogInformation(convertException, "Convert data failed.");
throw new ConvertDataFailedException(string.Format(Resources.ConvertDataFailed, convertException.Message), convertException);
}
catch (Exception ex)
{
_logger.LogError(ex, "Unhandled exception: convert data process failed.");
throw new ConvertDataUnhandledException(string.Format(Resources.ConvertDataFailed, ex.Message), ex);
}
}
public SaveToItPostProcessingStage(
[NotNull] IBranchNameBuilder branchNameBuilder,
[NotNull] IIssueNameBuilder issueNameBuilder,
[NotNull] ITemplateProvider templateProvider,
[NotNull] ITelemetryScopeProvider telemetryScopeProvider)
{
if (branchNameBuilder == null)
{
throw new ArgumentNullException(nameof(branchNameBuilder));
}
if (issueNameBuilder == null)
{
throw new ArgumentNullException(nameof(issueNameBuilder));
}
if (templateProvider == null)
{
throw new ArgumentNullException(nameof(templateProvider));
}
if (telemetryScopeProvider == null)
{
throw new ArgumentNullException(nameof(telemetryScopeProvider));
}
_branchNameBuilder = branchNameBuilder;
_issueNameBuilder = issueNameBuilder;
_templateProvider = templateProvider;
_telemetryScopeProvider = telemetryScopeProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="TemplateService"/> class.
/// </summary>
/// <param name="viewEngine">The view engine.</param>
/// <param name="bufferScope">The buffer scope.</param>
/// <param name="templateProvider">The template provider.</param>
public TemplateService(
ICompositeViewEngine viewEngine,
IViewBufferScope bufferScope,
ITemplateProvider templateProvider)
: this((IViewEngine)viewEngine, bufferScope, templateProvider)
{
}
// ReSharper restore NotAccessedField.Local
public CodeExplorerViewModel(
RubberduckParserState state,
RemoveCommand removeCommand,
IConfigProvider <GeneralSettings> generalSettingsProvider,
IConfigProvider <WindowSettings> windowSettingsProvider,
IUiDispatcher uiDispatcher,
IVBE vbe,
ITemplateProvider templateProvider,
ICodeExplorerSyncProvider syncProvider)
{
_state = state;
_state.StateChanged += HandleStateChanged;
_state.ModuleStateChanged += ParserState_ModuleStateChanged;
_externalRemoveCommand = removeCommand;
_generalSettingsProvider = generalSettingsProvider;
_windowSettingsProvider = windowSettingsProvider;
_uiDispatcher = uiDispatcher;
_vbe = vbe;
_templateProvider = templateProvider;
CollapseAllSubnodesCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteCollapseNodes, EvaluateCanSwitchNodeState);
ExpandAllSubnodesCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteExpandNodes, EvaluateCanSwitchNodeState);
ClearSearchCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteClearSearchCommand);
if (_externalRemoveCommand != null)
{
RemoveCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteRemoveCommand, _externalRemoveCommand.CanExecute);
}
OnPropertyChanged(nameof(Projects));
SyncCodePaneCommand = syncProvider.GetSyncCommand(this);
// Force a call to EvaluateCanExecute
OnPropertyChanged(nameof(SyncCodePaneCommand));
}
public virtual List<string> TransformList(ITemplateProvider templateProvider, List<TemplateData> templateData)
{
CultureInfo threadCulture = Thread.CurrentThread.CurrentCulture;
List<string> list = new List<string>();
TemplateCache templateCache = new TemplateCache(templateProvider);
foreach (TemplateData data in templateData)
{
string templateName = templateCache.GetOrCreateTemplate(data.Culture);
Thread.CurrentThread.CurrentCulture = data.Culture ?? threadCulture;
string content = null;
if (data.ObjectModel != null)
{
content = Transform(templateName, data.ObjectModel);
}
else
{
var replaceModel = data.ReplaceModel ?? new Dictionary<string, string>();
content = Transform(templateName, replaceModel);
}
list.Add(content);
}
Thread.CurrentThread.CurrentCulture = threadCulture;
return list;
}
// TODO: Move this in PluginService
public void RegisterAdditionalTemplateProvider(ITemplateProvider provider)
{
AdditionalProviders.Add(provider);
var dependencyObject = provider as DependencyObject;
if (dependencyObject == null)
{
throw new InvalidOperationException("The template provider must be a dependency object in order to be used correctly in the property view.");
}
var category = PropertyViewHelper.GetTemplateCategory(dependencyObject);
switch (category)
{
case PropertyViewHelper.Category.PropertyHeader:
PropertyViewHelper.HeaderProviders.RegisterTemplateProvider(provider);
break;
case PropertyViewHelper.Category.PropertyFooter:
PropertyViewHelper.FooterProviders.RegisterTemplateProvider(provider);
break;
case PropertyViewHelper.Category.PropertyEditor:
PropertyViewHelper.EditorProviders.RegisterTemplateProvider(provider);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Unregisters the given template into the static <see cref="TemplateProviderSelector"/>.
/// </summary>
/// <param name="templateProvider"></param>
public void UnregisterTemplateProvider([NotNull] ITemplateProvider templateProvider)
{
if (templateProviderNames.Remove(templateProvider.Name))
{
templateProviders.Remove(templateProvider);
}
}
public DeploymentCoordinator(
ITemplateProvider templateProvider,
IManagementClientProvider managementClientProvider)
{
_templateProvider = templateProvider;
_managementClientProvider = managementClientProvider;
}
public ServiceCollectionExtensionCodeGenerator(ServiceCollectionExtensionCodeGenerateOptions options, ITemplateProvider templateProvider, ServiceCollectionExtensionsModelProvider dataProvider, IRenderer renderer, IOutputService outputService)
{
Options = options;
TemplateProvider = templateProvider;
DataProvider = dataProvider;
Renderer = renderer;
OutputService = outputService;
}
public HtmlLoader(ITemplateProvider templateProvider)
{
if (templateProvider == null)
{
throw new NullReferenceException("templateProvider");
}
_templateProvider = templateProvider;
}
public EntityManagerInterfaceCodeGenerator(EntityManagerInterfaceCodeGenerateOptions options, ITemplateProvider templateProvider, ICodeGenerationModelProvider domainDataProvider, IRenderer renderer, IOutputService outputService)
{
Options = options;
TemplateProvider = templateProvider;
DomainDataProvider = domainDataProvider;
Renderer = renderer;
OutputService = outputService;
}
public SmtpNotificationChannel(ILogger <SmtpNotificationChannel> logger, ITemplateProvider templates, IOptionsSnapshot <AuditOptions> auditSettings, ChannelWriter <Action> queue, ISmtpProvider smtpProvider)
: base(logger, queue)
{
this.logger = logger;
this.templates = templates;
this.NotificationChannelDefinitions = auditSettings.Value.NotificationChannels.Smtp;
this.smtpProvider = smtpProvider;
}
public AuditEventProcessor(ILogger <AuditEventProcessor> logger, ITemplateProvider templates, IEnumerable <INotificationChannel> notificationChannels, IHttpContextAccessor httpContextAccessor, IOptionsSnapshot <AuditOptions> auditSettings)
{
this.logger = logger;
this.templates = templates;
this.httpContextAccessor = httpContextAccessor;
this.notificationChannels = notificationChannels;
this.auditSettings = auditSettings.Value;
}
public EntityWebApiControllerCodeGenerator(EntityWebApiControllerCodeGenerateOptions options, ITemplateProvider templateProvider, ICodeGenerationModelProvider domainDataProvider, IRenderer renderer, IOutputService outputService)
{
Options = options;
TemplateProvider = templateProvider;
DomainDataProvider = domainDataProvider;
Renderer = renderer;
OutputService = outputService;
}
public ChatModule(ISessionManager sessionManager, ITemplateProvider templateProvider)
{
m_Rooms = new Dictionary <string, ChatRoom> {
{ "MAIN", new ChatRoom(Guid.Empty) }
};
m_SessionManager = sessionManager;
m_TemplateProvider = templateProvider;
}
public void LoadNonExistingTemplate()
{
// Arrange
ITemplate template;
ITemplateProvider provider = this.GetFileTemplateProvider();
// Act & Assert
template = provider.Load("unknown");
}
public StatusMailProvider(
IBookingProvider bookingProvider,
ITemplateProvider templateProvider,
IEloverblikAPI eloverblikAPI)
{
BookingProvider = bookingProvider;
TemplateProvider = templateProvider;
EloverblikAPI = eloverblikAPI;
}
public TeamTemplateEditorWidget(ITemplateProvider <TeamTemplate, Player> provider) : base(provider)
{
treeview = new PlayerPropertiesTreeView();
treeview.PlayerClicked += this.OnPlayerClicked;
treeview.PlayersSelected += this.OnPlayersSelected;
FirstPageName = Catalog.GetString("Teams players");
AddTreeView(treeview);
AddTeamNamesWidget();
}
public SmtpNotificationChannel(ILogger <SmtpNotificationChannel> logger, IOptionsSnapshot <EmailOptions> emailSettings, ITemplateProvider templates, IOptionsSnapshot <AuditOptions> auditSettings, ChannelWriter <Action> queue, RandomNumberGenerator rng)
: base(logger, queue)
{
this.logger = logger;
this.rng = rng;
this.emailSettings = emailSettings.Value;
this.templates = templates;
this.NotificationChannelDefinitions = auditSettings.Value.NotificationChannels.Smtp;
}
public TemplateDataProvider(ILoggingService log, ID entryPointId, ITemplateProvider templateProvider)
{
_sitecoreItems = new Dictionary <ID, ISitecoreItem>();
EntryPointId = entryPointId;
_log = log;
_templateProvider = templateProvider;
Clear();
}
/// <summary>
/// Registers the given template into the static <see cref="TemplateProviderSelector"/>.
/// </summary>
/// <param name="templateProvider"></param>
public void RegisterTemplateProvider(ITemplateProvider templateProvider)
{
if (templateProvider == null) throw new ArgumentNullException("templateProvider");
if (templateProviderNames.Contains(templateProvider.Name))
throw new InvalidOperationException("A template provider with the same name has already been registered in this template selector.");
InsertTemplateProvider(templateProviders, templateProvider, new List<ITemplateProvider>());
templateProviderNames.Add(templateProvider.Name);
}
public CreateUrlProvider(IPersister persister, IEditUrlManager editUrlManager, IDefinitionManager definitions, ITemplateProvider[] templates, ContentActivator activator, AjaxRequestDispatcher dispatcher, Navigator navigator)
: base(dispatcher)
{
this.persister = persister;
this.managementPaths = editUrlManager;
this.definitions = definitions;
this.templates = templates;
this.activator = activator;
this.navigator = navigator;
}
public EmailService(ISmtpClientProvider smtpClient,
ITemplateProvider templateProvider,
IContentBuilder contentBuilder,
ICredentialsProvider credentialsProvider)
{
this.smtpClient = smtpClient;
this.templateProvider = templateProvider;
this.contentBuilder = contentBuilder;
this.credentialsProvider = credentialsProvider;
}
public MailService(SiteOptions siteOptions,
MailTokenService mailTokenService,
MailSender mailSender,
ITemplateProvider templateProvider)
{
_mailTokenService = mailTokenService;
_mailSender = mailSender;
_templateProvider = templateProvider;
_siteUrls = new EmailUrls(siteOptions.Root);
}
public LiquidWidgetFinder()
{
var container = GetContainer();
_templateProvider = container.GetInstance <ITemplateProvider>();
_widgetFactory = container.GetInstance <IWidgetFactory>();
_dataDecorators = container.GetInstance <List <LiquidDataDecorator> >().OrderBy(x => x.LevelToReachRealWrappe)
.ToList();
_widgetDataService = container.GetInstance <IWidgetDataService>();
}
public ArrestReportCommandService(
IReportsUnitOfWork unitOfWork,
IWorkflowInstanceService workflowInstanceService,
ITemplateProvider templateProvider,
ILog log,
IServiceAuthorizationPolicy authorizationPolicy,
IServiceIdentityProvider identityProvider)
: base(unitOfWork, workflowInstanceService, templateProvider, log, ModuleType.Arrest, authorizationPolicy, identityProvider)
{
}
public int CompareTo(ITemplateProvider other)
{
if (other == null) throw new ArgumentNullException("other");
// Both overrides all: undeterminated.
if (OverrideRule == OverrideRule.All && other.OverrideRule == OverrideRule.All)
return 0;
// This overrides all: this is first.
if (OverrideRule == OverrideRule.All)
return -1;
// Other overrides all: other is first.
if (other.OverrideRule == OverrideRule.All)
return 1;
// Both overrides none: undeterminated.
if (OverrideRule == OverrideRule.None && other.OverrideRule == OverrideRule.None)
return 0;
// This overrides none: other is first.
if (OverrideRule == OverrideRule.None)
return 1;
// Other overrides none: this is first.
if (other.OverrideRule == OverrideRule.None)
return -1;
// From this point, both have either the "Some" rule or the "Most" rule.
bool thisOverrides = OverriddenProviderNames.Contains(other.Name);
bool otherOverrides = other.OverriddenProviderNames.Contains(Name);
// Both overrides each other: undeterminated
if (thisOverrides && otherOverrides)
return 0;
// None overrides the other...
if (!thisOverrides && !otherOverrides)
{
// ...but this overrides most: this is first.
if (OverrideRule == OverrideRule.Most && other.OverrideRule == OverrideRule.Some)
return -1;
// ...but other overrides most: other is first.
if (OverrideRule == OverrideRule.Some && other.OverrideRule == OverrideRule.Most)
return 1;
// ...and both have the same rule: undeterminated
return 0;
}
// Result: whichever overrides the other is first.
return thisOverrides ? -1 : 1;
}
public TableScaffolder(
TemplateVars templateVars,
ITemplateProvider templateProvider,
IFilePersister filePersister,
ProjectItem projectItem,
ILogger logger)
{
this.templateVars = templateVars;
this.templateProvider = templateProvider;
this.filePersister = filePersister;
this.projectItem = projectItem;
this.logger = logger;
}
public virtual List<string> TransformList(
ITemplateProvider templateProvider, List<TemplateData> templateData)
{
List<string> list = new List<string>();
TemplateCache templateCache = new TemplateCache(templateProvider);
foreach (TemplateData data in templateData)
{
string template = templateCache.GetOrCreateTemplate(data.Culture);
string content = Transform(template, data.ReplaceModel);
list.Add(content);
}
return list;
}
public LanguageGateway(
IPersister persister,
IItemFinder finder,
IEditUrlManager editUrlManager,
ITemplateProvider[] templates,
IHost host,
ISecurityManager security,
IWebContext context,
StructureBoundDictionaryCache<int, LanguageInfo[]> languagesCache,
DescendantItemFinder descendantFinder,
EngineSection config)
{
this.persister = persister;
this.finder = finder;
this.editUrlManager = editUrlManager;
this.templates = templates;
this.host = host;
this.security = security;
this.context = context;
this.languagesCache = languagesCache;
this.descendantFinder = descendantFinder;
Enabled = config.Globalization.Enabled;
}
public virtual List<string> TransformList(
ITemplateProvider templateProvider, List<TemplateData> templateData)
{
List<string> list = new List<string>();
TemplateCache templateCache = new TemplateCache(templateProvider);
foreach (TemplateData data in templateData)
{
var transform = (XslCompiledTransform)templateCache.GetItem(data.Culture);
if (transform == null)
{
string template = templateProvider.ProvideTemplate(data.Culture);
transform = ConstructXslTransform(template);
templateCache.InsertItem(transform, data.Culture);
}
string content = null;
if (data.ObjectModel != null)
{
content = Transform(transform, data.ObjectModel);
}
else
{
var replaceModel = data.ReplaceModel ?? new Dictionary<string, string>();
content = Transform(transform, replaceModel);
}
list.Add(content);
}
return list;
}
public DefaultTemplateEngine(ITemplateProvider fileProvider, IEnumerable<ITemplateGenerator> generators)
{
this.fileProvider = fileProvider;
this.generators = generators;
}
private void UpdateDatabase(IEnumerable<Template> templates, ITemplateProvider templateProvider)
{
IList<Template> templatesFromDatabase = templateProvider.Load();
Dictionary<string, Template> names =
templatesFromDatabase.ToDictionary(templateFromDatabase => templateFromDatabase.Name);
foreach (Template loadedTemplate in templates)
{
if (names.Keys.Contains(loadedTemplate.Name))
{
Template template = names[loadedTemplate.Name];
template.HtmlTemplate = loadedTemplate.HtmlTemplate;
templateProvider.Update(template);
}
else
templateProvider.Save(loadedTemplate);
}
}
private static void InsertTemplateProvider(List<ITemplateProvider> list, ITemplateProvider templateProvider, List<ITemplateProvider> movedItems)
{
movedItems.Add(templateProvider);
// Find the first index where we can insert
int insertIndex = 1 + list.LastIndexOf(x => x.CompareTo(templateProvider) < 0);
list.Insert(insertIndex, templateProvider);
// Every following providers may have an override rule against the new template provider, we must potentially resort them.
for (int i = insertIndex + 1; i < list.Count; ++i)
{
var followingProvider = list[i];
if (followingProvider.CompareTo(templateProvider) < 0)
{
if (!movedItems.Contains(followingProvider))
{
list.RemoveAt(i);
InsertTemplateProvider(list, followingProvider, movedItems);
}
}
}
}
public TemplateAggregator(IDefinitionManager definitions, ITemplateProvider[] templateProviders)
{
this.definitions = definitions;
this.providers = templateProviders.OrderBy(tp => tp.SortOrder).ToArray();
}
public TemplateFactory(ITemplateProvider TemplateProvider = null, Encoding Encoding = null)
{
this.Encoding = Encoding;
this.TemplateProvider = TemplateProvider;
}
public TemplateEngine(ITemplateProvider templateProvider, ITemplateParser templateParser)
{
this.templateProvider = templateProvider;
this.templateParser = templateParser;
}
//инициализация
public TemplateCache(ITemplateProvider templateProvider)
{
_templateProvider = templateProvider;
_cache = new Dictionary<string, object>();
}
protected override int CompareProviders(ITemplateProvider x, ITemplateProvider y)
{
return string.Compare(x.Name, y.Name, StringComparison.Ordinal);
}
//инициализация
public NotificationSettings(ITemplateProvider templateProvider, ITemplateTransformer templateTransformer)
{
TemplateProvider = templateProvider;
TemplateTransformer = templateTransformer;
}
/// <summary>
///
/// </summary>
/// <param name="TemplateProvider"></param>
/// <param name="Encoding"></param>
/// <param name="OutputGeneratedCode"></param>
public TemplateFactory(ITemplateProvider TemplateProvider, Encoding Encoding, bool OutputGeneratedCode = false)
{
this.Encoding = Encoding;
this.TemplateProvider = TemplateProvider;
this.OutputGeneratedCode = OutputGeneratedCode;
}
public HtmlLoader(ITemplateProvider templateProvider)
{
if (templateProvider == null)
throw new NullReferenceException("templateProvider");
_templateProvider = templateProvider;
}
