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