Project-C/Model.cs at main · Peredurz/Project-C · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
using Microsoft.EntityFrameworkCore;

namespace Models
{
    public class ModelContext : DbContext
    {
        public ModelContext(DbContextOptions<ModelContext> options) : base(options)
        {
        }

        public DbSet<Employee> Employees { get; set; }
        public DbSet<Event> Events { get; set; }
        public DbSet<Review> Reviews { get; set; }
        public DbSet<Room> Rooms { get; set; }
        public DbSet<Availability> Availabilities { get; set; }
        public DbSet<EmployeeEvent> EmployeeEvents { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Employee>()
                .HasKey(e => e.Id);

            modelBuilder.Entity<Event>()
                .HasKey(ev => ev.Id);

            modelBuilder.Entity<Review>()
                .HasKey(r => new { r.EmployeeId, r.EventId });

            modelBuilder.Entity<Room>()
                .HasKey(r => r.Id);

            modelBuilder.Entity<Availability>()
                .HasKey(w => new { w.EmployeeId, w.Date });

            modelBuilder.Entity<EmployeeEvent>()
                .HasKey(ee => new { ee.EmployeeId, ee.EventId });

            modelBuilder.Entity<Employee>()
                .HasMany(e => e.Reviews)
                .WithOne(r => r.Employee)
                .HasForeignKey(r => r.EmployeeId)
                .OnDelete(DeleteBehavior.Cascade);

            modelBuilder.Entity<Event>()
                .HasMany(ev => ev.Reviews)
                .WithOne(r => r.Event)
                .HasForeignKey(r => r.EventId)
                .OnDelete(DeleteBehavior.Cascade);

            modelBuilder.Entity<Employee>()
                .HasOne(e => e.Room)
                .WithOne(r => r.Employee)
                .HasForeignKey<Room>(r => r.EmployeeId)
                .OnDelete(DeleteBehavior.Cascade);

            modelBuilder.Entity<Employee>()
                .HasMany(e => e.Availabilities)
                .WithOne(w => w.Employee)
                .HasForeignKey(w => w.EmployeeId)
                .OnDelete(DeleteBehavior.Cascade);

            modelBuilder.Entity<Availability>()
                .HasOne(w => w.Employee)
                .WithMany(e => e.Availabilities)
                .HasForeignKey(w => w.EmployeeId);

            modelBuilder.Entity<EmployeeEvent>()
                .HasOne(ee => ee.Employee)
                .WithMany(e => e.AttendedEvents)
                .HasForeignKey(ee => ee.EmployeeId)
                .OnDelete(DeleteBehavior.Cascade);

            modelBuilder.Entity<EmployeeEvent>()
                .HasOne(ee => ee.Event)
                .WithMany(ev => ev.Attendees)
                .HasForeignKey(ee => ee.EventId);
        }
    }
}