/// <summary> /// Given a declaration return a structure which pulls it apart, including all template /// arguments. It deals correctly with nested templates as well. /// </summary> /// <param name="typeDef"></param> public static IDecl ParseForTemplates(this string typeDef) { if (typeDef == null) throw new ArgumentNullException("typeDef"); /// /// Is the current typeDef a template? /// var m = templateParameterFinder.Match(typeDef); if (!m.Success) { return new RegularDecl(typeDef); } /// /// Now we have to carefully split up arguments. This is painful! We split by ",", but we /// have to be careful of sub template definitions that might contain commas. /// var argStrings = SplitTemplateArguments(m.Groups["types"].Value); var args = (from a in argStrings select ParseForTemplates(a)).ToArray(); /// /// Ok, now create a new template definition from that! /// var t = new TemplateInfo(m.Groups["tclass"].Value, args); return t; }
public Task<JSchema> GetSchemaFromTemplateAsync(TemplateInfo template) { // TODO: use async var type = _modelTypeRepository.GetModelTypeFromTemplate(template); var schemaGenerator = new JSchemaGenerator(); return Task.FromResult(schemaGenerator.Generate(type)); }
/// <summary> /// Returns a unique key that represent the template in the template cache. /// The template key is computed from the following parts: /// Template body hash, /// Global types hash, /// Imported templates hash, /// Referenced assemblies hash /// </summary> /// <param name="ti">Template info</param> /// <returns>Template key</returns> protected static string ComputeTemplateKey(TemplateInfo ti) { // Template body hash string hash = Utils.ComputeHash(ti.TemplateBody); // Global types hash hash += Utils.ComputeHash(ti.GlobalsTypes); // Imported templates hash if (ti.ImportedPrograms != null && ti.ImportedPrograms.Count > 0) { var keys = new List<string>(ti.ImportedPrograms.Keys); keys.Sort(); foreach (string path in keys) { hash += Utils.ComputeHash(ti.ImportedPrograms[path].TemplateBody); } } // Referenced assemblies hash hash += Utils.ComputeHash(ti.ReferencedAssemblies); // Template Key string templateKey = Utils.ComputeHash(hash); return templateKey; }
public HtmlFieldPrefixScope(TemplateInfo templateInfo, string htmlFieldPrefix) { this.templateInfo = templateInfo; previousHtmlFieldPrefix = templateInfo.HtmlFieldPrefix; templateInfo.HtmlFieldPrefix = htmlFieldPrefix; }
public Task UpdateDefaultModelForTemplateAsync(TemplateInfo template, object content) { var filePath = GetPath(template, DefaultFilename); if (!_fileSystem.DirectoryExists(_fileSystem.Path.GetDirectoryName(filePath))) _fileSystem.CreateDirectory(_fileSystem.Path.GetDirectoryName(filePath)); return Update(content, filePath); }
public Type GetModelTypeFromTemplate(TemplateInfo template) { Type type; if (!_repository.TryGetValue(template.Id, out type)) throw new KeyNotFoundException(string.Format("No type for template with id '{0}' found", template.Id)); return type; }
public Task<JSchema> GetSchemaFromTemplateAsync(TemplateInfo template) { var file = _fileSystem.Path.Combine(_viewPathInfo, SchemasPathInfo, _fileSystem.Path.ChangeExtension(PathInfo.Create(template.Id), "json")); if (!_fileSystem.FileExists(file)) return null; return GetSchema(file); }
public Task<JSchema> GetSchemaFromTemplateAsync(TemplateInfo template) { var extractor = new SchemaExtractor(new HandlebarsParser()); var helperHandlers = _helperHandlerFactory != null ? _helperHandlerFactory.Create().ToArray() : null; // TODO: Use async var schema = extractor.Run(template.Id, new StreamReader(template.Open()), _memberLocator, helperHandlers); if (schema != null && string.IsNullOrEmpty(schema.Title)) schema.Title = string.Concat(template.Id, "Model"); return Task.FromResult(schema); }
public string Generate(TemplateInfo templateInfo) { var builder = new StringBuilder(); using (var writer = new StringWriter(builder)) { writer.Write("{0}.register(\"{1}\", {{ render: function(ctx, model) {{ var w = function(v) {{ ctx.write(v); }}; var we = function(v) {{ ctx.writeEscape(v); }};", _templateRepository, templateInfo.Id); var clientContext = new JavascriptClientContext(templateInfo.Id, writer); var model = new JavascriptClientModel(null, "model"); _templateGenerator.Generate(templateInfo, clientContext, model); writer.Write("}});"); } return builder.ToString(); }
public async Task<JSchema> GetSchemaFromTemplateAsync(TemplateInfo template) { var comparer = new SchemaComparer(); var schema1Task = _schemaProvider.GetSchemaFromTemplateAsync(template); var schema2Task = _schemaBaseProvider.GetSchemaFromTemplateAsync(template); if (schema1Task == null) return await schema2Task; if (schema2Task == null) return await schema1Task; await Task.WhenAll(schema1Task, schema2Task).ConfigureAwait(false); return comparer.Apply(schema1Task.Result, schema2Task.Result, new SchemaComparisionReport()); }
public string Render(string fileName, params object[] args) { // Validate the args if (args.Length % 2 != 0) throw new ArgumentException("args must consist of key/value pairs, where the key is a string", "args"); for (int i = 0; i < args.Length; i += 2 ) { if (args[i].GetType() != typeof(string)) throw new ArgumentException("Args array must be string, object, string, object ...., where the strings are the argument names", "args"); } TemplateInfo template = null; // Template exists, invoke it if have not been changed on disk. if (_compiledTemplates.ContainsKey(fileName)) { TemplateInfo ti = _compiledTemplates[fileName]; // Template have changed, let's reload it if (ti.Changed < File.GetLastWriteTime(fileName)) { object templateClass = BuildTemplate(args, fileName); if (templateClass == null) return null; ti.compiledTemplate = templateClass; ti.Changed = DateTime.Now; } template = ti; } else { object templateClass = BuildTemplate(args, fileName); if (templateClass == null) return null; template = new TemplateInfo(); template.compiledTemplate = templateClass; template.fileName = fileName; template.Changed = DateTime.Now; _compiledTemplates.Add(fileName, template); } object o = template.compiledTemplate; return (string)o.GetType().InvokeMember("RunTemplate", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod, null, o, new object[] { args }); }
/// <summary> /// Compiles a Smarty-style template file into HTML output /// </summary> /// <param name="fileName">Path to the Smarty template to compile</param> /// <param name="variables">Key/value collection of template variable names and values</param> /// <returns>A compiled HTML document</returns> public string Render(string fileName, IDictionary<string, object> variables) { TemplateInfo template = null; TemplateInfo ti; lock (compiledTemplates) { if (compiledTemplates.TryGetValue(fileName, out ti)) { if (ti.Changed < File.GetLastWriteTimeUtc(fileName)) { // Template has changed, reload it object templateClass = BuildTemplate(fileName, variables); if (templateClass == null) return null; ti.CompiledTemplate = templateClass; ti.Changed = DateTime.UtcNow; } template = ti; } else { // Template has not been loaded yet, load it object templateClass = BuildTemplate(fileName, variables); if (templateClass == null) return null; template = new TemplateInfo(); template.CompiledTemplate = templateClass; template.FileName = fileName; template.Changed = DateTime.UtcNow; compiledTemplates.Add(fileName, template); } } object o = template.CompiledTemplate; return (string)o.GetType().InvokeMember("RunTemplate", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod, null, o, new object[] { variables }); }
public async Task Should_Create_And_Delete_Template() { // Setup string apiKey = ConfigurationManager.AppSettings["APIKey"]; string templateName = ConfigurationManager.AppSettings["TemplateExample"] + "_temp"; const string code = "Foobar"; // Exercise var api = new MandrillApi(apiKey); TemplateInfo result = await api.AddTemplate(new AddTemplateRequest(templateName) { FromName = "*****@*****.**", Code = code, Text = code, Publish = true }); TemplateInfo result2 = await api.DeleteTemplate(new DeleteTemplateRequest(templateName)); // Verify Assert.AreEqual(code, result.Code); Assert.AreEqual(code, result2.Code); }
public PageInfo(int pageNodeId, int pageContentId, PublishmentSystemInfo publishmentSystemInfo, TemplateInfo templateInfo, UserInfo userInfo) { TemplateInfo = templateInfo; PublishmentSystemId = publishmentSystemInfo.PublishmentSystemId; PageNodeId = pageNodeId; PageContentId = pageContentId; _pageAfterBodyScripts = new SortedDictionary <string, string>(); _pageBeforeBodyScripts = new SortedDictionary <string, string>(); _pageEndScripts = new SortedDictionary <string, string>(); _pageHeadScripts = new SortedDictionary <string, string>(); PublishmentSystemInfo = publishmentSystemInfo; UserInfo = userInfo; _uniqueId = 1; ChannelItems = new Stack(5); ContentItems = new Stack(5); CommentItems = new Stack(5); InputItems = new Stack(5); SqlItems = new Stack(5); SiteItems = new Stack(5); PhotoItems = new Stack(5); EachItems = new Stack(5); }
protected virtual TemplateInfo ParseTemplate(IItemData templateItem) { if (templateItem == null) { throw new ArgumentException("Template item passed to parse was null", nameof(templateItem)); } if (templateItem.TemplateId != TemplateTemplateId) { throw new ArgumentException("Template item passed to parse was not a Template item", nameof(templateItem)); } var result = new TemplateInfo { Id = templateItem.Id, BaseTemplateIds = ParseBaseTemplatesAndRejectIgnoredBaseTemplates(GetFieldValue(templateItem, BaseTemplateFieldId, string.Empty)), HelpText = GetFieldValue(templateItem, HelpTextFieldId, string.Empty), Name = templateItem.Name, OwnFields = ParseTemplateFields(templateItem), Path = templateItem.Path }; return(result); }
public PageInfo(int pageChannelId, int pageContentId, SiteInfo siteInfo, TemplateInfo templateInfo, Dictionary <string, object> pluginItems) { TemplateInfo = templateInfo; SiteId = siteInfo.Id; PageChannelId = pageChannelId; PageContentId = pageContentId; IsLocal = false; HeadCodes = new SortedDictionary <string, string>(); BodyCodes = new SortedDictionary <string, string>(); FootCodes = new SortedDictionary <string, string>(); SiteInfo = siteInfo; UserInfo = null; _uniqueId = 1; ApiUrl = ApiManager.OuterApiUrl; ChannelItems = new Stack <ChannelItemInfo>(5); ContentItems = new Stack <ContentItemInfo>(5); SqlItems = new Stack(5); SiteItems = new Stack(5); EachItems = new Stack(5); PluginItems = pluginItems; }
private void CreateScript(TemplateInfo info) { string className = Path.GetFileNameWithoutExtension(info.replacements["ClassName"]); string template = info.wholeTemplate; string ext = info.specialKeys["EXTENSION"]; foreach (KeyValuePair <string, string> pairs in info.replacements) { template = template.Replace("##" + pairs.Key + "##", pairs.Value); } string finalPath = Path.Combine(_createPath, className + ext.ToLower()); if (File.Exists(finalPath)) { Debug.LogError("File already exists: " + finalPath); } else { File.WriteAllText(finalPath, template, System.Text.Encoding.UTF8); AssetDatabase.Refresh(); } }
public ShaderTemplateSelector(SerializedProperty prop) { this.prop = prop; var paths = Utils.GetShaderTemplatePathList(); foreach (var path in paths) { if (Path.GetExtension(path) == Common.Setting.templateFileExtension) { var index = path.IndexOf(Common.Setting.templateDirectoryPath); var name = path .Substring(index + Common.Setting.templateDirectoryPath.Length + 1) .Replace(Common.Setting.templateFileExtension, ""); var info = new TemplateInfo() { name = name, path = path, }; list_.Add(info); } } }
private static void NormalizeArgs(ProjectBuildArgs args, TemplateInfo templateInfo) { if (args.TemplateName.IsNullOrEmpty()) { args.TemplateName = templateInfo.Name; } if (args.DatabaseProvider == DatabaseProvider.NotSpecified) { if (templateInfo.DefaultDatabaseProvider != DatabaseProvider.NotSpecified) { args.DatabaseProvider = templateInfo.DefaultDatabaseProvider; } } if (args.UiFramework == UiFramework.NotSpecified) { if (templateInfo.DefaultUiFramework != UiFramework.NotSpecified) { args.UiFramework = templateInfo.DefaultUiFramework; } } }
public void AddItem(UserSelection userSelection, TemplateInfo template, Func <TemplateInfo, string> getName) { if (template.MultipleInstance || !AlreadyAdded(userSelection, template)) { var itemName = getName(template); var usedNames = userSelection.Pages.Select(p => p.Name) .Concat(userSelection.Features.Select(f => f.Name)) .Concat(userSelection.Services.Select(f => f.Name)) .Concat(userSelection.Testing.Select(f => f.Name)); if (template.ItemNameEditable) { var itemBameValidationService = new ItemNameService(GenContext.ToolBox.Repo.ItemNameValidationConfig, () => usedNames); itemName = itemBameValidationService.Infer(itemName); } else { itemName = template.DefaultName; } AddItem(userSelection, itemName, template); } }
public IActionResult Update([FromBody] TemplateModel model) { TemplateInfo template = null; if (model.Id > 0) { template = _viewManager.GetPageTemplate(model.Id); } if (template == null) { template = new TemplateInfo(); } template.Name = model.Name; template.KeyName = model.KeyName; template.ModelClass = model.ModelClass; template.ViewPath = model.ViewPath.Replace("..", String.Empty); _viewManager.SavePageTemplate(template); return(Ok(new { template.TemplateId })); }
public void AddItem(UserSelection userSelection, TemplateInfo template, Func <TemplateInfo, string> getName) { if (template.MultipleInstance || !AlreadyAdded(userSelection, template)) { var itemName = getName(template); var usedNames = userSelection.Pages.Select(p => p.Name) .Concat(userSelection.Features.Select(f => f.Name)) .Concat(userSelection.Services.Select(f => f.Name)) .Concat(userSelection.Testing.Select(f => f.Name)); var validators = new List <Validator>() { new ExistingNamesValidator(usedNames), new ReservedNamesValidator(), }; if (template.ItemNameEditable) { validators.Add(new DefaultNamesValidator()); } itemName = Naming.Infer(itemName, validators); AddItem(userSelection, itemName, template); } }
public PageInfo(int pageChannelId, int pageContentId, SiteInfo siteInfo, TemplateInfo templateInfo) { TemplateInfo = templateInfo; SiteId = siteInfo.Id; PageChannelId = pageChannelId; PageContentId = pageContentId; IsLocal = false; _pageAfterBodyScripts = new SortedDictionary <string, string>(); _pageBeforeBodyScripts = new SortedDictionary <string, string>(); _pageEndScripts = new SortedDictionary <string, string>(); _pageHeadScripts = new SortedDictionary <string, string>(); SiteInfo = siteInfo; UserInfo = null; _uniqueId = 1; ApiUrl = PageUtility.OuterApiUrl; ChannelItems = new Stack <ChannelItemInfo>(5); ContentItems = new Stack <ContentItemInfo>(5); CommentItems = new Stack(5); SqlItems = new Stack(5); SiteItems = new Stack(5); EachItems = new Stack(5); }
protected void btnRender_Click(object sender, EventArgs e) { try { TemplateInfo _templateInfo = new TemplateInfo(); _templateInfo.TemplateID = new Guid(grdTemplate.SelectedRow.Cells[1].Text); RenderRequestInfo renderRequestInfo = new RenderRequestInfo(); renderRequestInfo.ComputerName = txtComputerName.Text; renderRequestInfo.CreatedBy = txtCreatedBy.Text; renderRequestInfo.PriorityID = PriorityId.Medium; renderRequestInfo.TemplateID = new Guid(_templateInfo.TemplateID.ToString()); renderRequestInfo.RequestTypeID = (int)(RenderMode)Enum.Parse(typeof(RenderMode), cboRenderMode.SelectedItem.Value); List <object> ParamValues = new List <object>() { int.Parse(txtParam1.Text) }; PackageData result = sxService.APIRenderRequest.AddToRenderRequestQ(renderRequestInfo, ParamValues); if (result.Status == SXStatus.Success) { lblMessage.Text = "The output is store in reposity folder at file: " + ((string)result.Data); } else { foreach (var code in result.ErrorCodes) { lblMessage.Text += " | " + code.ToString(); } } } catch (Exception ex) { lblMessage.Text = ex.Message; } }
public override void OnInitTemplateInfo(EventArgs e) { string str = BasePage.RequestString("updatetime"); DateTime?nullable = null; if (!string.IsNullOrEmpty(str)) { nullable = new DateTime?(DataConverter.CDate(str)); } string dynamicConfigTemplatePath = TemplatePage.GetDynamicConfigTemplatePath(Path.GetFileNameWithoutExtension(this.Page.Request.FilePath)); NameValueCollection values = new NameValueCollection(); values.Add("authorname", DataSecurity.FilterBadChar(BasePage.RequestString("authorname"))); if (!nullable.HasValue) { values.Add("updatetime", string.Empty); } else { values.Add("updatetime", nullable.Value.ToString("yyyy-MM-dd")); } if (!string.IsNullOrEmpty(dynamicConfigTemplatePath)) { TemplateInfo info = new TemplateInfo(); info.QueryList = values; info.PageName = TemplatePage.RebuildPageName(base.Request.Url.LocalPath, base.Request.QueryString); info.TemplateContent = Template.GetTemplateContent(dynamicConfigTemplatePath); info.RootPath = HttpContext.Current.Request.PhysicalApplicationPath; info.CurrentPage = DataConverter.CLng(base.Request.QueryString["page"], 1); info.PageType = 1; base.TemplateInfo = info; } else { TemplatePage.WriteErrMsg("您查看的作者未设置模板!", SiteConfig.SiteInfo.VirtualPath + "Default.aspx"); } }
private void codeActivity2_ExecuteCode(object sender, EventArgs e) { AddNewTreeRefresher addNewTreeRefresher = this.CreateAddNewTreeRefresher(this.EntityToken); IXmlPageTemplate newPageTemplate = this.GetBinding <IXmlPageTemplate>("NewPageTemplate"); string newPageTemplateMarkup = null; Guid copyOfId = this.GetBinding <Guid>("CopyOfId"); if (copyOfId == Guid.Empty) { newPageTemplateMarkup = _defaultTemplateMarkup.Replace(" ", "\t"); } else { XDocument copyDocument = TemplateInfo.GetTemplateDocument(copyOfId); newPageTemplateMarkup = copyDocument.ToString(); } IPageTemplateFile pageTemplateFile = DataFacade.BuildNew <IPageTemplateFile>(); pageTemplateFile.FolderPath = "/"; pageTemplateFile.FileName = string.Format("{0}.xml", PathUtil.CleanFileName(newPageTemplate.Title, true) ?? newPageTemplate.Id.ToString()); //if (FileNameAlreadyUsed(pageTemplateFile)) pageTemplateFile.FileName = newPageTemplate.Id.ToString() + pageTemplateFile.FileName; pageTemplateFile.SetNewContent(newPageTemplateMarkup); DataFacade.AddNew <IPageTemplateFile>(pageTemplateFile, "PageTemplateFileProvider"); newPageTemplate.PageTemplateFilePath = "/" + pageTemplateFile.FileName; newPageTemplate = DataFacade.AddNew <IXmlPageTemplate>(newPageTemplate); PageTemplateProviderRegistry.FlushTemplates(); addNewTreeRefresher.PostRefreshMesseges(newPageTemplate.GetDataEntityToken()); this.ExecuteAction(newPageTemplate.GetDataEntityToken(), new WorkflowActionToken(typeof(EditXmlPageTemplateWorkflow))); }
internal static string ObjectTemplate(HtmlHelper html, TemplateHelpers.TemplateHelperDelegate templateHelper) { ViewDataDictionary viewData = html.ViewContext.ViewData; TemplateInfo templateInfo = viewData.TemplateInfo; ModelMetadata modelMetadata = viewData.ModelMetadata; StringBuilder builder = new StringBuilder(); if (templateInfo.TemplateDepth > 1) // DDB #224751 { return(modelMetadata.Model == null ? modelMetadata.NullDisplayText : modelMetadata.SimpleDisplayText); } foreach (ModelMetadata propertyMetadata in modelMetadata.Properties.Where(pm => ShouldShow(pm, templateInfo))) { if (!propertyMetadata.HideSurroundingHtml) { string label = LabelExtensions.LabelHelper(html, propertyMetadata, propertyMetadata.PropertyName).ToHtmlString(); if (!String.IsNullOrEmpty(label)) { builder.AppendFormat(CultureInfo.InvariantCulture, "<div class=\"editor-label\">{0}</div>\r\n", label); } builder.Append("<div class=\"editor-field\">"); } builder.Append(templateHelper(html, propertyMetadata, propertyMetadata.PropertyName, null /* templateName */, DataBoundControlMode.Edit, null /* additionalViewData */)); if (!propertyMetadata.HideSurroundingHtml) { builder.Append(" "); builder.Append(html.ValidationMessage(propertyMetadata.PropertyName)); builder.Append("</div>\r\n"); } } return(builder.ToString()); }
private void encryptBtn_Click(object sender, EventArgs e) { var checkEncryptionStatus = SafeFileApiNativeMethods.IpcfIsFileEncrypted(filepathBox.Text.Trim()); if (checkEncryptionStatus.ToString().ToLower().Contains("encrypted")) { DialogResult isEncrypted = MessageBox.Show("Selected file is already encrypted"); if (isEncrypted == DialogResult.OK) { Application.Exit(); } } else { try { int templateNum = templateListBox.SelectedIndex; //MessageBox.Show(templateNum.ToString()); TemplateInfo selectedTemplateInfo = templates.ElementAt(templateNum); var license = SafeNativeMethods.IpcCreateLicenseFromTemplateId(selectedTemplateInfo.TemplateId); string encryptedFilePath = SafeFileApiNativeMethods.IpcfEncryptFile(filepathBox.Text.Trim(), license, SafeFileApiNativeMethods.EncryptFlags.IPCF_EF_FLAG_DEFAULT, false, false, true, IntPtr.Zero, null); DialogResult result = MessageBox.Show("File has been Encrypted and is at the following location: " + encryptedFilePath); if (result == DialogResult.OK) { Application.Exit(); } } catch (Exception ex) { DialogResult error = MessageBox.Show("Error: " + ex); if (error == DialogResult.OK) { Application.Exit(); } } } }
/// <summary> /// 获得指定的模板信息 /// </summary> /// <param name="templateid">皮肤id</param> /// <returns></returns> public static TemplateInfo GetTemplateItem(int templateid) { if (templateid <= 0) { return(null); } TemplateInfo templateinfo = null; DataRow[] dr = GetValidTemplateList().Select("templateid = " + templateid.ToString()); if (dr.Length > 0) { templateinfo = new TemplateInfo(); templateinfo.Templateid = Int16.Parse(dr[0]["templateid"].ToString()); templateinfo.Name = dr[0]["name"].ToString(); templateinfo.Directory = dr[0]["directory"].ToString(); templateinfo.Copyright = dr[0]["copyright"].ToString(); templateinfo.Templateurl = dr[0]["templateurl"].ToString(); } if (templateinfo == null) { dr = GetValidTemplateList().Select("templateid = 1"); if (dr.Length > 0) { templateinfo = new TemplateInfo(); templateinfo.Templateid = Int16.Parse(dr[0]["templateid"].ToString()); templateinfo.Name = dr[0]["name"].ToString(); templateinfo.Directory = dr[0]["directory"].ToString(); templateinfo.Copyright = dr[0]["copyright"].ToString(); templateinfo.Templateurl = dr[0]["templateurl"].ToString(); } } return(templateinfo); }
private void cmbTemplateGroup_SelectedIndexChanged(object sender, EventArgs e) { if (cmbTemplateGroup.SelectedIndex < 0) { return; } cmbTemplate.Items.Clear(); TemplateInfo template = cmbTemplateGroup.SelectedItem as TemplateInfo; if (template != null) { Collection <ModuleInfo> modules = ConfigCtrl.GetModules(template.FullPath); foreach (ModuleInfo item in modules) { cmbTemplate.Items.Add(item); } if (cmbTemplate.Items.Count > 0) { cmbTemplate.SelectedIndex = 0; } } }
public void TestLocalizedPostActionFields( int postActionIndex, string locale, string expectedDescription, string expectedManualInstructions) { _ = LoadHostWithLocalizationTemplates(out SettingsLoader settingsLoader); IReadOnlyList <TemplateInfo> localizedTemplates = settingsLoader.UserTemplateCache.GetTemplatesForLocale(locale, SettingsStore.CurrentVersion); Assert.True(localizedTemplates.Count != 0, "Test template couldn't be loaded."); TemplateInfo localizationTemplate = localizedTemplates.FirstOrDefault(t => t.Identity == "TestAssets.TemplateWithLocalization"); Assert.NotNull(localizationTemplate); ITemplate template = settingsLoader.LoadTemplate(localizationTemplate, null); Assert.NotNull(template); Assert.NotNull(template.Generator); ICreationEffects effects = template.Generator.GetCreationEffects( settingsLoader.EnvironmentSettings, template, new MockParameterSet(), settingsLoader.Components, Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()) ); Assert.NotNull(effects); Assert.NotNull(effects.CreationResult); Assert.NotNull(effects.CreationResult.PostActions); Assert.True(effects.CreationResult.PostActions.Count > postActionIndex, "Template does not contain enough post actions"); Assert.Equal(expectedDescription, effects.CreationResult.PostActions[postActionIndex].Description); Assert.Equal(expectedManualInstructions, effects.CreationResult.PostActions[postActionIndex].ManualInstructions); }
/// <summary> /// Occurs before any open document is saved. (Inherited from ApplicationEvents4_Event.) /// </summary> /// <param name="Doc"></param> /// <param name="SaveAsUI"></param> /// <param name="Cancel"></param> private void ThisDocument_DocumentBeforeSave(Word.Document Doc, ref bool SaveAsUI, ref bool Cancel) { try { if (Doc != Application.ActiveDocument) { return; } } catch { return; } TemplateInfo template = this.TemplateInfo; if (template.IsProntoDoc) { try { ContextManager contexMgr = new ContextManager(); contexMgr.SaveDocument(Doc, ref SaveAsUI, ref Cancel); } catch (BaseException baseExp) { ManagerException mgrExp = new ManagerException(ErrorCode.ipe_SaveDocumentError); mgrExp.Errors.Add(baseExp); throw mgrExp; } catch (Exception ex) { ManagerException mgrExp = new ManagerException(ErrorCode.ipe_SaveDocumentError, MessageUtils.Expand(Properties.Resources.ipe_SaveDocumentError, ex.Message), ex.StackTrace); throw mgrExp; } } }
/// <summary> /// 模板消息 /// </summary> /// <param name="openid"></param> public void SendTemplateMessage(string openid) { TemplateInfo temp = new TemplateInfo(); temp.template_id = "jp5-DHV2SfxMYNHpf9pRWlrKe8eHtv_j1nJOBiEKR8k"; temp.touser = openid; temp.url = "http://ljx.pqpqpq.cn"; temp.topcolor = "#FF0000"; Param p = new Param(); p.value = "黄先生"; p.color = "#173177"; p.value = DateTime.Now.ToString(); p.color = "#173177"; p.value = "0426"; p.color = "#173177"; p.value = "消费"; p.color = "#173177"; p.value = "人民币260.00元"; p.color = "#173177"; p.value = "06月07日19时24分"; p.color = "#173177"; p.value = "06月07日19时24分"; p.color = "#173177"; string data = JsonConvert.SerializeObject(temp); var json = RequestType.HttpPost("https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=" + getAccessToken(), data); }
/// <summary>Gets the template from this page's settings. If no template is set, sets a default.</summary> /// <returns>The template from this page's settings, or <c>null</c> if no valid template is available</returns> private TemplateInfo GetTemplateSetting() { TemplateInfo template = null; string templateFolderName = ModuleSettings.TemplateFolderName.GetValueAsStringFor(this); if (!string.IsNullOrEmpty(templateFolderName)) { template = this.GetTemplate(templateFolderName); } if (template == null) { template = this.GetDefaultTemplate(); if (template == null) { // if there are no templates, return null and cause the templating framework to throw an ArgumentNullException... return(null); } this.SetTemplateSetting(template.FolderName); } return(template); }
public async Task <ActionResult <GetResult> > Get([FromQuery] GetRequest request) { if (!await _authManager.HasAppPermissionsAsync(LoginManager.PermissionsTemplates)) { return(Unauthorized()); } var templateInfo = _loginManager.GetTemplateInfo(request.Name); var html = _loginManager.GetTemplateHtml(templateInfo); var isSystem = templateInfo.Publisher == "sscms"; if (isSystem) { templateInfo = new TemplateInfo(); } return(new GetResult { TemplateInfo = templateInfo, TemplateHtml = html, IsSystem = isSystem }); }
public static TemplateInfo GetDefaultTemplateInfo(int siteId, TemplateType templateType) { TemplateInfo info = null; var templateInfoDictionary = GetTemplateInfoDictionaryBySiteId(siteId); if (templateInfoDictionary != null) { foreach (var templateInfo in templateInfoDictionary.Values) { if (templateInfo.TemplateType == templateType && templateInfo.IsDefault) { info = templateInfo; break; } } } return(info ?? new TemplateInfo { SiteId = siteId, TemplateType = templateType }); }
public static ASObject GetCodePreview(string location, string serviceName, string methodName) { ManagementService managementService = new ManagementService(); Project project = managementService.GetProject(); string templateFolder = Path.Combine("templates", location); templateFolder = HttpContext.Current.Server.MapPath(templateFolder); TemplateInfo templateInfo = new TemplateInfo(string.Empty, templateFolder); Hashtable context = new Hashtable(); context["Project"] = project; context["Service"] = serviceName; context["Method"] = methodName; string preview; try { // See if we're running in full trust new SecurityPermission(PermissionState.Unrestricted).Demand(); WebTemplateGeneratorHost host = new WebTemplateGeneratorHost(context); TemplateEngineProxy proxy = new TemplateEngineProxy(); preview = proxy.Preview(templateInfo, host, TemplateEngineSettings.Default); } catch (SecurityException) { preview = "Security error. Code generation is not available in Medium Trust environment."; } ASObject asoCodePreview = new ASObject(); asoCodePreview["code"] = preview; return(asoCodePreview); }
public void CreateNodesHtml(NodeInfo nodeInfo) { TemplateInfo templateInfo = new TemplateInfo(); NameValueCollection values = new NameValueCollection(); values.Add("id", nodeInfo.NodeId.ToString()); values.Add("page", "1"); templateInfo.QueryList = values; templateInfo.RootPath = this.PhysicalApplicationPath; templateInfo.SiteUrl = this.SiteUrl; templateInfo.IsDynamicPage = false; templateInfo.PageType = 1; this.CreateNodeDefalutPageHtml(nodeInfo, templateInfo); templateInfo = new TemplateInfo(); values = new NameValueCollection(); values.Add("id", nodeInfo.NodeId.ToString()); values.Add("page", "1"); templateInfo.QueryList = values; templateInfo.RootPath = this.PhysicalApplicationPath; templateInfo.SiteUrl = this.SiteUrl; templateInfo.IsDynamicPage = false; templateInfo.PageType = 1; this.CreateNodeListPageHtml(nodeInfo, templateInfo); }
protected void BtnGoogle_Click(object sender, EventArgs e) { TemplateInfo templateInfo = new TemplateInfo(); templateInfo.QueryList = base.Request.QueryString; string path = "/其他模板/Google地图模板.html"; templateInfo.PageName = "GoogleSiteMap_Index.xml"; templateInfo.IsDynamicPage = false; templateInfo.CurrentPage = DataConverter.CLng(base.Request.QueryString["page"], 1); templateInfo.RootPath = base.Request.PhysicalApplicationPath; templateInfo.SiteUrl = SiteConfig.SiteInfo.SiteUrl; templateInfo.TemplateContent = Template.GetTemplateContent(path); TemplateTransform.GetHtml(templateInfo); FileSystemObject.WriteFile(VirtualPathUtility.AppendTrailingSlash(base.Request.PhysicalApplicationPath) + SiteConfig.SiteOption.CreateHtmlPath + templateInfo.PageName, TemplateTransform.GetHtml(templateInfo).TemplateContent); if (templateInfo.PageNum > 1) { int pageNum = templateInfo.PageNum; for (int i = 2; i < pageNum; i++) { templateInfo.QueryList = base.Request.QueryString; path = "/其他模板/Google地图模板.html"; templateInfo.PageName = "GoogleSiteMap_Index_" + i.ToString() + ".xml"; templateInfo.IsDynamicPage = false; templateInfo.CurrentPage = i; templateInfo.RootPath = base.Request.PhysicalApplicationPath; templateInfo.SiteUrl = SiteConfig.SiteInfo.SiteUrl; templateInfo.TemplateContent = Template.GetTemplateContent(path); TemplateTransform.GetHtml(templateInfo); FileSystemObject.WriteFile(VirtualPathUtility.AppendTrailingSlash(base.Request.PhysicalApplicationPath) + SiteConfig.SiteOption.CreateHtmlPath + templateInfo.PageName, TemplateTransform.GetHtml(templateInfo).TemplateContent); } } this.HypGoogleMap.Visible = true; this.HypGoogleMap.Text = "生成成功,点击提交地图!"; this.HypGoogleMap.NavigateUrl = "http://www.google.com/webmasters/sitemaps/ping?sitemap=" + templateInfo.SiteUrl + "/" + templateInfo.PageName; }
public static List <TemplateInfo> GetTemplateInfoList(SiteInfo siteInfo, int specialId) { var list = new List <TemplateInfo>(); var specialInfo = GetSpecialInfo(siteInfo.Id, specialId); if (specialInfo != null) { var directoryPath = GetSpecialDirectoryPath(siteInfo, specialInfo.Url); var srcDirectoryPath = GetSpecialSrcDirectoryPath(directoryPath); var htmlFilePaths = Directory.GetFiles(srcDirectoryPath, "*.html", SearchOption.AllDirectories); foreach (var htmlFilePath in htmlFilePaths) { var relatedPath = PathUtils.GetPathDifference(srcDirectoryPath, htmlFilePath); var templateInfo = new TemplateInfo { Charset = ECharset.utf_8, Content = GetContentByFilePath(htmlFilePath), CreatedFileExtName = ".html", CreatedFileFullName = PathUtils.Combine(specialInfo.Url, relatedPath), Id = 0, IsDefault = false, RelatedFileName = string.Empty, SiteId = siteInfo.Id, TemplateType = TemplateType.FileTemplate, TemplateName = relatedPath }; list.Add(templateInfo); } } return(list); }
private static bool ShouldShow(ModelMetadata metadata, TemplateInfo templateInfo) { return metadata.ShowForDisplay && metadata.ModelType != typeof(EntityState) && !metadata.IsComplexType && !templateInfo.Visited(metadata); }
private static bool ShouldShow(ModelExplorer modelExplorer, TemplateInfo templateInfo) { return modelExplorer.Metadata.ShowForDisplay && !modelExplorer.Metadata.IsComplexType && !templateInfo.Visited(modelExplorer); }
private void Replace(TemplateInfo template, List<StringManager> environment) { var newPrefix = new StringManager(string.Empty); foreach (TemplateItemInfo temp in template) { if (temp.IsBase) { newPrefix.AppendToBack(new StringManager(new string(temp.Symbol, 1)), 0); continue; } if (temp.IsProtect) { if (temp.Reference >= environment.Count) continue; newPrefix.AppendToBack(Protect(temp.Level, environment[temp.Reference]), 0); continue; } if (temp.IsAsNat) { if (temp.Reference >= environment.Count) { newPrefix.AppendToBack(new StringManager(AsNat(0)), 0); continue; } newPrefix.AppendToBack(new StringManager(AsNat(environment[temp.Reference].Length)), 0); continue; } } newPrefix.AppendToBack(_runningDna, _currentIndex); _runningDna = newPrefix; _currentIndex = 0; }
private void MatchReplace(PatternInfo pattern, TemplateInfo template) { long index = _currentIndex; var environment = new List<StringManager>(); var counters = new List<int>(); foreach (PatternItemInfo pat in pattern) { if (pat.IsBase) { if (index >= _runningDna.Length) return; if (_runningDna.HasPatternAtPosition( new[] { new string(pat.Symbol, 1) }, (int) index)) ++index; else return; continue; } if (pat.IsSkip) { index += pat.SkipCount; if (index >= _runningDna.Length) return; continue; } if (pat.IsSearch) { int patterIndex = _runningDna.IndexOf(pat.SearchPattern, (int) index); if (patterIndex != -1) index = patterIndex + pat.SearchPattern.Length; else return; continue; } if (pat.IsLevelUp) { counters.Insert(0, (int) index); continue; } if (pat.IsLevelDown) { environment.Add(_runningDna.Substring(counters[0], (int) index - counters[0])); counters.RemoveAt(0); continue; } } _currentIndex = (int) index; Replace(template, environment); }
private TemplateInfo DecodeTemplate() { var template = new TemplateInfo(); bool flag = true; while (flag) { if (_currentIndex >= _runningDna.Length) { lock (_runningMutex) { _state = RunningState.Stoped; return null; } } if (_runningDna.HasPatternAtPosition( new[] { "C" }, _currentIndex)) { ++_currentIndex; template.AppendBack('I'); continue; } if (_runningDna.HasPatternAtPosition( new[] { "F" }, _currentIndex)) { ++_currentIndex; template.AppendBack('C'); continue; } if (_runningDna.HasPatternAtPosition( new[] { "P" }, _currentIndex)) { ++_currentIndex; template.AppendBack('F'); continue; } if (_runningDna.HasPatternAtPosition( new[] { "IC" }, _currentIndex)) { _currentIndex += 2; template.AppendBack('P'); continue; } if (_runningDna.HasPatternAtPosition( new[] { "IF", "IP" }, _currentIndex)) { _currentIndex += 2; int level = DecodeNumber(); int reference = DecodeNumber(); template.AddReference(reference, level); continue; } if (_runningDna.HasPatternAtPosition( new[] { "IIC", "IIF" }, _currentIndex)) { _currentIndex += 3; flag = false; continue; } if (_runningDna.HasPatternAtPosition( new[] { "IIP" }, _currentIndex)) { _currentIndex += 3; int reference = DecodeNumber(); template.AddLengthOfReference(reference); continue; } if (_runningDna.HasPatternAtPosition( new[] { "III" }, _currentIndex)) { string toRna = _runningDna.Substring(_currentIndex + 3, 7).ToString(); OutputToRna(toRna); _currentIndex += 10; continue; } // Else stop. lock (_runningMutex) { _state = RunningState.Stoped; return null; } } return template; }
void CompileImportedTemplates(TemplateInfo ti, Program program) { foreach (string importCmd in program.ImportMacroCommands) { // Parse import command string programNamespace = importCmd.Split(new[] { ':' }, 2)[0]; string templatePath = importCmd.Split(new[] { ':' }, 2)[1]; Program importedProgram; ti.ImportedPrograms.TryGetValue(templatePath, out importedProgram); // Compile template program from template body if (importedProgram == null) { // TODO: Implement the template loader (see TODO.txt) - load from filesystem by default string templateBody = File.ReadAllText(templatePath); importedProgram = GetTemplateProgram(templateBody, templatePath); ti.ImportedPrograms.Add(templatePath, importedProgram); } // Compile imports of imported template CompileImportedTemplates(ti, importedProgram); // Save info about Imported program by namespace and path if (!ti.ImportedNamespaces.ContainsKey(programNamespace)) ti.ImportedNamespaces.Add(programNamespace, new HashSet<string> { templatePath }); else if (!ti.ImportedNamespaces[programNamespace].Contains(templatePath)) ti.ImportedNamespaces[programNamespace].Add(templatePath); } }
private TemplateInfo Initialize(TemplateInfo info) { byte[] barrTypeData = null; byte[] barrType = null; XDocument xdHeaderXml = null; byte[] barrSceneDll = null; try { if (info.TemplateDetails != null && info.TemplateDetails.Keys.Count > 0) { foreach (string skey in info.TemplateDetails.Keys) { switch (skey) { case CCommonConstants.FDDLL: barrType = info.TemplateDetails[skey].Data; break; case CCommonConstants.CDLL: barrTypeData = info.TemplateDetails[skey].Data; break; case CCommonConstants.XML: byte[] barrData = info.TemplateDetails[skey].Data; string sData = WaspEncoder.GetStringfromByte(barrData); xdHeaderXml = XDocument.Parse(sData); break; case CCommonConstants.SCENEDLL: barrSceneDll = info.TemplateDetails[skey].Data; break; case CCommonConstants.SGXML: byte[] barrSGXml = info.TemplateDetails[skey].Data; string sSGXml = WaspEncoder.GetStringfromByte(barrSGXml); info.SgXml = sSGXml; break; case CCommonConstants.METADATAXML: byte[] barrMetadataxml = info.TemplateDetails[skey].Data; string sMetadataxml = WaspEncoder.GetStringfromByte(barrMetadataxml); info.MetaDataXml = sMetadataxml; break; default: break; } } if (xdHeaderXml != null) { //checks whether given template is of unified type from header xml. info.IsUnifiedForm = Unified(xdHeaderXml); if (barrTypeData != null) { info.TemplatePlayerInfo = GetTypeFromAttachment(xdHeaderXml, barrTypeData, CCommonConstants.CDLL); } if (barrType != null) { info.TemplateDataInfo = GetTypeFromAttachment(xdHeaderXml, barrType, CCommonConstants.FDDLL); } } if (string.Compare(info.Type, "tickersg", StringComparison.OrdinalIgnoreCase) == 0) { info.IsTicker = true; } else { info.IsTicker = false; } m_objTempDtls = info; } } catch (Exception ex) { LogWriter.WriteLog(ex); WriteTrace(ex.ToString()); } return(m_objTempDtls); }
public static TemplateInfo GetBasicSettings(string TemplateName) { TemplateInfo objTemp = new TemplateInfo(); string filePath = Decide.IsTemplateDefault(TemplateName.Trim()) ? Utils.GetTemplateInfoFilePath_Default(TemplateName) : Utils.GetTemplateInfoFilePath(TemplateName); if (File.Exists(filePath)) { XmlDocument doc = new XmlDocument(); doc.Load(filePath); XmlNode root = doc.DocumentElement; objTemp.TemplateName = root.SelectSingleNode("name").ChildNodes[0].Value; objTemp.Author = root.SelectSingleNode("author").ChildNodes[0].Value; objTemp.Description = root.SelectSingleNode("description").ChildNodes[0].Value; objTemp.Website = root.SelectSingleNode("website").ChildNodes[0].Value; return objTemp; } else { return objTemp = TemplateHelper.CreateEmptyTemplateObject(); } }
// Add a template to a map. If the format is 7 or earlier, which only support one template, replace templates. Otherwise, // add at the end. void AddTemplateToMap(Map map, TemplateInfo template) { if (creationSettings.fileFormat.kind == MapFileFormatKind.OCAD && creationSettings.fileFormat.version <= 7) { map.Templates = new TemplateInfo[] { template }; } else { List<TemplateInfo> templates = new List<TemplateInfo>(); templates.AddRange(map.Templates); templates.Add(template); map.Templates = templates; } }
private PathInfo GetPath(TemplateInfo templateInfo, PathInfo id) { return _fileSystem.Path.Combine(PathInfo.Create(templateInfo.Id), FolderPath, _fileSystem.Path.ChangeExtension(id, ".json")); }
public Task<object> GetModelForTemplateAsync(TemplateInfo template, string dataId) { var filePath = GetPath(template, PathInfo.Create(dataId)); return GetModelFromPathAsync(filePath); }
public Task<object> GetDefaultModelForTemplateAsync(TemplateInfo template) { var filePath = GetPath(template, DefaultFilename); return GetModelFromPathAsync(filePath); }
private static LogixTag CreateStructTag(string Address, LogixProcessor Processor, ushort Elements, TemplateInfo Template) { if (Template.TemplateName == "COUNTER") { return new LogixCOUNTER(Address, Template, Processor, Elements); } else if (Template.TemplateName == "CONTROL") { return new LogixCONTROL(Address, Template, Processor, Elements); } else if (Template.TemplateName == "TIMER") { return new LogixTIMER(Address, Template, Processor, Elements); } else if (Template.TemplateName == "ASCIISTRING82") { return new LogixSTRING(Address, Template, Processor, Elements); } else { //Return as a UDT... return new LogixUDT(Address, Template, Processor, Elements); } }
public List<TemplateInfo> GetTemplateList() { DirectoryInfo dir = new DirectoryInfo(Server.MapPath("~/Templates")); List<TemplateInfo> lstTemplates = new List<TemplateInfo>(); foreach (DirectoryInfo temp in dir.GetDirectories()) { TemplateInfo tempObj = new TemplateInfo(temp.Name, temp.FullName, GetThumbPath(temp.FullName, temp.Name), false, false); lstTemplates.Add(tempObj); } lstTemplates.Insert(0, new TemplateInfo("Default", "/Core/Template/", GetThumbPath(HttpContext.Current.Server.MapPath("~/Core/Template/"), "Default"), true, true)); return lstTemplates; }
public static List<TemplateInfo> GetTemplateList() { string templatedir = Utils.GetAbsolutePath(TemplateConstants.TemplateDirectory); DirectoryInfo dir = new DirectoryInfo(templatedir); List<TemplateInfo> lstTemplates = new List<TemplateInfo>(); foreach (DirectoryInfo temp in dir.GetDirectories()) { TemplateInfo tempObj = new TemplateInfo(temp.Name); lstTemplates.Add(tempObj); } return lstTemplates; }
public void GenerateTemplateProgram(ref TemplateInfo ti) { // Init per-template compiling state (including inline templates compiling) // Default namespaces SetMetaPrefix("meta"); _metaNamespacePrefixStack = new List<string> { "meta" }; SetTalPrefix("tal"); _talNamespacePrefixStack = new List<string> { "tal" }; SetMetalPrefix("metal"); _metalNamespacePrefixStack = new List<string> { "metal" }; ti.ImportedPrograms = new Dictionary<string, Program>(); ti.ImportedNamespaces = new Dictionary<string, HashSet<string>>(); // Compile main template body ti.MainProgram = GetTemplateProgram(ti.TemplateBody, MainTemplatePath); // Compile imported templates CompileImportedTemplates(ti, ti.MainProgram); }
public static List<TemplateInfo> GetTemplateList(int PortalID) { string templates = Utils.GetAbsolutePath(TemplateConstants.TemplateDirectory); DirectoryInfo dir = new DirectoryInfo(templates); List<TemplateInfo> lstTemplates = new List<TemplateInfo>(); string activeTemplate = TemplateController.GetActiveTemplate(PortalID).TemplateName; if (activeTemplate.Length < 1) { activeTemplate = "Default"; } foreach (DirectoryInfo temp in dir.GetDirectories()) { TemplateInfo tempObj = new TemplateInfo(temp.Name, temp.FullName, GetThumbPath(temp.FullName, temp.Name, TemplateConstants.TemplateDirectory), false, false); if (temp.Name.ToLower().Replace(' ', '_').Equals(activeTemplate.ToLower())) { tempObj.IsActive = true; } lstTemplates.Add(tempObj); } bool IsDefaultActive = activeTemplate.ToLower().Equals("default") ? true : false; lstTemplates.Insert(0, new TemplateInfo("Default", "/Core/Template/", GetThumbPath(HttpContext.Current.Server.MapPath("~/Core/Template/"), "Template", "Core/"), IsDefaultActive, true)); List<TemplateInfo> lstFinalTemplates = new List<TemplateInfo>(); List<TemplateInfo> lstAppliedTemplates = new List<TemplateInfo>(); try { lstAppliedTemplates = TemplateController.GetPortalTemplates(); } catch (Exception) { throw; } foreach (TemplateInfo template in lstTemplates) { bool status = false; foreach (TemplateInfo templt in lstAppliedTemplates) { if (template.TemplateName.ToLower() == templt.TemplateName.ToLower() && templt.PortalID != PortalID) { status = true; break; } } if (!status) template.IsApplied = false; else template.IsApplied = true; } return lstTemplates; }
Dictionary<string, TemplateInfo> LoadTemplatesInfo(string cacheFolder) { var templateCache = new Dictionary<string, TemplateInfo>(); // Load assemblies containing type with full name [<TEMPLATE_NAMESPACE>.<TEMPLATE_TYPENAME>], // with one public method [public static string Render(Dictionary<string, object> globals)] var di = new DirectoryInfo(cacheFolder); foreach (FileInfo fi in di.GetFiles()) { Match fileNameMatch = _fileNamePatternRegex.Match(fi.Name); if (fileNameMatch.Success) { // Try to load file as assembly try { AssemblyName.GetAssemblyName(fi.FullName); } catch (BadImageFormatException) { // The file is not an Assembly continue; } // Get template hash from file name string templateHash = fileNameMatch.Groups["key"].Value; // Create template info var ti = new TemplateInfo { TemplateKey = templateHash }; // Try to load the Render() method from assembly Assembly assembly = Utils.ReadAssembly(fi.FullName); ti.RenderMethod = GetTemplateRenderMethod(assembly, ti); // Try to load the template generator version from assembly ti.GeneratorVersion = GetTemplateGeneratorVersion(assembly, ti); templateCache.Add(templateHash, ti); } } return templateCache; }
public static string GetDefaultName(TemplateInfo template) { return(template.DefaultName); }
private TemplateInfo ComputeFieldInfo(XmlReader reader, Dictionary<string, IDictionary<long, string>> maps) { var ret = new TemplateInfo(); ret.payloadNames = new List<string>(); ret.payloadFetches = new List<DynamicTraceEventData.PayloadFetch>(); ushort offset = 0; while (reader.Read()) { if (reader.Name == "data") { string inType = reader.GetAttribute("inType"); Type type = GetTypeForManifestTypeName(inType); ushort size = DynamicTraceEventData.SizeOfType(type); // Strings are weird in that they are encoded multiple ways. if (type == typeof(string) && inType == "win:AnsiString") size = DynamicTraceEventData.NULL_TERMINATED | DynamicTraceEventData.IS_ANSI; ret.payloadNames.Add(reader.GetAttribute("name")); IDictionary<long, string> map = null; string mapName = reader.GetAttribute("map"); if (mapName != null && maps != null) maps.TryGetValue(mapName, out map); ret.payloadFetches.Add(new DynamicTraceEventData.PayloadFetch(offset, size, type, map)); if (offset != ushort.MaxValue) { Debug.Assert(size != 0); if (size < DynamicTraceEventData.SPECIAL_SIZES) offset += size; else offset = ushort.MaxValue; } } } return ret; }