Esempio n. 1
0
        private void UpdateConstraint(DB.GreenTemplate aTemplate, ConstraintViewModel aViewModel, DB.GreenConstraint aParentConstraint = null)
        {
            if ((aViewModel.hasGreenConstraint || aViewModel.isDeleted) && aViewModel.greenConstraintId.HasValue)
            {
                this.UpdateConstraint(aViewModel);
            }

            if (aViewModel.hasGreenConstraint && aViewModel.greenConstraintId.HasValue == false && aViewModel.isDeleted == false) //Is New
            {
                DB.GreenConstraint lNewConstraint = this.AddNewConstraint(aViewModel);

                if (aParentConstraint != null)
                {
                    aParentConstraint.ChildGreenConstraints.Add(lNewConstraint);
                }

                aTemplate.ChildGreenConstraints.Add(lNewConstraint);

                foreach (ConstraintViewModel lChild in aViewModel.children)
                {
                    this.UpdateConstraint(aTemplate, lChild, lNewConstraint);
                }
            }
            else
            {
                foreach (ConstraintViewModel lChild in aViewModel.children)
                {
                    this.UpdateConstraint(aTemplate, lChild);
                }
            }
        }
Esempio n. 2
0
        private ConstraintViewModel BuildConstraint(DB.IObjectRepository tdb, string baseLink,
                                                    IGSettingsManager igSettings, DB.TemplateConstraint dbConstraint, int constraintCount, int?aParentConstraintId = null)
        {
            IFormattedConstraint fc         = FormattedConstraintFactory.NewFormattedConstraint(tdb, igSettings, dbConstraint);
            WIKIParser           wikiParser = new WIKIParser(tdb);

            ConstraintViewModel lGreenViewModel = new ConstraintViewModel()
            {
                constraintLabel    = dbConstraint.Label,
                headingDescription = dbConstraint.HeadingDescription,
                id            = dbConstraint.Id,
                order         = dbConstraint.Order,
                isHeading     = dbConstraint.IsHeading,
                isPrimitive   = dbConstraint.IsPrimitive,
                primitiveText = dbConstraint.PrimitiveText,
                templateId    = dbConstraint.TemplateId,
                number        = dbConstraint.Number,
                text          = fc.GetPlainText(false, false, false),
                conformance   = dbConstraint.Conformance,
                value         = dbConstraint.Value
            };

            lGreenViewModel.constraintDescription = GetConstraintDescription(dbConstraint);

            DB.GreenConstraint lGreenConstraint = dbConstraint.GreenConstraints.DefaultIfEmpty(null).FirstOrDefault();

            if (lGreenConstraint != null)
            {
                lGreenViewModel.Use(c =>
                {
                    c.businessName       = lGreenConstraint.Description;
                    c.elementName        = lGreenConstraint.Name;
                    c.xPath              = lGreenConstraint.RootXpath;
                    c.greenConstraintId  = lGreenConstraint.Id;
                    c.hasGreenConstraint = true;

                    if (lGreenConstraint.ImplementationGuideTypeDataTypeId.HasValue)
                    {
                        c.datatype   = lGreenConstraint.ImplementationGuideTypeDataType.DataTypeName;
                        c.datatypeId = lGreenConstraint.ImplementationGuideTypeDataType.Id;
                    }
                });
            }

            if (aParentConstraintId.HasValue)
            {
                lGreenViewModel.parentConstraintId = aParentConstraintId.Value;
            }

            int nextConstraintCount = 0;

            foreach (DB.TemplateConstraint cDbConstraint in dbConstraint.ChildConstraints.Where(cc => cc.IsPrimitive == false).OrderBy(y => y.Order))
            {
                ConstraintViewModel nextNewConstraint
                    = BuildConstraint(tdb, baseLink, igSettings, cDbConstraint, ++nextConstraintCount, dbConstraint.Id);
                lGreenViewModel.children.Add(nextNewConstraint);
            }

            return(lGreenViewModel);
        }
        private bool IsValid(ConstraintViewModel greenConstraint)
        {
            if (greenConstraint.hasGreenConstraint && !HasGreenChildren(greenConstraint) && greenConstraint.datatypeId == null)
            {
                return(false);
            }

            foreach (var child in greenConstraint.children)
            {
                if (!IsValid(child))
                {
                    return(false);
                }
            }

            return(true);
        }
        private bool AssertRequiredShallConstraints(DB.TemplateConstraint aRootConstraint, GreenTemplateViewModel aModel)
        {
            foreach (DB.TemplateConstraint lChildConstraint in aRootConstraint.ChildConstraints.Where(tc => tc.Conformance == "SHALL"))
            {
                if (!AssertRequiredShallConstraints(lChildConstraint, aModel))
                {
                    return(false);
                }
            }

            if (aRootConstraint.IsPrimitive)
            {
                return(true);
            }
            if (!string.IsNullOrEmpty(aRootConstraint.Value))
            {
                return(true);
            }
            if (aRootConstraint.ChildConstraints.Count > 0)
            {
                return(true);
            }

            ConstraintViewModel lFoundModel = null;

            foreach (ConstraintViewModel lViewConstraint in aModel.childConstraints)
            {
                lFoundModel = this.FindConstraint(lViewConstraint, c => c.id == aRootConstraint.Id);
                if (lFoundModel != null)
                {
                    break;
                }
            }

            if (lFoundModel == null)
            {
                return(false);
            }
            if (lFoundModel.isDeleted)
            {
                return(false);
            }
            return(lFoundModel.hasGreenConstraint);
        }
        private bool HasGreenChildren(ConstraintViewModel greenConstraint)
        {
            if (greenConstraint.children.Count(y => y.hasGreenConstraint) > 0)
            {
                return(true);
            }

            bool ret = false;

            foreach (var child in greenConstraint.children)
            {
                if (HasGreenChildren(child))
                {
                    ret = true;
                }
            }

            return(ret);
        }
Esempio n. 6
0
        private void UpdateConstraint(ConstraintViewModel aConstraint)
        {
            if (aConstraint.greenConstraintId.HasValue && aConstraint.isDeleted)
            {
                DB.GreenConstraint lModelToDelete = _tdb.GreenConstraints.Single(gc => gc.Id == aConstraint.greenConstraintId);

                foreach (DB.GreenConstraint lChild in lModelToDelete.ChildGreenConstraints.ToList())
                {
                    lChild.ParentGreenConstraint   = null;
                    lChild.ParentGreenConstraintId = null;
                }

                _tdb.GreenConstraints.DeleteObject(lModelToDelete);
            }
            else if (aConstraint.greenConstraintId.HasValue && aConstraint.isDeleted == false)
            {
                DB.GreenConstraint lModelToUpdate = _tdb.GreenConstraints.DefaultIfEmpty(null).SingleOrDefault(gc => gc.Id == aConstraint.greenConstraintId);
                if (lModelToUpdate == null)
                {
                    return;
                }

                if (!string.Equals(lModelToUpdate.Name, aConstraint.elementName))
                {
                    lModelToUpdate.Name = aConstraint.elementName;
                }
                if (!string.Equals(lModelToUpdate.Description, aConstraint.businessName))
                {
                    lModelToUpdate.Description = aConstraint.businessName;
                }
                if (lModelToUpdate.TemplateConstraintId != aConstraint.id)
                {
                    lModelToUpdate.TemplateConstraintId = aConstraint.id;
                }
                if (lModelToUpdate.ImplementationGuideTypeDataTypeId != aConstraint.datatypeId)
                {
                    lModelToUpdate.ImplementationGuideTypeDataTypeId = aConstraint.datatypeId;
                }
            }
        }
Esempio n. 7
0
        public GreenTemplateViewModel MapEntityToViewModel(DB.Template aTemplate)
        {
            DB.GreenTemplate       lGreenTemplate = aTemplate.GreenTemplates.DefaultIfEmpty(null).FirstOrDefault();
            GreenTemplateViewModel lViewModel     = new GreenTemplateViewModel();

            if (lGreenTemplate == null)
            {
                lViewModel.Name  = this.GetCamelCaseTemplateName(aTemplate.Name);
                lViewModel.IsNew = true;
            }
            else
            {
                lViewModel.Id   = lGreenTemplate.Id;
                lViewModel.Name = lGreenTemplate.Name;
            }

            lViewModel.TemplateId   = aTemplate.Id;
            lViewModel.TemplateName = aTemplate.Name;
            lViewModel.TemplateOid  = aTemplate.Oid;

            IGSettingsManager igManager    = new IGSettingsManager(_tdb, aTemplate.OwningImplementationGuideId);
            IIGTypePlugin     igTypePlugin = aTemplate.OwningImplementationGuide.ImplementationGuideType.GetPlugin();
            string            baseLink     = HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path) + "?Id=";

            int constraintCount = 0;

            foreach (DB.TemplateConstraint cDbConstraint
                     in aTemplate.ChildConstraints
                     .Where(y => y.Parent == null)
                     .Where(c => c.IsPrimitive == false)
                     .Where(c => string.IsNullOrEmpty(c.Value)).OrderBy(y => y.Order))
            {
                ConstraintViewModel lConstraintView = this.BuildConstraint(_tdb, baseLink, igManager, igTypePlugin, cDbConstraint, constraintCount);
                this.CreateIfRequiredGreenTemplateTree(lConstraintView);

                lViewModel.childConstraints.Add(lConstraintView);
            }

            return(lViewModel);
        }
Esempio n. 8
0
        private DB.GreenConstraint AddNewConstraint(ConstraintViewModel aNewConstraint)
        {
            DB.TemplateConstraint lUnderlyingConstraint = _tdb.TemplateConstraints.Single(tc => tc.Id == aNewConstraint.id);

            ConstraintXpathBuilder lXpathBuilder = new ConstraintXpathBuilder(_tdb);
            string lXpath = lXpathBuilder.GenerateXpath(lUnderlyingConstraint);

            DB.GreenConstraint lNewModel = new DB.GreenConstraint()
            {
                Description          = aNewConstraint.businessName,
                Name                 = aNewConstraint.elementName,
                TemplateConstraintId = aNewConstraint.id,
                RootXpath            = lXpath
            };

            if (aNewConstraint.datatypeId.HasValue)
            {
                DB.ImplementationGuideTypeDataType lDataType = _tdb.ImplementationGuideTypeDataTypes.Single(dt => dt.Id == aNewConstraint.datatypeId.Value);
                lNewModel.ImplementationGuideTypeDataType = lDataType;
            }

            return(lNewModel);
        }
        private ConstraintViewModel FindConstraint(ConstraintViewModel aStartConstraint, Func <ConstraintViewModel, bool> predicate)
        {
            foreach (ConstraintViewModel lChild in aStartConstraint.children)
            {
                ConstraintViewModel lModel = FindConstraint(lChild, predicate);
                if (lModel != null)
                {
                    return(lModel);
                }
                else
                {
                    continue;
                }
            }

            if (predicate(aStartConstraint))
            {
                return(aStartConstraint);
            }
            else
            {
                return(null);
            }
        }
Esempio n. 10
0
        private void CreateIfRequiredGreenTemplateTree(ConstraintViewModel aStartConstraint)
        {
            if (aStartConstraint.hasGreenConstraint)
            {
                return;
            }
            if (aStartConstraint.conformance != "SHALL" && aStartConstraint.conformance != "SHOULD")
            {
                return;
            }
            if (!string.IsNullOrEmpty(aStartConstraint.value))
            {
                return;
            }

            var lChildren = aStartConstraint.children
                            .Where(c => c.conformance == "SHALL" || c.conformance == "SHOULD")
                            .Where(c => string.IsNullOrEmpty(c.value));

            foreach (ConstraintViewModel lChild in lChildren)
            {
                CreateIfRequiredGreenTemplateTree(lChild);
            }

            if (aStartConstraint.children.Count > 0)
            {
                return;                                      //Leaf-level only
            }
            DB.TemplateConstraint lRootConstraint = _tdb.TemplateConstraints.Single(c => c.Id == aStartConstraint.id);

            aStartConstraint.Use(c =>
            {
                c.businessName       = c.elementName = lRootConstraint.Context;
                c.hasGreenConstraint = true;

                string lDataTypeToUse = null;

                // --- Identify data type to use, which will come from data types contained in the IG
                if (!string.IsNullOrEmpty(lRootConstraint.DataType) && lRootConstraint.DataType != "ANY")
                {
                    lDataTypeToUse = lRootConstraint.DataType;
                }
                else
                {
                    ConstraintXpathBuilder lBuilder = new ConstraintXpathBuilder(_tdb);
                    string lXpath = lBuilder.GenerateXpath(lRootConstraint);

                    ConstraintDataTypeResolver lResolver = new ConstraintDataTypeResolver();
                    string lDataType = lResolver.GetConstraintDataType(lRootConstraint, lXpath);

                    lDataTypeToUse = lDataType;
                }

                // --- Load data type, only use if constraint is leaf-level
                DB.ImplementationGuideTypeDataType lUnderlyingType
                    = _tdb.ImplementationGuideTypeDataTypes.SingleOrDefault(d => d.DataTypeName == lDataTypeToUse);

                if (lUnderlyingType != null && lRootConstraint.ChildConstraints.Count(y => !y.IsPrimitive) == 0)
                {
                    c.datatypeId = lUnderlyingType.Id;
                    c.datatype   = lUnderlyingType.DataTypeName;
                }
            });
        }