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> ();
 }

 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;
        }

 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;
 }

 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;
 }

        /// <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;
        }

        /// <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();
        }

        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;
        }

 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 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();
        }

        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();
        }

        public void Init(string columnName, TemplateType ttype, string guideColumns, QuestColumnType columnType)
        {
            strQuestColumnName = columnName;
            nQuestColumnValue = 0;
            type = ttype;
            strGuideColumnNames = guideColumns;
            strGuideColumnValues = string.Empty;

            emQuestColumnType = columnType;
        }

 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()));
            }
        }