UnivatePropertiesAPI/UnivateProperties_API/Repository/Users/RegisterRepository.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Drawing.Text;
using System.Linq;
using System.Text;
using UnivateProperties_API.Containers.Users;
using UnivateProperties_API.Containers.Users.Simple;
using UnivateProperties_API.Context;
using UnivateProperties_API.Helpers;
using UnivateProperties_API.Model.Communication;
using UnivateProperties_API.Model.Users;
using UnivateProperties_API.Repository.Communication;

namespace UnivateProperties_API.Repository.Users
{
    public class RegisterRepository : IRegisterRepository
    {
        private readonly DataContext _dbContext;

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

        public User Authenticate(string username, string password)
        {
            if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
                return null;

            var user = _dbContext.Users.SingleOrDefault(x => x.Username == username);

            // check if username exists
            if (user == null)
                throw new AppException("Username is incorrect");

            // check if password is correct
            if (!MyCommon.VerifyPasswordHash(password, user.PasswordHash, user.PasswordSalt))
                throw new AppException("Password is incorrect");

            // authentication successful
            return user;
        }

        public User Create(User user, string password, bool save, bool terms)
        {
            // validation
            if (string.IsNullOrWhiteSpace(password))
                throw new AppException("Password is required");

            if (_dbContext.Users.Any(x => x.Username == user.Username))
                throw new AppException("Username \"" + user.Username + "\" is already taken");

            MyCommon.CreatePasswordHash(password, out byte[] passwordHash, out byte[] passwordSalt);

            user.PasswordHash = passwordHash;
            user.PasswordSalt = passwordSalt;
            user.AcceptedTerms = terms;
            //user.Id = NewUserId();
            _dbContext.Users.Add(user);
            if (save)
            {
                _dbContext.SaveChanges();
            }

            return user;
        }

        public Agency CreateAgency(AgencyDto agency)
        {
            // validation
            /* if (string.IsNullOrWhiteSpace(agency.EaabeffcNumber))
                 throw new AppException("eaabeffcNumber is required");

             if (_dbContext.Agencies.Any(x => x.EAABEFFCNumber == agency.EaabeffcNumber))
                 throw new AppException("eaabeffcNumber \"" + agency.EaabeffcNumber + "\" already exists");*/
            if (!string.IsNullOrEmpty(agency.EaabeffcNumber))
            {
                var savedAgency = _dbContext.Agencies.Where(x => x.EAABEFFCNumber == agency.EaabeffcNumber).FirstOrDefault();
                if (savedAgency == null)
                {
                    Agency a = new Agency()
                    {
                        AgencyName = agency.Name,
                        EAABEFFCNumber = agency.EaabeffcNumber,
                        CompanyRegNumber = agency.RegNo
                    };
                    _dbContext.Agencies.Add(a);
                    CreatePerson(agency.User, PersonType.Agent, false, a);


                    return a;
                }
                else
                {
                    CreatePerson(agency.User, PersonType.Agent, false, savedAgency);
                    _dbContext.SaveChanges();
                    return savedAgency;
                }
            }
            else 
            {
                CreatePerson(agency.User, PersonType.Agent, false, null);
                _dbContext.SaveChanges();
                return null;
            }
        }

        public void CreatePerson(UserDto individual, PersonType personType, bool save, Agency agency)
        {
            // validation
            if (string.IsNullOrWhiteSpace(individual.Password))
                throw new AppException("Password is required");

            if (_dbContext.Users.Any(x => x.Username == individual.Username))
                throw new AppException("Individual \"" + individual.Username + "\" is already taken");

            MyCommon.CreatePasswordHash(individual.Password, out byte[] passwordHash, out byte[] passwordSalt);

            User createUser = new User(individual.Username, individual.Password);

            Create(createUser, individual.Password, false, individual.AcceptedTerms);

            Person p = null;
            
            if (personType == PersonType.Agent)
            {
                Agent agent = new Agent()
                {
                    Name = individual.Name,
                    Surname = individual.Surname,
                    User = createUser,
                    Email = individual.Email,
                    CellNumber = individual.CellNumber,
                    Telephone = individual.Telephone,
                    Agency = agency
                };
                //agent.Id = NewAgentId();
                agent.User.Role = Role.Agency;
                p = agent;
                _dbContext.Agents.Add(agent);
            }
            else if (personType == PersonType.Individual)
            {
                Individual i = new Individual()
                {
                    Name = individual.Name,
                    Surname = individual.Surname,
                    User = createUser,
                    Email = individual.Email,
                    CellNumber = individual.CellNumber,
                    Telephone = individual.Telephone
                };
                //i.Id = NewIndividualId();
                i.User.Role = Role.PrivateUser;
                p = i;
                _dbContext.Individuals.Add(i);

            }
            Template template = _dbContext.Templates.FirstOrDefault(x => x.Name == "IndivRegEmail");
            if (template != null && personType == PersonType.Individual)
            {
                    TemplateRepository templateRepository = new TemplateRepository(_dbContext);
                    templateRepository.SendEmailTemplate(template, p, new List<Model.BaseEntity>() { p });
            }

            Template templ = _dbContext.Templates.FirstOrDefault(x => x.Name == "AgencyRegEmail");
            if (templ != null)
            {
                TemplateRepository templateRepository = new TemplateRepository(_dbContext);
                templateRepository.SendEmailTemplate(templ, p, new List<Model.BaseEntity>() { p });
            }

            Template temp = _dbContext.Templates.FirstOrDefault(x => x.Name == "VerificationEmail");
            if (temp != null)
            {
                TemplateRepository templateRepository = new TemplateRepository(_dbContext);
                templateRepository.SendEmailTemplate(temp, p, new List<Model.BaseEntity>() { p });
            }

            if (save)
            {
                Save();
            }
        }

        public void Update(User userParam, string password = null)
        {
            var user = _dbContext.Users.Find(userParam.Id);

            if (user == null)
                throw new AppException("User not found");

            if (userParam.Username != user.Username)
            {
                // username has changed so check if the new username is already taken
                if (_dbContext.Users.Any(x => x.Username == userParam.Username))
                    throw new AppException("Username " + userParam.Username + " is already taken");
            }

            // update user properties
            user.Username = userParam.Username;

            // update password if it was entered
            if (!string.IsNullOrWhiteSpace(password))
            {
                MyCommon.CreatePasswordHash(password, out byte[] passwordHash, out byte[] passwordSalt);

                user.PasswordHash = passwordHash;
                user.PasswordSalt = passwordSalt;
            }

            //_dbContext.Users.Update(user);
            _dbContext.Entry(user).State = EntityState.Modified;
            _dbContext.SaveChanges();
        }

        [Authorize(Roles = Role.SuperAdmin)]
        public IEnumerable<User> GetAllUsers()
        {
            return _dbContext.Users;
        }

        [Authorize(Roles = Role.SuperAdmin)]
        public IEnumerable<Agency> GetAllAgencies()
        {
            return _dbContext.Agencies;
        }

        [Authorize(Roles = Role.SuperAdmin)]
        public IEnumerable<Individual> GetAllIndividuals()
        {
            return _dbContext.Individuals.Where(x => x.IsDeleted != true);
        }

        public User GetById(int id)
        {
            return _dbContext.Users.Find(id);
        }

        public Agency GetByAgencyId(int id)
        {
            return _dbContext.Agencies.Find(id);
        }

        public Individual GetByIndividualId(int id)
        {
            return _dbContext.Individuals.Find(id);
        }

        public void Delete(int id)
        {
            var user = _dbContext.Users.Find(id);
            if (user != null)
            {
                _dbContext.Users.Remove(user);
                _dbContext.SaveChanges();
            }
        }

        public void DeleteAgency(int id)
        {
            var agency = _dbContext.Agencies.Find(id);
            if (agency != null)
            {
                _dbContext.Remove(agency);
                _dbContext.SaveChanges();
            }
        }

        public void DeleteIndividual(int id)
        {
            var individual = _dbContext.Individuals.Find(id);
            if (individual != null)
            {
                _dbContext.Individuals.Remove(individual);
                _dbContext.SaveChanges();
            }
        }

        public void UpdatePassword(UserDto userParam)
        {
            var indiv = _dbContext.Individuals.Where(x => x.Email == userParam.Email).FirstOrDefault();
            var user = _dbContext.Users.Where(x => x.Id == indiv.UserId).FirstOrDefault();

            MyCommon.CreatePasswordHash(userParam.Password, out byte[] passwordHash, out byte[] passwordSalt);

            user.PasswordHash = passwordHash;
            user.PasswordSalt = passwordSalt;
            user.FPToken = "";

            //_dbContext.Users.Update(user);
            _dbContext.Entry(user).State = EntityState.Modified;
            Save();
        }

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

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

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

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

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

        public SimplePersonDto UserDetails(int userId)
        {
            var individual = _dbContext.Individuals.Where(i => i.UserId == userId).FirstOrDefault();

            if (individual == null)
            {
                var agent = _dbContext.Agents.Where(i => i.UserId == userId).FirstOrDefault();
                if (agent != null)
                {
                    return new SimplePersonDto()
                    {
                        Name = agent.Name,
                        Surname = agent.Surname,
                        Email = agent.Email
                    };
                }
                else
                {
                    return new SimplePersonDto(); ;
                }
            }
            else
            {
                return new SimplePersonDto()
                {
                    Name = individual.Name,
                    Surname = individual.Surname,
                    Email = individual.Email
                };
            }
        }

        public Individual GetIndividualByFPToken(string fpToken)
        {
            string linkStr = fpToken.Replace('!', '/');
            var user = _dbContext.Users.Where(usr => usr.FPToken == linkStr).FirstOrDefault();

            if (user != null)
            {
                var indiv = _dbContext.Individuals.Where(x => x.UserId == user.Id).FirstOrDefault();
                return indiv;
            }
            else
            {
                throw new Exception();
            }            
        }

        public void ForgotPasswordMailCheck(string mail)
        {
            var indiv = _dbContext.Individuals.Where(x => x.Email.ToUpper() == mail.ToUpper()).FirstOrDefault();
            var mailer = new MailRepository(_dbContext);
            if (indiv != null)
            {
                byte[] time = BitConverter.GetBytes(GetTime());
                byte[] mailByte = Encoding.ASCII.GetBytes(mail);
                var timeStr = GetTime().ToString();
                byte[] timeArr = Encoding.ASCII.GetBytes(timeStr);
                byte[] key = Guid.NewGuid().ToByteArray();

                string token = Convert.ToBase64String((timeArr.Concat(key).ToArray()).Concat(mailByte).ToArray());

                string secureKey = "EGV~A8pn;:9&zC]6";

                //encrypt token

                ClsCrypto lockey = new ClsCrypto(secureKey);

                var encryptedToken = lockey.Encrypt(token);
                var individual = _dbContext.Individuals.Where(e => e.Email == mail).FirstOrDefault();
                var user = _dbContext.Users.Where(x => x.Id == individual.UserId).FirstOrDefault();

                //send ecrypted token to db
                user.FPToken = encryptedToken;

                _dbContext.Entry(user).State = EntityState.Modified;
                //_dbContext.Users.Update(user);
                _dbContext.SaveChanges();

                string linkStr = encryptedToken.Replace('/', '!');

                //change below to test locally or QA
                //string url = "http://localhost:8080/#/forgotPasswordReset/" + linkStr;
                //string url = "http://training.provision-sa.com:122/#/forgotPasswordReset/" + linkStr;
                //string url = "https://www.pvsl.co.za:97/#/forgotPasswordReset/" + linkStr;
                string url = "https://www.univateproperties.co.za/#/forgotPasswordReset/" + linkStr;

                mailer.ForgotPassword(indiv, url);
            }
            else
            {
                throw new Exception();
            }
        }

        private double GetTime()
        {
            return DateTime.Now.Subtract(new DateTime(1970, 1, 1)).TotalMilliseconds;
        }
    }
}