/// <summary>
        ///     News the application_ add new relationship implementation.
        /// </summary>
        /// <param name="cardinality">The cardinality.</param>
        /// <param name="cascadeDelete">if set to <c>true</c> [cascade delete].</param>
        /// <param name="cascadeDeleteTo">if set to <c>true</c> [cascade delete to].</param>
        /// <param name="implicitInSolution">if set to <c>true</c> [implicit in solution].</param>
        /// <param name="reverseImplicitInSolution">if set to <c>true</c> [reverse implicit in solution].</param>
        public void NewApplication_AddNewRelationshipImpl(CardinalityEnum_Enumeration cardinality, bool cascadeDelete, bool cascadeDeleteTo, bool implicitInSolution, bool reverseImplicitInSolution)
        {
            var application = TestMigrationHelper.CreateAppLibraryApplication( );

            application.SetCardinality(cardinality);

            DataTable appDataBit = application.Data.Tables[TableNames.AppDataBit];

            AppDetails.CreateAppDataRow(appDataBit, application.AppVerUid, application.RelationshipUid, AppDetails.CascadeDeleteUid, cascadeDelete);
            AppDetails.CreateAppDataRow(appDataBit, application.AppVerUid, application.RelationshipUid, AppDetails.CascadeDeleteToUid, cascadeDeleteTo);
            AppDetails.CreateAppDataRow(appDataBit, application.AppVerUid, application.RelationshipUid, AppDetails.ImplicitInSolutionUid, implicitInSolution);
            AppDetails.CreateAppDataRow(appDataBit, application.AppVerUid, application.RelationshipUid, AppDetails.ReverseImplicitInSolutionUid, reverseImplicitInSolution);

            TestMigrationHelper.SaveAppLibraryApplication(application);

            AppManager.DeployApp(RunAsDefaultTenant.DefaultTenantName, application.SolutionUid.ToString("B"));

            long            tenantId = RequestContext.TenantId;
            DatabaseContext context  = DatabaseContext.GetContext( );

            Assert.IsTrue(TenantMergeProcessorTestHelper.ConfirmTenantEntity(context, tenantId, application.FromTypeUid), "Type A was not deployed as part of an existing application.");
            Assert.IsTrue(TenantMergeProcessorTestHelper.ConfirmTenantEntity(context, tenantId, application.ToTypeUid), "Type B was not deployed as part of an existing application.");
            Assert.IsTrue(TenantMergeProcessorTestHelper.ConfirmTenantEntity(context, tenantId, application.RelationshipUid), "Relationship was not deployed as part of an existing application.");

            Assert.IsTrue(TenantMergeProcessorTestHelper.ConfirmTenantRelationship(context, tenantId, Direction.Forward, AppDetails.CardinalityUid, application.RelationshipUid, AppDetails.ConvertCardinalityEnumToUpgradeId(cardinality)), "Relationship cardinality was not deployed.");
            Assert.IsTrue(TenantMergeProcessorTestHelper.ConfirmTenantFieldValue(context, tenantId, DataTableType.Bit, application.RelationshipUid, AppDetails.CascadeDeleteUid, cascadeDelete), "Relationship cascadeDelete value was not deployed.");
            Assert.IsTrue(TenantMergeProcessorTestHelper.ConfirmTenantFieldValue(context, tenantId, DataTableType.Bit, application.RelationshipUid, AppDetails.CascadeDeleteToUid, cascadeDeleteTo), "Relationship cascadeDelete to value was not deployed.");
            Assert.IsTrue(TenantMergeProcessorTestHelper.ConfirmTenantFieldValue(context, tenantId, DataTableType.Bit, application.RelationshipUid, AppDetails.ImplicitInSolutionUid, implicitInSolution), "Relationship implicitInSolution value was not deployed.");
            Assert.IsTrue(TenantMergeProcessorTestHelper.ConfirmTenantFieldValue(context, tenantId, DataTableType.Bit, application.RelationshipUid, AppDetails.ReverseImplicitInSolutionUid, reverseImplicitInSolution), "Relationship reverseImplicitInSolution value was not deployed.");
        }
 public void NewApplication_AddNewRelationship_ManyToOne(
     [Values(CardinalityEnum_Enumeration.ManyToOne)] CardinalityEnum_Enumeration cardinality,
     [Values(true, false)] bool cascadeDelete,
     [Values(true, false)] bool cascadeDeleteTo,
     [Values(true, false)] bool implicitInSolution,
     [Values(true, false)] bool reverseImplicitInSolution
     )
 {
     NewApplication_AddNewRelationshipImpl(cardinality, cascadeDelete, cascadeDeleteTo, implicitInSolution, reverseImplicitInSolution);
 }
            /// <summary>
            ///     Initializes a new instance of the <see cref="RelationshipDetails" /> class.
            /// </summary>
            /// <param name="relationship">The relationship.</param>
            /// <param name="fromInstance">From instance.</param>
            /// <param name="toInstance">To instance.</param>
            /// <param name="cardinality">The cardinality.</param>
            /// <param name="cascadeDelete">if set to <c>true</c> [cascade delete].</param>
            /// <param name="cascadeDeleteTo">if set to <c>true</c> [cascade delete to].</param>
            /// <param name="implicitInSolution">if set to <c>true</c> [implicit in solution].</param>
            /// <param name="reverseImplicitInSolution">if set to <c>true</c> [reverse implicit in solution].</param>
            public RelationshipDetails(Relationship relationship, Entity fromInstance, Entity toInstance, CardinalityEnum_Enumeration cardinality, bool cascadeDelete, bool cascadeDeleteTo, bool implicitInSolution, bool reverseImplicitInSolution) : base(relationship)
            {
                FromType = new BasicEntityDetails(relationship.FromType);
                ToType   = new BasicEntityDetails(relationship.ToType);

                FromInstance = new BasicEntityDetails(fromInstance);
                ToInstance   = new BasicEntityDetails(toInstance);

                Cardinality               = cardinality;
                CascadeDelete             = cascadeDelete;
                CascadeDeleteTo           = cascadeDeleteTo;
                ImplicitInSolution        = implicitInSolution;
                ReverseImplicitInSolution = reverseImplicitInSolution;
            }
Exemple #4
0
        /// <summary>
        /// Sets the cardinality.
        /// </summary>
        /// <param name="cardinality">The cardinality.</param>
        public void SetCardinality(CardinalityEnum_Enumeration cardinality)
        {
            DataTable appRelationship = Data.Tables[TableNames.AppRelationship];

            var cardinalityRow = appRelationship.Rows.Find(new object[]
            {
                AppVerUid,
                CardinalityUid,
                RelationshipUid,
                OneToOneUid
            });

            if (cardinalityRow != null)
            {
                cardinalityRow["ToUid"] = ConvertCardinalityEnumToUpgradeId(cardinality);
            }
        }
Exemple #5
0
        void TestRelationship(CardinalityEnum_Enumeration cardinality, Action <RecordChangeAuditPolicy, EntityType, EntityType> setPolicyAction, Action <Resource, Resource, Relationship> updateAction, string expected)
        {
            Func <EntityType, EntityType, Relationship> createRelFn = (rType1, rType2) =>
            {
                var rel = new Relationship()
                {
                    Name = "MyRel"
                };
                rel.FromType = rType1;
                rel.ToType   = rType2;

                rel.RelType_Enum     = RelTypeEnum_Enumeration.RelCustom;
                rel.Cardinality_Enum = cardinality;

                return(rel);
            };

            TestRelationship(createRelFn, setPolicyAction, updateAction, expected);
        }
        /// <summary>
        ///     Gets the cardinality enumeration upgrade identifier.
        /// </summary>
        /// <param name="cardinality">The cardinality.</param>
        /// <returns></returns>
        protected Guid GetCardinalityEnumUpgradeId(CardinalityEnum_Enumeration cardinality)
        {
            switch (cardinality)
            {
            case CardinalityEnum_Enumeration.OneToOne:
                return(OneToOneUpgradeId);

            case CardinalityEnum_Enumeration.OneToMany:
                return(OneToManyUpgradeId);

            case CardinalityEnum_Enumeration.ManyToOne:
                return(ManyToOneUpgradeId);

            case CardinalityEnum_Enumeration.ManyToMany:
                return(ManyToManyUpgradeId);

            default:
                throw new ArgumentException(@"Invalid cardinality.", "cardinality");
            }
        }
Exemple #7
0
        /// <summary>
        ///     Converts the cardinality enumeration to upgrade identifier.
        /// </summary>
        /// <param name="cardinality">The cardinality.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentException">Invalid cardinality value</exception>
        public static Guid ConvertCardinalityEnumToUpgradeId(CardinalityEnum_Enumeration cardinality)
        {
            switch (cardinality)
            {
            case CardinalityEnum_Enumeration.OneToOne:
                return(AppDetails.OneToOneUid);

            case CardinalityEnum_Enumeration.OneToMany:
                return(AppDetails.OneToManyUid);

            case CardinalityEnum_Enumeration.ManyToOne:
                return(AppDetails.ManyToOneUid);

            case CardinalityEnum_Enumeration.ManyToMany:
                return(AppDetails.ManyToManyUid);

            default:
                throw new ArgumentException("Invalid cardinality value");
            }
        }
 /// <summary>
 ///     Initializes a new instance of the <see cref="RelationshipEntry" /> class.
 /// </summary>
 /// <param name="typeId">The type identifier.</param>
 /// <param name="fromId">From identifier.</param>
 /// <param name="toId">To identifier.</param>
 /// <param name="cardinality">The cardinality.</param>
 public RelationshipEntry(Guid typeId, Guid fromId, Guid toId, CardinalityEnum_Enumeration cardinality)
     : this(typeId, fromId, toId)
 {
     Cardinality = cardinality;
 }