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

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data.Entity;
using System.IO;
using System.Linq;
using Thermo.Active.Model.DatabaseModels;
using Thermo.Active.Model.DTOModels;
using Thermo.Active.Model.DTOModels.MaintenanceModels;
using Thermo.Active.Utils;
using static Thermo.Active.Config.ServerConfig;
using static Thermo.Active.Model.Constants;

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

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

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

        public List<DTOPerformModel> GetPerformedMaintenancesFromId(int maintenanceId)
        {
            List<DTOPerformModel> valRet = new List<DTOPerformModel>();

            List<PerformedMaintenanceModel> maintList = (from maintenances in dbCtx.PerformedMaintenances
                                                         where maintenances.MaintenanceId == maintenanceId
                                                         select maintenances)
                                                        .Include("Maintainer").OrderByDescending(x => x.Date)
                                                        .ToList();


            foreach (PerformedMaintenanceModel maintenance in maintList)
            {
                if (maintenance.ControlWord != -2)
                    valRet.Add(new DTOPerformModel()
                    {
                        Date = maintenance.Date,
                        Countervalue = (uint)Math.Ceiling(SupportFunctions.ConvertInUmeas(maintenance.CounterValue, maintenance.Maintenance.UnitOfMeasure.Value)),
                        ControlWord = maintenance.ControlWord,
                        User = maintenance.Maintainer != null ? maintenance.Maintainer.Username : null
                    });
            }

            return valRet;
        }

        public List<PerformedMaintenanceModel> FindLastPerformedMaintenances()
        {
            List<PerformedMaintenanceModel> lastMaintenances = new List<PerformedMaintenanceModel>();
            // Find last performed maintenance
            lastMaintenances = (from maintenances in dbCtx.PerformedMaintenances
                                where maintenances.Date == (from m1 in dbCtx.PerformedMaintenances // Select max data of performed maintenance
                                                            where m1.MaintenanceId == maintenances.MaintenanceId
                                                            select m1.Date
                                                            ).Max()
                                select maintenances)
                                .Include("Maintainer")
                                .ToList();

            return lastMaintenances;
        }

        public PerformedMaintenanceModel PerformeMaintenance(uint counterValue, int maintenanceId, int userId, int controlWord)
        {
            PerformedMaintenanceModel performed = new PerformedMaintenanceModel()
            {
                CounterValue = (int)counterValue,
                Date = DateTime.Now,
                MaintenanceId = maintenanceId,
                MaintainerId = userId,
                ControlWord = controlWord
            };

            dbCtx.PerformedMaintenances.Add(performed);

            // Commit changes
            dbCtx.SaveChanges();

            return performed;
        }

        public MaintenanceModel FindById(int id)
        {
            return dbCtx
                .Maintenances
                .Find(id);
        }

        public List<MaintenanceModel> FindAll()
        {
            return dbCtx
                .Maintenances
                .ToList();
        }

        public MaintenanceModel Create(DTONewMaintenanceModel newMaint, int userId)
        {
            int counter = 0;

            //fix the maintenance number to 1 (machine Counter)
            if (newMaint.Type == MAINTENANCE_TYPE.MACHINE_INTERVAL)
                counter = 0;

            MaintenanceModel dbMaint = new MaintenanceModel()
            {
                MaintenanceId = GetUserMaintenanceId(dbCtx.Maintenances),
                CreationDate = DateTime.Now,
                CounterId = counter,
                Interval = newMaint.Interval,
                Deadline = newMaint.Deadline,
                Description = newMaint.Description,
                Title = newMaint.Title,
                Type = newMaint.Type,
                UnitOfMeasure = newMaint.UnitOfMeasure,
                UserId = userId,
                LastExpirationDate = null
            };

            // Add to database
            dbCtx.Maintenances.Add(dbMaint);
            // Commit changes
            dbCtx.SaveChanges();
            return dbMaint;
        }

        private int GetUserMaintenanceId(IEnumerable<MaintenanceModel> maintenances)
        {
            int max = maintenances.Select(x => x.MaintenanceId).Max();
            // If there aren't user maintenance return 100
            if (max < 100)
                return 100;
            else
                return max + 1;
        }

        public MaintenanceModel Update(int maintenanceId, DTOUpdateMaintenanceModel newMaint)
        {
            MaintenanceModel dbMaint = FindById(maintenanceId);

            if (dbMaint != null)
            {
                dbMaint.Title = newMaint.Title;
                dbMaint.Description = newMaint.Description;
                dbMaint.Deadline = newMaint.Deadline;
                dbMaint.Interval = newMaint.Interval;
                dbMaint.UnitOfMeasure = newMaint.UnitOfMeasure;

                // Commit changes
                dbCtx.SaveChanges();
            }

            return dbMaint;
        }

        public void Delete(int maintId)
        {
            MaintenanceModel maint = FindById(maintId);
            Delete(maint);
        }

        public void Delete(MaintenanceModel maint)
        {
            dbCtx.Maintenances.Remove(maint);
            dbCtx.SaveChanges();
        }

        public void CheckDifferencesFromDbAndXml()
        {
            List<MaintenanceModel> dbMaintenances = dbCtx
                .Maintenances
                .ToList();

            // Find database rows that has to be deleted
            List<MaintenanceModel> toDeleteMaint = dbMaintenances.Where(x => x.UserId == null &&
                !MaintenancesConfig.Select(y => y.Id).Contains(x.MaintenanceId)
            ).ToList();

            // Delete database items
            foreach (var item in toDeleteMaint)
                dbCtx.Maintenances.Remove(item);
            dbCtx.SaveChanges();

            // Find common data from
            List<MaintenanceModel> toUpdateMaint = dbMaintenances.Where(x =>
                MaintenancesConfig.Select(y => y.Id).Contains(x.MaintenanceId)
            )
            .ToList();

            // Update rows
            if (toUpdateMaint != null)
                foreach (MaintenanceModel item in toUpdateMaint)
                {
                    // find maintenances to be updated into db
                    var old = dbCtx.Maintenances.FirstOrDefault(x => x.MaintenanceId == item.MaintenanceId);

                    if (old != null)
                        // Update model
                        old = MaintenancesConfig.Where(x => x.Id == item.MaintenanceId).Select(x =>
                        {
                            old.MaintenanceId = x.Id;
                            old.Deadline = x.Deadline;
                            old.Interval = x.Intervall.TotalMinutes;
                            old.Type = (MAINTENANCE_TYPE)Enum.Parse(typeof(MAINTENANCE_TYPE), x.Type);
                            old.CounterId = x.CouterId;
                            old.UnitOfMeasure = (MAINTENANCE_UNIT_OF_MEASURE)Enum.Parse(typeof(MAINTENANCE_UNIT_OF_MEASURE), x.UnitOfMeasure);
                            return old;
                        }).FirstOrDefault();
                }

            dbCtx.SaveChanges();

            // Get new maintenance from file
            List<MaintenanceModel> toAddMaint = MaintenancesConfig
                .Where(x => !toUpdateMaint.Select(y => y.MaintenanceId).Contains(x.Id))
                .Select(x => new MaintenanceModel()
                {
                    MaintenanceId = x.Id,
                    Deadline = x.Deadline,
                    Interval = x.Intervall.TotalMinutes,
                    Type = (MAINTENANCE_TYPE)Enum.Parse(typeof(MAINTENANCE_TYPE), x.Type),
                    CounterId = x.CouterId,
                    CreationDate = DateTime.Now,
                    UnitOfMeasure = (MAINTENANCE_UNIT_OF_MEASURE)Enum.Parse(typeof(MAINTENANCE_UNIT_OF_MEASURE), x.UnitOfMeasure),
                    UserId = null,
                    LastExpirationDate = null
                })
                .ToList();

            // Add new maintenances to database
            if (toAddMaint != null)
            {
                dbCtx.Maintenances.AddRange(toAddMaint);
                dbCtx.SaveChanges();
            }
        }

        public void UpdateLastExpirationDate(int id, DateTime expDate)
        {
            MaintenanceModel maintenance = FindById(id);

            if (maintenance != null)
            {
                maintenance.LastExpirationDate = expDate;
                dbCtx.SaveChanges();
            }
        }

        #region Notes

        public MaintenanceNoteModel FindNoteById(int noteId)
        {
            return dbCtx
                .MaintenancesNotes
                .Where(x => x.Id == noteId)
                .Include("User")
                .FirstOrDefault();
        }

        public List<MaintenanceNoteModel> FindNotes()
        {
            return dbCtx
                .MaintenancesNotes
                .ToList();
        }

        public List<DTOMaintenanceNoteModel> GetNotesByMaintId(int maintenanceId)
        {
            return dbCtx
                .MaintenancesNotes
                .Where(x => x.MaintenanceId == maintenanceId) // Filter by id
                .Select(x => new DTOMaintenanceNoteModel() // Convert to return model
                {
                    Id = x.Id,
                    DateTime = x.DateTime,
                    Message = x.Message,
                    User = new DTOMessageUserModel()
                    {
                        Id = x.User.UserId,
                        FirstName = x.User.FirstName,
                        LastName = x.User.LastName,
                        Username = x.User.Username
                    }
                })
                .ToList();
        }

        public DTOMaintenanceNoteModel CreateNote(int userId, int maintenanceId, DTONewMaintenanceNoteModel newNote)
        {
            // Create model
            MaintenanceNoteModel note = new MaintenanceNoteModel()
            {
                Message = newNote.Message,
                DateTime = DateTime.Now,
                MaintenanceId = maintenanceId,
                UserId = userId
            };
            // Add & save into database
            dbCtx.MaintenancesNotes.Add(note);

            dbCtx.SaveChanges();

            dbCtx.Entry(note).Reference(x => x.User).Load();
            dbCtx.Users.Attach(note.User);

            return (DTOMaintenanceNoteModel)note;
        }

        public DTOMaintenanceNoteModel UpdateNote(MaintenanceNoteModel note, DTONewMaintenanceNoteModel newNote)
        {
            note.Message = newNote.Message;
            dbCtx.SaveChanges();

            return (DTOMaintenanceNoteModel)note;
        }

        public void DeleteNote(int noteId)
        {
            MaintenanceNoteModel note = FindNoteById(noteId);
            dbCtx.MaintenancesNotes.Remove(note);

            dbCtx.SaveChanges();
        }

        #endregion Notes

        #region Attachment

        public List<MaintenanceFileModel> FindAttachmentByMaintenance(int maintenanceId)
        {
            return dbCtx
                .MaintenanceFiles
                .Where(x => x.MaintenanceId == maintenanceId)
                .ToList();
        }

        public MaintenanceFileModel FindAttachmentById(int attachmentId)
        {
            return dbCtx
                .MaintenanceFiles
                .Where(x => x.AttachmentId == attachmentId)
                .FirstOrDefault();
        }

        public MaintenanceFileModel AddAttachment(string fileName, string localFileName, int maintenanceId, int userId)
        {
            MaintenanceFileModel file = new MaintenanceFileModel()
            {
                FileName = fileName,
                LocalFileName = localFileName,
                MaintenanceId = maintenanceId,
                UserId = userId
            };
            // Add to db
            dbCtx.MaintenanceFiles.Add(file);

            dbCtx.SaveChanges();

            return file;
        }

        public void DeleteAttachment(int attachmentId)
        {
            MaintenanceFileModel file = dbCtx.MaintenanceFiles.Where(x => x.AttachmentId == attachmentId).FirstOrDefault();
            if (file != null)
            {
                dbCtx.MaintenanceFiles.Remove(file);

                dbCtx.SaveChanges();
            }
        }

        public void DeleteAttachment(MaintenanceFileModel attachment)
        {
            dbCtx.MaintenanceFiles.Remove(attachment);

            dbCtx.SaveChanges();

            if (File.Exists(MAINTENANCE_ATTACHMENT_PATH + attachment.LocalFileName))
                File.Delete(MAINTENANCE_ATTACHMENT_PATH + attachment.LocalFileName);
        }

        #endregion Attachment

        public bool CheckPassword(string password, string machineNumber, uint plcCounter, out int cw)
        {
            cw = -1;

            SupportFunctions.ConvertStringMachineNumberIntoNumber(machineNumber, out bool containsLetters, out int intMachineVal);
            if (!GetDataFromMaintenancePassword(password, containsLetters, out int pwdMachineNumber, out int pwdHours, out cw))
                return false;

            // Check machine number 
            if (intMachineVal == pwdMachineNumber)
            {
                // Convert plcCounter in hours and check if password is expired
                if (((plcCounter / 3600) - pwdHours) <= 50)
                {
                    return true; // Ok
                }
            }

            return false; // Invalid Password
        }

        private bool GetDataFromMaintenancePassword(string password, bool containsLetters, out int number, out int hours, out int cw)
        {
            number = -1;
            hours = -1;
            cw = -1;

            if (String.IsNullOrEmpty(password))
                return false;

            string tmpPassword1 = "",
                tmpPassword3 = "",
                tmpPassword4 = "",
                tmpPassword5 = "";

            Hashtable htCifrario = new Hashtable
            {
                { 'K', "0" },
                { 'M', "1" },
                { 'X', "2" },
                { 'N', "3" },
                { 'G', "4" },
                { 'V', "5" },
                { 'P', "6" },
                { 'Z', "7" },
                { 'H', "8" },
                { 'Q', "9" }
            };

            // Create tmpPassword5 changing characters that matches with characters in the hashtable  
            foreach (char c in password)
            {
                if (htCifrario.ContainsKey(c))
                    tmpPassword5 += htCifrario[c].ToString(); // Change character with hashtable val
                else
                    tmpPassword5 += c;
            }

            // Get control number
            var stringCw = Right(tmpPassword5, 1);
            if (!int.TryParse(stringCw, out int controlNumber))
                return false;

            tmpPassword4 = tmpPassword5.Remove(tmpPassword5.Length - 1);

            // Create tmpPassoword3
            foreach (char c in tmpPassword4)
            {
                // If tmpPassword is empty copy the first character
                if (tmpPassword3.Length == 0)
                {
                    tmpPassword3 = c.ToString();
                }
                else
                {
                    // Check if character is a number
                    if (char.IsNumber(c))
                        // Add first digit of -> Number + 10 - control number
                        tmpPassword3 += Right((char.GetNumericValue(c) + 10 - controlNumber).ToString(), 1);
                    else
                        tmpPassword3 += c.ToString();
                }
            }

            if (containsLetters)
            {
                tmpPassword1 = tmpPassword3.PadLeft(15, '0');

                number = Convert.ToInt32(tmpPassword1.Substring(5, 8), 16); // Convert from hexadecimal
                cw = Convert.ToInt32(tmpPassword1.Substring(13, 2), 16); // Convert from hexadecimal
            }
            else
            {
                tmpPassword1 = tmpPassword3.PadLeft(11, '0');

                number = Convert.ToInt32(tmpPassword1.Substring(5, 4), 16); // Convert from hexadecimal
                cw = Convert.ToInt32(tmpPassword1.Substring(9, 2), 16); // Convert from hexadecimal
            }

            hours = Convert.ToInt32(tmpPassword1.Substring(0, 5), 16);  // Convert from hexadecimal

            return true;
        }

        private static string Right(string value, int size)
        {
            // if length is greater than "size" resets "size"
            size = (value.Length < size ? value.Length : size);
            // Substring is the equivalent of VB NET RIGHT
            string newValue = value.Substring(value.Length - size);
            return newValue;
        }
    }
}