cms_thermo_active/Step.Model/DTOModels/DTOAlarmsModel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Step.Model.DTOModels
{
    public class DTOAlarmsModel
    {
        public List<GenericAlarmModel> NcAlarms { get; set; }
        public List<GenericAlarmModel> PlcAlarms { get; set; }
        public List<ProcessAlarmModel> ProcessAlarms { get; set; }

        public DTOAlarmsModel()
        {
            NcAlarms = new List<GenericAlarmModel>();
            PlcAlarms = new List<GenericAlarmModel>();
            ProcessAlarms = new List<ProcessAlarmModel>();
        }

        public void Clear()
        {
            NcAlarms.Clear();
            PlcAlarms.Clear();
            ProcessAlarms.Clear();
        }

        public override bool Equals(object obj)
        {
            var item = obj as DTOAlarmsModel;

            if(item == null)
                return false;

            if (item.NcAlarms.Count != NcAlarms.Count || item.PlcAlarms.Count != this.PlcAlarms.Count || item.ProcessAlarms.Count != this.ProcessAlarms.Count)
                return false;

            bool isEqual = item.NcAlarms.All(NcAlarms.Contains);
            if (!isEqual)
                return false;

            isEqual = item.PlcAlarms.All(PlcAlarms.Contains);
            if (!isEqual)
                return false;

            isEqual = item.ProcessAlarms.All(ProcessAlarms.Contains);
            if (!isEqual)
                return false;

            return true;
        }

        public DTOAlarmsModel IntersectModels(DTOAlarmsModel newAlarms)
        {
            DTOAlarmsModel result = new DTOAlarmsModel();
            // Get common data 
            result.NcAlarms = NcAlarms.Where(x => newAlarms.NcAlarms.Contains(x as GenericAlarmModel)).ToList();
            // Concat common data + new data
            result.NcAlarms = result.NcAlarms.Concat(
                newAlarms.NcAlarms.Where(x => !NcAlarms.Contains(x as GenericAlarmModel)).ToList() // Find not contained data in the old list
                ).ToList();

            // Get common data 
            result.PlcAlarms = PlcAlarms.Where(x => newAlarms.PlcAlarms.Contains(x as GenericAlarmModel)).ToList();
            // Concat common data + new data
            result.PlcAlarms = result.PlcAlarms.Concat(
                newAlarms.PlcAlarms.Where(x => !PlcAlarms.Contains(x as GenericAlarmModel)).ToList() // Find not contained data in the old list
                ).ToList();

            // Get common data
            result.ProcessAlarms = ProcessAlarms.Where(x => newAlarms.ProcessAlarms.Contains(x as ProcessAlarmModel)).ToList();

            // Concat common data + new data in the list
            result.ProcessAlarms = result.ProcessAlarms.Concat( 
                newAlarms.ProcessAlarms.Where(x => !ProcessAlarms.Contains(x as ProcessAlarmModel)).ToList()  // Find not contained data in the old list
                ).ToList();

            return result;
        }
    }

    public class GenericAlarmModel
    {
        public string alarmMessage;
        public DateTime dateTime;

        public override bool Equals(object obj)
        {
            var item = obj as GenericAlarmModel;

            if (item == null)
                return false;

            if (item.alarmMessage == alarmMessage)
                return true;
            else
                return false;
        }
    }

    public class ProcessAlarmModel
    {
        public string alarmMessage;
        public ushort process;
        public DateTime dateTime;

        public override bool Equals(object obj)
        {
            var item = obj as ProcessAlarmModel;

            if (item == null)
                return false;

            if (item.process == process && item.alarmMessage == alarmMessage )
                return true;
            else
                return false;
        }
    }
    class DTOAlarmsModelComparer : IEqualityComparer<DTOAlarmsModel>
    {
        public  bool Equals(DTOAlarmsModel x, DTOAlarmsModel y)
        {
            if (x == null)
                return false;

            if (x.NcAlarms.Count != y.NcAlarms.Count || x.PlcAlarms.Count != y.PlcAlarms.Count || x.ProcessAlarms.Count != y.ProcessAlarms.Count)
                return false;

            bool isEqual = x.NcAlarms.All(y.NcAlarms.Contains);
            if (!isEqual)
                return false;

            isEqual = x.PlcAlarms.All(y.PlcAlarms.Contains);
            if (!isEqual)
                return false;

            isEqual = x.ProcessAlarms.All(y.ProcessAlarms.Contains);
            if (!isEqual)
                return false;

            return true;
        }

        public int GetHashCode(DTOAlarmsModel obj)
        {
            throw new NotImplementedException();
        }
    }
}