prs/prs.scheduler/SchedulePlugin.cs

using Comal.Classes;
using InABox.Clients;
using InABox.Core;

using System;
using System.Collections.Generic;
using System.Linq;

namespace Comal.TaskScheduler.Shared
{
    public abstract class SchedulePlugin<T> : ISchedulePlugin where T : Entity, IPersistent, IRemotable, ISchedulable, new()
    {

        //public Entity LoadEntity(Guid id)
        //{
        //    Entity = new Client<T>().Load(new Filter<T>(x => x.ID).IsEqualTo(id)).FirstOrDefault();
        //    return Entity;
        //}
        
        public Entity[] LoadEntities(Guid[] ids)
        {
            return new Client<T>().Load(new Filter<T>(x => x.ID).InList(ids)).ToArray<Entity>();
        }

        public virtual void LoadKanban(Kanban kanban, Schedule schedule, T entity) { }

        public virtual void LoadJob(Job job, Schedule schedule, T entity) { }

        private Kanban CreateKanban(Schedule schedule, T Entity)
        {
            Logger.Send(LogType.Information, ClientFactory.UserID, String.Format("  * Creating Scheduled Task: {0} {1}", schedule.DueDate, schedule.Title));

            Kanban kanban = new Kanban();
            kanban.Title = Entity.ToString() + " - " + schedule.Title;
            kanban.Notes = new string[] { schedule.Description };
            kanban.ScheduleLink.ID = schedule.ID;
            kanban.Category = "Open";
            kanban.EmployeeLink.ID = schedule.EmployeeLink.ID;
            kanban.ManagerLink.ID = schedule.ManagerLink.ID;
            kanban.DueDate = schedule.DueDate;
            kanban.Type.ID = schedule.KanbanType.ID;

            //kanban.QAForm.ID = schedule.QAForm.ID;

            LoadKanban(kanban, schedule, Entity);

            new Client<Kanban>().Save(kanban, "Task Created by Scheduler");

            var subscribers = new List<KanbanSubscriber>();
            if(kanban.EmployeeLink.ID != Guid.Empty)
            {
                if(kanban.ManagerLink.ID == kanban.EmployeeLink.ID)
                {
                    var subscriber = new KanbanSubscriber();
                    subscriber.Kanban.ID = kanban.ID;
                    subscriber.Employee.ID = schedule.EmployeeLink.ID;
                    subscriber.Assignee = true;
                    subscriber.Manager = true;
                    subscribers.Add(subscriber);
                }
                else
                {
                    var subscriber = new KanbanSubscriber();
                    subscriber.Kanban.ID = kanban.ID;
                    subscriber.Employee.ID = schedule.EmployeeLink.ID;
                    subscriber.Assignee = true;
                    subscribers.Add(subscriber);
                }
            }
            if (kanban.ManagerLink.ID != Guid.Empty && kanban.ManagerLink.ID != kanban.EmployeeLink.ID)
            {
                var subscriber = new KanbanSubscriber();
                subscriber.Kanban.ID = kanban.ID;
                subscriber.Employee.ID = schedule.ManagerLink.ID;
                subscriber.Manager = true;
                subscribers.Add(subscriber);
            }
            new Client<KanbanSubscriber>().Save(subscribers, "");

            if (schedule.Report.IsValid())
            {
                Guid docid = Guid.Empty;
                using (Client<Document> client = new Client<Document>())
                {
                    Document doc = client.Load(new Filter<Document>(x => x.ID).IsEqualTo(schedule.Report.ID)).FirstOrDefault();
                    if (doc != null)
                    {
                        doc.ID = Guid.Empty;
                        client.Save(doc, "Scheduled Task Report Created");
                        docid = doc.ID;
                    }
                }
                if (docid != Guid.Empty)
                {
                    KanbanDocument kdoc = new KanbanDocument();
                    kdoc.EntityLink.ID = kanban.ID;
                    kdoc.DocumentLink.ID = docid;
                    new Client<KanbanDocument>().Save(kdoc, "Scheduled Task Report Created");
                }
            }

            return kanban;
        }

        private void CreateJob(Schedule schedule, T entity)
        {
            Logger.Send(LogType.Information, ClientFactory.UserID, String.Format("  * Creating Scheduled Job: [0] {0}", schedule.DueDate, schedule.Title));

            Job job = new Job();
            job.ScheduleLink.ID = schedule.ID;
            job.ExpectedCompletionDate = schedule.DueDate;
            job.Name = entity.ToString() + " - " + schedule.Title;
            job.Notes = new string[] { schedule.Description };
            job.EmployeeLink.ID = schedule.EmployeeLink.ID;
            job.ManagerLink.ID = schedule.ManagerLink.ID;
            //job.QAForm.ID = schedule.QAForm.ID;

            LoadJob(job, schedule, entity);

            new Client<Job>().Save(job, "Scheduled Job Created");

            if (schedule.Report.IsValid())
            {
                Guid docid = Guid.Empty;
                using (Client<Document> client = new Client<Document>())
                {
                    Document doc = client.Load(new Filter<Document>(x => x.ID).IsEqualTo(schedule.Report.ID)).FirstOrDefault();
                    if (doc != null)
                    {
                        doc.ID = Guid.Empty;
                        client.Save(doc, "Scheduled Task Report Created");
                        docid = doc.ID;
                    }
                }
                if (docid != Guid.Empty)
                {
                    JobDocument jdoc = new JobDocument();
                    jdoc.EntityLink.ID = job.ID;
                    jdoc.DocumentLink.ID = docid;
                    new Client<JobDocument>().Save(jdoc, "Scheduled Task Report Created");
                }
            }
        }

        private static bool IsOpen<TType>(Schedule schedule) where TType : Entity, IPersistent, IRemotable, IScheduleAction, new()
        {
            CoreTable result = new Client<TType>().Query(
                new Filter<TType>(x => x.ScheduleLink.ID).IsEqualTo(schedule.ID).And(x => x.Completed).IsEqualTo(DateTime.MinValue),
                new Columns<TType>(x => x.ID),
                null
            );
            return result.Rows.Any();
        }

        public bool Execute(Schedule schedule, Entity entity)
        {
            return Execute(schedule, (T)entity);
        }

        public virtual bool Execute(Schedule schedule, T entity)
        {
            if (schedule.Rollover.Equals(ScheduleRollover.FromDueDate))
            {
                if (schedule.DueDate.AddDays(0 - schedule.LeadTime) <= DateTime.Now)
                {
                    if (schedule.ScheduleType == ScheduleType.Task)
                        CreateKanban(schedule, (T)entity);
                    else
                        CreateJob(schedule, (T)entity);

                    schedule.DueDate = schedule.GetNextDate(schedule.DueDate);
                    new Client<Schedule>().Save(schedule, "Schedule Updated by Task (Due Date)");

                    return true;
                }
            }
            else
            {
                bool isopen = (schedule.ScheduleType == ScheduleType.Task) ? IsOpen<Kanban>(schedule) : IsOpen<Job>(schedule);
                if (!isopen)  // ie no open tasks
                {
                    if (schedule.DueDate.AddDays(0 - schedule.LeadTime) <= DateTime.Now)
                    {
                        if (schedule.ScheduleType == ScheduleType.Task)
                            CreateKanban(schedule, (T)entity);
                        else
                            CreateJob(schedule, (T)entity);

                        return true;
                    }
                }
            }
            return false;
        }



    }


}