public static IList<DocTemplate> GetTemplatesOnlyForOrganization(IUnitOfWork uow, TemplateType type, Organization org) { return uow.Session.QueryOver<DocTemplate> () .Where(x => x.TemplateType == type) .Where(x => x.Organization == org) .List<DocTemplate> (); }
private async Task<Email> BuildEmail(IUserDto user, TemplateType templateType, string token) { var email = new Email { Subject = String.Empty }; var bodyBuilder = new StringBuilder(200); using (StreamReader reader = _templateProvider.GetTemplate(templateType)) { string line = await reader.ReadLineAsync(); for (int i = 0; line != null; i++) { if (i == 0) { email.Subject = ReplaceMetaTagsWithUserData(line, user, token); } else { bodyBuilder.AppendLine(ReplaceMetaTagsWithUserData(line, user, token)); } line = await reader.ReadLineAsync(); } } email.Body = bodyBuilder.ToString(); return email; }
public static IList<DocTemplate> GetTemplatesForAnyOrganization(IUnitOfWork uow, TemplateType type) { return uow.Session.QueryOver<DocTemplate> () .Where(x => x.TemplateType == type) .Where(x => x.Organization == null) .List<DocTemplate> (); }
protected TemplatePage() : base() { templateClasses = TemplateClasses.U; templateType = TemplateType.U; templateGuid = ""; }
/// <summary> /// Constructor to handle the creation of an uninstall action with all information passed in. /// </summary> /// <param name="os"></param> /// <param name="template"></param> /// <param name="arch"></param> /// <param name="productcode"></param> /// <param name="wixobj"></param> public UninstallAction(ICollection<OperatingSystemConfiguration> os, TemplateType template, ICollection<ArchitectureConfiguration> arch, string productcode, WixObjectType wixobj) { Template = template; Architectures = arch; ProductCode = productcode; WixObject = wixobj; OS = os; }
public static ICodeTemplate FindDefaultTemplate(TemplateType templateType, Session session, Type codeTemplateType, CodeDomProvider codeDomProvider){ const ICodeTemplate template = null; var binaryOperator = new BinaryOperator(template.GetPropertyName(x => x.TemplateType),templateType); var isDefault = new BinaryOperator(template.GetPropertyName(x => x.IsDefault),true); var provider = new BinaryOperator(template.GetPropertyName(x => x.CodeDomProvider),codeDomProvider); return session.FindObject(PersistentCriteriaEvaluationBehavior.InTransaction, codeTemplateType, new GroupOperator(binaryOperator, isDefault,provider)) as ICodeTemplate; }
/// <summary> /// Получаем первый подходящий шаболон документа по указанным критериям. /// </summary> public static DocTemplate GetTemplate(IUnitOfWork uow, TemplateType type, Organization org) { var forOrg = GetTemplatesOnlyForOrganization(uow, type, org); if (forOrg.Count > 0) return forOrg.First(); var any = GetTemplatesForAnyOrganization(uow, type); return any.FirstOrDefault(); }
/// <summary> Constructor (called by derived classes only) </summary> protected TemplateKey(TemplateType templateType, object dataType) { Exception ex = ValidateDataType(dataType, "dataType"); if (ex != null) throw ex; _dataType = dataType; _templateType = templateType; }
public IPersistentClassInfo CreateClassInfo(string name, TemplateType templateType = TemplateType.Class) { var persistentClassInfo = _objectSpace.CreateWCObject<IPersistentClassInfo>(); _persistentAssemblyInfo.PersistentClassInfos.Add(persistentClassInfo); persistentClassInfo.SetDefaultTemplate(templateType); persistentClassInfo.Name = GetTableName(name); persistentClassInfo.PersistentAssemblyInfo = _persistentAssemblyInfo; persistentClassInfo.BaseType = typeof(XPLiteObject); return persistentClassInfo; }
internal GridViewAuditActionTemplate( TemplateType type, string columnName, string headerText) { _columnName = columnName; _headerText = headerText; _type = type; }
public static void SetDefaultTemplate(this IPersistentTemplatedTypeInfo persistentMemberInfo, TemplateType templateType) { var objectSpace = ObjectSpace.FindObjectSpaceByObject(persistentMemberInfo); persistentMemberInfo.CodeTemplateInfo = objectSpace.CreateWCObject<ICodeTemplateInfo>(); ICodeTemplate defaultTemplate = CodeTemplateBuilder.CreateDefaultTemplate(templateType, persistentMemberInfo.Session, WCTypesInfo.Instance.FindBussinessObjectType<ICodeTemplate>(), GetProvider(persistentMemberInfo)); persistentMemberInfo.CodeTemplateInfo.CodeTemplate = defaultTemplate; persistentMemberInfo.CodeTemplateInfo.CloneProperties(); }
IEnumerable<MemberGeneratorInfo> CreateMembersCore(IEnumerable<DBColumn> dbColumns, IPersistentClassInfo persistentClassInfo = null, TemplateType coreTemplateType = TemplateType.XPReadWritePropertyMember, TemplateType refTemplateType = TemplateType.XPReadWritePropertyMember) { return dbColumns.SelectMany(dbColumn => { var memberGeneratorInfos = new List<MemberGeneratorInfo>(); if (IsOneToOneOnTheKey(dbColumn) && coreTemplateType != TemplateType.ReadWriteMember) { memberGeneratorInfos.Add(CreateFkMember(dbColumn, persistentClassInfo, coreTemplateType, TemplateType.XPOneToOneReadOnlyPropertyMember)); } memberGeneratorInfos.Add(CreateMember(dbColumn, persistentClassInfo, coreTemplateType, refTemplateType)); return memberGeneratorInfos; }).Where(info => info.PersistentMemberInfo != null); }
public static void SetDefaultTemplate(this IPersistentMemberInfo persistentMemberInfo, TemplateType templateType) { persistentMemberInfo.CodeTemplateInfo = (ICodeTemplateInfo)Activator.CreateInstance(TypesInfo.Instance.CodeTemplateInfoType, persistentMemberInfo.Session); ICodeTemplate defaultTemplate = CodeTemplateBuilder.CreateDefaultTemplate(templateType, persistentMemberInfo.Session, TypesInfo.Instance.CodeTemplateType, persistentMemberInfo.Owner.PersistentAssemblyInfo.CodeDomProvider); persistentMemberInfo.CodeTemplateInfo.CodeTemplate = defaultTemplate; }
public void Init(string columnName, TemplateType ttype, string guideColumns, QuestColumnType columnType) { strQuestColumnName = columnName; nQuestColumnValue = 0; type = ttype; strGuideColumnNames = guideColumns; strGuideColumnValues = string.Empty; emQuestColumnType = columnType; }
public static void SetDefaultTemplate(this IPersistentTemplatedTypeInfo persistentMemberInfo, TemplateType templateType) { var objectType = WCTypesInfo.Instance.FindBussinessObjectType<ICodeTemplateInfo>(); persistentMemberInfo.CodeTemplateInfo = (ICodeTemplateInfo)objectType.CreateInstance(new object[] { persistentMemberInfo.Session }); var defaultTemplate = CodeTemplateBuilder.CreateDefaultTemplate(templateType, persistentMemberInfo.Session, WCTypesInfo.Instance.FindBussinessObjectType<ICodeTemplate>(), GetProvider(persistentMemberInfo)); persistentMemberInfo.CodeTemplateInfo.CodeTemplate = defaultTemplate; persistentMemberInfo.CodeTemplateInfo.CloneProperties(); }
IPersistentClassInfo CreatePersistentClassInfo(string name, TemplateType templateType, IPersistentAssemblyInfo persistentAssemblyInfo) { var findBussinessObjectType = WCTypesInfo.Instance.FindBussinessObjectType<IPersistentClassInfo>(); var info = _objectSpace.Session.FindObject(PersistentCriteriaEvaluationBehavior.InTransaction, findBussinessObjectType, CriteriaOperator.Parse("Name=?", name)) as IPersistentClassInfo; if (info != null) return info; var persistentClassInfo = CreateNew(name); persistentAssemblyInfo.PersistentClassInfos.Add(persistentClassInfo); persistentClassInfo.SetDefaultTemplate(templateType); return persistentClassInfo; }
internal GridViewIsSignedTemplate( TemplateType type, string columnName, string headerText, string isSignedOverride) { _columnName = columnName; _headerText = headerText; _isSignedOverride = isSignedOverride; _type = type; }
public static ICodeTemplate CreateDefaultTemplate(TemplateType templateType, Session session, Type codeTemplateType, CodeDomProvider codeDomProvider) { var defaultTemplate = CodeTemplateQuery.FindDefaultTemplate(templateType, session, codeTemplateType,codeDomProvider); if (defaultTemplate== null) { defaultTemplate = (ICodeTemplate)Activator.CreateInstance(codeTemplateType, session); defaultTemplate.IsDefault = true; defaultTemplate.TemplateType=templateType; defaultTemplate.CodeDomProvider=codeDomProvider; defaultTemplate.SetDefaults(); } return defaultTemplate; }
private static IEnumerable<Template> GetTemplates(IEnumerable<FilePath> directories, TemplateType type) { foreach (var directory in directories) { foreach (var file in Directory.GetFiles(directory.FullPath, "*.template", SearchOption.AllDirectories)) { var template = Template.FromFile(new FilePath(file)); if (template.Type == type) yield return template; } } }
protected override void Render(HtmlTextWriter writer) { if (this.Page is TemplatePage) { tempClass = ((TemplatePage)this.Page).TemplateClasses; tempType = ((TemplatePage)this.Page).TemplateType; } foreach (Template temp in Template.List(tempClass,tempType)) { writer.Write(String.Format(listFormat, temp.Guid, temp.Title, temp.Classes.ToString(), temp.Type.ToString(),temp.IsDefault.ToString())); } }
public virtual StreamReader GetTemplate(TemplateType templateType) { switch (templateType) { case TemplateType.EmailConfirmation: return OpenStreamReader("~/App_Data/EmailTemplates/RegistrationConfirmationEmail.txt"); case TemplateType.ResetPassword: return OpenStreamReader("~/App_Data/EmailTemplates/ResetPasswordEmail.txt"); default: throw new NotSupportedException(String.Format("Template type '{0}' is not supported", templateType)); } }
// ReSharper disable once UnusedParameter.Local private Template GetTemplate(string name, TemplateType type) { if (definition.Templates == null) throw new TemplateException(Strings.XmlNoTemplatesElement); var template = definition.Templates.FirstOrDefault(t => t.name.Equals(name, StringComparison.InvariantCulture)); if (template == null) throw new TemplateException(string.Format(Strings.XmlTemplateNotFound, name)); if (template.type != type) throw new TemplateException(string.Format(Strings.XmlTemplateUnexpectedType, name)); return template; }
public void Init(string columnName, TemplateType ttype, string xname, string yname, string zname, string mapidname, bool refenceMe, bool needRefence) { strQuestColumnName = columnName; type = ttype; strNewColumnXName = xname; strNewColumnYName = yname; strNewColumnZName = zname; strNewColumnMapIdName = mapidname; pointFinal.nX = 0; pointFinal.nY = 0; pointFinal.nZ = 0; nQuestColumnValue = 0; bIsRefenceMe = refenceMe; bNeedRefence = needRefence; }
public AFElementTemplate GetTemplate(TemplateType templateType) { AFDatabase database = GetAFDatabase(); AFElementTemplate template = database.ElementTemplates[templateLookup[templateType]]; if (templateType == TemplateType.GPXEventFrame) { template.InstanceType = typeof(AFEventFrame); } else { template.InstanceType = typeof(AFElement); } return template; }
private TemplateMetaData GetTemplate(TemplateType type) { var templates = _fileService.GetTemplates(type).ToArray(); switch (templates.Length) { case 0: return null; case 1: return templates.First(); default: return ShowUiAndGetTemplate(templates); } }
private static IEnumerable<FileInfo> GetFileInfos(TemplateType type) { switch (type) { case TemplateType.SitecoreItem: return TryGetFiles(".\\Resources\\Item Templates"); case TemplateType.SitecoreTemplate: return TryGetFiles(".\\Resources\\Template Templates"); case TemplateType.Partial: return TryGetFiles(".\\Resources\\Partials"); default: throw new ArgumentOutOfRangeException(nameof(type), type, null); } }
// // Ensure that the input set of shapes meets the desired application and template parameters. // public static bool VerifyInputParameters(List<ShapeType> shapeList, TemplateType type) { // We have an artificial limitation in the number of figures we combine. if (shapeList.Count > 3) throw new ArgumentException("Cannot synthesize a figure with more than 3 Figures."); if (type.CompareTo(TemplateType.DEMARCATION) < 0 && shapeList.Count != 2) { throw new ArgumentException("Expected two figures with a synthesis dictacted by template: " + type); } if (type.CompareTo(TemplateType.DEMARCATION) > 0 && shapeList.Count < 3) { throw new ArgumentException("Expected three figures with a synthesis dictacted by template: " + type); } return true; }
public IEnumerable<MissingTemplate> Validate(TemplateType type, params string[] names) { var templates = readTemplates(type); foreach (var name in names) { if (templates.Any(x => x.Name.EqualsIgnoreCase(name))) { continue; } yield return new MissingTemplate { Name = name, TemplateType = type, ValidChoices = templates.Select(x => x.Name).ToArray() }; } }
public string GenerateEmailAllStudents(Ceremony ceremony, Student student, string body, TemplateType templateType, Registration registration, Attachment attachment, HttpRequestBase request, UrlHelper url) { //Check.Require(registrationParticipation != null, "registrationParticipation is required."); Check.Require(ceremony != null, "ceremony is required"); Check.Require(student != null, "student is required"); Check.Require(!string.IsNullOrWhiteSpace(body), "body is required."); _request = request; _url = url; _ceremony = ceremony; _student = student; //_registrationParticipation = registrationParticipation; //_registration = registrationParticipation.Registration; _registration = registration ?? new Registration(); _template = new Template(){TemplateType = templateType}; _attachment = attachment; return HandleBody(body); }
IPersistentMemberInfo CreateMember(Column column, IPersistentClassInfo owner, TemplateType templateType) { var columnName = column.Name; ForeignKey foreignKey = _foreignKeyCalculator.GetForeignKey(column); if (column.IsForeignKey && owner.CodeTemplateInfo.CodeTemplate.TemplateType != TemplateType.Struct && _foreignKeyCalculator.IsOneToOne(foreignKey, columnName)) templateType = TemplateType.XPOneToOnePropertyMember; else if (foreignKey != null && foreignKey.Columns.Count > 1) { columnName = foreignKey.ReferencedTable; } if (_objectSpace.FindObject<IPersistentMemberInfo>(info => info.Name == columnName && info.Owner == owner, PersistentCriteriaEvaluationBehavior.InTransaction) != null) return null; if (!(column.IsForeignKey)) { return CreatePersistentCoreTypeMemberInfo(column, owner, templateType); } if (foreignKey != null) { IPersistentClassInfo referenceClassInfo = GetReferenceClassInfo(foreignKey.ReferencedTable); var persistentReferenceMemberInfo = CreatePersistentReferenceMemberInfo(columnName, owner, referenceClassInfo, templateType); return persistentReferenceMemberInfo; } throw new NotImplementedException(column.Name + " " + ((Table)column.Parent).Name); }
private void MakePdwWatermark(Microsoft.Office.Interop.Word.Application wApp, TemplateType templateType, Core.InternalBookmarkDomain firstDomain) { try { Microsoft.Office.Interop.Word.Selection Selection = wApp.Selection; Microsoft.Office.Interop.Word.Shape wmShape; Selection.Select(); // set focus on header to put watermark wApp.ActiveWindow.ActivePane.View.SeekView = Microsoft.Office.Interop.Word.WdSeekView.wdSeekCurrentPageHeader; //Create the watermar shape wmShape = Selection.HeaderFooter.Shapes.AddTextEffect( Microsoft.Office.Core.MsoPresetTextEffect.msoTextEffect1, GenPdwWatermarkValue(templateType, firstDomain), "Times New Roman", 1, Microsoft.Office.Core.MsoTriState.msoFalse, Microsoft.Office.Core.MsoTriState.msoFalse, 0, 0); //Set all of the attributes of the watermark wmShape.Select(); wmShape.Name = PdwWaterMarkName; wmShape.TextEffect.NormalizedHeight = Microsoft.Office.Core.MsoTriState.msoFalse; wmShape.Line.Visible = Microsoft.Office.Core.MsoTriState.msoFalse; wmShape.Fill.Visible = Microsoft.Office.Core.MsoTriState.msoTrue; wmShape.Fill.Solid(); wmShape.Fill.ForeColor.RGB = (int)Microsoft.Office.Interop.Word.WdColor.wdColorGray25; wmShape.Fill.Transparency = 0.5f; wmShape.Rotation = GenPdwWatermarkRotation(templateType); wmShape.LockAspectRatio = Microsoft.Office.Core.MsoTriState.msoTrue; wmShape.Height = GenPdwWatermarkHeight(wApp, templateType); wmShape.Width = wApp.InchesToPoints(7.64f); wmShape.WrapFormat.AllowOverlap = -1; //true wmShape.WrapFormat.Side = Microsoft.Office.Interop.Word.WdWrapSideType.wdWrapBoth; wmShape.WrapFormat.Type = Microsoft.Office.Interop.Word.WdWrapType.wdWrapNone; //3 wmShape.RelativeHorizontalPosition = Microsoft.Office.Interop.Word.WdRelativeHorizontalPosition.wdRelativeHorizontalPositionMargin; wmShape.RelativeVerticalPosition = Microsoft.Office.Interop.Word.WdRelativeVerticalPosition.wdRelativeVerticalPositionMargin; wmShape.Left = (float)Microsoft.Office.Interop.Word.WdShapePosition.wdShapeCenter; wmShape.Top = (float)Microsoft.Office.Interop.Word.WdShapePosition.wdShapeCenter; //set focus back to document wApp.ActiveWindow.ActivePane.View.SeekView = Microsoft.Office.Interop.Word.WdSeekView.wdSeekMainDocument; } catch { } }
private static string GetTemplateSettingsKey(TestFramework testFramework, MockFramework mockFramework, TemplateType templateType) { return(GetTemplateSettingsKey(testFramework.Name, mockFramework.Name, templateType.ToString())); }
public string GetTemplate(TestFramework testFramework, MockFramework mockFramework, TemplateType templateType) { string templateSettingKey = GetTemplateSettingsKey(testFramework, mockFramework, templateType); if (this.store.PropertyExists(CollectionPath, templateSettingKey)) { return(this.store.GetString(CollectionPath, templateSettingKey)); } switch (templateType) { case TemplateType.File: var templateGenerator = new DefaultTemplateGenerator(); return(templateGenerator.Get(testFramework, mockFramework)); case TemplateType.MockFieldDeclaration: return(mockFramework.MockFieldDeclarationCode); case TemplateType.MockFieldInitialization: return(mockFramework.MockFieldInitializationCode); case TemplateType.MockObjectReference: return(mockFramework.MockObjectReferenceCode); default: throw new ArgumentOutOfRangeException(nameof(templateType), templateType, null); } }
/// <summary> /// Returns the Export Template Placeholders for a Template Type /// </summary> /// <param name="templateType">Template Type</param> /// <returns>Export Template Placeholder</returns> public override List <ExportTemplatePlaceholder> GetExportTemplatePlaceholdersForType(TemplateType templateType) { List <ExportTemplatePlaceholder> exportPlaceholders = new List <ExportTemplatePlaceholder> { ExportUtil.CreatePlaceHolder(Placeholder_TargetMarker_Name, _localizer) }; if (!_isTeleport) { exportPlaceholders.Add(ExportUtil.CreatePlaceHolder(Placeholder_HasDirectContinueFunction_Start, _localizer)); exportPlaceholders.Add(ExportUtil.CreatePlaceHolder(Placeholder_HasDirectContinueFunction_End, _localizer)); exportPlaceholders.Add(ExportUtil.CreatePlaceHolder(Placeholder_HasNoDirectContinueFunction_Start, _localizer)); exportPlaceholders.Add(ExportUtil.CreatePlaceHolder(Placeholder_HasNoDirectContinueFunction_End, _localizer)); exportPlaceholders.Add(ExportUtil.CreatePlaceHolder(Placeholder_DirectContinueFunction, _localizer)); exportPlaceholders.Add(ExportUtil.CreatePlaceHolder(Placeholder_HasMovementState_Start, _localizer)); exportPlaceholders.Add(ExportUtil.CreatePlaceHolder(Placeholder_HasMovementState_End, _localizer)); exportPlaceholders.Add(ExportUtil.CreatePlaceHolder(Placeholder_HasNoMovementState_Start, _localizer)); exportPlaceholders.Add(ExportUtil.CreatePlaceHolder(Placeholder_HasNoMovementState_End, _localizer)); exportPlaceholders.Add(ExportUtil.CreatePlaceHolder(Placeholder_MovementState, _localizer)); } exportPlaceholders.AddRange(_flexFieldPlaceholderResolver.GetExportTemplatePlaceholdersForType(TemplateType.ObjectNpc)); return(exportPlaceholders); }
// ==== /// <summary> /// Parses an AiTemplate file, loading all of its objects into the ObjectManager /// </summary> /// <param name="FilePath">The full path to the extracted AiTemplate.ai file</param> public static void Parse(AiFile ConFile) { // Split our contents into an object araray IEnumerable <Token> FileTokens = Tokenize( String.Join(Environment.NewLine, File.ReadAllLines(ConFile.FilePath).Where(x => !String.IsNullOrWhiteSpace(x))) ); // Create our needed objects RemComment Comment = new RemComment(); // Create an empty object template ObjectTemplate template = new ObjectTemplate(); // Add our file objects ConFile.Objects = new Dictionary <string, ObjectTemplate>(); // proceed foreach (Token Tkn in FileTokens) { // Clean line up string TokenValue = Tkn.Value.TrimStart().TrimEnd(Environment.NewLine.ToCharArray()); // Handle Rem Comments if (Tkn.Kind == RemComment) { StringBuilder CommentBuilder = new StringBuilder(); CommentBuilder.AppendLine(TokenValue); Comment.Position = Tkn.Position; Comment.Value += CommentBuilder.ToString(); } // Handle Object Starts else if (Tkn.Kind == ObjectStart) { // Split line into function call followed by and arguments string[] funcArgs = TokenValue.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries); // Get function info [0] => templateName [1] => methodOrVariable string[] funcInfo = funcArgs[0].Split(new char[] { '.' }); // Get our template type TemplateType Type = (TemplateType)Enum.Parse(typeof(TemplateType), funcInfo[0], true); // Create the new object template = (Type == TemplateType.AiTemplate) ? new AiTemplate() : new ObjectTemplate(); template.Name = funcArgs.Last(); template.TemplateTypeString = funcInfo[0]; template.ObjectType = (funcArgs.Length > 2) ? funcArgs[1] : ""; template.TemplateType = Type; template.Comment = Comment; template.Position = Tkn.Position; template.Properties = new Dictionary <string, List <ObjectProperty> >(); template.File = ConFile; // Add object to our objects array, and our object manager ConFile.Objects.Add(template.Name, template); ObjectManager.RegisterObject(template.Name, ConFile); // Reset comment Comment = new RemComment(); } // handle properties else if (Tkn.Kind == ObjectProperty) { // Split line into function call followed by and arguments string[] funcArgs = TokenValue.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries); // Get function info [0] => templateName [1] => methodOrVariable string[] funcInfo = funcArgs[0].Split(new char[] { '.' }); // Sub object? if (funcInfo[1] == "addPlugIn") { // Throw an exception if we are invalidly adding a plugin if (template.TemplateType != TemplateType.AiTemplate) { throw new Exception("Attempting to add a plugin to object type: " + template.TemplateType.ToString()); } // Fetch the plugin ObjectTemplate plugin = ObjectManager.GetObjectByName(funcArgs[1]); // Add template plugin (template as AiTemplate).Plugins.Add( (AiTemplatePluginType)Enum.Parse(typeof(AiTemplatePluginType), plugin.ObjectType, true), plugin ); } // Create the object property ObjectProperty prop = new ObjectProperty() { Name = funcInfo[1], Comment = Comment, Position = Tkn.Position, Values = funcArgs.Skip(1).ToArray(), }; // Add template property if we dont have one if (!template.Properties.ContainsKey(funcInfo[1])) { template.Properties.Add(funcInfo[1], new List <ObjectProperty>()); } // Add the porperty template.Properties[funcInfo[1]].Add(prop); // Reset comment Comment = new RemComment(); } } }
public async Task <string> GenerateAsync <T>(string templateName, T templateModel, TemplateType type) { var templatesFolder = Path.Combine(_hostingEnvironment.ContentRootPath, type == TemplateType.Email ? "Messages\\EmailTemplates" : "Messages\\SmsTemplates"); var path = Path.Combine(templatesFolder, templateName + ".mustache"); try { return(Nustache.Core.Render.FileToString(path, templateModel)); } catch (InvalidCastException) { Console.WriteLine($"Incorrect model was passed for template: {path}"); throw; } }
/// <summary> /// Returns the Export Template Placeholders for a Template Type /// </summary> /// <param name="templateType">Template Type</param> /// <returns>Export Template Placeholder</returns> public override List <ExportTemplatePlaceholder> GetExportTemplatePlaceholdersForType(TemplateType templateType) { List <ExportTemplatePlaceholder> exportPlaceholders = new List <ExportTemplatePlaceholder> { ExportUtil.CreatePlaceHolder(Placeholder_Quantity, _localizer) }; exportPlaceholders.AddRange(_flexFieldPlaceholderResolverItem.GetExportTemplatePlaceholdersForType(TemplateType.ObjectNpc)); exportPlaceholders.AddRange(_flexFieldPlaceholderResolverNpc.GetExportTemplatePlaceholdersForType(TemplateType.ObjectNpc)); return(exportPlaceholders); }
protected MvxScaffoldingBase(TemplateType templateType) { MvxScaffoldingContext.CurrentTemplateType = templateType; }
public async Task <string> GenerateAsync <T>(string templateName, T templateVm, TemplateType type) { if (type == TemplateType.Sms) { throw new ArgumentException("SMS template should be local!"); } Uri baseUri = new Uri(_emailGeneratorSettings.EmailTemplatesHost); Uri templateUri = new Uri(baseUri, templateName + ".html"); var emailTemplate = GetEmailTemplate(templateUri.AbsoluteUri); var emailTemplateWithData = InsertData(await emailTemplate, templateVm); return(emailTemplateWithData); }
// // Given a template: \alpha - \beta , etc. // public static List <FigSynthProblem> SynthesizeFromTemplate(List <ShapeType> shapeList, TemplateType type) { // // Construct the default shape for the bigger shape-type specified. // Figure defaultLargeFigure = Figure.ConstructDefaultShape(shapeList[0]); switch (type) { // // Two Shapes // case TemplateType.ALPHA_MINUS_BETA: // a - b return(ConstructSequentialSubtraction(shapeList)); case TemplateType.ALPHA_PLUS_BETA: // a + b return(ConstructSequentialAddition(shapeList)); // // Three Shapes // case TemplateType.ALPHA_PLUS_BETA_PLUS_GAMMA: // a + b + c return(ConstructSequentialAddition(shapeList)); case TemplateType.ALPHA_PLUS_LPAREN_BETA_MINUS_GAMMA_RPAREN: // a + (b - c) = (b - c) + a case TemplateType.ALPHA_MINUS_BETA_PLUS_GAMMA: // (a - b) + c return(ConstructParenSubtractionThenAppend(shapeList)); case TemplateType.LPAREN_ALPHA_PLUS_BETA_RPAREN_MINUS_GAMMA: // (a + b) - c return(ConstructAppendThenSubtract(shapeList)); case TemplateType.ALPHA_MINUS_BETA_MINUS_GAMMA: // a - b - c return(ConstructSequentialSubtraction(shapeList)); case TemplateType.ALPHA_MINUS_LPAREN_BETA_MINUS_GAMMA_RPAREN: // a - (b - c) return(ConstructGroupedSubtraction(shapeList)); } return(new List <FigSynthProblem>()); }
public void RunStarted(object automationObject, Dictionary <string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams) { if (GlobalReplacementsDictionaryStorage != null) // workaround (see above) { GlobalReplacementsDictionary = GlobalReplacementsDictionaryStorage.Split('\f').ToDictionary(l => l.Split('\v')[0], l => l.Split('\v')[1]); } if (runKind == WizardRunKind.AsMultiProject) { GlobalReplacementsDictionary = new Dictionary <string, string>(); ProjectsToGenerate = new HashSet <string>(); _DTE dte = automationObject as _DTE; replacementsDictionary.TryGetValue("$projectname$", out _solutionName); replacementsDictionary.TryGetValue("$safeprojectname$", out _solutionSafeName); TemplateType type = TemplateType.Module; if (replacementsDictionary.ContainsKey("$HardwareType$")) { Enum.TryParse(replacementsDictionary["$HardwareType$"], out type); } WizardWindow window = new WizardWindow(type); window.ProjectName = _solutionName; window.ProjectSafeName = _solutionSafeName; if (window.ShowDialog() != true) { throw new WizardCancelledException(); } GlobalReplacementsDictionary.Add("$HardwareFullName$", window.ProjectName); GlobalReplacementsDictionary.Add("$HardwareShortName$", window.ProjectSafeName); GlobalReplacementsDictionary.Add("$HardwareFileSystemName$", window.ProjectSafeName); GlobalReplacementsDictionary.Add("$ManufacturerFullName$", window.ManufacturerName); GlobalReplacementsDictionary.Add("$ManufacturerShortName$", window.ManufacturerSafeName); GlobalReplacementsDictionary.Add("$Netmf41XmlPrefix$", window.SupportsNETMF41 ? xmlTagStart : xmlCommentStart + xmlTagStart); GlobalReplacementsDictionary.Add("$Netmf41XmlSuffix$", window.SupportsNETMF41 ? xmlTagEnd : xmlTagEnd + xmlCommentEnd); GlobalReplacementsDictionary.Add("$Netmf42XmlPrefix$", window.SupportsNETMF42 ? xmlTagStart : xmlCommentStart + xmlTagStart); GlobalReplacementsDictionary.Add("$Netmf42XmlSuffix$", window.SupportsNETMF42 ? xmlTagEnd : xmlTagEnd + xmlCommentEnd); GlobalReplacementsDictionary.Add("$Netmf43XmlPrefix$", window.SupportsNETMF43 ? xmlTagStart : xmlCommentStart + xmlTagStart); GlobalReplacementsDictionary.Add("$Netmf43XmlSuffix$", window.SupportsNETMF43 ? xmlTagEnd : xmlTagEnd + xmlCommentEnd); GlobalReplacementsDictionary.Add("$Netmf44XmlPrefix$", window.SupportsNETMF44 ? xmlTagStart : xmlCommentStart + xmlTagStart); GlobalReplacementsDictionary.Add("$Netmf44XmlSuffix$", window.SupportsNETMF44 ? xmlTagEnd : xmlTagEnd + xmlCommentEnd); GlobalReplacementsDictionary.Add("$WizardGuid41$", Guid.NewGuid().ToString()); GlobalReplacementsDictionary.Add("$WizardGuid41be$", Guid.NewGuid().ToString()); GlobalReplacementsDictionary.Add("$WizardGuid41le$", Guid.NewGuid().ToString()); GlobalReplacementsDictionary.Add("$WizardGuid42$", Guid.NewGuid().ToString()); GlobalReplacementsDictionary.Add("$WizardGuid42be$", Guid.NewGuid().ToString()); GlobalReplacementsDictionary.Add("$WizardGuid42le$", Guid.NewGuid().ToString()); GlobalReplacementsDictionary.Add("$WizardGuid43$", Guid.NewGuid().ToString()); GlobalReplacementsDictionary.Add("$WizardGuid43be$", Guid.NewGuid().ToString()); GlobalReplacementsDictionary.Add("$WizardGuid43le$", Guid.NewGuid().ToString()); GlobalReplacementsDictionary.Add("$WizardGuid44$", Guid.NewGuid().ToString()); GlobalReplacementsDictionary.Add("$WizardGuid44be$", Guid.NewGuid().ToString()); GlobalReplacementsDictionary.Add("$WizardGuid44le$", Guid.NewGuid().ToString()); if (window.HardwareImage != null) { GlobalReplacementsDictionary.Add("$HardwareImagePath$", window.HardwareImagePath); } GlobalReplacementsDictionary.Add("$SocketsXml$", window.GetSocketsXml()); GlobalReplacementsDictionary.Add("$ProvidedSocketsXml$", window.GetProvidedSocketsXml()); GlobalReplacementsDictionary.Add("$PowerXml$", window.GetPowerXml()); GlobalReplacementsDictionary.Add("$HardwareWidth$", window.HardwareWidth.ToString(CultureInfo.InvariantCulture)); GlobalReplacementsDictionary.Add("$HardwareHeight$", window.HardwareHeight.ToString(CultureInfo.InvariantCulture)); // remember which MF version projects to generate as we need to cancel the wizard for them individually ProjectsToGenerate.Add(window.ProjectSafeName); // installer if (window.SupportsNETMF41) { ProjectsToGenerate.Add(window.ProjectSafeName + "_41"); } if (window.SupportsNETMF42) { ProjectsToGenerate.Add(window.ProjectSafeName + "_42"); } if (window.SupportsNETMF43) { ProjectsToGenerate.Add(window.ProjectSafeName + "_43"); } if (window.SupportsNETMF44) { ProjectsToGenerate.Add(window.ProjectSafeName + "_44"); } // workaround (see above) GlobalReplacementsDictionaryStorage = string.Join("\f", GlobalReplacementsDictionary.Select(p => p.Key + "\v" + p.Value)); } else if (runKind == WizardRunKind.AsNewProject) { string projectName; if (replacementsDictionary.TryGetValue("$projectname$", out projectName) && ProjectsToGenerate != null) { if (!ProjectsToGenerate.Contains(projectName)) { throw new WizardCancelledException(); } } } if (GlobalReplacementsDictionary != null) { foreach (KeyValuePair <string, string> replacementItem in GlobalReplacementsDictionary) { replacementsDictionary.Add(replacementItem.Key, replacementItem.Value); } } }
// // Given the list of shapes AND a desired template, synthesize. // public static List <FigSynthProblem> SynthesizeFromTemplateAndFigures(List <ShapeType> shapeList, TemplateType type) { if (!VerifyInputParameters(shapeList, type)) { return(new List <FigSynthProblem>()); } return(SynthesizeFromTemplate(shapeList, type)); }
public static bool SynthesizerMain(Dictionary <ShapeType, int> figureCountMap, TemplateType type) { // // Convert the incoming dictionary to a simple list of shapes to process in order. // List <List <ShapeType> > shapesSets = ConvertShapeMapToList(figureCountMap); bool success = true; foreach (List <ShapeType> shapes in shapesSets) { // // Construct the figure recursively. // List <FigSynthProblem> problems = SynthesizeFromTemplateAndFigures(shapes, type); // // Construct the problem so that it can be passed to the Solver. // success = ConstructProblemsToSolve(problems) || success; } return(success); }
private float GenPdwWatermarkHeight(Microsoft.Office.Interop.Word.Application wApp, TemplateType templateType) { switch (templateType) { case TemplateType.Pdw: return(wApp.InchesToPoints(2.82f)); case TemplateType.Pdh: return(200); default: return(wApp.InchesToPoints(2.82f)); } }
MemberGeneratorInfo CreateMember(DBColumn dbColumn, IPersistentClassInfo persistentClassInfo = null, TemplateType coreTemplateType = TemplateType.XPReadWritePropertyMember, TemplateType refTemplateType = TemplateType.XPReadWritePropertyMember) { return(CreateMemberCore(dbColumn, persistentClassInfo, coreTemplateType, refTemplateType)); }
/// <summary> /// Returns the Export Template Placeholders for a Template Type /// </summary> /// <param name="templateType">Template Type</param> /// <returns>Export Template Placeholder</returns> public override List <ExportTemplatePlaceholder> GetExportTemplatePlaceholdersForType(TemplateType templateType) { return(new List <ExportTemplatePlaceholder> { ExportUtil.CreatePlaceHolder(Placeholder_GroupContent, _localizer) }); }
public static async Task <string> GetStlCurrentUrlAsync(IParseManager parseManager, Site site, int channelId, int contentId, Content content, TemplateType templateType, int templateId, bool isLocal) { var currentUrl = string.Empty; if (templateType == TemplateType.IndexPageTemplate) { currentUrl = await parseManager.PathManager.GetWebUrlAsync(site); } else if (templateType == TemplateType.ContentTemplate) { if (content == null) { var nodeInfo = await parseManager.DatabaseManager.ChannelRepository.GetAsync(channelId); currentUrl = await parseManager.PathManager.GetContentUrlAsync(site, nodeInfo, contentId, isLocal); } else { currentUrl = await parseManager.PathManager.GetContentUrlAsync(site, content, isLocal); } } else if (templateType == TemplateType.ChannelTemplate) { currentUrl = await parseManager.PathManager.GetChannelUrlAsync(site, await parseManager.DatabaseManager.ChannelRepository.GetAsync(channelId), isLocal); } else if (templateType == TemplateType.FileTemplate) { currentUrl = await parseManager.PathManager.GetFileUrlAsync(site, templateId, isLocal); } //currentUrl是当前页面的地址,前后台分离的时候,不允许带上protocol //return PageUtils.AddProtocolToUrl(currentUrl); return(currentUrl); }
public RelayCommand(Package package, int commandId, Guid commandSet, Action <object, EventArgs> menuCallback, Action <object, TemplateType> beforeQueryStatus, TemplateType templateType) { _package = package; if (ServiceProvider.GetService(typeof(IMenuCommandService)) is OleMenuCommandService commandService) { var menuCommandID = new CommandID(commandSet, commandId); var menuItem = new OleMenuCommand(menuCallback.Invoke, menuCommandID); if (beforeQueryStatus != null) { menuItem.BeforeQueryStatus += (s, e) => beforeQueryStatus.Invoke(s, templateType); } commandService.AddCommand(menuItem); } }
/// <summary> /// Returns the Export Template Placeholders for a Template Type /// </summary> /// <param name="templateType">Template Type</param> /// <returns>Export Template Placeholder</returns> public override List <ExportTemplatePlaceholder> GetExportTemplatePlaceholdersForType(TemplateType templateType) { List <ExportTemplatePlaceholder> exportPlaceholders = new List <ExportTemplatePlaceholder>(); if (_languageKeyGenerator != null) { exportPlaceholders.AddRange(_languageKeyGenerator.GetExportTemplatePlaceholders(GetLanguageKeyValueDesc())); } exportPlaceholders.AddRange(ScribanPlaceholderGenerator.GetPlaceholdersForObject <ScribanRenderingClass>(_localizerFactory, GetObjectKey())); exportPlaceholders.RemoveAll(p => p.Name.EndsWith(string.Format(".{0}", StandardMemberRenamer.Rename(nameof(ScribanFlexFieldObject.UnusedFields))))); return(exportPlaceholders); }
private IEnumerable <ITemplateInfo> GetTemplates(string framework, TemplateType templateType) { return(VBStyleGenerationTestsFixture.Templates .Where(t => t.GetFrameworkList().Contains(framework) && t.GetTemplateType() == templateType)); }
/// <summary> /// Returns true if the action renderer has placeholders for a template type /// </summary> /// <param name="templateType">Tempalte Type to check</param> /// <returns>true if the action renderer has placeholders for the template type</returns> public override bool HasPlaceholdersForTemplateType(TemplateType templateType) { return((templateType == TemplateType.TaleActionRemoveItemFromChooseNpc && _isRemoval) || (templateType == TemplateType.TaleActionSpawnItemForChooseNpc && !_isRemoval)); }
/// <summary> /// Returns the Export Template Placeholders for a Template Type /// </summary> /// <param name="templateType">Template Type</param> /// <returns>Export Template Placeholder</returns> public override List <ExportTemplatePlaceholder> GetExportTemplatePlaceholdersForType(TemplateType templateType) { List <ExportTemplatePlaceholder> exportPlaceholders = _dailyRoutineEventPlaceholderResolver.GetPlaceholders(); exportPlaceholders.AddRange(_flexFieldPlaceholderResolver.GetExportTemplatePlaceholdersForType(TemplateType.ObjectNpc)); return(exportPlaceholders); }
public Template Convert(StructureDefinition strucDef, Template template = null) { if (string.IsNullOrEmpty(strucDef.ConstrainedType)) { throw new Exception("StructureDefinition.constrainedType is required"); } if (template == null) { ImplementationGuide unassignedImplementationGuide = this.tdb.ImplementationGuides.SingleOrDefault(y => y.Name == DSTU2Helper.DEFAULT_IG_NAME && y.ImplementationGuideTypeId == this.implementationGuideType.Id); if (unassignedImplementationGuide == null) { unassignedImplementationGuide = new ImplementationGuide() { Name = DSTU2Helper.DEFAULT_IG_NAME, ImplementationGuideType = this.implementationGuideType, Organization = this.tdb.Organizations.Single(y => y.Name == DSTU2Helper.DEFAULT_ORG_NAME) }; this.tdb.ImplementationGuides.AddObject(unassignedImplementationGuide); } template = new Template() { OwningImplementationGuide = unassignedImplementationGuide, ImplementationGuideType = this.implementationGuideType, Author = this.tdb.Users.Single(y => y.UserName == DSTU2Helper.DEFAULT_USER_NAME && y.Organization.Name == DSTU2Helper.DEFAULT_ORG_NAME), Organization = this.tdb.Organizations.Single(y => y.Name == DSTU2Helper.DEFAULT_ORG_NAME), IsOpen = true }; } // Name if (template.Name != strucDef.Name) { template.Name = strucDef.Name; } // Descrition if (template.Description != strucDef.Description) { template.Description = strucDef.Description; } // Identifier -> Oid string identifier = strucDef.Url; if (string.IsNullOrEmpty(identifier)) { identifier = string.Format(DSTU2Helper.STRUCDEF_NEW_IDENTIFIER_FORMAT, Guid.NewGuid()); } if (template.Oid != identifier) { template.Oid = identifier; } // ConstrainedType -> Template Type TemplateType templateType = this.tdb.TemplateTypes.SingleOrDefault(y => y.ImplementationGuideTypeId == this.implementationGuideType.Id && y.RootContextType == strucDef.ConstrainedType); if (templateType == null) { throw new Exception("Could not find Template Type for " + strucDef.ConstrainedType); } if (template.TemplateType != templateType) { template.TemplateType = templateType; } if (template.PrimaryContext != template.TemplateType.RootContext) { template.PrimaryContext = template.TemplateType.RootContext; } if (template.PrimaryContextType != template.TemplateType.RootContextType) { template.PrimaryContextType = template.TemplateType.RootContextType; } // Bookmark template.Bookmark = Template.GenerateBookmark(template.Name, template.TemplateType.Name.ToUpper()); if (strucDef.Snapshot != null && strucDef.Differential == null) { throw new Exception("Trifolia does not support snapshots for DSTU2, yet"); } // Differential.Element -> Constraint if (strucDef.Differential != null) { // Remove all current constraints from the template so that we re-create foreach (var cc in template.ChildConstraints.ToList()) { this.tdb.TemplateConstraints.DeleteObject(cc); } ElementNavigator navigator = new ElementNavigator(strucDef.Differential.Element); TemplateConstraint current = null; if (navigator.MoveToFirstChild() && navigator.MoveToFirstChild()) { while (true) { if (navigator.Current.Slicing != null) { if (!navigator.MoveToNext()) { if (current != null && current.ParentConstraint != null && navigator.MoveToParent()) { current = current.ParentConstraint; } else { break; } } continue; } TemplateConstraint next = new TemplateConstraint(); next.Context = navigator.PathName; next.ParentConstraint = current; next.Order = current != null?current.ChildConstraints.Count() : template.ChildConstraints.Count(y => y.ParentConstraint == null); if (navigator.Elements.Any(y => y.Path == navigator.Path && y.Slicing != null)) { next.IsBranch = true; } template.ChildConstraints.Add(next); string cardinality = string.Format("{0}..{1}", navigator.Current.Min == null ? 0 : navigator.Current.Min, string.IsNullOrEmpty(navigator.Current.Max) ? "*" : navigator.Current.Max); if (next.Cardinality != cardinality) { next.Cardinality = cardinality; } string conformance = cardinality.StartsWith("1") ? "SHALL" : "SHOULD"; if (next.Conformance != conformance) { next.Conformance = conformance; } if (navigator.MoveToFirstChild()) { current = next; continue; } else if (navigator.MoveToNext()) { continue; } else if (navigator.MoveToParent() && navigator.MoveToNext()) { current = current.ParentConstraint; continue; } else { break; } } } } return(template); }
IEnumerable <MemberGeneratorInfo> CreateMembersCore(IEnumerable <DBColumn> dbColumns, IPersistentClassInfo persistentClassInfo = null, TemplateType coreTemplateType = TemplateType.XPReadWritePropertyMember, TemplateType refTemplateType = TemplateType.XPReadWritePropertyMember) { return(dbColumns.SelectMany(dbColumn => { var memberGeneratorInfos = new List <MemberGeneratorInfo>(); if (IsOneToOneOnTheKey(dbColumn) && coreTemplateType != TemplateType.ReadWriteMember) { memberGeneratorInfos.Add(CreateFkMember(dbColumn, persistentClassInfo, coreTemplateType, TemplateType.XPOneToOneReadOnlyPropertyMember)); } else { memberGeneratorInfos.Add(CreateMember(dbColumn, persistentClassInfo, coreTemplateType, refTemplateType)); } return memberGeneratorInfos; }).Where(info => info.PersistentMemberInfo != null)); }
/// <summary> /// Returns true if the action renderer has placeholders for a template type /// </summary> /// <param name="templateType">Tempalte Type to check</param> /// <returns>true if the action renderer has placeholders for the template type</returns> public override bool HasPlaceholdersForTemplateType(TemplateType templateType) { return(templateType == TemplateType.TaleActionSpawnItemAtMarker); }
IPersistentCoreTypeMemberInfo CreatePersistentCoreTypeMemberInfo(DBColumn column, IPersistentClassInfo persistentClassInfo, TemplateType templateType) { var persistentCoreTypeMemberInfo = _objectSpace.CreateWCObject <IPersistentCoreTypeMemberInfo>(); persistentCoreTypeMemberInfo.Name = column.Name; persistentCoreTypeMemberInfo.DataType = column.ColumnType; if (persistentClassInfo == null) { var tableName = ClassGenerator.GetTableName(_dbTable.Name); persistentClassInfo = _classInfos[tableName].PersistentClassInfo; } persistentClassInfo.OwnMembers.Add(persistentCoreTypeMemberInfo); persistentCoreTypeMemberInfo.SetDefaultTemplate(templateType); return(persistentCoreTypeMemberInfo); }
public void SetTemplate(TestFramework testFramework, MockFramework mockFramework, TemplateType templateType, string template) { this.store.SetString(CollectionPath, GetTemplateSettingsKey(testFramework, mockFramework, templateType), template); }
IPersistentMemberInfo CreatePersistentReferenceMemberInfo(string name, IPersistentClassInfo persistentClassInfo, IPersistentClassInfo persistentReferenceClassInfo, TemplateType templateType) { var persistentReferenceMemberInfo = _objectSpace.CreateWCObject <IPersistentReferenceMemberInfo>(); persistentReferenceMemberInfo.Name = name; persistentReferenceMemberInfo.ReferenceClassInfo = persistentReferenceClassInfo; if (persistentClassInfo == null) { persistentClassInfo = _classInfos[ClassGenerator.GetTableName(_dbTable.Name)].PersistentClassInfo; } persistentClassInfo.OwnMembers.Add(persistentReferenceMemberInfo); persistentReferenceMemberInfo.SetDefaultTemplate(templateType); if (templateType != TemplateType.XPOneToOnePropertyMember && templateType != TemplateType.XPOneToOneReadOnlyPropertyMember && persistentClassInfo.CodeTemplateInfo.CodeTemplate.TemplateType == TemplateType.Class && persistentReferenceClassInfo.CodeTemplateInfo.CodeTemplate.TemplateType == TemplateType.Class) { CreateCollection(persistentReferenceMemberInfo, persistentClassInfo); } return(persistentReferenceMemberInfo); }
public UserSelectionGroup GetGroup(TemplateType templateType) => Groups.First(t => t.TemplateType == templateType);
private ObservableCollection <SavedTemplateViewModel> GetCollection(TemplateType templateType) { return(Groups.First(g => g.TemplateType == templateType).Items); }