using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;

namespace Demo_Validation.Models;

public partial class User11Context : DbContext
{
    public User11Context()
    {
    }

    public User11Context(DbContextOptions<User11Context> options)
        : base(options)
    {
    }

    public virtual DbSet<ActivitiesAndEvent> ActivitiesAndEvents { get; set; }

    public virtual DbSet<Activity> Activities { get; set; }

    public virtual DbSet<City> Cities { get; set; }

    public virtual DbSet<Country> Countries { get; set; }

    public virtual DbSet<Event> Events { get; set; }

    public virtual DbSet<Juri> Juris { get; set; }

    public virtual DbSet<Role> Roles { get; set; }

    public virtual DbSet<User> Users { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
#warning To protect potentially sensitive information in your connection string, you should move it out of source code. You can avoid scaffolding the connection string by using the Name= syntax to read it from configuration - see https://go.microsoft.com/fwlink/?linkid=2131148. For more guidance on storing connection strings, see https://go.microsoft.com/fwlink/?LinkId=723263.
        => optionsBuilder.UseNpgsql("Host=45.67.56.214;Port=5421;Database=user11;Username=user11;Password=JSZHJyg1");

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<ActivitiesAndEvent>(entity =>
        {
            entity.HasKey(e => e.ActivitiesAndEventsId).HasName("activities_and_events_pk");

            entity.ToTable("activities_and_events");

            entity.Property(e => e.ActivitiesAndEventsId)
                .UseIdentityAlwaysColumn()
                .HasColumnName("activities_and_events_id");
            entity.Property(e => e.ActivitieId).HasColumnName("activitie_id");
            entity.Property(e => e.EventId).HasColumnName("event_id");

            entity.HasOne(d => d.Activitie).WithMany(p => p.ActivitiesAndEvents)
                .HasForeignKey(d => d.ActivitieId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("activities_and_events_activities_fk_1");

            entity.HasOne(d => d.Event).WithMany(p => p.ActivitiesAndEvents)
                .HasForeignKey(d => d.EventId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("activities_and_events_events_fk");
        });

        modelBuilder.Entity<Activity>(entity =>
        {
            entity.HasKey(e => e.ActivityId).HasName("activities_pk");

            entity.ToTable("activities");

            entity.Property(e => e.ActivityId)
                .UseIdentityAlwaysColumn()
                .HasColumnName("activity_id");
            entity.Property(e => e.ActivityDay).HasColumnName("activity_day");
            entity.Property(e => e.ActivityName)
                .HasColumnType("character varying")
                .HasColumnName("activity_name");
            entity.Property(e => e.ActivityTime).HasColumnName("activity_time");
            entity.Property(e => e.ModeratorId).HasColumnName("moderator_id");

            entity.HasOne(d => d.Moderator).WithMany(p => p.Activities)
                .HasForeignKey(d => d.ModeratorId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("activities_users_fk");
        });

        modelBuilder.Entity<City>(entity =>
        {
            entity.HasKey(e => e.CityId).HasName("city_pk");

            entity.ToTable("city");

            entity.Property(e => e.CityId)
                .ValueGeneratedNever()
                .HasColumnName("city_id");
            entity.Property(e => e.CityName)
                .HasColumnType("character varying")
                .HasColumnName("city_name");
        });

        modelBuilder.Entity<Country>(entity =>
        {
            entity.HasKey(e => e.CountryId).HasName("country_pk");

            entity.ToTable("country");

            entity.Property(e => e.CountryId)
                .UseIdentityAlwaysColumn()
                .HasColumnName("country_id");
            entity.Property(e => e.Code)
                .HasColumnType("character varying")
                .HasColumnName("code");
            entity.Property(e => e.Code2).HasColumnName("code_2");
            entity.Property(e => e.CountryName)
                .HasColumnType("character varying")
                .HasColumnName("country_name");
            entity.Property(e => e.CountryNameEn)
                .HasColumnType("character varying")
                .HasColumnName("country_name(en)");
        });

        modelBuilder.Entity<Event>(entity =>
        {
            entity.HasKey(e => e.EvantId).HasName("events_pk");

            entity.ToTable("events");

            entity.Property(e => e.EvantId)
                .UseIdentityAlwaysColumn()
                .HasColumnName("evant_id");
            entity.Property(e => e.CityId).HasColumnName("city_id");
            entity.Property(e => e.DateEvant).HasColumnName("date_evant");
            entity.Property(e => e.Days).HasColumnName("days");
            entity.Property(e => e.NameEvant)
                .HasColumnType("character varying")
                .HasColumnName("name_evant");
            entity.Property(e => e.WinnerId).HasColumnName("winner_id");

            entity.HasOne(d => d.City).WithMany(p => p.Events)
                .HasForeignKey(d => d.CityId)
                .HasConstraintName("events_city_fk");

            entity.HasOne(d => d.Winner).WithMany(p => p.Events)
                .HasForeignKey(d => d.WinnerId)
                .HasConstraintName("events_users_fk");
        });

        modelBuilder.Entity<Juri>(entity =>
        {
            entity.HasKey(e => e.ActivityAndJuriId).HasName("juris_pk");

            entity.ToTable("juris");

            entity.Property(e => e.ActivityAndJuriId)
                .UseIdentityAlwaysColumn()
                .HasColumnName("activity_and_juri_id");
            entity.Property(e => e.ActivityId).HasColumnName("activity_id");
            entity.Property(e => e.JurisId).HasColumnName("juris_id");

            entity.HasOne(d => d.Activity).WithMany(p => p.Juris)
                .HasForeignKey(d => d.ActivityId)
                .HasConstraintName("juris_activities_fk");

            entity.HasOne(d => d.Juris).WithMany(p => p.Juris)
                .HasForeignKey(d => d.JurisId)
                .HasConstraintName("juris_users_fk");
        });

        modelBuilder.Entity<Role>(entity =>
        {
            entity.HasKey(e => e.RoleId).HasName("roles_pk");

            entity.ToTable("roles");

            entity.Property(e => e.RoleId)
                .UseIdentityAlwaysColumn()
                .HasColumnName("role_id");
            entity.Property(e => e.RoleName)
                .HasColumnType("character varying")
                .HasColumnName("role_name");
        });

        modelBuilder.Entity<User>(entity =>
        {
            entity.HasKey(e => e.UserId).HasName("users_pk");

            entity.ToTable("users");

            entity.Property(e => e.UserId)
                .UseIdentityAlwaysColumn()
                .HasColumnName("user_id");
            entity.Property(e => e.Direction)
                .HasColumnType("character varying")
                .HasColumnName("direction");
            entity.Property(e => e.UserCountryId).HasColumnName("user_country_id");
            entity.Property(e => e.UserDateBirth).HasColumnName("user_date_birth");
            entity.Property(e => e.UserEmail)
                .HasColumnType("character varying")
                .HasColumnName("user_email");
            entity.Property(e => e.UserGander)
                .HasColumnType("character varying")
                .HasColumnName("user_gander");
            entity.Property(e => e.UserName)
                .HasColumnType("character varying")
                .HasColumnName("user_name");
            entity.Property(e => e.UserPassword)
                .HasColumnType("character varying")
                .HasColumnName("user_password");
            entity.Property(e => e.UserPhone)
                .HasColumnType("character varying")
                .HasColumnName("user_phone");
            entity.Property(e => e.UserPhoto)
                .HasColumnType("character varying")
                .HasColumnName("user_photo");
            entity.Property(e => e.UserRoleId).HasColumnName("user_role_id");

            entity.HasOne(d => d.UserCountry).WithMany(p => p.Users)
                .HasForeignKey(d => d.UserCountryId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("users_country_fk");

            entity.HasOne(d => d.UserRole).WithMany(p => p.Users)
                .HasForeignKey(d => d.UserRoleId)
                .OnDelete(DeleteBehavior.ClientSetNull)
                .HasConstraintName("users_roles_fk");
        });
        modelBuilder.HasSequence("activities_activity_id_seq").HasMax(2147483647L);
        modelBuilder.HasSequence("activities_and_events_activities_and_events_id_seq").HasMax(2147483647L);
        modelBuilder.HasSequence("country_country_seq").HasMax(2147483647L);
        modelBuilder.HasSequence("events_evant_id_seq").HasMax(2147483647L);
        modelBuilder.HasSequence("juris_activity_and_juri_id_seq").HasMax(2147483647L);
        modelBuilder.HasSequence("roles_role_id_seq").HasMax(2147483647L);
        modelBuilder.HasSequence("users_user_id_seq").HasMax(2147483647L);

        OnModelCreatingPartial(modelBuilder);
    }

    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}