cms_thermo_active/Thermo.Active.Database/Controllers/UsersController.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Web.Helpers;
using Thermo.Active.Model.DatabaseModels;
using Thermo.Active.Model.DTOModels;
using static Thermo.Active.Config.ServerConfig;
using static Thermo.Active.Model.Constants;

namespace Thermo.Active.Database.Controllers
{
    public class UsersController : IDisposable
    {
        private DatabaseContext dbCtx;

        public UsersController()
        {
            // Initialize database context
            dbCtx = new DatabaseContext();
        }

        public void Dispose()
        {
            // Clear database context
            dbCtx.Dispose();
        }

        public DTOUserModel Create(string username, string password, string firstName, string lastName, CultureInfo language)
        {
            UserModel user = CreateUserModel(username, password, firstName, lastName, language);
            // Add to database
            dbCtx.Users.Add(user);
            // Commit changes
            dbCtx.SaveChanges();

            using (MachinesUsersController machController = new MachinesUsersController())
            {
                machController.Create(MachineConfig.MachineId, user.UserId, 3);
            }

            return GetUserInfo(user.UserId);
        }

        public static UserModel CreateUserModel(int id, string username, string password, string firstName, string lastName, CultureInfo language)
        {
            // Create a new user model with params
            return new UserModel()
            {
                UserId = id,
                Username = username,
                Password = Crypto.HashPassword(password),
                FirstName = firstName,
                LastName = lastName,
                SecurityStamp = Guid.NewGuid().ToString(),
                Language = language
            };
        }

        public static UserModel CreateUserModel(string username, string password, string firstName, string lastName, CultureInfo language)
        {
            return CreateUserModel(0, username, password, firstName, lastName, language);
        }

        public DTOUserModel GetUserInfo(int userId)
        {
            // Find user by Id with Role object included
            UserModel userDatabaseModel = dbCtx.Users.Where(u => u.UserId == userId).FirstOrDefault();
            if (userDatabaseModel == null)
                return null;

            DTORoleModel roleModel = null;

            // Find user role through machineUser table
            using (MachinesUsersController machinesUsersControler = new MachinesUsersController())
            {
                roleModel = machinesUsersControler.GetUserRoleData(MachineConfig.MachineId, userId);
                if (roleModel == null)
                    return null;
            }

            return new DTOUserModel() // Return DTOUserModel
            {
                Id = userDatabaseModel.UserId,
                Username = userDatabaseModel.Username,
                FirstName = userDatabaseModel.FirstName,
                LastName = userDatabaseModel.LastName,
                Language = userDatabaseModel.Language,
                Role = roleModel
            };
        }

        public UserModel FindById(int id)
        {
            // Find user by Id with Role object included
            return dbCtx.Users.Where(u => u.UserId == id).FirstOrDefault();
        }

        public UserModel FindByUsername(string username)
        {
            // Find user by Id with Role object included
            return dbCtx.Users.Where(u => u.Username == username).FirstOrDefault();
        }

        public UserModel FindByUsernameAndPassword(string username, string password)
        {
            // Find if username exists
            UserModel user = FindByUsername(username);

            if (user != null)
            {
                if (user.Deleted == true)
                    return null;

                // Check if the passwords match
                if (Crypto.VerifyHashedPassword(user.Password, password) != true)
                {
                    return null;
                }
            }

            return user;
        }

        public void CreateCmsDefaultUserIfNotExists(int machineId, string username, string password, string name, string lastname, CultureInfo info, ROLE_IDS roleId)
        {
            // Find if there is a cms standard user
            UserModel user = FindByUsername(username);
            if (user == null)
            {
                // If not exist add new user
                user = dbCtx.Users.Add(
                    CreateUserModel(username, password, name, lastname, info)
                );

                // Commit changes
                dbCtx.SaveChanges();
            }
            // Add user to local machine users if not exists
            using (MachinesUsersController machinesUsersController = new MachinesUsersController())
            {
                MachineUserModel machineUser = machinesUsersController.FindByUserId(machineId, user.UserId);

                if (machineUser == null)
                    machinesUsersController.Create(machineId, user.UserId, (int)roleId);
            }
        }

        public void ChangeUserLanguage(int userId, CultureInfo newLanguage)
        {
            UserModel user = FindById(userId);

            if (user != null)
            {
                user.Language = newLanguage;
                dbCtx.SaveChanges();
            }
        }

        public List<DTOMessageUserModel> GetMessageUserList()
        {
            using (MachinesUsersController machineController = new MachinesUsersController())
            {

                // Find user by Id with Role object included
                var tmpUser = dbCtx
                    .Users
                    .Where(x => x.Deleted == false) // Get not deleted users
                    .Join(dbCtx.MachinesUsers,
                        u => u.UserId,
                        m => m.UserId,
                        (u, m) => new { Users = u, MachinesUsers = m }
                     )
                    .Where(x => x.MachinesUsers.Role.Level < MIN_CMS_ROLE)
                    .ToList();

                return tmpUser
                    .Select(x => new DTOMessageUserModel() // Return DTOUserModel
                    {
                        Id = x.Users.UserId,
                        FirstName = x.Users.FirstName,
                        LastName = x.Users.LastName,
                        Username = x.Users.Username
                    })
                    .GroupBy(elem => elem.Id).Select(group => group.First())
                    .ToList();
            }
        }

        #region User Manager

        public List<DTOUserModel> GetUserList()
        {
            using (MachinesUsersController machineController = new MachinesUsersController())
            {

                // Find user by Id with Role object included
                var tmpUser = dbCtx
                    .Users
                    .Where(x => x.Deleted == false) // Get not deleted users
                    .ToList();

                return tmpUser
                    .Select(x => new DTOUserModel() // Return DTOUserModel
                    {
                        Id = x.UserId,
                        Username = x.Username,
                        FirstName = x.FirstName,
                        LastName = x.LastName,
                        Language = x.Language,
                        Role = machineController.GetUserRoleData(MachineConfig.MachineId, x.UserId)
                    }).Where(
                    x => x.Role.Level < MIN_CMS_ROLE)
                    .ToList();
            }
        }

        public DTOUserModel UpdateUserData(int userId, DTONewUserModel userData)
        {
            UserModel user = FindById(userId);

            if (user != null)
            {
                user.FirstName = userData.FirstName;
                user.LastName = userData.LastName;
                user.Username = userData.Username;

                dbCtx.SaveChanges();
            }

            return GetUserInfo(userId);
        }

        public DTOUserModel UpdateUserPassword(int userId, DTONewPasswordrModel userData)
        {
            UserModel user = FindById(userId);
            if (user != null)
            {
                user.Password = Crypto.HashPassword(userData.newPassword);
                dbCtx.SaveChanges();
            }

            return GetUserInfo(userId);
        }

        public bool isCMSRole(int roleId)
        {
            var tmpRole = dbCtx.Roles
                .ToList()
                .First(X => X.RoleId == roleId);

            if (tmpRole == null)
                return true;
            else
                return tmpRole.Level >= MIN_CMS_ROLE;
        }

        public DTOUserModel UpdateUserRole(int userId, int roleId)
        {
            using (MachinesUsersController machineController = new MachinesUsersController())
            {
                machineController.UpdateUserRole(MachineConfig.MachineId, userId, roleId);
            }

            return GetUserInfo(userId);
        }

        public void DeleteUser(UserModel user)
        {
            user.Deleted = true;

            dbCtx.SaveChanges();
        }

        #endregion User Manager
    }
}