public MessageFactory(
ICommonServices services,
ITemplateEngine templateEngine,
ITemplateManager templateManager,
IMessageModelProvider modelProvider,
IMessageTemplateService messageTemplateService,
IQueuedEmailService queuedEmailService,
ILanguageService languageService,
IEmailAccountService emailAccountService,
EmailAccountSettings emailAccountSettings,
IDownloadService downloadService)
{
_services = services;
_templateEngine = templateEngine;
_templateManager = templateManager;
_modelProvider = modelProvider;
_messageTemplateService = messageTemplateService;
_queuedEmailService = queuedEmailService;
_languageService = languageService;
_emailAccountService = emailAccountService;
_emailAccountSettings = emailAccountSettings;
_downloadService = downloadService;
T = NullLocalizer.Instance;
Logger = NullLogger.Instance;
}
public ExpandableBuilderViewModel(IApplicationLogger logger, ITemplateManager templateManager)
: base(logger, templateManager)
{
Title = "Expandable Builder";
EnvironmentVariables.AddRange(Environment.GetEnvironmentVariables().Keys.OfType <string>());
}
public override void Render(object toRender, Stream output)
{
AppContentResponder appContentResponder = ContentResponder.AppContentResponders[AppName];
ITemplateManager templateManager = appContentResponder.AppTemplateManager;
string templateName = GetTemplateName(toRender);
string templates = templateManager.CombinedCompiledTemplates;
string renderedContent = DustScript.Render(templates, templateName, toRender);
byte[] data;
if (HttpArgs.Has("layout", out string layout))
{
string absolutePath = ExecutionRequest.Request.Url.AbsolutePath;
string extension = Path.GetExtension(absolutePath);
string path = absolutePath.Truncate(extension.Length);
LayoutModel layoutModel = appContentResponder.GetLayoutModelForPath(path);
layoutModel.LayoutName = layout;
layoutModel.PageContent = renderedContent;
MemoryStream ms = new MemoryStream();
appContentResponder.CommonTemplateManager.RenderLayout(layoutModel, ms);
ms.Seek(0, SeekOrigin.Begin);
data = ms.GetBuffer();
}
else
{
data = Encoding.UTF8.GetBytes(renderedContent);
}
output.Write(data, 0, data.Length);
}
public TemplateController(ITemplateManager manager, IOptions <AppSettings> settings, IOptions <ConnectionStrings> conStrings)
{
_templateManager = manager;
_appSettings = settings.Value;
_conStrings = conStrings.Value;
_templateManager.SetConnectionString(_conStrings.DefaultConnection);
}
/// <summary>
/// Sets the resolver used to locate unknown templates.
/// </summary>
/// <param name="resolver">The resolver instance to use.</param>
/// <returns>The current configuration builder.</returns>
public IConfigurationBuilder ManageUsing(ITemplateManager resolver)
{
Contract.Requires(resolver != null);
_config.TemplateManager = resolver;
return(this);
}
public CustomRazorTemplateManager(ShellSettings shellSettings,
IOrchardServices orchardServices)
{
_shellSettings = shellSettings;
_orchardServices = orchardServices;
_defaultTemplateManager = new DelegateTemplateManager();
}
public MessageFactory(
SmartDbContext db,
ICommonServices services,
ITemplateEngine templateEngine,
ITemplateManager templateManager,
IMessageModelProvider modelProvider,
IQueuedEmailService queuedEmailService,
ILanguageService languageService,
IEmailAccountService emailAccountService,
EmailAccountSettings emailAccountSettings,
IMediaService mediaService,
IEventPublisher eventPublisher,
IStoreContext storeContext,
IWorkContext workContext)
{
_db = db;
_services = services;
_templateEngine = templateEngine;
_templateManager = templateManager;
_modelProvider = modelProvider;
_queuedEmailService = queuedEmailService;
_languageService = languageService;
_emailAccountService = emailAccountService;
_emailAccountSettings = emailAccountSettings;
_mediaService = mediaService;
_eventPublisher = eventPublisher;
_storeContext = storeContext;
_workContext = workContext;
}
public ManageTemplateViewmodel(IShellService shellService, ITemplateManager templateMgr)
: base(shellService)
{
_templateMgr = templateMgr;
InitializeData();
}
protected override void UpgradeClass(ITemplateManager templateManager,
SpaceBody spaceBody,
Mapping upgradeMapping)
{
spaceBody.gameObject.layer = LayerHelper.Sun;
spaceBody.mappingUpgradeSpaceObject = upgradeMapping;
}
public ConfiguratorViewModel(IApplicationLogger logger, IEventAggregator events, IApplicationCommands commands,
ITemplateManager templateManager, IDriveDetector driveDetector, IMessageDisplayService messageService,
ElementViewModelFactory elementFactory, IConfiguratorService configurator, IVariableStore variables)
{
_logger = logger;
_templateManager = templateManager;
_driveDetector = driveDetector;
_messageService = messageService;
_elementFactory = elementFactory;
_configurator = configurator;
_variables = variables;
Title = "Configurator";
events.GetEvent <TemplateSelectedEvent>().Subscribe(OnTemplateSelected);
events.GetEvent <ScanDrivesCompletedEvent>().Subscribe(OnScanDrivesCompleted);
ImportCommand = new DelegateCommand(OnImport, () => true);
commands.ImportCommand.RegisterCommand(ImportCommand);
PrevPageCommand = new DelegateCommand <PageViewModel>(OnPrevPage, CanPrevPage);
NextPageCommand = new DelegateCommand <PageViewModel>(OnNextPage, page => true);
RescanCommand = new DelegateCommand(OnScanDrives, () => !IsScanning);
RescanCommand.Execute();
}
public Notifier(ITemplateManager templateManager, ITemplateSettings templateSettings, IEmailer emailer, IEmailAddressSettings emailAddressSettings)
{
this.templateManager = templateManager;
this.templateSettings = templateSettings;
this.emailer = emailer;
this.emailAddressSettings = emailAddressSettings;
}
private void ApplyItemOption(ITemplateManager <ItemOptionTemplate> options, int itemOptionID, int level)
{
if (itemOptionID <= 0)
{
return;
}
var option = options.Get(itemOptionID);
var data = option.LevelData[level];
PAD += data.IncPAD;
PDD += data.IncPDD;
MAD += data.IncMAD;
MDD += data.IncMDD;
ACC += data.IncACC;
EVA += data.IncEVA;
Speed += data.IncSpeed;
Jump += data.IncJump;
Option.PADr += data.IncPADr;
Option.PDDr += data.IncPDDr;
Option.MADr += data.IncMADr;
Option.MDDr += data.IncMDDr;
Option.ACCr += data.IncACCr;
Option.EVAr += data.IncEVAr;
}
internal string BuildNJangoPage(string workingDirectory, string templateFile, IronPython.Runtime.PythonDictionary pyContext)
{
TemplateManagerProvider templateProvider = new TemplateManagerProvider();
ITemplateManager manager = templateProvider.GetNewManager();
Dictionary <string, object> context = new Dictionary <string, object>();
foreach (object str in pyContext.Keys)
{
context.Add(str.ToString(), pyContext[str]);
}
if (File.Exists(workingDirectory + @"\" + templateFile.ToString()))
{
TextReader reader = manager.RenderTemplate(
workingDirectory + @"\" + templateFile.ToString(),
(Dictionary <string, Object>)context);
return(reader.ReadToEnd());
}
else
{
return("Template not found");
}
}
public Deployer(ITemplateManager templateManager, IProvisionManager provisioningManager, IHandlerFactory handlerFactory, ITokeniser tokeniser)
{
this.templateManger = templateManager;
this.provisioningManager = provisioningManager;
this.handlerFactory = handlerFactory;
this.tokeniser = tokeniser;
}
public ContinentManager(ITemplateManager templateManager, FieldManager fieldManager)
{
Continents = templateManager
.GetAll <ContinentTemplate>()
.Select(c => new Continent(templateManager, fieldManager, c))
.ToList();
}
public Viewer()
{
InitializeComponent();
provider = new TemplateManagerProvider()
.WithSetting(Constants.EXCEPTION_IF_ERROR, false)
.WithLoader(new TemplateLoader(templateSource))
.GetNewManager();
}
protected internal void InitializeCommonTemplateRenderer()
{
OnCommonTemplateRendererInitializing();
CommonTemplateManager = new CommonDustRenderer(this);
OnCommonTemplateRendererInitialized();
}
public Viewer()
{
InitializeComponent();
provider = new TemplateManagerProvider()
.WithSetting(Constants.EXCEPTION_IF_ERROR, false)
.WithLoader(new TemplateLoader(templateSource))
.GetNewManager();
}
public ContactManager(IExcelFilesManager excelFilesManager, ITemplateManager templateManager,
IInventoryManager inventoryManager, ILogger logger)
{
_excelFilesManager = excelFilesManager;
_templateManager = templateManager;
_logger = logger;
_inventoryManager = inventoryManager;
}
/// <summary>
/// Initialises the configuration.
/// </summary>
/// <param name="config">The core configuration.</param>
/// <param name="serviceConfig">The service configuration.</param>
private void InitialiseConfiguration(RazorEngineConfigurationSection config, TemplateServiceConfigurationElement serviceConfig)
{
// Set whether we are allowing missing properties on dynamic.
AllowMissingPropertiesOnDynamic = config.AllowMissingPropertiesOnDynamic;
// Set whether we load templates with Assembly.Load(byte[]).
DisableTempFileLocking = config.DisableTempFileLocking;
// Add the global namespaces.
AddNamespaces(config.Namespaces);
// Add the specific namespaces.
AddNamespaces(serviceConfig.Namespaces);
// Sets the activator.
SetActivator(config.ActivatorType);
// Sets the base template type.
SetBaseTemplateType(serviceConfig.BaseTemplateType);
// Sets the compiler service factory.
SetCompilerServiceFactory(config.CompilerServiceFactoryType);
Debug = serviceConfig.Debug;
// Sets the encoded string factory.
SetEncodedStringFactory(serviceConfig.EncodedStringFactoryType);
// Sets the reference resolver.
SetReferenceResolver(config.ReferenceResolverType);
#pragma warning disable 0618 // Backwards Compat.
// Sets the template resolver.
SetTemplateResolver(config.TemplateResolverType);
if (Resolver != null)
{
TemplateManager = new WrapperTemplateManager(Resolver);
}
#pragma warning restore 0618 // Backwards Compat.
// Sets the template manager.
SetTemplateManager(config.TemplateManagerType);
// Set the language.
Language = serviceConfig.Language;
// Sets the activator.
SetActivator(config.ActivatorType);
// Sets the compiler service factory.
SetCompilerServiceFactory(config.CompilerServiceFactoryType);
#pragma warning disable 0618 // Backwards Compat.
// Sets the template resolver.
SetTemplateResolver(config.TemplateResolverType);
#pragma warning restore 0618 // Backwards Compat.
}
/// <summary>
/// Initializes a new instance of the <see cref="RazorGenerator" /> class.
/// </summary>
/// <param name="templateManager">The template manager.</param>
public RazorGenerator(ITemplateManager templateManager)
{
service = RazorEngineService.Create(new TemplateServiceConfiguration()
{
Language = RazorEngine.Language.CSharp,
EncodedStringFactory = new RawStringFactory(),
TemplateManager = templateManager,
});
}
public WvsContainer(
IApplicationLifetime appLifetime,
ICacheClient cache,
IMessageBus messageBus,
ILockProvider lockProvider,
IOptions <WvsContainerOptions> info,
IDataContextFactory dataContextFactory,
ITemplateManager templateManager,
IScriptConversationManager conversationManager
) : base(appLifetime, cache, messageBus, info, dataContextFactory)
{
_token = new CancellationTokenSource();
_services = new List <IService>();
Info.LoginServices
.Select(o => new WvsLogin(
appLifetime,
cache,
messageBus,
new OptionsWrapper <LoginServiceInfo>(o),
dataContextFactory,
lockProvider,
templateManager
))
.ForEach(_services.Add);
Info.GameServices
.Select(o => new WvsGame(
appLifetime,
cache,
messageBus,
new OptionsWrapper <GameServiceInfo>(o),
dataContextFactory,
templateManager,
conversationManager
))
.ForEach(_services.Add);
Info.ShopServices
.Select(o => new WvsShop(
appLifetime,
cache,
messageBus,
new OptionsWrapper <ShopServiceInfo>(o),
dataContextFactory,
templateManager
))
.ForEach(_services.Add);
Info.TradeServices
.Select(o => new WvsTrade(
appLifetime,
cache,
messageBus,
new OptionsWrapper <TradeServiceInfo>(o),
dataContextFactory,
templateManager
))
.ForEach(_services.Add);
}
private void tsmiCreateClrTrigger_Click(object sender, EventArgs e)
{
var tf = TemplateManagerFactory.Instance;
ITemplateManager man = tf.GetCodeTemplateManager();
Template t = man.GetTemplate("CS.CreateClrTriggerSnippet.cs");
insertTemplateCode(t);
}
private void insertTemplate(string templateKey)
{
var tf = TemplateManagerFactory.Instance;
ITemplateManager man = tf.GetSqlTemplateManager(_lastConnection);
Template t = man.GetTemplate(templateKey);
insertTemplateCode(t);
}
/// <summary>
/// Sets the template manager.
/// </summary>
/// <param name="templateManagerType">The template manager type.</param>
private void SetTemplateManager(string templateManagerType)
{
var type = GetType(templateManagerType);
if (type != null)
{
TemplateManager = GetInstance <ITemplateManager>(type);
}
}
public ConfiguratorService(IFileService fileService, IVariableStore variables,
ITaskCommandFactory commandFactory, ITemplateManager templateManager, IApplicationSettings settings)
{
_fileService = fileService;
_variables = variables;
_commandFactory = commandFactory;
_templateManager = templateManager;
_settings = settings;
}
private void tsmiCSharpAdoSnippet_Click(object sender, EventArgs e)
{
var tf = TemplateManagerFactory.Instance;
ITemplateManager man = tf.GetCodeTemplateManager();
Template t = man.GetTemplate("CS.AdoCodeSnippet.cs");
insertTemplateCode(t);
}
public TemplatesController(
IMapper mapper,
ITemplateManager templateManager) : base()
{
_mapper = mapper;
_templateManager = templateManager;
MapExceptionsToStatusCodes();
}
public NotificationManager(
IEmailService emailService,
ITemplateManager templateManager,
IWebHostEnvironment webHostEnvironment)
{
_emailService = emailService;
_templateManager = templateManager;
_webHostEnvironment = webHostEnvironment;
}
public ProjectHandler(NodeProviderBroker broker, ITemplateDirectory template_manager, List<Tag> tags, List<Filter> filters, string project_directory)
{
this.broker = broker;
TemplateManager = template_manager;
this.tags = tags;
this.filters = filters;
this.project_directory = project_directory;
template_loader = new TemplateLoader(project_directory);
parser = InitializeParser();
}
/// <summary>
/// Конструктор.
/// </summary>
/// <param name="logger"><see cref="ILogger{TCategoryName}"/>.</param>
/// <param name="templateManager"><see cref="ITemplateManager"/>.</param>
/// <param name="emailBodyGenerator"><see cref="IEmailBodyGenerator"/>.</param>
public EmailMessageFactory(
ILogger <EmailMessageFactory> logger,
ITemplateManager templateManager,
IEmailBodyGenerator emailBodyGenerator
)
{
this.logger = logger;
this.templateManager = templateManager;
this.emailBodyGenerator = emailBodyGenerator;
}
public ContinentManager(ITemplateManager templateManager, FieldManager fieldManager)
{
_templateManager = templateManager;
_fieldManager = fieldManager;
Continents = _templateManager
.GetAll <ContinentTemplate>()
.Select(c => new Continent(c, _fieldManager))
.ToList();
}
public FieldSetManager(ITemplateManager templateManager, FieldManager fieldManager)
{
FieldSets = templateManager
.GetAll <FieldSetTemplate>()
.Select(f => new FieldSet(f, fieldManager))
.ToDictionary(
f => f.SetTemplate.Name,
f => f
);
}
public UserAppService(IRepository <User, long> userRepository, IPermissionManager permissionManager, IFileStoreManager fileStoreManager, IUsersAppNotificationsSender usersAppNotificationsSender, UserNotificationManager userNotificationManager, ICinotamMailSender cinotamMailSender, ITemplateManager templateManager)
{
_userRepository = userRepository;
_permissionManager = permissionManager;
_fileStoreManager = fileStoreManager;
_usersAppNotificationsSender = usersAppNotificationsSender;
_userNotificationManager = userNotificationManager;
_cinotamMailSender = cinotamMailSender;
_templateManager = templateManager;
}
public ProjectHandler(NodeProviderBroker broker, IVsHierarchy hier, string project_directory)
{
this.broker = broker;
template_loader = new TemplateLoader(project_directory);
type_resolver = new TypeResolver(hier);
TemplateDirectory = new TemplateDirectory(project_directory);
parser = new TemplateManagerProvider()
.WithTags(type_resolver.Tags)
.WithFilters(type_resolver.Filters)
.WithSetting(NDjango.Constants.EXCEPTION_IF_ERROR, false)
.WithLoader(template_loader)
.GetNewManager();
}
private void ValidateSyntaxTree(ITemplateManager manager)
{
var template = manager.GetTemplate(Template, new TestTyperesolver(),
new TypeResolver.ModelDescriptor(new TypeResolver.IDjangoType[]
{
new TypeResolver.CLRTypeDjangoType("Standard", typeof(EmptyClass))
}));
//the same logic responsible for retriving nodes as in NodeProvider class (DjangoDesigner).
var nodes = GetNodes(template.Nodes.ToList().ConvertAll
(node => (INode)node)).FindAll(node =>
(node is ICompletionValuesProvider)
|| (node.NodeType == NodeType.ParsingContext)
|| (node.ErrorMessage.Message != ""));
var actualResult = nodes.ConvertAll(
node =>
{
var valueProvider = node as ICompletionValuesProvider;
var values =
valueProvider == null ?
new List<string>()
: valueProvider.Values;
var contextValues = new List<string>(values);
switch (node.NodeType)
{
case NodeType.ParsingContext:
contextValues.InsertRange(0 ,(node.Context.TagClosures));
return new DesignerData(node.Position, node.Length, contextValues.ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message);
case NodeType.Reference:
return new DesignerData(node.Position, node.Length, GetModelValues(node.Context.Model, RecursionDepth).ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message);
default:
return new DesignerData(node.Position, node.Length, new List<string>(values).ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message);
}
});
for (var i = 0; i < actualResult.Count; i++)
{
Assert.AreEqual(ResultForDesigner[i].Length, actualResult[i].Length, "Invalid Length");
Assert.AreEqual(ResultForDesigner[i].Position, actualResult[i].Position, "Invalid Position");
Assert.AreEqual(ResultForDesigner[i].ErrorMessage, actualResult[i].ErrorMessage, "Invalid ErrorMessage");
Assert.AreEqual(ResultForDesigner[i].Severity, actualResult[i].Severity, "Invalid Severity");
Assert.AreEqual(ResultForDesigner[i].Values, actualResult[i].Values, "Invalid Values Array " + i);
}
Assert.AreEqual(ResultForDesigner.Count(), actualResult.Count);
}
public void Update()
{
uint pitemid;
IVsMultiItemSelect ppMIS;
IntPtr ppHier,ppSC;
object directory = "";
if (ErrorHandler.Succeeded(SelectionService.GetCurrentSelection(out ppHier, out pitemid, out ppMIS, out ppSC)))
{
try
{
hierarchy = (IVsHierarchy)Marshal.GetObjectForIUnknown(ppHier);
hierarchy.GetProperty(VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ProjectDir, out directory);
projectDir = directory.ToString();
}
finally
{
Marshal.Release(ppHier);
}
}
if (parser == null)
parser = InitializeParser();
if (templatesDir == null)
{
templatesDir = new TemplateDirectory();
templatesDir.selectionTracker = SelectionService;
}
}
public DjangoView(NDjango.Interfaces.ITemplateManager iTemplateManager, string viewPath)
{
this.iTemplateManager = iTemplateManager;
this.viewPath = viewPath;
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="connection">Соединение с БД</param>
/// <param name="templateManager">Менеджер</param>
public FakeStrategy(IDbConnection connection, ITemplateManager templateManager)
: base(connection, templateManager)
{
}
/// <summary>
/// Create a new readonly view (and copy) of the given configuration.
/// </summary>
/// <param name="config">the configuration to copy.</param>
public ReadOnlyTemplateServiceConfiguration(ITemplateServiceConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
_allowMissingPropertiesOnDynamic = config.AllowMissingPropertiesOnDynamic;
_activator = config.Activator;
if (_activator == null)
{
throw new ArgumentNullException("config", "the configured Activator cannot be null!");
}
_baseTemplateType = config.BaseTemplateType;
// Check if the baseTemplateType is valid.
if (_baseTemplateType != null && (!typeof(ITemplate).IsAssignableFrom(_baseTemplateType) || typeof(ITemplate) == _baseTemplateType))
{
throw new ArgumentOutOfRangeException("config", "the configured BaseTemplateType must implement ITemplate!");
}
_cachingProvider = config.CachingProvider;
if (_cachingProvider == null)
{
throw new ArgumentNullException("config", "the configured CachingProvider cannot be null!");
}
#if !RAZOR4
#pragma warning disable 0618 // Backwards Compat.
_codeInspectors = config.CodeInspectors;
if (_codeInspectors == null)
{
throw new ArgumentNullException("config", "the configured CodeInspectos cannot be null!");
}
_codeInspectors = new List<ICodeInspector>(_codeInspectors);
#pragma warning restore 0618 // Backwards Compat.
#endif
_compilerServiceFactory = config.CompilerServiceFactory;
if (_compilerServiceFactory == null)
{
throw new ArgumentNullException("config", "the configured CompilerServiceFactory cannot be null!");
}
_debug = config.Debug;
_disableTempFileLocking = config.DisableTempFileLocking;
_encodedStringFactory = config.EncodedStringFactory;
if (_encodedStringFactory == null)
{
throw new ArgumentNullException("config", "the configured EncodedStringFactory cannot be null!");
}
_language = config.Language;
_namespaces = config.Namespaces;
if (_namespaces == null)
{
throw new ArgumentNullException("config", "the configured Namespaces cannot be null!");
}
_namespaces = new HashSet<string>(_namespaces);
_referenceResolver = config.ReferenceResolver;
if (_referenceResolver == null)
{
throw new ArgumentNullException("config", "the configured ReferenceResolver cannot be null!");
}
#pragma warning disable 0618 // Backwards Compat.
_resolver = config.Resolver;
_templateManager = config.TemplateManager;
if (_templateManager == null)
{
if (_resolver != null)
{
_templateManager = new Xml.WrapperTemplateManager(_resolver);
}
else
{
throw new ArgumentNullException("config", "the configured TemplateManager and Resolver cannot be null!");
}
}
#pragma warning restore 0618 // Backwards Compat.
}
public void setup()
{
parser = TestHelper.InitializeParser();
}
public NDjangoView(string viewPath, ITemplateManager templateManager)
{
this.viewPath = viewPath;
this.templateManager = templateManager;
}
/// <summary>
/// �����������
/// </summary>
/// <param name="connection">���������� � ��</param>
/// <param name="templateManager">��������</param>
public StrategyBase(IDbConnection connection, ITemplateManager templateManager)
{
TemplateManager = templateManager;
this.connection = connection;
}
public RazorEngineSetup(ITemplateManager templateManager)
{
this.templateManager = templateManager;
}
public NDjangoView(ITemplate template, ITemplateManager templateManager)
{
this.template = template;
this.templateManager = templateManager;
}
