public void Configure(EntityTypeBuilder <ValueAnswer> builder)
        {
            builder.AnswersBaseConfigure();

            builder.Property(x => x.Value)
            .IsRequired()
            .HasMaxLength(EntityConfigs.TextMaxLength);

            builder.Property(x => x.Definition)
            .IsRequired()
            .HasMaxLength(EntityConfigs.TextAreaMaxLength);

            builder.Property(x => x.Description)
            .IsRequired()
            .HasMaxLength(EntityConfigs.TextAreaMaxLength);

            builder.HasOne(x => x.UserStepResult)
            .WithMany(s => s.ValueAnswers)
            .HasForeignKey(x => x.UserStepResultId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.Question)
            .WithMany(s => s.ValueAnswers)
            .HasForeignKey(x => x.QuestionId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);
        }
        public void Configure(EntityTypeBuilder <PreparingAnswer> builder)
        {
            builder.AnswersBaseConfigure();

            builder.Property(x => x.Date)
            .IsRequired(false);

            builder.Property(x => x.HowItWillBeDone)
            .IsRequired()
            .HasMaxLength(EntityConfigs.TextAreaMaxLength);

            builder.Property(x => x.IsCompleted)
            .IsRequired()
            .HasDefaultValue(false);

            builder.HasOne(x => x.IssueOptionAnswer)
            .WithMany(s => s.PreparingAnswers)
            .HasForeignKey(x => x.IssueOptionAnswerId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.UserStepResult)
            .WithMany(s => s.PreparingAnswers)
            .HasForeignKey(x => x.UserStepResultId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.Question)
            .WithMany(s => s.PreparingAnswers)
            .HasForeignKey(x => x.QuestionId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);
        }
        public void Configure(EntityTypeBuilder <BooleanAnswer> builder)
        {
            builder.AnswersBaseConfigure();

            builder.HasOne(x => x.Resource)
            .WithMany(s => s.BooleanAnswers)
            .HasForeignKey(x => x.ResourceId)
            .IsRequired(false)
            .OnDelete(DeleteBehavior.Restrict);

            builder.Property(x => x.Answer)
            .IsRequired();

            builder.HasOne(x => x.UserStepResult)
            .WithMany(s => s.BooleanAnswers)
            .HasForeignKey(x => x.UserStepResultId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.Question)
            .WithMany(s => s.BooleanAnswers)
            .HasForeignKey(x => x.QuestionId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);
        }
Exemple #4
0
        public void Configure(EntityTypeBuilder <SelectAnswer> builder)
        {
            builder.AnswersBaseConfigure();

            builder.Property(x => x.AltOption)
            .IsRequired(false)
            .HasMaxLength(EntityConfigs.TextMaxLength);

            builder.HasOne(x => x.Option)
            .WithMany(s => s.SelectAnswers)
            .HasForeignKey(x => x.OptionId)
            .IsRequired(false)
            .OnDelete(DeleteBehavior.SetNull);

            builder.HasOne(x => x.Issue)
            .WithMany(s => s.SelectAnswers)
            .HasForeignKey(x => x.IssueId)
            .IsRequired(false)
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.UserStepResult)
            .WithMany(s => s.SelectAnswers)
            .HasForeignKey(x => x.UserStepResultId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.Question)
            .WithMany(s => s.SelectAnswers)
            .HasForeignKey(x => x.QuestionId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);
        }
        public void Configure(EntityTypeBuilder<StakeholderRatingAnswer> builder)
        {
            builder.AnswersBaseConfigure();

            builder.Property(x => x.Grade)
                .IsRequired(false);

            builder.Property(x => x.Priority)
               .IsRequired(true);

            builder.HasOne(x => x.Stakeholder)
                .WithMany(s => s.StakeholderRatingAnswers)
                .HasForeignKey(x => x.StakeholderId)
                .IsRequired(true)
                .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.UserStepResult)
                .WithMany(s => s.StakeholderRatingAnswers)
                .HasForeignKey(x => x.UserStepResultId)
                .IsRequired()
                .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.Question)
                .WithMany(s => s.StakeholderRatingAnswers)
                .HasForeignKey(x => x.QuestionId)
                .IsRequired()
                .OnDelete(DeleteBehavior.Restrict);

        }
        public void Configure(EntityTypeBuilder <StakeholderAnswer> builder)
        {
            builder.AnswersBaseConfigure();

            builder.Property(x => x.IsInternal)
            .HasDefaultValue(false)
            .IsRequired(true);

            builder.Property(x => x.LastName)
            .IsRequired(false)
            .HasMaxLength(EntityConfigs.TextMaxLength);

            builder.Property(x => x.FirstName)
            .IsRequired(false)
            .HasMaxLength(EntityConfigs.TextMaxLength);

            builder.Property(x => x.Email)
            .IsRequired(false)
            .HasMaxLength(EntityConfigs.TextMaxLength);

            builder.HasOne(x => x.Category)
            .WithMany(x => x.CategoryStakeholders)
            .IsRequired(false)
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.User)
            .WithMany(s => s.StakeholderAnswers)
            .HasForeignKey(x => x.UserId)
            .IsRequired(false)
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.UserStepResult)
            .WithMany(s => s.StakeholderAnswers)
            .HasForeignKey(x => x.UserStepResultId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.Question)
            .WithMany(s => s.StakeholderAnswers)
            .HasForeignKey(x => x.QuestionId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);
        }
Exemple #7
0
        public void Configure(EntityTypeBuilder <StrategicIssueAnswer> builder)
        {
            builder.AnswersBaseConfigure();

            builder.Property(x => x.Why)
            .IsRequired()
            .HasMaxLength(EntityConfigs.TextAreaMaxLength);

            builder.Property(x => x.Result)
            .IsRequired()
            .HasMaxLength(EntityConfigs.TextAreaMaxLength);

            builder.Property(x => x.Goal)
            .IsRequired()
            .HasMaxLength(EntityConfigs.TextAreaMaxLength);

            builder.Property(x => x.Solution)
            .IsRequired()
            .HasMaxLength(EntityConfigs.TextAreaMaxLength);

            builder.Property(x => x.Ranking)
            .IsRequired();

            builder.HasOne(x => x.Issue)
            .WithMany(s => s.StrategicIssueAnswers)
            .HasForeignKey(x => x.IssueId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.UserStepResult)
            .WithMany(s => s.StrategicIssueAnswers)
            .HasForeignKey(x => x.UserStepResultId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.Question)
            .WithMany(s => s.StrategicIssueAnswers)
            .HasForeignKey(x => x.QuestionId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);
        }
        public void Configure(EntityTypeBuilder <FileAnswer> builder)
        {
            builder.AnswersBaseConfigure();

            builder.HasOne(x => x.File)
            .WithMany(s => s.FileAnswers)
            .HasForeignKey(x => x.FileId)
            .IsRequired(true)
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.UserStepResult)
            .WithMany(s => s.FileAnswers)
            .HasForeignKey(x => x.UserStepResultId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);

            builder.HasOne(x => x.Question)
            .WithMany(s => s.FileAnswers)
            .HasForeignKey(x => x.QuestionId)
            .IsRequired()
            .OnDelete(DeleteBehavior.Restrict);
        }