Example #1
0
        private void AddBuildType_Click(object sender, System.Windows.RoutedEventArgs e)
        {
            try
            {
                if (InputBox.ShowDialog("Build Type", "Name").IsFalse())
                {
                    return;
                }

                BuildTypeModel buildType = new BuildTypeModel
                {
                    BuildTypeName  = InputBox.Result,
                    BuildTypeIndex = this.OptionSetup.BuildTypes.Length
                };

                this.OptionSetup.BuildTypes = this.OptionSetup.BuildTypes.Add(buildType);

                this.uxBuildTypes.Items.Add(buildType);

                this.uxBuildTypes[buildType.BuildTypeIndex].Header = $"{InputBox.Result} = [[{buildType.BuildTypeIndex}]]";

                buildType.PropertyChanged += this.BuildType_Changed;
            }
            catch (Exception err)
            {
                MessageBox.Show(err.InnerExceptionMessage());
            }
        }
Example #2
0
        public string BuildSampleForeachTableScript(ErdCanvasModel sampleCanvas, List <ErdCanvasModel> allErdModels, TableModel table, OptionSetupModel classOption)
        {
            if (classOption.BuildTypes.Length == 0)
            {
                return(string.Empty);
            }

            this.ErdCanvas = sampleCanvas;

            this.AllErdCanvasModels = allErdModels;

            this.SelectedTable = table;

            StringBuilder result = new StringBuilder();

            int minIndex = classOption.BuildTypes.Min(m => m.BuildTypeIndex);

            BuildTypeModel body = classOption.BuildTypes.FirstOrDefault(mi => mi.BuildTypeIndex == minIndex);

            result.Append(this.ReplaceParameters(body.Code));

            this.BuildTypeIteration(ref result, classOption.BuildTypes);

            this.ExecuteIfStatment(ref result, 0);

            return(this.RemoveTrailingCharacters(result));
        }
Example #3
0
        public string BuildSingleFile(OptionSetupModel classOption)
        {
            if (classOption.BuildTypes.Length == 0)
            {
                return(string.Empty);
            }

            StringBuilder result = new StringBuilder();

            int minIndex = classOption.BuildTypes.Min(m => m.BuildTypeIndex);

            BuildTypeModel body = classOption.BuildTypes.FirstOrDefault(mi => mi.BuildTypeIndex == minIndex);

            result.Append(body.Code);

            this.ExecuteIfStatment(ref result, 0);

            return(this.RemoveTrailingCharacters(result));
        }
Example #4
0
        private void BuildTypeSwitch(BuildTypeModel buildType, ref StringBuilder injectionText)
        {
            switch (buildType.RepeatType)
            {
            case RepeatTypeEnum.ForeachPrimaryKeyInTable:

                #region FOREACH PRIMARY KEY IN TABLE

                ColumnObjectModel[] keyColumnsArray = this.SelectedTable.Columns
                                                      .Where(pk => pk.InPrimaryKey).ToArray();

                for (int keyCol = 0; keyCol < keyColumnsArray.Length; ++keyCol)
                {
                    this.SelectedColumn = keyColumnsArray[keyCol];

                    injectionText.Append(this.ReplaceParameters(buildType.Code));
                }

                break;

                #endregion

            case RepeatTypeEnum.ForeachPrimaryOnlyKeyInTable:

                #region FOREACH PRIMARY KEY IN TABLE

                ColumnObjectModel[] keyOnlyColumnsArray = this.SelectedTable.Columns
                                                          .Where(pk => pk.InPrimaryKey &&
                                                                 !pk.IsForeignkey).ToArray();

                for (int keyCol = 0; keyCol < keyOnlyColumnsArray.Length; ++keyCol)
                {
                    this.SelectedColumn = keyOnlyColumnsArray[keyCol];

                    injectionText.Append(this.ReplaceParameters(buildType.Code));
                }

                break;

                #endregion

            case RepeatTypeEnum.ForeachForeignKeyInTable:

                #region FOREACH FOREIGN KEY IN TABLE (NON-PRIMARY KEY)

                ColumnObjectModel[] foreignKeyColumnsArray = this.SelectedTable.Columns
                                                             .Where(pk => pk.IsForeignkey &&
                                                                    !pk.InPrimaryKey)
                                                             .ToArray();

                for (int keyCol = 0; keyCol < foreignKeyColumnsArray.Length; ++keyCol)
                {
                    this.SelectedColumn = foreignKeyColumnsArray[keyCol];

                    injectionText.Append(this.ReplaceParameters(buildType.Code));
                }

                break;

                #endregion

            case RepeatTypeEnum.ForeachPrimaryForeignKeyInTable:

                #region FOREACH FOREIGN KEY IN TABLE (INCLUDED PRIMARY KEYS)

                ColumnObjectModel[] foreignAndPrimaryKeyColumnsArray = this.SelectedTable.Columns
                                                                       .Where(pk => pk.IsForeignkey)
                                                                       .ToArray();

                for (int keyCol = 0; keyCol < foreignAndPrimaryKeyColumnsArray.Length; ++keyCol)
                {
                    this.SelectedColumn = foreignAndPrimaryKeyColumnsArray[keyCol];

                    injectionText.Append(this.ReplaceParameters(buildType.Code));
                }

                break;

                #endregion

            case RepeatTypeEnum.ForeachNonColumnInTable:

                #region FOREACH NON-KEY COLUMN IN TABLE

                ColumnObjectModel[] nonKeyColumnsArray = this.SelectedTable.Columns
                                                         .Where(nk => !nk.InPrimaryKey &&
                                                                !nk.IsForeignkey).ToArray();

                for (int keyCol = 0; keyCol < nonKeyColumnsArray.Length; ++keyCol)
                {
                    this.SelectedColumn = nonKeyColumnsArray[keyCol];

                    injectionText.Append(this.ReplaceParameters(buildType.Code));
                }

                break;

                #endregion

            case RepeatTypeEnum.ForeachColumnInTable:

                #region FOREACH COLUMN IN TABLE

                foreach (ColumnObjectModel column in this.SelectedTable.Columns)
                {
                    this.SelectedColumn = column;

                    injectionText.Append(this.ReplaceParameters(buildType.Code));
                }

                break;

                #endregion

            case RepeatTypeEnum.ForeachReferencedTable:

                #region FOREACH REFERENCED TABLE

                Dictionary <string, TableModel> referenceTables = new Dictionary <string, TableModel>();

                foreach (ErdCanvasModel canvas in this.AllErdCanvasModels)
                {
                    foreach (TableModel table in canvas.SegmentTables)
                    {
                        if (table.Columns.Any(col => col.ForeignKeyTable == this.SelectedTable.TableName) &&
                            !referenceTables.ContainsKey(table.TableName))
                        {
                            referenceTables.Add(table.TableName, table);
                        }
                    }
                }

                foreach (TableModel table in referenceTables.Values)
                {
                    this.SelectedReferencedTable = table;

                    injectionText.Append(this.ReplaceParameters(buildType.Code));
                }

                break;

                #endregion

            case RepeatTypeEnum.Once:
            default:

                injectionText.Append(this.ReplaceParameters(buildType.Code));

                break;
            }
        }
Example #5
0
        private void BuildTypeIteration(ref StringBuilder result, BuildTypeModel[] buildTypesArray)
        {
            for (int x = 1; x < buildTypesArray.Length; ++x)
            {
                BuildTypeModel buildType = buildTypesArray[x];

                string buildTypeParameter = $"[[{buildType.BuildTypeIndex}]]";

                StringBuilder injectionText = new StringBuilder();

                switch (buildType.RepeatType)
                {
                case RepeatTypeEnum.ForeachTableInCanvas:

                    List <BuildTypeModel> nextTypesList = new List <BuildTypeModel>();

                    int xIndex = x;

                    while (xIndex < buildTypesArray.Length)
                    {
                        nextTypesList.Add(buildTypesArray[xIndex]);

                        ++xIndex;
                    }

                    for (int table = 0; table < this.ErdCanvas.SegmentTables.Count; ++table)
                    {
                        this.SelectedTable = this.ErdCanvas.SegmentTables[table];

                        injectionText.Append(this.ReplaceParameters(buildType.Code));

                        this.BuildTypeIteration(ref injectionText, nextTypesList.ToArray());
                    }

                    break;

                case RepeatTypeEnum.ForeachTableInProject:

                    List <BuildTypeModel> nextTypesListB = new List <BuildTypeModel>();

                    int xIndexB = x;

                    while (xIndexB < buildTypesArray.Length)
                    {
                        nextTypesListB.Add(buildTypesArray[xIndexB]);

                        ++xIndexB;
                    }

                    foreach (ErdCanvasModel canvas in this.AllErdCanvasModels)
                    {
                        foreach (TableModel table in canvas.SegmentTables)
                        {
                            this.SelectedTable = table;

                            injectionText.Append(this.ReplaceParameters(buildType.Code));

                            this.BuildTypeIteration(ref injectionText, nextTypesListB.ToArray());
                        }
                    }

                    break;

                default:

                    this.BuildTypeSwitch(buildType, ref injectionText);

                    break;
                }

                result.Replace(buildTypeParameter, this.RemoveTrailingCharacters(injectionText));
            }
        }