bo/Workbench/Processor/Task/TaskItem.cs

using System.Text;
using Quadarax.Foundation.Core.Business.Processor.Enums;
using Quadarax.Foundation.Core.Business.Processor.Queue;
using Quadarax.Foundation.Core.Logging;
using Quadarax.Foundation.Core.Object;
using Quadarax.Foundation.Core.Value.Extensions;

namespace Quadarax.Foundation.Core.Business.Processor.Task
{
    internal class TaskItem : ITaskItem
    {
        #region *** Properties ***

        /// <summary>
        /// <inheritdoc cref="ITaskItem.Id"/>
        /// </summary>
        public long Id { get; internal set; }
        /// <summary>
        /// <inheritdoc cref="ITaskItem.QueueType"/>
        /// </summary>
        public ProcessQueueTypeEnum QueueType { get;private set; }
        /// <summary>
        /// <inheritdoc cref="ITaskItem.Created"/>
        /// </summary>
        public DateTime Created { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.Changed"/>
        /// </summary>
        public DateTime? Changed { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.AffinityToken"/>
        /// </summary>
        public IAffinityToken? AffinityToken { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.Reference"/>
        /// </summary>
        public string Reference { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.Status"/>
        /// </summary>
        public ProcessStatusEnum Status { get; private set; }
        /// <summary>
        /// <inheritdoc cref="ITaskItem.ProviderClass"/>
        /// </summary>
        public string ProviderClass { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.Priority"/>
        /// </summary>
        public byte Priority { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.ProcessingValidFrom"/>
        /// </summary>
        public DateTime ProcessingValidFrom { get;private set; }
        /// <summary>
        /// <inheritdoc cref="ITaskItem.ProcessingValidTo"/>
        /// </summary>
        public DateTime? ProcessingValidTo { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.AttemptsLeft"/>
        /// </summary>
        public int AttemptsLeft { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.AttemptTimeout"/>
        /// </summary>
        public TimeSpan? AttemptTimeout { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.StatStarted"/>
        /// </summary>
        public DateTime StatStarted { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.StatFinished"/>
        /// </summary>
        public DateTime StatFinished { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.StatLastAttemptDuration"/>
        /// </summary>
        public TimeSpan StatLastAttemptDuration { get; private set;}
        /// <summary>
        /// <inheritdoc cref="ITaskItem.StatusLog"/>
        /// </summary>
        public ITaskStatusLogItem[] StatusLog => _statusLog.ToArray();

        public TypedArgument[] Arguments => _arguments.ToArray(); 
        #endregion

        #region *** Private Fields ***
        private readonly List<ITaskStatusLogItem> _statusLog = new();
        private readonly List<TypedArgument> _arguments = new();
        private ILog _log;
        private ProcessQueue _parent; 
        #endregion

        #region *** Constructors ***
        private TaskItem(ProcessQueue parent, long id, ProcessStatusEnum initialStatus, string reference, string source, TypedArgument[] initialArguments, byte priority, int attepts, TimeSpan? attemptTimeout, DateTime validFrom, DateTime? validTo, ITaskStatusLogItem[]? initialStatusLog):
            this(parent, reference, source, initialArguments, priority, attepts, attemptTimeout, validFrom, validTo, initialStatusLog)
        {
            Id = id;
            Status = initialStatus;
        }
        public TaskItem(ProcessQueue parent, string reference, string providerClass, TypedArgument[] initialArguments, byte priority, int attepts, TimeSpan? attemptTimeout, DateTime validFrom, DateTime? validTo, ITaskStatusLogItem[]? initialStatusLog)
        {	
            AffinityToken = null;
            _parent = parent ?? throw new ArgumentNullException(nameof(parent)); 
            _log = new ConsoleLogger().GetLogger(GetType());      
            Priority = priority;
            Reference = reference;
            ProviderClass = providerClass;
            _arguments.Setup(initialArguments);
            AttemptTimeout = attemptTimeout;
            AttemptsLeft = attepts;
            ProcessingValidFrom = validFrom;
            ProcessingValidTo = validTo;
            Created = DateTime.Now;
            if (initialStatusLog != null)
                _statusLog.Setup(initialStatusLog);
            Status = ProcessStatusEnum.Pending; 
            Id = long.MinValue;
        }
        #endregion

        
        #region *** Public Operations ***
        public void Postpone(TimeSpan postponeInterval, string reason)
        {
            throw new NotImplementedException();
        }

        public void Stop(string reason, bool willPause = true, bool willFail = false)
        {
            throw new NotImplementedException();
        }

        public void Reset(string reason, TimeSpan postponeValid)
        {
            throw new NotImplementedException();
        }

        public void Delete(string reason, bool immediate = false)
        {
            throw new NotImplementedException();
        }
        public bool Euqals(ITaskItemData data)
        {
            return ((ITaskItemData)this).Equals(data);
        }

        public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("Id=");
            sb.Append(Id == long.MinValue ? "NEW" : Id.ToString()).Append(";");
            sb.Append("Ref=").Append(Reference).Append(";");
            sb.Append("Sta=").Append(Status).Append(";");
            sb.Append("Cre=").Append(Created.ToString("G")).Append(";");
            return sb.ToString();
        }
        #endregion

        #region *** Internal Operations ***

        internal void CopyFrom(ITaskItemData data)
        {
            Id = data.Id;
            Status = data.Status;
            Changed = data.Changed;
            Reference = data.Reference;
            ProviderClass = data.ProviderClass;
            Priority = data.Priority;
            ProcessingValidFrom = data.ProcessingValidFrom;
            ProcessingValidTo = data.ProcessingValidTo;
            Created = data.Created;
            Changed = data.Changed;
            StatStarted = data.StatStarted;
            StatFinished = data.StatFinished;
            StatLastAttemptDuration = data.StatLastAttemptDuration;
            AttemptsLeft = data.AttemptsLeft;
            AttemptTimeout = data.AttemptTimeout;
            _statusLog.Clear();
            _statusLog.AddRange(data.StatusLog);
            _arguments.Clear();
            _arguments.AddRange(data.Arguments);
        }

        bool IEquatable<ITaskItemData>.Equals(ITaskItemData? other)
        {
            if (other == null)
                return false;

            var result = Id == other.Id &&
                Status == other.Status &&
                Changed == other.Changed &&
                Reference == other.Reference &&
                ProviderClass == other.ProviderClass &&
                Priority == other.Priority &&
                ProcessingValidFrom == other.ProcessingValidFrom &&
                ProcessingValidTo == other.ProcessingValidTo &&
                Created == other.Created &&
                Changed == other.Changed &&
                StatStarted == other.StatStarted &&
                StatFinished == other.StatFinished &&
                StatLastAttemptDuration == other.StatLastAttemptDuration &&
                AttemptsLeft == other.AttemptsLeft &&
                AttemptTimeout == other.AttemptTimeout &&
                _statusLog.SequenceEqual(other.StatusLog) &&
                _arguments.SequenceEqual(other.Arguments);
            return result;
        }
        #endregion
    }
}