public void createFormDSExtension(IFormDataSource formDataSource) { // Find current model var modelSaveInfo = Common.CommonUtil.GetCurrentModelSaveInfo(); var metaModelService = Common.CommonUtil.GetModelSaveService(); string className = Common.CommonUtil.GetNextClassExtensionName(formDataSource.Name); string intrinsicStr = "formdatasourcestr"; string extensionOfStr = $"ExtensionOf({intrinsicStr}({formDataSource.RootElement.Name},{formDataSource.Name}))"; Microsoft.Dynamics.AX.Metadata.MetaModel.AxClass extensionClass = ClassHelper.GetExistingExtensionClass(formDataSource.Name, extensionOfStr); if (extensionClass == null) { extensionClass = new AxClass() { Name = className }; extensionClass.SourceCode.Declaration = $"[{extensionOfStr}]\npublic final class {className}\n{{\n\n}}"; } metaModelService.CreateClass(extensionClass, modelSaveInfo); Common.CommonUtil.AddElementToProject(extensionClass); }
protected void AddClassMethodCode(AxClass newAxClass) { if (String.IsNullOrEmpty(CodeGenerate.GetResult())) { return; } if (IsPreviewMode) { CodeGenerate.AppendLine(""); } else { if (CodeGenerate.MethodType == ClassMethodType.ClassDeclaration) { newAxClass.SourceCode.Declaration = CodeGenerate.GetResult(); } else { AxMethod axMethod = new AxMethod(); axMethod.Name = CodeGenerate.MethodName; axMethod.IsStatic = (CodeGenerate.MethodType == ClassMethodType.Static); axMethod.Source = CodeGenerate.GetResult(); newAxClass.AddMethod(axMethod); } CodeGenerate.ClearResult(); } }
public void applyValidateMethod(AxClass selectedClass, AxClass contractClass) { var validateMethod = selectedClass.Methods.Where(m => m.Name.Equals("Validate", StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault(); AxMethod axValidateMethod = new AxMethod() { Name = "validate", ReturnType = new AxMethodReturnType() { Type = Microsoft.Dynamics.AX.Metadata.Core.MetaModel.CompilerBaseType.AnyType, TypeName = "boolean" } }; if (validateMethod != null) { axValidateMethod.Source = validateMethod.Source.Replace("Object calledFrom = null", ""); } else { // we need to put a dummy method here axValidateMethod.Source = @" public boolean validate(Object calledFrom = null) { boolean ret; ret = super(calledFrom); return ret; }" + Environment.NewLine; } contractClass.AddMethod(axValidateMethod); }
public void run() { AxClass axClass = MetadataProvider.Classes.Read(classItem.Name); bool allMethodsDocumented = true; // Please do not disappoint me! :) foreach (AxMethod method in axClass.Methods) { IContent tagContent = null; string devDoc = string.Empty; if (!method.Source.Contains("<summary>")) { tagContent = new SummaryTag(method); tagContent = new ParamTag(tagContent, method); tagContent = new ExceptionTag(tagContent, method); tagContent = new ReturnsTag(tagContent, method); tagContent = new RemarksTag(tagContent, method); method.Source = method.Source.Insert(0, $"{tagContent.getContent()}\n"); allMethodsDocumented = false; // Shame on you! :( } } if (allMethodsDocumented) { CoreUtility.DisplayInfo("All your methods are documented already! I've transfered $500,00 to your bank account as reward!"); } else { this.MetaModelService.UpdateClass(axClass, this.ModelSaveInfo); } }
public static AxClass GetExistingExtensionClass(string className, string extensionOfStr) { AxClass axClass = null; var metaModelService = Common.CommonUtil.GetModelSaveService(); //This searches across all models var classNameExts = metaModelService.GetClassNames().ToList() .Where(searchClass => searchClass.ToLowerInvariant().Contains(className.ToLowerInvariant()) && metaModelService.GetClass(searchClass).Declaration.ToLowerInvariant().Contains(extensionOfStr.ToLowerInvariant()) ) .ToList(); string classNameExt = String.Empty; var currentModel = Common.CommonUtil.GetCurrentModel(); foreach (var classNameE in classNameExts) { // Determine if the model this class belongs to is a part of the current project model var modelInfo = metaModelService.GetClassModelInfo(classNameE).ToList() .Where(modelInfoCur => modelInfoCur.Module.Equals(currentModel.Module, StringComparison.InvariantCultureIgnoreCase)) .FirstOrDefault(); if (modelInfo != null) { classNameExt = classNameE; break; } } if (String.IsNullOrEmpty(classNameExt) == false) { axClass = metaModelService.GetClass(classNameExt); } return(axClass); }
/// <summary> /// Called when user clicks on the add-in menu /// </summary> /// <param name="e">The context of the VS tools and metadata</param> public override void OnClick(AddinDesignerEventArgs e) { try { // we will create Extension class here var selectedElement = e.SelectedElement as Microsoft.Dynamics.Framework.Tools.MetaModel.Automation.IRootElement; if (selectedElement != null) { // Find current model var modelSaveInfo = Common.CommonUtil.GetCurrentModelSaveInfo(); var metaModelService = Common.CommonUtil.GetModelSaveService(); // Create a class with the same name + _Extension and add it to the project string className = Common.CommonUtil.GetNextClassExtensionName(selectedElement.Name); string intrinsicStr = String.Empty; if (selectedElement is ITable || selectedElement is IDataEntityView) { intrinsicStr = "tableStr"; } else if (selectedElement is IClassItem) { intrinsicStr = "classStr"; } else if (selectedElement is IForm) { intrinsicStr = "formStr"; } Microsoft.Dynamics.AX.Metadata.MetaModel.AxClass extensionClass; string extensionOfStr = $"ExtensionOf({intrinsicStr}({selectedElement.Name}))"; // Find an existing class where the extension is already used extensionClass = ClassHelper.GetExistingExtensionClass(selectedElement.Name, extensionOfStr); if (extensionClass == null) { extensionClass = new AxClass() { Name = className }; extensionClass.SourceCode.Declaration = $"[{extensionOfStr}]\npublic final class {className}\n{{\n\n}}"; } metaModelService.CreateClass(extensionClass, modelSaveInfo); Common.CommonUtil.AddElementToProject(extensionClass); } else if (e.SelectedElement is IFormDataSource) { this.createFormDSExtension(e.SelectedElement as IFormDataSource); } } catch (Exception ex) { CoreUtility.HandleExceptionWithErrorMessage(ex); } }
protected override void Create() { var element = new AxClass { Name = ElementName }; MetaService.CreateClass(element, Model); }
/// <summary> /// Called when user clicks on the add-in menu /// </summary> /// <param name="e">The context of the VS tools and metadata</param> public override void OnClick(AddinDesignerEventArgs e) { try { // we will create Extension class here var selectedElement = e.SelectedElement as Microsoft.Dynamics.Framework.Tools.MetaModel.Automation.IRootElement; if (selectedElement != null) { // Find current model var modelSaveInfo = Common.CommonUtil.GetCurrentModelSaveInfo(); var metaModelService = Common.CommonUtil.GetModelSaveService(); var metadataType = selectedElement.GetMetadataType(); // Create a class with the same name + _Extension and add it to the project // ClassName string baseClassName = selectedElement.Name + "_Extension"; string className = baseClassName; int numClassesFound = 0; while (metaModelService.GetClass(className) != null) { numClassesFound++; className = baseClassName + numClassesFound.ToString(); } string intrinsicStr = String.Empty; if (selectedElement is ITable || selectedElement is IDataEntityView) { intrinsicStr = "tableStr"; } else if (selectedElement is IClassItem) { intrinsicStr = "classStr"; } else if (selectedElement is IForm) { intrinsicStr = "formStr"; } Microsoft.Dynamics.AX.Metadata.MetaModel.AxClass extensionClass = new AxClass() { Name = className }; extensionClass.SourceCode.Declaration = $"[ExtensionOf({intrinsicStr}({selectedElement.Name}))]\npublic final class {className}\n{{\n\n}}"; metaModelService.CreateClass(extensionClass, modelSaveInfo); Common.CommonUtil.AddElementToProject(extensionClass); } } catch (Exception ex) { CoreUtility.HandleExceptionWithErrorMessage(ex); } }
/// <summary> /// Called when user clicks on the add-in menu /// </summary> /// <param name="e">The context of the VS tools and metadata</param> public override void OnClick(AddinEventArgs e) { try { // Find project to work with VSProjectNode project = LocalUtils.GetActiveProject(); // An alternative way is calling ProjectHelper.GetProjectDetails(), but it's not consistent // with how projectService.AddElementToActiveProject() determines the active project. // ProjectHelper return the startup project, which doens't have to be the active project. if (project == null) { throw new InvalidOperationException("No project selected."); } // Create a new class AxClass axClass = new AxClass() { Name = "MyNewClass", IsAbstract = true // Set a property for demonstration }; // Find metamodel service needed below // Find current model //ModelInfo model = metaModelService.GetModel(ProjectHelper.GetProjectDetails().Model); ModelInfo model = project.GetProjectsModelInfo(); // Prepare information needed for saving ModelSaveInfo saveInfo = new ModelSaveInfo { Id = model.Id, Layer = model.Layer }; // Create class in the right model var metaModelProviders = ServiceLocator.GetService(typeof(IMetaModelProviders)) as IMetaModelProviders; var metaModelService = metaModelProviders.CurrentMetaModelService; metaModelService.CreateClass(axClass, saveInfo); // Add the class to the active project var projectService = ServiceLocator.GetService(typeof(IDynamicsProjectService)) as IDynamicsProjectService; projectService.AddElementToActiveProject(axClass); } catch (Exception ex) { CoreUtility.HandleExceptionWithErrorMessage(ex); } }
public static AxClass Construct(string name, dynamic baseElement = null) { AxClass myClass = new AxClass { Name = name }; if (baseElement != null) { string baseClassInterfaceName = baseElement.Caption; AxClass myBaseClassInterface = LocalUtils.MetaService.GetClass(baseClassInterfaceName); if (myBaseClassInterface.IsInterface) { myClass.Implements = new System.Collections.Generic.List <string> { baseClassInterfaceName }; foreach (var axMethod in myBaseClassInterface.Methods) { myClass.Methods.Add(axMethod); } } else { myClass.Extends = baseClassInterfaceName; if (myBaseClassInterface.IsFinal) { throw new Exception("Selected class is set as final, it cannot be extended"); } if (myBaseClassInterface.IsAbstract) { foreach (var axAbstractMethod in myBaseClassInterface.Methods.Where(m => m.IsAbstract)) { axAbstractMethod.IsAbstract = false; axAbstractMethod.Source = axAbstractMethod.Source.Replace("abstract ", ""); myClass.Methods.Add(axAbstractMethod); } } } } return(myClass); }
/// <summary> /// Adds a new method (with a hard-coded name and empty body) to the selected class. /// </summary> /// <param name="c">The class to which the method will be added.</param> /// <remarks> /// The method is added to the underlying file, but not to the designer. /// Visual Studio will detect the change and asks the user if the file should be reloaded. /// Another approach is needed to update the designer directly. /// </remarks> void AddMethodToFile(ClassItem c) { AxClass axClass = (AxClass)c.GetMetadataType(); // Add the method to the class axClass.AddMethod(BuildMethod()); // Prepare objects needed for saving var metaModelProviders = ServiceLocator.GetService(typeof(IMetaModelProviders)) as IMetaModelProviders; var metaModelService = metaModelProviders.CurrentMetaModelService; // Getting the model will likely have to be more sophisticated, such as getting the model of the project and checking // if the object has the same model. // But this shold do for demonstration. ModelInfo model = DesignMetaModelService.Instance.CurrentMetadataProvider.Classes.GetModelInfo(axClass.Name).FirstOrDefault <ModelInfo>(); // Update the file metaModelService.UpdateClass(axClass, new ModelSaveInfo(model)); }
void CreateClass() { AxHelper axHelper = new AxHelper(); NewAxClass = axHelper.MetadataProvider.Classes.Read(ClassName); //newAxClass = axHelper.MetadataProvider.Classes.Read("Tutorial_RunbaseBatch"); if (NewAxClass != null) { throw new Exception($"Class {ClassName} already exists"); } if (IsCreateMenuItem) { if (axHelper.MetadataProvider.MenuItemActions.Read(ClassName) != null) { throw new Exception($"Menu item action {ClassName} already exists"); } } NewAxClass = new AxClass { Name = ClassName }; CreateClassMethods(); axHelper.MetaModelService.CreateClass(NewAxClass, axHelper.ModelSaveInfo); axHelper.AppendToActiveProject(NewAxClass); AddLog($"Class: {NewAxClass.Name}; "); if (IsCreateMenuItem) { AxMenuItemAction axMenuItem = new AxMenuItemAction { Name = ClassName, Object = ClassName, ObjectType = MenuItemObjectType.Class }; axMenuItem.Label = ClassDescription; axMenuItem.HelpText = $"{axMenuItem.Label} operation"; axHelper.MetaModelService.CreateMenuItemAction(axMenuItem, axHelper.ModelSaveInfo); axHelper.AppendToActiveProject(axMenuItem); AddLog($"MenuItem: {axMenuItem.Name}; "); } }
void CreateClass() { AxHelper axHelper = new AxHelper(); NewAxClass = axHelper.MetadataProvider.Classes.Read(ClassName); if (NewAxClass != null) { throw new Exception($"Class {ClassName} already exists"); } NewAxClass = new AxClass { Name = ClassName }; CreateClassMethodsContract(); axHelper.MetaModelService.CreateClass(NewAxClass, axHelper.ModelSaveInfo); axHelper.AppendToActiveProject(NewAxClass); AddLog($"Class: {NewAxClass.Name}; "); }
public static AxClass GetExistingExtensionClass(string className, string extensionOfStr) { AxClass axClass = null; var metaModelService = Common.CommonUtil.GetModelSaveService(); var classNameExt = metaModelService.GetClassNames().ToList() .Where(searchClass => searchClass.ToLowerInvariant().Contains(className.ToLowerInvariant()) && metaModelService.GetClass(searchClass) .Declaration.ToLowerInvariant() .Contains(extensionOfStr.ToLowerInvariant()) ) .FirstOrDefault(); if (String.IsNullOrEmpty(classNameExt) == false) { axClass = metaModelService.GetClass(classNameExt); } return(axClass); }
void CreateControllerClass() { AxHelper axHelper = new AxHelper(); NewAxClass = axHelper.MetadataProvider.Classes.Read(ClassNameController); if (NewAxClass != null) { CoreUtility.DisplayInfo($"Class {NewAxClass.Name} already exists"); axHelper.AppendToActiveProject(NewAxClass); } else { NewAxClass = new AxClass { Name = ClassNameController }; CreateControllerMethods(); axHelper.MetaModelService.CreateClass(NewAxClass, axHelper.ModelSaveInfo); axHelper.AppendToActiveProject(NewAxClass); AddLog($"Class: {NewAxClass.Name}; "); } }
public static void Create(UtilElementType type, string name) { if (Project == null) { throw new InvalidOperationException("No project selected."); } _name = name; switch (type) { case UtilElementType.DisplayTool: var existsDisplayTool = LocalUtils.MetaService.GetMenuItemDisplayNames().Contains(name); if (!existsDisplayTool) { var displayMenu = new AxMenuItemDisplay { Name = name }; LocalUtils.MetaService.CreateMenuItemDisplay(displayMenu, Model); AddAotElement <AxMenuItemDisplay>(); } break; case UtilElementType.OutputTool: var existsOutputTool = LocalUtils.MetaService.GetMenuItemDisplayNames().Contains(name); if (!existsOutputTool) { var outputMenu = new AxMenuItemOutput { Name = name }; LocalUtils.MetaService.CreateMenuItemOutput(outputMenu, Model); AddAotElement <AxMenuItemOutput>(); } break; case UtilElementType.ActionTool: var existsActionTool = LocalUtils.MetaService.GetMenuItemDisplayNames().Contains(name); if (!existsActionTool) { var actionMenu = new AxMenuItemAction { Name = name }; LocalUtils.MetaService.CreateMenuItemAction(actionMenu, Model); AddAotElement <AxMenuItemAction>(); } break; case UtilElementType.Query: var existsQuery = LocalUtils.MetaService.GetQueryNames().Contains(name); if (!existsQuery) { var query = new AxQuerySimple { Name = name }; LocalUtils.MetaService.CreateQuery(query, Model); AddAotElement <AxQuerySimple>(); } break; case UtilElementType.Enum: var Enum = LocalUtils.MetaService.GetEnumNames().Contains(name); if (!Enum) { var edtEnum = new AxEnum { Name = name }; LocalUtils.MetaService.CreateEnum(edtEnum, Model); AddAotElement <AxEnum>(); } break; case UtilElementType.ExtendedType: break; case UtilElementType.Table: var existsTable = LocalUtils.MetaService.GetTableNames().Contains(name); if (!existsTable) { var table = new AxTable { Name = name }; LocalUtils.MetaService.CreateTable(table, Model); AddAotElement <AxTable>(); } break; case UtilElementType.Class: var existsClass = LocalUtils.MetaService.GetClassNames().Contains(name); if (!existsClass) { var axClass = new AxClass { Name = name }; LocalUtils.MetaService.CreateClass(axClass, Model); AddAotElement <AxClass>(); } break; case UtilElementType.SSRSReport: var existsSsrsReport = LocalUtils.MetaService.GetReportNames().Contains(name); if (!existsSsrsReport) { var srsReport = new AxReport { Name = name }; LocalUtils.MetaService.CreateReport(srsReport, Model); AddAotElement <AxReport>(); } break; case UtilElementType.Form: var existsForm = LocalUtils.MetaService.GetFormNames().Contains(name); if (!existsForm) { var axForm = new AxForm { Name = name }; LocalUtils.MetaService.CreateForm(axForm, Model); AddAotElement <AxForm>(); } break; case UtilElementType.Menu: var existsMenu = LocalUtils.MetaService.GetMenuNames().Contains(name); if (!existsMenu) { var axMenu = new AxMenu { Name = name }; LocalUtils.MetaService.CreateMenu(axMenu, Model); AddAotElement <AxMenu>(); } break; case UtilElementType.SecDuty: var existsSecDuty = LocalUtils.MetaService.GetSecurityDutyNames().Contains(name); if (!existsSecDuty) { var axDuty = new AxSecurityDuty { Name = name }; LocalUtils.MetaService.CreateSecurityDuty(axDuty, Model); AddAotElement <AxSecurityDuty>(); } break; case UtilElementType.SecPolicy: var existsSecPolicy = LocalUtils.MetaService.GetSecurityPolicyNames().Contains(name); if (!existsSecPolicy) { var axPolicy = new AxSecurityPolicy { Name = name }; LocalUtils.MetaService.CreateSecurityPolicy(axPolicy, Model); AddAotElement <AxSecurityPolicy>(); } break; case UtilElementType.SecPrivilege: var existsSecPrivilege = LocalUtils.MetaService.GetSecurityPrivilegeNames().Contains(name); if (!existsSecPrivilege) { var privilege = new AxSecurityPrivilege { Name = name }; LocalUtils.MetaService.CreateSecurityPrivilege(privilege, Model); AddAotElement <AxSecurityPrivilege>(); } break; case UtilElementType.SecRole: var existsSecRole = LocalUtils.MetaService.GetSecurityRoleNames().Contains(name); if (!existsSecRole) { var role = new AxSecurityRole { Name = name }; LocalUtils.MetaService.CreateSecurityRole(role, Model); AddAotElement <AxSecurityRole>(); } break; default: throw new Exception("Element not supported"); } }
public bool Run() { if (ResultClassName.Length > 80) { throw new Exception($"Class name can't be more than 80 symbols({ResultClassName.Length})"); } AxHelper axHelper = new AxHelper(); AxClass newClass = axHelper.MetadataProvider.Classes.Read(ResultClassName); bool res = false; if (newClass == null) { res = true; //throw new Exception($"Class {ResultClassName} already exists"); newClass = new AxClass { IsFinal = true, Name = ResultClassName }; if (ClassModeType == ExtensionClassModeType.EventHandler) { newClass.IsStatic = true; } string typeStr = ""; switch (ElementType) { case Kernel.ExtensionClassType.Form: typeStr = "formstr"; break; case Kernel.ExtensionClassType.Class: typeStr = "classstr"; break; case Kernel.ExtensionClassType.Table: typeStr = "tablestr"; break; case Kernel.ExtensionClassType.FormDataField: typeStr = "formdatafieldstr"; break; case Kernel.ExtensionClassType.FormDataSource: typeStr = "formdatasourcestr"; break; case Kernel.ExtensionClassType.FormControl: typeStr = "formcontrolstr"; break; case Kernel.ExtensionClassType.DataEntityView: typeStr = "dataentityviewstr"; break; case Kernel.ExtensionClassType.View: typeStr = "viewstr"; break; case Kernel.ExtensionClassType.Map: typeStr = "mapstr"; break; } StringBuilder declarationText = new StringBuilder(); if (ClassModeType == ExtensionClassModeType.Extension) { if (string.IsNullOrWhiteSpace(SubElementName)) { declarationText.AppendLine($"[ExtensionOf({typeStr}({ElementName}))]"); } else { declarationText.AppendLine($"[ExtensionOf({typeStr}({ElementName}, {SubElementName}))]"); } } declarationText.AppendLine($"final{(newClass.IsStatic ? " static " : " ")}class {newClass.Name}"); declarationText.AppendLine("{"); declarationText.AppendLine("}"); newClass.SourceCode.Declaration = declarationText.ToString(); axHelper.MetaModelService.CreateClass(newClass, axHelper.ModelSaveInfo); axHelper.AppendToActiveProject(newClass); AddLog($"Class: {newClass.Name}; "); } else { CoreUtility.DisplayInfo($"Class {newClass.Name} already exists"); axHelper.AppendToActiveProject(newClass); } return(res); }
public void Run() { AxHelper axHelper = new AxHelper(); AxClass newClass = axHelper.MetadataProvider.Classes.Read(ResultClassName); if (newClass != null) { throw new Exception($"Class {ResultClassName} already exists"); } newClass = new AxClass { IsFinal = true, Name = ResultClassName }; if (ClassType == ExtensionClassType.EventHandler) { newClass.IsStatic = true; } string typeStr = ""; switch (ElementType) { case ExtensionClassObject.Form: typeStr = "formstr"; break; case ExtensionClassObject.Class: typeStr = "classstr"; break; case ExtensionClassObject.Table: typeStr = "tablestr"; break; case ExtensionClassObject.FormDataField: typeStr = "formdatafieldstr"; break; case ExtensionClassObject.FormDataSource: typeStr = "formdatasourcestr"; break; case ExtensionClassObject.FormControl: typeStr = "formcontrolstr"; break; case ExtensionClassObject.DataEntityView: typeStr = "dataentityviewstr"; break; } StringBuilder declarationText = new StringBuilder(); if (ClassType == ExtensionClassType.Extension) { if (string.IsNullOrWhiteSpace(SubElementName)) { declarationText.AppendLine($"[ExtensionOf({typeStr}({ElementName}))]"); } else { declarationText.AppendLine($"[ExtensionOf({typeStr}({ElementName}, {SubElementName}))]"); } } declarationText.AppendLine($"final{(newClass.IsStatic ? " static " : " ")}class {newClass.Name}"); declarationText.AppendLine("{"); declarationText.AppendLine("}"); newClass.SourceCode.Declaration = declarationText.ToString(); axHelper.MetaModelService.CreateClass(newClass, axHelper.ModelSaveInfo); axHelper.AppendToActiveProject(newClass); AddLog($"Class: {newClass.Name}; "); }
/// <summary> /// Called when user clicks on the add-in menu /// </summary> /// <param name="e">The context of the VS tools and metadata</param> public override void OnClick(AddinDesignerEventArgs e) { try { int displayOrder = 0; // we will create Extension class here var selectedElement = e.SelectedElement as Microsoft.Dynamics.Framework.Tools.MetaModel.Automation.IRootElement; if (selectedElement != null) { // Find current model var modelSaveInfo = Common.CommonUtil.GetCurrentModelSaveInfo(); var metaModelService = Common.CommonUtil.GetModelSaveService(); IClassItem classItem = selectedElement as IClassItem; // Get the selected class AxClass object AxClass selectedClass = Common.CommonUtil.GetModelSaveService().GetClass(classItem.Name); // TODO: check that the class is a RunBaseBatch class. Otherwise send message that this is not required. // Create Contract class Microsoft.Dynamics.AX.Metadata.MetaModel.AxClass contractClass = new AxClass() { Name = classItem.Name + "Contract", }; contractClass.Implements.Add("SysOperationValidatable"); contractClass.AddAttribute(new AxAttribute() { Name = "DataContract" }); contractClass.SourceCode.Declaration = $"[DataContract]\npublic final class {contractClass.Name} implements SysOperationValidatable\n{{\n\n}}"; // this is replaced again later with the variables List <string> contractParms = new List <string>(); // store the variables here List <string> contractParmMethods = new List <string>(); // store the parm methods here List <string> axParmVariables = new List <string>(); List <AxMethod> axMethods = new List <AxMethod>(); string currentGroup = string.Empty; string headerAttributes = "DataContract"; int headerAttributeOrder = 0; var dialogMethod = selectedClass.Methods.Where(m => m.Name.Equals("dialog", StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault(); if (dialogMethod != null) { // from the dialog method we would know what the code fields should be var dialogSource = dialogMethod.Source; // var dialogLines = dialogSource.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries).ToList(); foreach (var dialogLine in dialogLines) { if (dialogLine.Trim().StartsWith("public")) { continue; } else if (dialogLine.Contains(".addGroup(")) { // set the group name here string dialogSourceLine = dialogLine.Substring(dialogLine.IndexOf("(") + 1); dialogSourceLine = dialogSourceLine.Replace(");", "").Replace("\"", "").Trim(); string currentGrouplabel = dialogSourceLine; currentGroup = dialogSourceLine; if (currentGroup.StartsWith("@")) { // we need to get a name for this group var label = Labels.LabelHelper.FindLabelGlobally(currentGrouplabel); if (label != null) { currentGroup = label.LabelText; } } currentGroup = currentGroup.Replace(" ", "").Trim(); headerAttributes += $", SysOperationGroupAttribute('{currentGroup}', \"{currentGrouplabel}\", '{headerAttributeOrder}')"; headerAttributeOrder++; } else if (dialogLine.Contains(".addField")) { string addFieldLine = dialogLine.Trim(); // so over here we will get the field to add as a member & parm method addFieldLine = addFieldLine.Substring(addFieldLine.IndexOf(".addField")); addFieldLine = addFieldLine.Substring(addFieldLine.IndexOf("(") + 1); addFieldLine = addFieldLine.Replace(");", "").Trim(); var parameters = addFieldLine.Split(new string[] { "," }, StringSplitOptions.None).ToList(); parameters.ForEach(p => p.Trim()); string fieldType = String.Empty; string fieldLabel = String.Empty; string fieldHelp = String.Empty; string fieldName = String.Empty; string attributes = String.Empty; attributes = $"[DataMember, SysOperationDisplayOrder('{displayOrder}')"; // we will always have a fieldType (or atleast we should) fieldType = parameters[0].Substring(parameters[0].IndexOf("(") + 1) .Replace("(", "").Replace(")", "").Trim(); if (parameters.Count >= 2) { fieldName = parameters[1].Replace("\"", "").Trim(); //if (String.IsNullOrEmpty(fieldLabel) == false) //{ // attributes += $", SysOperationLabel('{fieldName}')"; //} } if (parameters.Count >= 3) { fieldLabel = parameters[2].Replace("\"", "").Trim(); if (String.IsNullOrEmpty(fieldLabel) == false) { attributes += $", SysOperationLabel(\"{fieldLabel}\")"; } } if (parameters.Count >= 4) { fieldHelp = parameters[3].Replace("\"", "").Trim(); if (String.IsNullOrEmpty(fieldHelp) == false) { attributes += $", SysOperationHelpText(\"{fieldHelp}\")"; } } // add the group here if (!String.IsNullOrEmpty(currentGroup)) { attributes += $", SysOperationGroupMemberAttribute(\"{currentGroup}\")"; } attributes += "]"; /* Crude method * string fieldType = addFieldLine.Substring(0, addFieldLine.IndexOf(",")); * fieldType = fieldType.Substring(fieldType.IndexOf("(") + 1) * .Replace("(", "").Replace(")", "").Trim(); * * string fieldLabel = String.Empty; * string fieldHelp = String.Empty; * string fieldName = addFieldLine.Substring(addFieldLine.IndexOf(",") + 1) * .Replace(")", "").Replace(";", "").Trim(); * if (fieldName.Count(c => c == ',') > 0) * { * // that means there is a label / help label in here as well * // Break the fieldname further * // find the label here * string fieldNameLabel = fieldName; * fieldName = fieldNameLabel.Substring(0, fieldNameLabel.IndexOf(",")).Trim(); * * // find the help label here * } */ AxClassMemberVariable axVar = new AxClassMemberVariable { TypeName = fieldType, Name = fieldName }; axVar.Type = Microsoft.Dynamics.AX.Metadata.Core.MetaModel.CompilerBaseType.AnyType; axParmVariables.Add($"\t{fieldType} {fieldName};"); contractClass.AddMember(axVar); // need to add Attributes here // add parameters to the method //fieldName = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(fieldName); AxMethod method = new AxMethod { Name = "parm" + System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(fieldName), ReturnType = new AxMethodReturnType() { TypeName = fieldType } }; //,{SysOperationLabelAttribute(""{}"")} // add the group & label & help attribute method.Source = //$@" [DataMember,SysOperationDisplayOrder('{displayOrder}')] $@" {attributes} public {fieldType} {method.Name} ({fieldType} _{fieldName} = {fieldName}) {{ {fieldName} = _{fieldName}; return {fieldName}; }}" + Environment.NewLine; //contractClass.AddMethod(method); axMethods.Add(method); displayOrder++; } } } // Add all the axmethods here string parmVarSource = string.Empty; axParmVariables.ForEach(s => parmVarSource = parmVarSource + "\n" + s); //contractClass.SourceCode.Declaration = $"[DataContract]\npublic final class {contractClass.Name}\n{{\n{parmVarSource}\n\n}}"; contractClass.SourceCode.Declaration = $"[{headerAttributes}]\npublic final class {contractClass.Name} implements SysOperationValidatable\n{{\n{parmVarSource}\n\n}}"; axMethods.ForEach(method => contractClass.AddMethod(method)); // Create validate method this.applyValidateMethod(selectedClass, contractClass); metaModelService.CreateClass(contractClass, modelSaveInfo); Common.CommonUtil.AddElementToProject(contractClass); //extensionClass.SourceCode.Declaration = $"[ExtensionOf({intrinsicStr}({selectedElement.Name}))]\npublic final class {className}\n{{\n\n}}"; /* * * metaModelService.CreateClass(extensionClass, modelSaveInfo); * Common.CommonUtil.AddElementToProject(extensionClass); */ } } catch (Exception ex) { CoreUtility.HandleExceptionWithErrorMessage(ex); } }