it:ad:code_first:howto:define_models:relationships:examples:misc1

For Many to One (Invoice/LineItems):

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

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

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


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

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


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

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

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);
        }

    }
}
  • /home/skysigal/public_html/data/pages/it/ad/code_first/howto/define_models/relationships/examples/misc1.txt
  • Last modified: 2023/11/04 23:30
  • by 127.0.0.1