prs/prs.stores/BaseStore.cs

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Comal.Classes;
using InABox.Core;
using InABox.Database;
using System;
using com.sun.org.glassfish.external.probe.provider.annotations;
using PRS.Shared.Events;

namespace Comal.Stores
{
    public class UserPlatform
    {
        public string UserID { get; set; }
        public Platform Platform { get; set; }
        public string Version { get; set; }
    }

    public static class PlatformCache
    {
        static PlatformCache()
        {
            Platforms = new List<UserPlatform>();
        }

        public static List<UserPlatform> Platforms { get; }
    }

    public class BaseStore<T> : Store<T> where T : Entity, new()
    {
        protected override Filter<T>? PrepareFilter(Filter<T>? filter)
        {
            CheckPlatformVersion();

            return base.PrepareFilter(filter);
        }

        protected override void BeforeSave(T entity)
        {
            CheckPlatformVersion();
            if (entity is IProblems problems && problems.Problem.Notes?.Length == 1 &&
                string.IsNullOrEmpty(problems.Problem.Notes[0]))
                problems.Problem.Notes = null;
            base.BeforeSave(entity);
        }

        protected override void AfterSave(T entity)
        {
            base.AfterSave(entity);

            EventUtils.AfterSave(this, entity);
        }

        protected override void BeforeDelete(T entity)
        {
            CheckPlatformVersion();
            base.BeforeDelete(entity);
        }

        private void CheckPlatformVersion()
        {
            if (string.IsNullOrEmpty(UserID) || string.IsNullOrEmpty(Version))
                return;

            var platform = PlatformCache.Platforms.FirstOrDefault(x => x.UserID.Equals(UserID) && x.Platform.Equals(Platform));
            if (platform == null)
            {
                platform = new UserPlatform { UserID = UserID, Platform = Platform, Version = "???" };
                PlatformCache.Platforms.Add(platform);
            }

            if (!platform.Version.Equals(Version))
            {
                platform.Version = Version;

                if(Platform == Platform.Wpf || Platform == Platform.TimeBench)
                {
                    var user = Provider.Load(new Filter<User>(x => x.UserID).IsEqualTo(UserID)).FirstOrDefault();
                    if(user is not null)
                    {
                        var current = Platform switch
                        {
                            Platform.Wpf => user.Platform.DesktopVersion,
                            Platform.TimeBench => user.Platform.MobileVersion,
                            _ => ""
                        };
                        if (!Version.Equals(current))
                        {
                            switch (Platform)
                            {
                                case Platform.Wpf:
                                    user.Platform.DesktopVersion = Version;
                                    break;
                                case Platform.TimeBench:
                                    user.Platform.MobileVersion = Version;
                                    break;
                            }
                            Provider.Save(user);
                        }
                    }
                }
            }
        }
        
        protected void UnlinkTrackingKanban<TEntityKanban, TEntity, TEntityLink>(TEntity entity)
            where TEntityKanban : EntityKanban<TEntity, TEntityLink>, new()
            where TEntity : Entity
            where TEntityLink : IEntityLink<TEntity>, new()
        {
            var kanbans = Provider.Query(
                new Filter<TEntityKanban>(x => x.Entity.ID).IsEqualTo(entity.ID).And(x => x.Kanban.Locked).IsEqualTo(true),
                Columns.Required<TEntityKanban>().Add(
                    x => x.Entity.ID,
                    x => x.Kanban.ID,
                    x => x.Kanban.Locked
                )
            );
            if (!kanbans.Rows.Any())
                return;
            var kanban = kanbans.Rows.First().ToObject<RequisitionKanban, KanbanLink, Kanban>(x => x.Kanban);
            kanban.Locked = false;
            Provider.Save(kanban);
        }

        protected void UpdateTrackingKanban<TEntityKanban, TEntity, TEntityLink>(TEntity entity, Func<TEntity, KanbanStatus> status)
            where TEntityKanban : EntityKanban<TEntity, TEntityLink>, new()
            where TEntity : Entity
            where TEntityLink : IEntityLink<TEntity>, new()
        {
            var kanbans = Provider.Query(
                new Filter<TEntityKanban>(x => x.Entity.ID).IsEqualTo(entity.ID),
                Columns.Required<TEntityKanban>().Add(x => x.Entity.ID, x => x.Kanban.ID, x => x.Kanban.Status, x => x.Kanban.Closed, x => x.Kanban.Completed, x => x.Kanban.EmployeeLink.ID, x => x.Kanban.Notes, x => x.Kanban.DueDate, x => x.Kanban.Title, x => x.Kanban.Summary)
            );
            if (!kanbans.Rows.Any())
                return;
            var oldcategory = kanbans.Rows.First().Get<TEntityKanban, KanbanStatus>(c => c.Kanban.Status);
            var newcategory = status(entity);
            if (!Equals(newcategory, oldcategory))
            {
                var kanban = kanbans.Rows.First().ToObject<RequisitionKanban, KanbanLink, Kanban>(x => x.Kanban);
                kanban.Status = newcategory;
                var notes = kanban.Notes.ToList();
                notes.Add(string.Format("{0:yyyy-MM-dd HH:mm:ss} {1}: {2}", DateTime.Now, UserID, "Task Status updated by Requisition Progress"));
                kanban.Notes = notes.ToArray();
                kanban.Locked = true;
                FindSubStore<Kanban>().Save(kanban, "Updated due to Requisition Status Change");
            }
        }
        
        protected void NotifyEmployee<TEntity>(
            TEntity entity,
            Func<TEntity, Guid> employeeid,
            Func<TEntity, bool> filter,
            Func<TEntity, string> title,
            Func<TEntity, string> body
        ) where TEntity : Entity
        {
            if (!filter(entity))
                return;

            var employees = Provider.Query(
                new Filter<Employee>(x => x.ID).IsEqualTo(employeeid(entity)).Or(x => x.UserLink.ID).IsEqualTo(UserGuid),
                Columns.None<Employee>().Add(x => x.ID).Add(x => x.UserLink.ID).Add(x => x.Name)
            ).Rows.Select(r => new Tuple<Guid, Guid, string>(
                    r.Get<Employee, Guid>(c => c.ID),
                    r.Get<Employee, Guid>(c => c.UserLink.ID),
                    r.Get<Employee, string>(c => c.Name)
                )
            );

            var recipient = employees.FirstOrDefault(x => Equals(x.Item1, employeeid(entity)));
            var sender = employees.FirstOrDefault(x => Equals(x.Item2, UserGuid));

            if (recipient == null || sender == null)
                return;

            if (recipient.Item2 == UserGuid)
                return;

            var notification = new Notification();

            notification.Employee.ID = recipient.Item1;

            notification.Sender.ID = sender.Item1;

            notification.Title = title(entity);

            var sb = new StringBuilder();
            sb.AppendLine(string.Format("Dear {0},\n", recipient.Item3.Split(' ').First()));

            sb.Append(body.Invoke(entity));

            if (sender != null)
                sb.AppendLine(string.Format("\n\nRegards,\n{0}.", sender.Item3.Split(' ').First()));

            notification.Description = sb.ToString();

            notification.EntityType = typeof(TEntity).EntityName();
            notification.EntityID = entity.ID;

            FindSubStore<Notification>().Save(notification, "");
        }

        protected Guid GetEmployeeIDFromUserGuid()
        {
            return Provider.Query(
                    new Filter<Employee>(x => x.UserLink.ID).IsEqualTo(UserGuid),
                    Columns.None<Employee>().Add(x => x.ID)
                ).Rows.FirstOrDefault()?
                .Get<Employee, Guid>(x => x.ID) ?? Guid.Empty;
        }
    }
}