it:ad:code_first:howto:define_models:relationships:examples:misc1 [Notes]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
For Many to One (Invoice/LineItems):

<sxh csharp>
            modelBuilder.Entity<Invoice>()
                .HasMany(bcwi => bcwi.LineItems)
                .WithRequired()
                .HasForeignKey(bc => bc.InvoiceFK);
</sxh>


<sxh csharp>
                
                modelBuilder.Entity<WorkInstruction>()
                   .HasMany(wi => wi.Comments)
                   .WithRequired()
                   .HasForeignKey(n => n.ParentFK);

</sxh>


<sxh csharp>
                modelBuilder.Entity<WorkInstruction>()
                  .HasMany(wi => wi.Attachments)
                  .WithRequired()
                  .HasForeignKey(a => a.ParentFK);
                            

</sxh>

<sxh csharp>

                modelBuilder.Entity<AttachmentAttributes>()
                     .HasRequired(a => a.Attachment)
                     .WithMany()
                     .HasForeignKey(a => a.AttachmentId);

</sxh>



The child entities of course have to have a required property:

<sxh csharp>

                modelBuilder.Entity<Attachment>()
                    .Property(wi => wi.ParentFK)
                    .IsRequired();

                modelBuilder.Entity<Note>()
                    .Property(wi => wi.ParentFK)
                    .IsRequired();

</sxh>





































    namespace Nab.Wdms.PM.Infrastructure.Data
    {

                _tracingService.Trace(TraceLevel.Verbose, "OnModelBuilding:Complete:{0}", this);
            }

            private void CreateRoutingRuleRelationShips(DbModelBuilder modelBuilder)
            {


                modelBuilder.Entity<RoutingRuleSet>()
                    .HasKey(m => m.Id);

                modelBuilder.Entity<RoutingRuleSet>()
                    .HasMany(m => m.Rules)
                    .WithRequired()
                    .HasForeignKey(m => m.RuleSetFK)
                    .WillCascadeOnDelete(false);



                modelBuilder.Entity<RoutingRule>()
                    .HasKey(m => m.Id);

                modelBuilder.Entity<RoutingRule>()
                    .HasOptional(m=>m.Location)
                    .WithMany()
                    .HasForeignKey(m=>m.LocationFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<RoutingRule>()
                    .HasOptional(m=>m.ParentWorkInstructionType)
                    .WithMany()
                    .HasForeignKey(m=>m.ParentWorkInstructionTypeFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<RoutingRule>()
                    .HasOptional(m=>m.WorkInstructionType)
                    .WithMany()
                    .HasForeignKey(m=>m.WorkInstructionTypeFK)
                    .WillCascadeOnDelete(false);


                modelBuilder.Entity<RoutingRule>()
                    .HasRequired(m=>m.WorkflowStep)
                    .WithMany()
                    .HasForeignKey(m=>m.WorkflowStepFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<RoutingRule>()
                    .Property(m=>m.RequiresSpecialRules)
                    .IsRequired();

                modelBuilder.Entity<RoutingRule>()
                    .Property(m=>m.ResultingGroups)
                    .IsRequired();

                modelBuilder.Entity<RoutingRule>()
                    .HasMany(m => m.AdditionalData)
                    .WithRequired()
                    .HasForeignKey(m=>m.RuleFK)
                    .WillCascadeOnDelete(false);


            }

            private void CreateWorkflowStepConstraints(DbModelBuilder modelBuilder)
            {
                modelBuilder.Entity<WorkflowStep>()
                    .HasKey(m=>m.Id);
                modelBuilder.Entity<WorkflowStep>()
                    .Property(m => m.Name).IsRequired();
                modelBuilder.Entity<WorkflowStep>()
                    .Property(m => m.Description).IsOptional();
            }



            private void CreateM01BankWorkInstructionRelationships(DbModelBuilder modelBuilder)
            {
                _tracingService.Trace(TraceLevel.Verbose, "--OnModelBuilding:.......:{0}:{1}", this, "CreateM01BankWorkInstructionRelationships");

                //*-1 back to Core BankWorkInstruction:
                modelBuilder.Entity<BankWorkInstruction>()
                    .HasRequired(bwi => bwi.WorkInstruction)
                    .WithOptional();
                //MAY HAVE TO .WillCascadeOnDelete(false);

                //*-1:to Lookup
                modelBuilder.Entity<BankWorkInstruction>()
                    .HasRequired(bwi => bwi.Location)
                    .WithMany()
                    .HasForeignKey(bwi => bwi.LocationFK);

                //*-1:to Lookup
                modelBuilder.Entity<BankWorkInstruction>()
                    .HasOptional(wi => wi.InitiatingChannel)
                    .WithMany()
                    .HasForeignKey(wi => wi.InitiatingChannelFK);


                // not sure if required - can't run yet
                //modelBuilder.Entity<BankWorkInstruction>()
                //    .Property(wi => wi.WorkInstructionFK)
                //    .IsRequired();
                //modelBuilder.Entity<BankWorkInstruction>()
                //    .Property(wi => wi.LocationFK)
                //    .IsRequired();
                //modelBuilder.Entity<BankWorkInstruction>()
                //    .Property(wi => wi.InitiatingChannelFK)
                //    .IsRequired();
            }

            private void CreateM01LookupRelationships(DbModelBuilder modelBuilder)
            {
                _tracingService.Trace(TraceLevel.Verbose, "--OnModelBuilding:.......:{0}:{1}", this, "CreateM01LookupRelationships");

                //Create 1 to 1 'parent' BankWorkInstruction:
                modelBuilder.Entity<BankCustomerWorkInstruction>()
                    .HasRequired(bcwi => bcwi.BankWorkInstruction)
                    .WithRequiredDependent();

                modelBuilder.Entity<BankCustomerWorkInstruction>()
                    .HasMany(bcwi => bcwi.Customers)
                    .WithRequired()
                    .HasForeignKey(bc => bc.BankCustomerWorkInstructionFK);

                modelBuilder.Entity<BankCustomerWorkInstruction>()
                    .Property(m => m.Account)
                    .HasMaxLength(EntityAndDatabaseConstants.AccountLength)
                    .IsFixedLength();


                // not sure if required - can't run yet
                //modelBuilder.Entity<BankCustomerWorkInstruction>()
                //    .Property(wi => wi.BankWorkInstructionFK)
                //    .IsRequired();

            }

            private void CreateM01WorkflowRelationships(DbModelBuilder modelBuilder)
            {

                _tracingService.Trace(TraceLevel.Verbose, "--OnModelBuilding:.......:{0}:{1}", this, "CreateM01WorkflowRelationships");

                //---------------------------------------------------------
                //Create Relationships between individual WF's and base wf:
                modelBuilder.Entity<M01WF00>()
                   .HasRequired(wi => wi.BankCustomerWorkInstruction)
                   .WithOptional();
                modelBuilder.Entity<M01WF01>()
                    .HasRequired(wi => wi.BankCustomerWorkInstruction)
                    .WithOptional();
                //MAY HAVE TO .WillCascadeOnDelete(false);
                modelBuilder.Entity<M01WF02>()
                    .HasRequired(wi => wi.BankCustomerWorkInstruction)
                    .WithOptional();
                //MAY HAVE TO .WillCascadeOnDelete(false);
                modelBuilder.Entity<M01WF03>()
                    .HasRequired(wi => wi.BankCustomerWorkInstruction)
                    .WithOptional();
                //MAY HAVE TO .WillCascadeOnDelete(false);
                modelBuilder.Entity<M01WF04>()
                    .HasRequired(wi => wi.BankCustomerWorkInstruction)
                    .WithOptional();
                modelBuilder.Entity<M01WF05>()
                    .HasRequired(wi => wi.BankCustomerWorkInstruction)
                    .WithOptional();
                modelBuilder.Entity<M01WF06>()
                    .HasRequired(wi => wi.BankCustomerWorkInstruction)
                    .WithOptional();

          
            }


            private void CreateM01WorkflowLookupRelationships(DbModelBuilder modelBuilder)
            {
                _tracingService.Trace(TraceLevel.Verbose, "--OnModelBuilding:.......:{0}:{1}", this, "CreateM01WorkflowLookupRelationships");

                

                // ------ M01WF01
                modelBuilder.Entity<M01WF01>()
                    .HasOptional(wi => wi.AccountType)
                    .WithMany()
                    .HasForeignKey(wi => wi.AccountTypeFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF01>()
                   .HasOptional(wi => wi.FxCompleteOption)
                   .WithMany()
                   .HasForeignKey(wi => wi.FxCompleteFK)
                   .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF01>()
                    .HasOptional(wi => wi.PhysicalsStoredAndOriginalsOption)
                    .WithMany()
                    .HasForeignKey(wi => wi.PhysicalsStoredAndOriginalsOptionFK)
                    .WillCascadeOnDelete(false);



                // ------ M01WF02
                modelBuilder.Entity<M01WF02>()
                    .HasOptional(wi => wi.BankBuyCurrencyType)
                    .WithMany()
                    .HasForeignKey(wi => wi.BankBuyCurrencyTypeFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF02>()
                    .HasOptional(wi => wi.BankSellCurrencyType)
                    .WithMany()
                    .HasForeignKey(wi => wi.BankSellCurrencyTypeFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF02>()
                    .HasOptional(wi => wi.CurrencyType)
                    .WithMany()
                    .HasForeignKey(wi => wi.CurrencyTypeFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF02>()
                  .HasOptional(wi => wi.FxCompleteOption)
                  .WithMany()
                  .HasForeignKey(wi => wi.FxCompleteFK)
                  .WillCascadeOnDelete(false);                

                modelBuilder.Entity<M01WF02>()
                    .HasOptional(wi => wi.PhysicalsStoredAndOriginalsOption)
                    .WithMany()
                    .HasForeignKey(wi => wi.PhysicalsStoredAndOriginalsOptionFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF02>()
                    .HasOptional(wi => wi.RollOverInstructionType)
                    .WithMany()
                    .HasForeignKey(wi => wi.RollOverInstructionTypeFK)
                    .WillCascadeOnDelete(false);   



                // ------ M01WF03
                modelBuilder.Entity<M01WF03>()
                    .HasOptional(wi => wi.BankBuyCurrencyType)
                    .WithMany()
                    .HasForeignKey(wi => wi.BankBuyCurrencyTypeFK)
                    .WillCascadeOnDelete(false);
                modelBuilder.Entity<M01WF03>()
                    .HasOptional(wi => wi.BankSellCurrencyType)
                    .WithMany()
                    .HasForeignKey(wi => wi.BankSellCurrencyTypeFK)
                    .WillCascadeOnDelete(false);
                modelBuilder.Entity<M01WF03>()
                    .HasOptional(wi => wi.PhysicalsStoredAndOriginalsOption)
                    .WithMany()
                    .HasForeignKey(wi => wi.PhysicalsStoredAndOriginalsOptionFK)
                    .WillCascadeOnDelete(false);
               


                // ------ M01WF04
                modelBuilder.Entity<M01WF04>()
                    .HasOptional(wi => wi.BankBuyCurrencyType)
                    .WithMany()
                    .HasForeignKey(wi => wi.BankBuyCurrencyTypeFK)
                    .WillCascadeOnDelete(false);
                modelBuilder.Entity<M01WF04>()
                    .HasOptional(wi => wi.BankSellCurrencyType)
                    .WithMany()
                    .HasForeignKey(wi => wi.BankSellCurrencyTypeFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF04>()
                  .HasOptional(wi => wi.CollateralReleaseOption)
                  .WithMany()
                  .HasForeignKey(wi => wi.CollateralReleaseFK)
                  .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF04>()
                  .HasOptional(wi => wi.FxCompleteOption)
                  .WithMany()
                  .HasForeignKey(wi => wi.FxCompleteFK)
                  .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF04>()
                   .HasOptional(wi => wi.LoanMaintenanceType)
                   .WithMany()
                   .HasForeignKey(wi => wi.LoanMaintenanceTypeFK)
                   .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF04>()
                    .HasOptional(wi => wi.PhysicalsStoredAndOriginalsOption)
                    .WithMany()
                    .HasForeignKey(wi => wi.PhysicalsStoredAndOriginalsOptionFK)
                    .WillCascadeOnDelete(false);



                // ------ M01WF05
                modelBuilder.Entity<M01WF05>()
                  .HasOptional(wi => wi.PhysicalsStoredAndOriginalsOption)
                  .WithMany()
                  .HasForeignKey(wi => wi.PhysicalsStoredAndOriginalsOptionFK)
                  .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF05>()
                    .HasOptional(wi => wi.RoutingType)
                    .WithMany()
                    .HasForeignKey(wi => wi.RoutingTypeFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF05>()
                    .HasOptional(wi => wi.TeamType)
                    .WithMany()
                    .HasForeignKey(wi => wi.TeamTypeFK)
                    .WillCascadeOnDelete(false);

             
              

                // ------ M01WF06
                modelBuilder.Entity<M01WF06>()
                    .HasOptional(wi => wi.BankBuyCurrencyType)
                    .WithMany()
                    .HasForeignKey(wi => wi.BankBuyCurrencyTypeFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF06>()
                    .HasOptional(wi => wi.BankSellCurrencyType)
                    .WithMany()
                    .HasForeignKey(wi => wi.BankSellCurrencyTypeFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF06>()
                  .HasOptional(wi => wi.FxCompleteOption)
                  .WithMany()
                  .HasForeignKey(wi => wi.FxCompleteFK)
                  .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF06>()
                    .HasOptional(wi => wi.PaymentInType)
                    .WithMany()
                    .HasForeignKey(wi => wi.PaymentInTypeFK)
                    .WillCascadeOnDelete(false);

                modelBuilder.Entity<M01WF06>()
                    .HasOptional(wi => wi.PaymentOutType)
                    .WithMany()
                    .HasForeignKey(wi => wi.PaymentOutTypeFK)
                    .WillCascadeOnDelete(false);

               modelBuilder.Entity<M01WF06>()
                    .HasOptional(wi => wi.PhysicalsStoredAndOriginalsOption)
                    .WithMany()
                    .HasForeignKey(wi => wi.PhysicalsStoredAndOriginalsOptionFK)
                    .WillCascadeOnDelete(false);


            }

            private void CreateM01WorkflowConstraints(DbModelBuilder modelBuilder)
            {
                _tracingService.Trace(TraceLevel.Verbose, "OnModelBuilding:.......:{0}:{1}", this, "CreateM01WorkflowConstraints");

                modelBuilder.Entity<BankCustomer>()
                    .Property(m => m.CustomerNumber)
                    .HasMaxLength(EntityAndDatabaseConstants.CustomerNumberLength)
                    .IsFixedLength()
                    .IsRequired();
                    
                // ------ M01WF01

                //modelBuilder.Entity<BankCustomerWorkInstruction>()
                //    .Property(m => m.Account)
                //    .HasMaxLength(EntityAndDatabaseConstants.AccountLength);
                

                // ------ M01WF02
                
                modelBuilder.Entity<M01WF02>()
                                .Property(m => m.ConfirmationExt)
                                .HasMaxLength(EntityAndDatabaseConstants.ConfirmationExtensionLength);

                ////SKY12831A:
                //modelBuilder.Entity<M01WF02>()
                //    .Property(m => m.Account) 
                //    .HasMaxLength(EntityAndDatabaseConstants.AccountLength)
                //    .IsFixedLength();

                modelBuilder.Entity<M01WF02>()
                    .Property(m => m.DepositAmount)
                    .HasPrecision(EntityAndDatabaseConstants.MoneyLength, EntityAndDatabaseConstants.MoneyDecimalPlaces);

                modelBuilder.Entity<M01WF02>()
                    .Property(m => m.DepositCustomerRate)
                    .HasPrecision(EntityAndDatabaseConstants.PercentageSevenLength, EntityAndDatabaseConstants.PercentageFourDecimalPlaces);

                modelBuilder.Entity<M01WF02>()
                   .Property(m => m.BankBuyCurrencyAmount)
                   .HasPrecision(EntityAndDatabaseConstants.MoneyLength, EntityAndDatabaseConstants.MoneyDecimalPlaces);

                modelBuilder.Entity<M01WF02>()
                   .Property(m => m.BankSellCurrencyAmount)
                   .HasPrecision(EntityAndDatabaseConstants.MoneyLength, EntityAndDatabaseConstants.MoneyDecimalPlaces);

                modelBuilder.Entity<M01WF02>()
                   .Property(m => m.CustomerRate)
                   .HasPrecision(EntityAndDatabaseConstants.PercentageSevenLength, EntityAndDatabaseConstants.PercentageFourDecimalPlaces);

                modelBuilder.Entity<M01WF02>()
                    .Property(m => m.DealerRate)
                    .HasPrecision(EntityAndDatabaseConstants.PercentageSevenLength, EntityAndDatabaseConstants.PercentageFourDecimalPlaces);

                modelBuilder.Entity<M01WF02>()
                   .Property(m => m.FxPurpose)
                   .HasMaxLength(EntityAndDatabaseConstants.FxPurposeLength);

                //modelBuilder.Entity<M01WF02>()
                //    .Property(m =>m.TenureYears)
                   

                // ------ M01WF03

                //////SKY12831A:
                //modelBuilder.Entity<M01WF03>()
                //    .Property(m => m.Account)
                //    .HasMaxLength(EntityAndDatabaseConstants.AccountLength)
                //    .IsFixedLength();

                modelBuilder.Entity<M01WF03>()
                    .Property(m => m.FxPurpose)
                    .HasMaxLength(EntityAndDatabaseConstants.FxPurposeLength);

                modelBuilder.Entity<M01WF03>()
                 .Property(m => m.BankBuyCurrencyAmount)
                 .HasPrecision(EntityAndDatabaseConstants.MoneyLength, EntityAndDatabaseConstants.MoneyDecimalPlaces);

                modelBuilder.Entity<M01WF03>()
                   .Property(m => m.BankSellCurrencyAmount)
                   .HasPrecision(EntityAndDatabaseConstants.MoneyLength, EntityAndDatabaseConstants.MoneyDecimalPlaces);

                modelBuilder.Entity<M01WF03>()
                   .Property(m => m.CustomerRate)
                   .HasPrecision(EntityAndDatabaseConstants.PercentageSevenLength, EntityAndDatabaseConstants.PercentageFourDecimalPlaces);

                modelBuilder.Entity<M01WF03>()
                    .Property(m => m.DealerRate)
                    .HasPrecision(EntityAndDatabaseConstants.PercentageSevenLength, EntityAndDatabaseConstants.PercentageFourDecimalPlaces);

              


                // ------ M01WF04

                ////SKY12831A:
                //modelBuilder.Entity<M01WF04>()
                //    .Property(m => m.Account)
                //    .HasMaxLength(EntityAndDatabaseConstants.AccountLength)
                //    .IsFixedLength();

                modelBuilder.Entity<M01WF04>()
                   .Property(m => m.FxPurpose)
                   .HasMaxLength(EntityAndDatabaseConstants.FxPurposeLength);

                modelBuilder.Entity<M01WF04>()
                 .Property(m => m.BankBuyCurrencyAmount)
                 .HasPrecision(EntityAndDatabaseConstants.MoneyLength, EntityAndDatabaseConstants.MoneyDecimalPlaces);

                modelBuilder.Entity<M01WF04>()
                   .Property(m => m.BankSellCurrencyAmount)
                   .HasPrecision(EntityAndDatabaseConstants.MoneyLength, EntityAndDatabaseConstants.MoneyDecimalPlaces);

                modelBuilder.Entity<M01WF04>()
                   .Property(m => m.CustomerRate)
                   .HasPrecision(EntityAndDatabaseConstants.PercentageSevenLength, EntityAndDatabaseConstants.PercentageFourDecimalPlaces);

                modelBuilder.Entity<M01WF04>()
                    .Property(m => m.DealerRate)
                    .HasPrecision(EntityAndDatabaseConstants.PercentageSevenLength, EntityAndDatabaseConstants.PercentageFourDecimalPlaces);

                modelBuilder.Entity<M01WF04>()
                  .Property(m => m.ConfirmationExt)
                  .HasMaxLength(EntityAndDatabaseConstants.ConfirmationExtensionLength);


                // ------ M01WF05
                //SKY12831A:
                //modelBuilder.Entity<M01WF05>()
                //    .Property(m => m.Account)
                //    .HasMaxLength(EntityAndDatabaseConstants.AccountLength)
                //    .IsFixedLength();

                // ------ M01WF06

                ////SKY12831A:
                //modelBuilder.Entity<M01WF06>()
                //    .Property(m => m.Account)
                //    .HasMaxLength(EntityAndDatabaseConstants.AccountLength)
                //    .IsFixedLength();

                modelBuilder.Entity<M01WF06>()
                 .Property(m => m.FxPurpose)
                 .HasMaxLength(EntityAndDatabaseConstants.FxPurposeLength);

                modelBuilder.Entity<M01WF06>()
                 .Property(m => m.BankBuyCurrencyAmount)
                 .HasPrecision(EntityAndDatabaseConstants.MoneyLength, EntityAndDatabaseConstants.MoneyDecimalPlaces);

                modelBuilder.Entity<M01WF06>()
                   .Property(m => m.BankSellCurrencyAmount)
                   .HasPrecision(EntityAndDatabaseConstants.MoneyLength, EntityAndDatabaseConstants.MoneyDecimalPlaces);

                modelBuilder.Entity<M01WF06>()
                   .Property(m => m.CustomerRate)
                   .HasPrecision(EntityAndDatabaseConstants.PercentageSevenLength, EntityAndDatabaseConstants.PercentageFourDecimalPlaces);

                modelBuilder.Entity<M01WF06>()
                    .Property(m => m.DealerRate)
                    .HasPrecision(EntityAndDatabaseConstants.PercentageSevenLength, EntityAndDatabaseConstants.PercentageFourDecimalPlaces);

                modelBuilder.Entity<M01WF06>()
                  .Property(m => m.ConfirmationExt)
                  .HasMaxLength(EntityAndDatabaseConstants.ConfirmationExtensionLength);
            }

        }
    }