public override void CreateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            if (IsNew)
            {
                base.CreateEntities(context);

                PxMetaModel.FootnoteValue footnoteValue = new PxMetaModel.FootnoteValue();

                footnoteValue.ValuePool = Value.ValuePool;

                footnoteValue.ValueCode = Value.ValueCode;

                footnoteValue.FootnoteNo = FootnoteNo;

                footnoteValue.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;

                footnoteValue.LogDate = DateTime.Now;

                context.AddToFootnoteValues(footnoteValue
                    );
            }

            else
            {
                base.UpdateEntities(context);
            }
        }
        public override void CreateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            if (IsNew)
            {
                base.CreateEntities(context);

                PxMetaModel.FootnoteContTime footnoteContentTime = new PxMetaModel.FootnoteContTime();

                footnoteContentTime.MainTable = ContentTime.Content.MainTable.TableId;

                footnoteContentTime.Contents = ContentTime.Content.Content;

                footnoteContentTime.TimePeriod = ContentTime.TimePeriod;

                footnoteContentTime.FootnoteNo = FootnoteNo;

                footnoteContentTime.Cellnote = "N";

                footnoteContentTime.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;

                footnoteContentTime.LogDate = DateTime.Now;

                context.AddToFootnoteContTimes(footnoteContentTime);
            }

            else
            {
                base.UpdateEntities(context);
            }
        }
        public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            base.DeleteEntities(context);

            var f = (from c in context.FootnoteMainTables
                        where c.FootnoteNo == FootnoteNo && c.MainTable == MainTable.TableId
                        select c).First();

            context.DeleteObject(f);
        }
        public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            base.DeleteEntities(context);

            var f = (from cv in context.FootnoteContVbls
                     where cv.FootnoteNo == FootnoteNo && cv.MainTable == MainTable.TableId && cv.Contents == Content.Content && cv.Variable == Variable.Variable
                     select cv).First();

            context.DeleteObject(f);
        }
        public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            base.DeleteEntities(context);

            var f = (from fvalue in context.FootnoteValues
                     where fvalue.FootnoteNo == FootnoteNo  && fvalue.ValuePool == Value.ValuePool && fvalue.ValueCode == Value.ValueCode
                     select fvalue).First();

            context.DeleteObject(f);
        }
        public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            base.DeleteEntities(context);

            var f = (from cfvalue in context.FootnoteContValues
                     where cfvalue.FootnoteNo == FootnoteNo && cfvalue.MainTable == MainTable.TableId && cfvalue.Contents == Content.Content && cfvalue.Variable == Variable.Variable && cfvalue.ValuePool == Value.ValuePool && cfvalue.ValueCode == Value.ValueCode
                     select cfvalue).First();

            context.DeleteObject(f);
        }
        public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            base.DeleteEntities(context);

            var f = (from fcontTime in context.FootnoteContTimes
                     where fcontTime.FootnoteNo == FootnoteNo && fcontTime.MainTable == ContentTime.Content.MainTable.TableId && fcontTime.Contents == ContentTime.Content.Content && fcontTime.TimePeriod == ContentTime.TimePeriod
                     select fcontTime).FirstOrDefault();
            if (f != null)
            {
                context.DeleteObject(f);
            }
        }
        public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            base.DeleteEntities(context);

            var f = (from c in context.FootnoteContents
                     where c.FootnoteNo == FootnoteNo && c.MainTable == MainTable.TableId && c.Contents == Content.Content
                     select c).FirstOrDefault();
            if (f != null)
            {
                context.DeleteObject(f);
            }
        }
Example #9
0
 public void Save(PxMetaModel.PcAxisMetabaseEntities context)
 {
     //TODO check if isdirty works
     if (IsDirty)
     {
         if (IsNew)
         {
             CreateEntities(context);
         }
         else
         {
             UpdateEntities(context);
         }
     }
 }
Example #10
0
        public override void CreateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            if (IsNew)
            {
                PxMetaModel.ContentsTime contentsTime = new PxMetaModel.ContentsTime();
                contentsTime.TimePeriod = TimePeriod;
                contentsTime.Contents = Content.Content;
                contentsTime.MainTable = Content.MainTable.TableId;
                contentsTime.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                contentsTime.LogDate = DateTime.Now;

                context.AddToContentsTimes(contentsTime);

                foreach (var timeFootnote in TimeFootnotes)
                {
                    timeFootnote.ContentTime = this;
                    timeFootnote.Save(context);
                }
            }
        }
Example #11
0
        public override void UpdateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            if (!IsNew)
            {
                var valueset = (from vs in context.ValueSets
                                where vs.ValueSet1 == Valueset
                                select vs).First();
                valueset.PresText = PresText;
                valueset.Description = PresText;
                valueset.Elimination = Elimination;
                valueset.SortCodeExists = "Y";
                valueset.Footnote = "S";
                valueset.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                valueset.LogDate = DateTime.Now;

                var valueset_eng = (from vs_eng in context.ValueSet_Eng
                                    where vs_eng.ValueSet == Valueset
                                    select vs_eng).First();
                valueset_eng.PresText = PresTextEnglish;
                valueset_eng.Description = PresTextEnglish;
                valueset_eng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                valueset_eng.LogDate = DateTime.Now;

                foreach (var v in Values)
                {
                    if (!v.IsNew)
                    {
                        v.ValuePool = ValuePool;
                        v.Save(context);
                    }
                }
            }
        }
        public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            base.DeleteEntities(context);
            var menuSel_Eng = (from mse in context.MenuSelection_Eng
                               where mse.Menu == Parent.Menu && mse.Selection == Menu
                               select mse).FirstOrDefault();
            if (menuSel_Eng != null)
            {
                context.DeleteObject(menuSel_Eng);
            }
            var menusel = (from ms in context.MenuSelections
                           where ms.Menu == Parent.Menu && ms.Selection == Menu
                               select ms).FirstOrDefault();
            if (menusel != null)
            {

                context.DeleteObject(menusel);
            }
        }
Example #13
0
        public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            foreach  (PxTime time in _time)
            {
                time.DeleteEntities(context);
            }

            foreach (PxContentFootnote contentFootnote in Footnotes)
            {

                contentFootnote.DeleteEntities(context);
            }

            foreach (PxContentVariableFootnote contentVariableFootnote in ContentVariableFootnotes)
            {

                contentVariableFootnote.DeleteEntities(context);
            }

            foreach (PxContentValueFootnote contentValueFootnote in ContentValueFootnotes)
            {

                contentValueFootnote.DeleteEntities(context);
            }

            foreach (PxContentVariableFootnote contentVariableFootnote in RemovedContentVariableFootnotes)
            {
                contentVariableFootnote.DeleteEntities(context);
            }

            foreach (PxContentFootnote contentFootnote in RemovedFootnotes)
            {
                contentFootnote.DeleteEntities(context);
            }

            foreach (PxContentValueFootnote contentValueFootnote in RemovedContentValueFootnotes)
            {
                contentValueFootnote.DeleteEntities(context);
            }

            var contEngToDel = (from c in context.Contents_Eng
                                where c.Contents == Content && c.MainTable == MainTable.TableId
                                select c).FirstOrDefault();
            if (contEngToDel != null)
            {
                context.DeleteObject(contEngToDel);
            }

            var contToDel = (from c in context.Contents
                             where c.Contents == Content && c.MainTable == MainTable.TableId
                             select c).FirstOrDefault();
            if (contToDel != null)
            {
                context.DeleteObject(contToDel);
            }
        }
Example #14
0
        public override void UpdateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            if (!IsNew)
            {
                var footnote = (from f in context.Footnotes
                                where f.FootnoteNo == FootnoteNo
                                select f).First();
                footnote.MandOpt = MandOption;
                footnote.FootnoteText = FootnoteText;
                footnote.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                footnote.LogDate = DateTime.Now;

                var footnoteEng = (from f in context.Footnote_Eng
                                   where f.FootnoteNo == FootnoteNo
                                   select f).First();
                footnoteEng.FootnoteText = FootnoteTextEnglish;
                footnoteEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                footnoteEng.LogDate = DateTime.Now;
            }
        }
Example #15
0
 public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
 {
     var fEng = (from c in context.Footnote_Eng
                         where c.FootnoteNo == FootnoteNo
                         select c).FirstOrDefault();
     if (fEng != null)
     {
         context.DeleteObject(fEng);
     }
     var f = (from c in context.Footnotes
                      where c.FootnoteNo == FootnoteNo
                      select c).FirstOrDefault();
     if (f != null)
     {
         context.DeleteObject(f);
     }
 }
        public override void CreateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            PxMetaModel.MenuSelection menuSelection = new PxMetaModel.MenuSelection();

            menuSelection.Menu = Parent.Menu;
            menuSelection.Selection = Menu;
            menuSelection.PresText = PresText;
            menuSelection.PresTextS = PresTextS;
            menuSelection.Presentation = Presentation;
            menuSelection.LevelNo = LevelNo;
            menuSelection.Description = Description;
            menuSelection.SortCode = SortCode;
            menuSelection.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            menuSelection.LogDate = DateTime.Now;

            context.AddToMenuSelections(menuSelection);

            PxMetaModel.MenuSelection_Eng menuSelectionEng = new PxMetaModel.MenuSelection_Eng();

            menuSelectionEng.MenuSelection = menuSelection;
            menuSelectionEng.PresText = PresTextEnglish;
            menuSelectionEng.PresTextS = PresTextSEnglish;
            menuSelectionEng.Presentation = PresentationEnglish;
            menuSelectionEng.Description = DescriptionEnglish;
            menuSelectionEng.SortCode = SortCodeEnglish;
            menuSelectionEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            menuSelectionEng.LogDate = DateTime.Now;

            context.AddToMenuSelection_Eng(menuSelectionEng);
        }
        public override void UpdateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            if (!IsNew)
            {
                var mainTable = (from mt in context.MainTables
                                 where mt.MainTable1 == TableId
                                 select mt).First();

                mainTable.PresText = PresText;
                mainTable.PresTextS = PressTextS;
                mainTable.TableStatus = TableStatus;
                mainTable.SpecCharExists = SpecCharExists;
                mainTable.ContentsVariable = ContentVariable;
                mainTable.PresCategory = PresCategory;
                mainTable.TimeScale = TimeScaleId;
                mainTable.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                mainTable.LogDate = DateTime.Now;

                var mainTableEng = (from mte in context.MainTable_Eng
                                    where mte.MainTable == TableId
                                    select mte).First();
                mainTableEng.PresText = TableTitleEnglish;
                mainTableEng.PresTextS = TableTitleEnglish;
                mainTableEng.Status = EnglishStatus;
                mainTableEng.Published = EnglishPublished;
                mainTableEng.ContentsVariable = ContentVariableEnglish;
                mainTableEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                mainTableEng.LogDate = DateTime.Now;

            }

            short counter = 0;
            foreach (var content in _contents)
            {
                counter++;
                content.StoreColumnNo = counter;
                content.MainTable = this;
                content.Save(context);
            }

            counter = 0;
            foreach (var variable in _variables)
            {
                counter++;
                variable.StoreColumnNo = counter;
                variable.MainTable = this;
                variable.Save(context);

            }

            foreach (var f in Footnotes)
            {
                f.MainTable = this;
                f.Save(context);
            }

            foreach (var mainTableValueFootnote in MainTableValueFootnotes)
            {
                mainTableValueFootnote.MainTable = this;
                mainTableValueFootnote.Save(context);
            }
            foreach (var variable in _removedVariables)
            {
                variable.DeleteEntities(context);
            }

            foreach (var content in RemovedContents)
            {
                content.DeleteEntities(context);
            }

            foreach (var footnote in RemovedFootnotes)
            {
                footnote.DeleteEntities(context);
            }
        }
        public override void CreateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            if (IsNew)
            {
                PxMetaModel.MainTable mainTable = new PxMetaModel.MainTable();

                mainTable.MainTable1 = TableId;
                mainTable.PresText = PresText;
                mainTable.PresTextS = PressTextS;
                mainTable.TableStatus = TableStatus;
                mainTable.SpecCharExists = SpecCharExists;
                mainTable.ContentsVariable = ContentVariable;
                mainTable.TableId = TableId;
                mainTable.PresCategory = PresCategory;
                mainTable.ProductId = ProductId;
                mainTable.SubjectCode = Theme;
                mainTable.TimeScale = TimeScaleId;
                mainTable.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                mainTable.LogDate = DateTime.Now;

                context.AddToMainTables(mainTable);

                PxMetaModel.MainTable_Eng mainTableEng = new PxMetaModel.MainTable_Eng();
                mainTableEng.MainTable1 = mainTable;
                mainTableEng.PresText = TableTitleEnglish;
                mainTableEng.PresTextS = TableTitleEnglish;
                mainTableEng.Status = EnglishStatus;
                mainTableEng.Published = EnglishPublished;
                mainTableEng.ContentsVariable = ContentVariableEnglish;
                mainTableEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                mainTableEng.LogDate = DateTime.Now;

                context.AddToMainTable_Eng(mainTableEng);

                short counter = 0;
                foreach (var content in _contents)
                {
                    counter++;
                    content.StoreColumnNo = counter;
                    content.MainTable = this;
                    content.Save(context);

                }

                PxMetaModel.SubTable subTable = new PxMetaModel.SubTable();
                subTable.MainTable1 = mainTable;
                subTable.SubTable1 = "1";
                subTable.PresText = mainTable.PresText;
                subTable.CleanTable = "X";
                subTable.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                subTable.LogDate = DateTime.Now;

                context.AddToSubTables(subTable);

                PxMetaModel.SubTable_Eng subTableEng = new PxMetaModel.SubTable_Eng();
                subTableEng.SubTable1 = subTable;
                subTableEng.PresText = mainTableEng.PresText;
                subTableEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                subTableEng.LogDate = DateTime.Now;

                counter = 0;
                foreach (var variable in _variables)
                {
                    counter++;
                    variable.StoreColumnNo = counter;
                    variable.MainTable = this;
                    variable.Save(context);
                }

                foreach (var footnote in Footnotes)
                {
                    footnote.MainTable = this;

                    footnote.Save(context);
                }

                foreach (var mainTableValueFootnote in MainTableValueFootnotes)
                {
                    mainTableValueFootnote.MainTable = this;
                    mainTableValueFootnote.Save(context);
                }

            }
        }
Example #19
0
        public override void CreateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            if (IsNew)
            {
                PxMetaModel.Variable variable = new PxMetaModel.Variable();
                variable.Variable1 = Variable;
                variable.PresText = PresText;
                variable.VariableInfo = VariableInfo;
                variable.Footnote = Footnote;
                variable.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                variable.LogDate = DateTime.Now;

                context.AddToVariables(variable);

                PxMetaModel.Variable_Eng variableEng = new PxMetaModel.Variable_Eng();
                variableEng.Variable1 = variable;
                variableEng.PresText = PresTextEnglish;
                variableEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                variableEng.LogDate = DateTime.Now;

                context.AddToVariable_Eng(variableEng);
            }

            PxMetaModel.SubTableVariable subTableVariable = new PxMetaModel.SubTableVariable();
            subTableVariable.MainTable = MainTable.TableId;
            subTableVariable.SubTable =  "1";
            subTableVariable.Variable = Variable;
            subTableVariable.ValueSet = String.IsNullOrWhiteSpace(ValueSet)?null:ValueSet;
            subTableVariable.VariableType = VariableType;
            subTableVariable.StoreColumnNo = StoreColumnNo;
            subTableVariable.UserID = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            subTableVariable.LogDate = DateTime.Now;

            context.AddToSubTableVariables(subTableVariable);

            foreach (var variableFootnote in VariableFootnotes)
            {
                variableFootnote.Variable = this;
                variableFootnote.Save(context);
            }
        }
Example #20
0
 public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
 {
     var var = (from v in context.SubTableVariables
                where v.MainTable == MainTable.TableId && v.SubTable == "1" && v.Variable == Variable
                select v).First();
     context.DeleteObject(var);
 }
Example #21
0
 public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
 {
     base.DeleteEntities(context);
     foreach (PxTimeFootnote timeFootnote in _timeFootnotes)
     {
         timeFootnote.DeleteEntities(context);
     }
     var contTime = (from ct in context.ContentsTimes
                     where ct.Contents == Content.Content && ct.MainTable == Content.MainTable.TableId && ct.TimePeriod == TimePeriod
                     select ct).First();
     context.DeleteObject(contTime);
 }
Example #22
0
        public override void UpdateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            if (!IsNew)
            {
                PxMetaModel.Variable variable = (from v in context.Variables
                                                 where v.Variable1 == Variable
                                                 select v).First();
                variable.PresText = PresText;
                variable.VariableInfo = VariableInfo;
                variable.Footnote = Footnote == null ? "N" : Footnote;
                variable.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                variable.LogDate = DateTime.Now;

                PxMetaModel.Variable_Eng variableEng = (from v in context.Variable_Eng
                                                        where v.Variable == Variable
                                                        select v).First();
                variableEng.PresText = PresTextEnglish;
                variableEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                variableEng.LogDate = DateTime.Now;
            }

            PxMetaModel.SubTableVariable subTableVariable = (from st in context.SubTableVariables
                                                             where st.MainTable == MainTable.TableId && st.SubTable == "1" && st.Variable == Variable
                                                             select st).FirstOrDefault();
            if (subTableVariable == null)
            {
                subTableVariable = new PxMetaModel.SubTableVariable();
                subTableVariable.MainTable = MainTable.TableId;
                subTableVariable.SubTable = "1";
                subTableVariable.Variable = Variable;
                context.AddToSubTableVariables(subTableVariable);
            }

            subTableVariable.ValueSet = String.IsNullOrWhiteSpace(ValueSet) ? null : ValueSet;
            subTableVariable.VariableType = VariableType;
            subTableVariable.StoreColumnNo = StoreColumnNo;
            subTableVariable.UserID = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            subTableVariable.LogDate = DateTime.Now;

            foreach (var variableFootnote in VariableFootnotes)
            {
                variableFootnote.Variable = this;
                variableFootnote.Save(context);
            }

            foreach (var removedVariableFootnote in RemovedVariableFootnotes)
            {
                removedVariableFootnote.DeleteEntities(context);
            }
        }
        public override void CreateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            // Creates the ValuePool object
            context.ValuePools.AddObject(new PxMetaModel.ValuePool() 
                {ValuePool1 = ValuePool,
                 PresText = PresText,
                 Description = Description,
                 ValueTextExists = "L",
                 ValuePres = "T",
                 UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name,
                 LogDate = DateTime.Now});

            //Creates the english value pool object
            context.ValuePool_Eng.AddObject(new PxMetaModel.ValuePool_Eng()
            {
                ValuePool = ValuePool,
                PresText = PresTextEnglish,
                ValuePoolEng = ValuePoolAlias, 
                UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name,
                LogDate = DateTime.Now
            });

        #endregion

        }
Example #24
0
        public override void CreateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            PxMetaModel.Value value = new PxMetaModel.Value();
            value.ValuePool = ValuePool;
            value.ValueCode = ValueCode;
            value.ValueTextL = ValueText;
            value.Footnote = Footnote;
            value.SortCode = ValueCode;
            value.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            value.LogDate = DateTime.Now;

            context.AddToValues(value);

            PxMetaModel.Value_Eng valueEng = new PxMetaModel.Value_Eng();
            valueEng.Value = value;
            valueEng.ValuetextL = ValueTextEnglish;
            valueEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            valueEng.LogDate = DateTime.Now;
            valueEng.SortCode = ValueCode;
            context.AddToValue_Eng(valueEng);

            foreach(var valueFootnote in ValueFootnotes)
            {
                valueFootnote.Value = this;
                valueFootnote.Save(context);
            }
        }
        public override void DeleteEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            base.DeleteEntities(context);

            if (!IsNew)
            {
                foreach (var content in _contents)
                {
                    content.DeleteEntities(context);
                }

                foreach (var variable in _variables)
                {
                    variable.DeleteEntities(context);
                }

                var subTable_Eng = (from st in context.SubTable_Eng
                                where st.MainTable == this.TableId && st.SubTable == "1"
                                select st).FirstOrDefault();
                if (subTable_Eng != null)
                {
                    context.DeleteObject(subTable_Eng);
                }

                var subTable = (from st in context.SubTables
                                where st.MainTable == this.TableId && st.SubTable1 == "1"
                                select st).FirstOrDefault();
                if (subTable != null)
                {
                    context.DeleteObject(subTable);
                }

                foreach (var f in Footnotes)
                {

                    f.DeleteEntities(context);
                }

                foreach (var mainTableValueFootnote in MainTableValueFootnotes)
                {
                    mainTableValueFootnote.DeleteEntities(context);
                }
                foreach (var variable in _removedVariables)
                {
                    variable.DeleteEntities(context);
                }

                foreach (var content in RemovedContents)
                {
                    content.DeleteEntities(context);
                }

                foreach (var footnote in RemovedFootnotes)
                {
                    footnote.DeleteEntities(context);
                }
                var mainTableEng = (from mte in context.MainTable_Eng
                                    where mte.MainTable == TableId
                                    select mte).FirstOrDefault();
                if (mainTableEng != null)
                {
                    context.DeleteObject(mainTableEng);
                }

                var mainTable = (from mt in context.MainTables
                                 where mt.MainTable1 == TableId
                                 select mt).FirstOrDefault();

                if (mainTable != null)
                {
                    context.DeleteObject(mainTable);
                }

            }
        }
Example #26
0
        public override void CreateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            //Create the valueset
            PxMetaModel.ValueSet vs = new PxMetaModel.ValueSet();
            vs.ValueSet1 = Valueset;
            vs.PresText = PresText;
            vs.Description = PresText;
            vs.Elimination = Elimination;
            vs.ValuePool = ValuePool;
            vs.ValuePres = ValuePres;
            vs.SortCodeExists = "Y";
            vs.Footnote = "S";
            vs.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            vs.LogDate = DateTime.Now;

            context.AddToValueSets(vs);

            PxMetaModel.ValueSet_Eng vsEng = new PxMetaModel.ValueSet_Eng();
            vsEng.ValueSet1 = vs;
            vsEng.PresText = PresTextEnglish;
            vsEng.Description = PresTextEnglish;
            vsEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            vsEng.LogDate = DateTime.Now;

            context.AddToValueSet_Eng(vsEng);

            int sortCode = 0;
            foreach (var v in Values)
            {
                sortCode++;
                if (v.IsNew)
                {
                    v.ValuePool = ValuePool;
                    v.Footnote = "N";
                    v.CreateEntities(context);
                }

                //Create vs value
                PxMetaModel.VSValue vsValue = new PxMetaModel.VSValue();
                vsValue.ValueSet1 = vs;
                vsValue.ValuePool = ValuePool;
                vsValue.ValueCode = v.ValueCode;
                int lengthOfCountValues = Values.Count.ToString().Length;
                string stringSortCode = "";
                for (int i = 0; i < lengthOfCountValues - sortCode.ToString().Length; i++)
                {
                    stringSortCode += "0";
                }
                stringSortCode += sortCode.ToString();
                vsValue.SortCode = stringSortCode;
                vsValue.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                vsValue.LogDate = DateTime.Now;

                context.AddToVSValues(vsValue);

                //Create vs value eng
                PxMetaModel.VSValue_Eng vsValueEng = new PxMetaModel.VSValue_Eng();
                vsValueEng.ValueSet1 = vs;
                vsValueEng.ValuePool = ValuePool;
                vsValueEng.ValueCode = v.ValueCode;
                vsValueEng.SortCode = sortCode.ToString();
                vsValueEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                vsValueEng.LogDate = DateTime.Now;

                context.AddToVSValue_Eng(vsValueEng);
            }
        }
Example #27
0
        public override void CreateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            if (IsNew)
            {
                PxMetaModel.Footnote footnote = new PxMetaModel.Footnote();
                footnote.FootnoteNo = FootnoteNo;
                footnote.FootnoteType = FootnoteType;
                footnote.MandOpt = MandOption;
                footnote.FootnoteText = FootnoteText;
                footnote.ShowFootnote = ShowFootnote;
                footnote.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                footnote.LogDate = DateTime.Now;
                context.AddToFootnotes(footnote);

                PxMetaModel.Footnote_Eng footnoteEng = new PxMetaModel.Footnote_Eng();

                footnoteEng.Footnote = footnote;
                footnoteEng.FootnoteText = FootnoteTextEnglish;
                footnoteEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                footnoteEng.LogDate = DateTime.Now;
                context.AddToFootnote_Eng(footnoteEng);
            }
        }
Example #28
0
        public override void UpdateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            PxMetaModel.Content content = (from c in context.Contents
                                           where c.MainTable == MainTable.TableId && c.Contents == Content
                                           select c).First();

            content.PresText = PresText;
            content.PresTextS = PressTextS;
            content.PresCode = MainTable.ProductId + StoreColumnNo;
            content.Copyright = Copyright;
            content.StatAuthority = StatAuthority;
            content.Producer = Producer;
            content.Unit = Unit;
            content.PresDecimals = PresDecimals;
            content.PresCellsZero = PresCellsZero;
            content.PresMissingLine = PresMissingLine;
            content.AggregPossible = AggregPossible;
            content.RefPeriod = RefPeriod;
            content.StockFA = StockFA;
            content.BasePeriod = BasePeriod;
            content.CFPrices = String.IsNullOrWhiteSpace(CFPrices) ? null : CFPrices;
            content.DayAdj = DayAdj;
            content.SeasAdj = SeasAdj;
            content.FootnoteContents = FootnoteContents == null ? "N" : FootnoteContents;
            content.FootnoteVariable = FootnoteVariable == null ? "N" : FootnoteVariable;
            content.FootnoteValue = FootnoteValue == null ? "N" : FootnoteValue;
            content.FootnoteTime = FootnoteTime == null ? "N" : FootnoteTime;
            content.StoreColumnNo = StoreColumnNo;
            content.StoreFormat = StoreFormat;
            content.StoreNoChar = StoreNoChar;
            content.StoreDecimals = StoreDecimals;
            content.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            content.LogDate = DateTime.Now;

            PxMetaModel.Contents_Eng contentEng = (from c in context.Contents_Eng
                                                   where c.MainTable == MainTable.TableId && c.Contents == Content
                                                   select c).First();

            contentEng.PresText = PressTextEnglish;
            contentEng.PresTextS = PressTextEnglishS;
            contentEng.RefPeriod = RefPeriodEnglish;
            contentEng.BasePeriod = BasePeriod;
            contentEng.Unit = UnitEnglish;
            contentEng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            contentEng.LogDate = DateTime.Now;

            foreach (PxContentFootnote contentFootnote in Footnotes)
            {
                contentFootnote.MainTable = MainTable;

                contentFootnote.Content = this;

                contentFootnote.Save(context);
            }

            foreach (PxContentVariableFootnote contentVariableFootnote in ContentVariableFootnotes)
            {
                contentVariableFootnote.MainTable = MainTable;
                contentVariableFootnote.Content = this;
                contentVariableFootnote.Save(context);
            }

            foreach (PxContentValueFootnote contentValueFootnote in ContentValueFootnotes)
            {
                contentValueFootnote.MainTable = MainTable;
                contentValueFootnote.Content = this;
                contentValueFootnote.Save(context);
            }

            foreach (PxContentVariableFootnote contentVariableFootnote in RemovedContentVariableFootnotes)
            {
                contentVariableFootnote.DeleteEntities(context);
            }

            foreach (PxContentFootnote contentFootnote in RemovedFootnotes)
            {
                contentFootnote.DeleteEntities(context);
            }

            foreach (PxContentValueFootnote contentValueFootnote in RemovedContentValueFootnotes)
            {
                contentValueFootnote.DeleteEntities(context);
            }
        }
Example #29
0
        //TODO update entities
        public override void UpdateEntities(PxMetaModel.PcAxisMetabaseEntities context)
        {
            PxMetaModel.Value value = (from v in context.Values
                             where v.ValuePool == ValuePool && v.ValueCode == ValueCode
                             select v).First();

            value.ValueTextL = ValueText;
            value.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            value.LogDate = DateTime.Now;

            PxMetaModel.Value_Eng value_eng = value.Value_Eng;

            value_eng.ValuetextL = ValueTextEnglish;
            value_eng.UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            value_eng.LogDate = DateTime.Now;

            foreach (var valueFootnote in ValueFootnotes)
            {
                valueFootnote.Value = this;
                valueFootnote.Save(context);
            }

            foreach (var removedValueFootnote in RemovedValueFootnotes)
            {
                removedValueFootnote.DeleteEntities(context);
            }
        }
Example #30
0
 public virtual void UpdateEntities(PxMetaModel.PcAxisMetabaseEntities context)
 {
 }