UnivatePropertiesAPI/UnivateProperties_API/Repository/Timeshare/WeekRepository.cs

using Abp.Domain.Entities;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using UnivateProperties_API.Containers.Timeshare;
using UnivateProperties_API.Containers.Timeshare.Detailed;
using UnivateProperties_API.Containers.Users;
using UnivateProperties_API.Context;
using UnivateProperties_API.Helpers;
using UnivateProperties_API.Helpers.Communication;
using UnivateProperties_API.Model;
using UnivateProperties_API.Model.Communication;
using UnivateProperties_API.Model.Region;
using UnivateProperties_API.Model.Timeshare;
using UnivateProperties_API.Repository.Communication;
using UnivateProperties_API.Repository.Region;
using UnivateProperties_API.Repository.Users;

namespace UnivateProperties_API.Repository.Timeshare
{
    public interface IWeekRepository : IRepository<TimeshareWeek>
    {
        int SaveNewWeek(TimeshareWeekDto sellItem);        
    }

    public class WeekRepository : IWeekRepository
    {
        private readonly DataContext _dbContext;

        public WeekRepository(DataContext dbContext)
        {
            _dbContext = dbContext;
        }

        public List<TimeshareWeek> Get(Func<TimeshareWeek, bool> where)
        {
            return _dbContext.Weeks.Where(where).ToList();
        }

        public List<TimeshareWeek> GetAll()
        {
            return _dbContext.Weeks.ToList();
        }

        public TimeshareWeek GetDetailed(Func<TimeshareWeek, bool> first)
        {
            var item = _dbContext.Weeks.FirstOrDefault(first);
            item = GetDetailedWeek(item);
            return item;
        }

        public DetailedWeekDto GetMyDetailed(Func<TimeshareWeek, bool> first)
        {
            var item = GetDetailed(first);
            if(item != null)
            {
                return new DetailedWeekDto(item);
            }
            return null;
        }

        public List<WeekDto> GetDtoListAll()
        {
            List<WeekDto> list = new List<WeekDto>();
            foreach (var item in GetDetailedAll())
            {
                list.Add(new WeekDto(item));
            }

            var listIds = list.Select(x => x.WeekUni).ToList();

            foreach (var  item in GetTenderWeeks())
            {
                if (!listIds.Contains(item.WeekUni))
                    list.Add(item);
            }
            return list;
        }

        public List<WeekDto> GetMyWeeks(int userId)
        {
            List<WeekDto> list = new List<WeekDto>();
            UserRepository userRepository = new UserRepository(_dbContext);
            var user = userRepository.Get(x => x.Id == userId).FirstOrDefault();
            if (user.IsUserInRole(Role.SuperAdmin))
            {
                foreach (var item in GetDetailedAll())
                {
                    list.Add(new WeekDto(item));
                }
            }
            else if (user.IsUserInRole(Role.Agency))
            {
                var agent = _dbContext.Agents.FirstOrDefault(x => x.UserId == userId);
                if(agent != null)
                {
                    foreach (var item in GetDetailedAll().Where(x => x.AgencyId == agent.AgencyId))
                    {
                        list.Add(new WeekDto(item));
                    }
                }                
            }
            else if (user.IsUserInRole(Role.Agent) || user.IsUserInRole(Role.ManagingAgent))
            {
                var agent = _dbContext.Agents.FirstOrDefault(x => x.UserId == userId);
                if(agent != null)
                {
                    foreach (var item in GetDetailedAll().Where(x => x.AgentId == agent.Id))
                    {
                        list.Add(new WeekDto(item));
                    }
                }
            }
            else
            {
                var individual = _dbContext.Individuals.FirstOrDefault(x => x.UserId == userId);
                if(individual != null)
                {
                    foreach (var item in GetDetailedAll().Where(x => x.OwnerId == individual.Id))
                    {
                        list.Add(new WeekDto(item));
                    }
                }                
            }
            return list;
        }

        public List<RegionDto> GetAvailResort()
        {
            List<RegionDto> list = new List<RegionDto>();
            var allItems = GetDtoListAll();
            foreach (var item in allItems)
            {
                if (item.Region != null)
                {
                    if (!list.Any(x => x.RegionCode == item.Region.RegionCode))
                    {
                        list.Add(new RegionDto(item.Region.RegionCode, item.Region.RegionName));
                    }
                    foreach (var i in list.Where(x => x.RegionCode == item.Region.RegionCode))
                    {
                        i.TryAddResort(item.Resort.ResortCode, item.Resort.ResortName);
                    }
                }
            }
            list = list.OrderBy(x => x.RegionName).ToList();
            foreach (var region in list)
            {
                region.OrderResorts();
                foreach (var resort in region.Resorts)
                {
                    resort.Available = allItems.Count(x => x.Resort.ResortCode == resort.ResortCode);
                }
            }
            return list;
        }

        public List<TimeshareWeek> GetDetailedAll()
        {
            var list = GetAll();
            List<TimeshareWeek> weeklist = new List<TimeshareWeek>();
            foreach (var item in list)
            {
                weeklist.Add(GetDetailedWeek(item));
            }
            return weeklist;
        }

        private TimeshareWeek GetDetailedWeek(TimeshareWeek week)
        {
            if (week.AgencyId != null)
            {
                AgencyRepository agency = new AgencyRepository(_dbContext);
                week.Agency = agency.Get(x => x.Id == week.AgencyId).FirstOrDefault();
            }
            if (week.AgentId != null)
            {
                AgentRepository agent = new AgentRepository(_dbContext);
                week.Agent = agent.Get(x => x.Id == week.AgentId).FirstOrDefault();
            }
            if (week.StatusId != 0)
            {
                StatusRepository status = new StatusRepository(_dbContext);
                week.Status = status.Get(x => x.Id == week.StatusId).FirstOrDefault();
            }
            else
            {
                StatusRepository repo = new StatusRepository(_dbContext);
                week.Status = repo.GetDetailed(s => s.Code == "A1");
            }
            if (week.RegionId != 0)
            {
                ProvinceRepository province = new ProvinceRepository(_dbContext);
                week.Region = province.Get(x => x.Id == week.RegionId).FirstOrDefault();
            }
            if (week.OwnerId != 0)
            {
                IndividualRepository individual = new IndividualRepository(_dbContext);
                week.Owner = individual.Get(x => x.Id == week.OwnerId).FirstOrDefault();
            }
            return week;
        }

        public void Insert(TimeshareWeek item)
        {
            item = GetDetailedWeek(item);
            StatusRepository repo = new StatusRepository(_dbContext);
            var stat = repo.Get(x => x.Code == "A1" && x.StatusType == StatusType.Timeshare).FirstOrDefault();
            if (stat == null)
            {
                //Create initial
                stat = new Status()
                {
                    Code = "A1",
                    Description = "Pending verification",
                    StatusType = StatusType.Timeshare,
                    ModifiedBy = "KobusB"
                };
                repo.Insert(stat);
            }
            //item.Id = NewId();
            item.ProcessFlows.Add(new Model.ProcessFlow.ProcessFlow()
            {
                Status = item.Status,
                Timeshare = item
            });
            TemplateRepository templateRepository = new TemplateRepository(_dbContext);
            if(item.Owner != null)
            {
                var template = _dbContext.Templates.FirstOrDefault(x => x.Name == "WeekLoaded-Owner");
                if(template != null)
                {
                    templateRepository.SendEmailTemplate(template, item.Owner, new List<BaseEntity>() { item, item.Owner });
                }
                template = _dbContext.Templates.FirstOrDefault(x => x.Name == "WeekLoaded-UV");
                if(template != null)
                {
                    templateRepository.SendEmailTemplate(template, item.Owner, new List<BaseEntity>() { item, item.Owner });
                }
            }            
            _dbContext.Add(item);
            Save();
        }

        public void Insert(IEnumerable<TimeshareWeek> items)
        {
            //int id = NewId();
            foreach (var item in items)
            {
                //item.Id = id;
                _dbContext.Add(item);
                //id += 1;
            }
            Save();
        }

        public void Remove(TimeshareWeek item)
        {
            var i = _dbContext.Weeks.Find(item);
            _dbContext.Weeks.Remove(i);
            Save();
        }

        public void Remove(IEnumerable<TimeshareWeek> items)
        {
            foreach (var item in items)
            {
                var i = _dbContext.Weeks.Find(item);
                _dbContext.Weeks.Remove(i);
            }
            Save();
        }

        public void RemoveAtId(int item)
        {
            var i = _dbContext.Weeks.Find(item);
            _dbContext.Weeks.Remove(i);
            Save();
        }

        public void Save()
        {
            _dbContext.SaveChanges();
        }

        public void Update(TimeshareWeek item)
        {
            var saved = _dbContext.Weeks.Where(w => w.Id == item.Id).FirstOrDefault();
            if (saved.Mandate != item.Mandate)
            {
                if (item.Mandate)
                    saved.DateMandated = DateTime.Now;
            }
            if (saved.WeekStatus != item.WeekStatus)
            {
                saved.WeekStatus = item.WeekStatus;
            }
            if (saved.Publish != item.Publish)
            {
                saved.Publish = item.Publish;
            }
            if (saved.PulbishedDate != item.PulbishedDate)
            {
                saved.PulbishedDate = item.PulbishedDate;
            }
            _dbContext.Entry(saved).State = EntityState.Modified;
            Save();
        }

        public List<TimeshareWeek> GetBy(WeekFilterDto week)
        {
            List<TimeshareWeek> item = GetDetailedAll();
            if (!string.IsNullOrEmpty(week.RegionCode))
            {
                item = item.Where(x => x.Region != null && x.Region.Code?.ToLower() == week.RegionCode.ToLower()).ToList();
            }
            if (!string.IsNullOrEmpty(week.ResortCode))
            {
                item = item.Where(x => x.ResortCode?.ToLower() == week.ResortCode).ToList();
            }
            if (week.Date != null)
            {
                item = item.Where(x =>
                                        x.ArrivalDate >= week.Date.Value.AddDays(-7)
                                        && x.DepartureDate <= week.Date.Value.AddDays(7)).ToList();
            }
            if (week.MinAmount != null && week.MinAmount != 0)
            {
                item = item.Where(x => x.SellPrice >= week.MinAmount).ToList();
            }
            if (week.MaxAmount != null && week.MaxAmount != 0)
            {
                item.Where(x => x.SellPrice <= week.MaxAmount).ToList();
            }
            return item;
        }

        //public int NewId()
        //{
        //    int id = 0;
        //    if (_dbContext.Weeks.Count() > 0)
        //    {
        //        id = _dbContext.Weeks.Max(x => x.Id);
        //    }
        //    id += 1;
        //    return id;
        //}

        private int _TenderId = 10000;
        private int GetTenderId()
        {
            return _TenderId++;
        }

        public List<WeekDto> GetTenderWeeks()
        {
            List<WeekDto> list = new List<WeekDto>();
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(MyCommon.TenderUrl);
            request.Method = "GET";
            WebResponse response = request.GetResponse();
            using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
            {
                string result = reader.ReadToEnd();

                if (result.Length > 0)
                {
                    string cleanLine;
                    string[] lines = result.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
                    foreach (string line in lines)
                    {
                        cleanLine = line.Replace("<br>", "");
                        cleanLine = cleanLine.Replace("<br >", "");
                        cleanLine = cleanLine.Replace("<br/>", "");
                        cleanLine = cleanLine.Replace("<br />", "");
                        list.Add(new WeekDto(GetTenderId(),cleanLine));
                    }
                }
            }
            // Check that all regions are same as other
            list
                .Where(x => x.Region != null && x.Region.RegionCode == "FN")
                .ToList()
                .ForEach(x => x.Region.RegionCode = ChangeRegion(x.Region.RegionCode));
            list = GetRegion(list);
            return list;
        }

        private List<WeekDto> GetRegion(List<WeekDto> list)
        {
            ProvinceRepository province = new ProvinceRepository(_dbContext);
            Province prov = null;
            foreach(var item in list)
            {
                prov = province.GetDetailed(x => x.Code == item.Region.RegionCode);
                if(prov != null)
                {
                    item.Region = new RegionDto(prov.Id, prov.Code, prov.Description);
                }                
            }
            return list;
        }

        private string ChangeRegion(string value)
        {
            switch(value)
            {
                case "FN":
                    return "KZN";
                case "L":
                    return "LI";
                default:
                    return value;
            }
        }

        public List<DetailedWeekDto> GetNeedApproval()
        {
            List<DetailedWeekDto> detList = new List<DetailedWeekDto>();
            var status = _dbContext.Status.FirstOrDefault(x => x.Code == "A1" && x.StatusType == StatusType.Timeshare);
            if(status != null)
            {
                var list = GetDetailedAll().Where(x => x.Status != null && x.Status.Id == status.Id).ToList();
                list.ForEach(x => detList.Add(new DetailedWeekDto(x)));
            }
            return detList;
        }

        public void VerifyWeek(int id)
        {
            var week = _dbContext.Weeks.FirstOrDefault(x => x.Id == id);
            var newStatus = _dbContext.Status.FirstOrDefault(x => x.Code.ToLower() == "a2" && x.StatusType == StatusType.Timeshare);
            if(week != null && newStatus != null)
            {
                week = GetDetailedWeek(week);
                week.Status = newStatus;
                Update(week);
                var template = _dbContext.Templates.Where(x => x.Name == "WeekAuthorized").FirstOrDefault();
                if(template != null)
                {
                    
                    TemplateRepository tempRepo = new TemplateRepository(_dbContext);
                    tempRepo.SendEmailTemplate(template, week.Owner, new List<BaseEntity>() { week, week.Owner, week.Owner.User});
                }
            }
        }

        public void PublishWeek(int id)
        {
            var week = _dbContext.Weeks.FirstOrDefault(x => x.Id == id);
            var newStatus = _dbContext.Status.FirstOrDefault(x => x.Code.ToLower() == "b1" && x.StatusType == StatusType.Timeshare);
            if (week != null && newStatus != null)
            {
                week.Status = newStatus;
                Update(week);
            }
        }

        public int SaveNewWeek(TimeshareWeekDto sellItem)
        {
            var owner = _dbContext.Individuals.Where(x => x.Id == sellItem.OwnerObject.Id).FirstOrDefault();
            var address = _dbContext.Addresses.Where(a => a.Id == sellItem.OwnerObject.Address.Id).FirstOrDefault();
            var banking = _dbContext.BankAccounts.Where(b => b.Id == sellItem.OwnerObject.BankingDetails.Id).FirstOrDefault();
            var status = _dbContext.Status.Where(s => s.Code == "A1" && s.StatusType == StatusType.Timeshare).FirstOrDefault();
            var agent = _dbContext.Agents.Where(ag => ag.Id == sellItem.AgentId).FirstOrDefault();

            #region Address
            if (sellItem.OwnerObject.Address.PostalCode != "")
            {
                if (address == null)
                {
                    address = new Model.Misc.Address();
                }
                address.StreetNumber = sellItem.OwnerObject.Address.StreetNumber;
                address.Street = sellItem.OwnerObject.Address.Street;
                address.Suburb = sellItem.OwnerObject.Address.Suburb;
                address.City = sellItem.OwnerObject.Address.City;
                address.Province = sellItem.OwnerObject.Address.Province;
                address.PostalCode = sellItem.OwnerObject.Address.PostalCode;

                if (address.Id == 0)
                {
                    _dbContext.Add(address);
                    Save();
                }
                else
                {
                    _dbContext.Entry(address).State = EntityState.Modified;
                    Save();
                }
            }
            #endregion

            #region Banking
            if (sellItem.OwnerObject.BankingDetails.AccountHolder != "")
            {
                if (banking == null)
                {
                    banking = new Model.Banks.BankAccount();
                }
                banking.AccountHolder = sellItem.OwnerObject.BankingDetails.AccountHolder;
                banking.AccountNumber = sellItem.OwnerObject.BankingDetails.AccountNumber;
                banking.BankId = sellItem.OwnerObject.BankingDetails.Bank.Id;

                if (banking.Id == 0)
                {
                    _dbContext.Add(banking);
                    Save();
                }
                else
                {
                    _dbContext.Entry(banking).State = EntityState.Modified;
                    Save();
                }
            }
            #endregion

            #region Owner
            if (owner == null)
            {
                owner = new Model.Users.Individual();
            }
            if (address != null)
            {
                owner.AddressId = address.Id;
                owner.Address = address;
            }
            if (banking != null)
            {
                owner.BankAccount = banking;
                owner.BankAccountId = banking.Id;
            }
            owner.Name = sellItem.OwnerObject.Name;
            owner.Surname = sellItem.OwnerObject.Surname;
            owner.IdNumber = sellItem.OwnerObject.IdNumber;
            owner.CompanyRegNumber = sellItem.OwnerObject.CompanyRegNumber;            
            owner.Email = sellItem.OwnerObject.EmailAddress;
            owner.CellNumber = sellItem.OwnerObject.CellNumber;
            owner.Telephone = sellItem.OwnerObject.LandlineNumber;

            switch (sellItem.OwnerObject.MaritalStatus.ToUpper())
            {
                case "N/A":
                    owner.HowMarried = MarriedType.NotApplicable;
                    break;
                case "IN COMMUNITY OF PROPERTY":
                    owner.HowMarried = MarriedType.ICOP;
                    break;
                case "OUT OF COMMUNITY OF PROPERTY":
                    owner.HowMarried = MarriedType.OCOP;
                    break;
                case "OTHER":
                    owner.HowMarried = MarriedType.Other;
                    break;
                case "TRADITIONAL WEDDING":
                    owner.HowMarried = MarriedType.Traditional;
                    break;
                case "SINGLE":
                    owner.HowMarried = MarriedType.Single;
                    break;
                case "DIVORCED":
                    owner.HowMarried = MarriedType.Divorced;
                    break;
                case "WIDOW":
                    owner.HowMarried = MarriedType.Widow;
                    break;
                case "COMMITTED RELATIONSHIP":
                    owner.HowMarried = MarriedType.CommittedRelationship;
                    break;
                case "PARTNER":
                    owner.HowMarried = MarriedType.Partner;
                    break;
                default:
                    owner.HowMarried = MarriedType.NotApplicable;
                    break;
            }

            owner.SpouseCellnumber = sellItem.OwnerObject.SpouseCellnumber;
            owner.SpouseEmail = sellItem.OwnerObject.SpouseEmail;
            owner.SpouseName = sellItem.OwnerObject.SpouseName;
            owner.SpouseSurname = sellItem.OwnerObject.SpouseSurname;
            owner.SpouseTelephone = sellItem.OwnerObject.SpouseSurname;

            if (owner.Id == 0)
            {
                _dbContext.Add(owner);
                Save();
            }
            else
            {
                _dbContext.Entry(owner).State = EntityState.Modified;
                Save();
            }
            #endregion

            var week = new TimeshareWeek();
            foreach (string prop in week.GetAllProperties())
            {
                if (prop != "Item" && prop != "Display")
                    week[prop] = sellItem[prop];
            }
            week.Region = null;
            week.RegionId = sellItem.Region.Id;
            week.OwnerId = owner.Id;
            if (week.Mandate)
                week.DateMandated = DateTime.Now;

            TemplateRepository templateRepository = new TemplateRepository(_dbContext);
            
            var template = _dbContext.Templates.FirstOrDefault(x => x.Name == "WeekLoaded-Owner");

            if (agent != null)
            {
                template = _dbContext.Templates.FirstOrDefault(x => x.Name == "WeekLoaded-Agent");
                if (template != null)
                {
                    templateRepository.SendEmailTemplateWeek(template, agent, sellItem);
                }
            }
            else 
            {
                if (template != null)
                {
                    templateRepository.SendEmailTemplateWeek(template, owner, sellItem);
                }
                template = _dbContext.Templates.FirstOrDefault(x => x.Name == "WeekLoaded-UV");
                if (template != null)
                {
                    templateRepository.SendEmailTemplate(template, sellItem.Owner, new List<BaseEntity>() { sellItem, sellItem.Owner });
                }
                
            }


            week.StatusId = status.Id;
            _dbContext.Add(week);
            Save();

            return week.Id;
        }
    }
}