FCC/Applications/Gateway/POS/PosApp/PosAppDbContext.cs

using Edge.Core.Database.Models;
using Gateway.POS.Models;
using Microsoft.EntityFrameworkCore;

namespace Gateway.POS
{
    public class PosAppDbContext : DbContext
    {
        private DbContextOptions options;
        public PosAppDbContext() : base()
        {
        }
        //public AppDbContext(DbContextOptions options) : base(options) { this.options = options; }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlite("Data Source=Gateway_Pos_App_database.db");
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Transaction>().HasIndex(p => new { p.Id }).IsUnique(true);
            modelBuilder.Entity<Transaction>().HasIndex(p => new { p.ReceiptId }).IsUnique(true);
            modelBuilder.Entity<Transaction>().HasIndex(p => new { p.ShiftId }).IsUnique(false);
            modelBuilder.Entity<Transaction>().HasIndex(p => new { p.ServerSideTimestamp }).IsUnique(false);
            modelBuilder.Entity<Transaction>().HasIndex(p => new { p.TotalAmount }).IsUnique(false);
            modelBuilder.Entity<Transaction>().HasIndex(p => new { p.NetAmount }).IsUnique(false);

            modelBuilder.Entity<FuelItem>().HasIndex(p => new { p.Amount }).IsUnique(false);
            modelBuilder.Entity<FuelItem>().HasIndex(p => new { p.FuelProductCode }).IsUnique(false);
            modelBuilder.Entity<FuelItem>().HasIndex(p => new { p.SiteLevelNozzleId }).IsUnique(false);
            modelBuilder.Entity<FuelItem>().HasIndex(p => new { p.PumpId, p.NozzleLogicalId }).IsUnique(false);

            modelBuilder.Entity<Operator>().HasIndex(p => new { p.Name }).IsUnique(true);

            modelBuilder.Entity<MembershipAccount>().HasIndex(p => new { p.Name, p.CompanyName, p.PhoneNumber }).IsUnique(false);
            modelBuilder.Entity<MembershipSubAccountIdentity>().HasIndex(p => new { p.MembershipSubAccountId, p.Identity, p.IdentityCarrierType }).IsUnique(true);
            modelBuilder.Entity<MembershipTag>().HasIndex(p => new { p.Name }).IsUnique(true);
            modelBuilder.Entity<MembershipAccount_M2M_MembershipTag>().HasKey(p => new { p.MembershipTagId, p.MembershipAccountId });
            modelBuilder.Entity<MembershipSubAccount_M2M_MembershipTag>().HasKey(p => new { p.MembershipTagId, p.MembershipSubAccountId });

            #region otherwise, sqlite does not support Sum on decimal columns, so here underlying use double.

            modelBuilder.Entity<Transaction>().Property(e => e.TotalAmount).HasConversion<double>();
            modelBuilder.Entity<Transaction>().Property(e => e.NetAmount).HasConversion<double>();

            modelBuilder.Entity<Gateway.POS.Models.Payment>().Property(e => e.ExpectAmount).HasConversion<double>();
            modelBuilder.Entity<Gateway.POS.Models.Payment>().Property(e => e.PaidAmount).HasConversion<double>();

            modelBuilder.Entity<FuelItem>().Property(e => e.Qualtity).HasConversion<double>();
            modelBuilder.Entity<FuelItem>().Property(e => e.Amount).HasConversion<double>();
            modelBuilder.Entity<FuelItem>().Property(e => e.Price).HasConversion<double>();
            modelBuilder.Entity<FuelItem>().Property(e => e.TotalVolume).HasConversion<double>();

            modelBuilder.Entity<MembershipProfitAccount>().Property(e => e.Balance).HasConversion<double>();
            modelBuilder.Entity<MembershipProfitAccountRecharge>().Property(e => e.RechargeAmount).HasConversion<double>();
            modelBuilder.Entity<MembershipProfitAccountRedeem>().Property(e => e.RedeemedProfitAmount).HasConversion<double>();

            #endregion

            modelBuilder.Entity<MembershipAccount_M2M_MembershipTag>()
                .HasOne(at => at.Account)
                .WithMany(acct => acct.AccountTags)
                .HasForeignKey(at => at.MembershipAccountId);

            modelBuilder.Entity<MembershipSubAccount_M2M_MembershipTag>()
                .HasOne(at => at.SubAccount)
                .WithMany(subAcct => subAcct.SubAccountTags)
                .HasForeignKey(at => at.MembershipSubAccountId);

            modelBuilder.Entity<Transaction>().HasOne(t => t.MembershipProfitAccountRecharge).WithOne(r => r.SourceTrx)
                .HasForeignKey<MembershipProfitAccountRecharge>(b => b.SourceTrxId);
            modelBuilder.Entity<Transaction>().HasOne(t => t.MembershipProfitAccountRedeem).WithOne(r => r.SourceTrx)
                .HasForeignKey<MembershipProfitAccountRedeem>(b => b.SourceTrxId);
        }

        public DbSet<Gateway.POS.Models.Transaction> Transactions { get; set; }

        public DbSet<Gateway.POS.Models.Discount> Discounts { get; set; }

        public DbSet<Gateway.POS.Models.FuelItem> FuelItems { get; set; }

        public DbSet<Gateway.POS.Models.Payment> Payments { get; set; }

        public DbSet<Gateway.POS.Models.Operator> Operators { get; set; }

        public DbSet<Gateway.POS.Models.MembershipAccount> MembershipAccounts { get; set; }

        public DbSet<Gateway.POS.Models.MembershipSubAccountIdentity> MembershipSubAccountIdentities { get; set; }

        public DbSet<Gateway.POS.Models.MembershipSubAccount> MembershipSubAccounts { get; set; }

        public DbSet<Gateway.POS.Models.MembershipProfitAccount> MembershipProfitAccounts { get; set; }

        public DbSet<Gateway.POS.Models.MembershipProfitAccountRecharge> MembershipProfitAccountRecharges { get; set; }

        public DbSet<Gateway.POS.Models.MembershipProfitAccountRedeem> MembershipProfitAccountRedeems { get; set; }

        public DbSet<Gateway.POS.Models.MembershipTag> MembershipTags { get; set; }

        public DbSet<Gateway.POS.Models.MembershipAccount_M2M_MembershipTag> MembershipAccount_M2M_MembershipTags { get; set; }

        public DbSet<Gateway.POS.Models.MembershipSubAccount_M2M_MembershipTag> MembershipSubAccount_M2M_MembershipTags { get; set; }

    }
}