path: root/Software/Visual_Studio/Tango.DAL.Observables/ObservableEntity.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Entity;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Tango.Core;
using Tango.DAL.Remote.DB;
using Tango.DAL.Remote;
using Tango.Settings;

namespace Tango.DAL.Observables
{
    public abstract class ObservableEntity : ExtendedObject, IObservableEntity
    {
        public abstract int ID { get; set; }
        public abstract string Guid { get; set; }
        public abstract DateTime LastUpdated { get; set; }
        public abstract bool Deleted { get; set; }

        public abstract void Save();
        internal abstract void Save(List<IObservableEntity> savedEntities);

        public static String DalNameToStandardName(String dalName)
        {
            return String.Join("", dalName.Split('_').Select(x => ToTitleCase(x)));
        }

        public static string ToTitleCase(string s)
        {
            return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(s.ToLower());
        }

        protected static void MapEntityToObservable(Object entity, IObservableEntity observable)
        {
            String guid = entity.GetType().GetProperty("GUID").GetValue(entity).ToString();
            LoadedObjectsService.Add(guid, observable);

            foreach (var prop in entity.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                String name = prop.Name == "ID" ? "ID" : DalNameToStandardName(prop.Name);

                if (prop.PropertyType.IsGenericType)
                {
                    object observableCollection = observable.GetType().GetProperty(name).GetValue(observable);
                    observableCollection.GetType().GetMethod("Clear").Invoke(observableCollection, new object[] { });

                    Type genericType = observable.GetType().GetProperty(name).PropertyType.GenericTypeArguments.Single();

                    foreach (var item in prop.GetValue(entity) as IEnumerable)
                    {
                        guid = item.GetType().GetProperty("GUID").GetValue(item).ToString();

                        var loadedEntity = LoadedObjectsService.Get(guid);

                        if (loadedEntity != null)
                        {
                            observableCollection.GetType().GetMethod("Add").Invoke(observableCollection, new object[] { loadedEntity });
                        }
                        else
                        {
                            IObservableEntity newObservable = Activator.CreateInstance(genericType, new object[] { item }) as IObservableEntity;
                            LoadedObjectsService.Add(guid, newObservable);
                            observableCollection.GetType().GetMethod("Add").Invoke(observableCollection, new object[] { newObservable });
                        }
                    }
                }
                else if (prop.PropertyType.IsClass && prop.PropertyType != typeof(String) && prop.PropertyType != typeof(DateTime))
                {
                    Type propType = observable.GetType().GetProperty(name).PropertyType;

                    var nullableGuid = prop.GetValue(entity).GetType().GetProperty("GUID").GetValue(prop.GetValue(entity));

                    if (nullableGuid == null)
                    {
                        nullableGuid = System.Guid.NewGuid().ToString();
                        prop.GetValue(entity).GetType().GetProperty("GUID").SetValue(prop.GetValue(entity), nullableGuid);
                    }

                    guid = nullableGuid.ToString();

                    var loadedEntity = LoadedObjectsService.Get(guid);

                    if (loadedEntity != null)
                    {
                        observable.GetType().GetProperty(name).SetValue(observable, loadedEntity);
                    }
                    else
                    {
                        IObservableEntity newObservable = Activator.CreateInstance(propType, new object[] { prop.GetValue(entity) }) as IObservableEntity;
                        LoadedObjectsService.Add(guid, newObservable);
                        observable.GetType().GetProperty(name).SetValue(observable, newObservable);
                    }
                }
                else
                {
                    observable.GetType().GetProperty(name).SetValue(observable, prop.GetValue(entity));
                }
            }
        }

        public static TObservable CreateObservableFromEntity<TObservable>(Object entity) where TObservable : IObservableEntity
        {
            String guid = entity.GetType().GetProperty("GUID").GetValue(entity).ToString();
            var observable = LoadedObjectsService.Get(guid);

            if (observable != null)
            {
                return (TObservable)observable;
            }
            else
            {
                return (TObservable)Activator.CreateInstance(typeof(TObservable), new object[] { entity });
            }
        }

        public List<KeyValuePair<String, String>> GetDependentEntitiesNameAndGuid()
        {
            List<KeyValuePair<String, String>> namesAndIds = new List<KeyValuePair<string, string>>();

            foreach (var prop in this.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(x => x.PropertyType.IsGenericType))
            {
                IList list = prop.GetValue(this) as IList;

                foreach (var item in list)
                {
                    namesAndIds.Add(new KeyValuePair<string, string>(item.GetType().Name, item.GetType().GetProperty("ID").GetValue(item).ToString()));
                }
            }

            return namesAndIds;
        }

        public abstract void Delete();
        public abstract Task SaveAsync();
        public abstract void SoftDelete();
        public abstract Task SoftDeleteAsync();
    }

    public abstract class ObservableEntity<T> : ObservableEntity where T : class
    {
        private Regex regExDAL;
        private bool _isNew;

        protected T Entity { get; set; }

        private Int32 _id;
        [EntityFieldName("ID")]
        public override Int32 ID
        {
            get { return _id; }
            set { _id = value; RaisePropertyChanged(nameof(ID)); }
        }

        private String _guid;
        [EntityFieldName("GUID")]
        public override String Guid
        {
            get { return _guid; }
            set { _guid = value; RaisePropertyChanged(nameof(Guid)); }
        }

        private DateTime _lastUpdated;
        [EntityFieldName("LAST_UPDATED")]
        public override DateTime LastUpdated
        {
            get { return _lastUpdated; }
            set { _lastUpdated = value; RaisePropertyChanged(nameof(LastUpdated)); }
        }

        private bool _deleted;
        [EntityFieldName("DELETED")]
        public override bool Deleted
        {
            get { return _deleted; }
            set { _deleted = value; RaisePropertyChanged(nameof(Deleted)); }
        }

        public ObservableEntity()
        {
            Entity = Activator.CreateInstance<T>();
            Guid = System.Guid.NewGuid().ToString();
            LastUpdated = DateTime.UtcNow;
            _isNew = true;
        }

        public ObservableEntity(T entity)
        {
            Entity = entity;

            regExDAL = new Regex(@"
                (?<=[A-Z])(?=[A-Z][a-z]) |
                 (?<=[^A-Z])(?=[A-Z]) |
                 (?<=[A-Za-z])(?=[^A-Za-z])", RegexOptions.IgnorePatternWhitespace);
        }

        public override void Save()
        {
            Save(new List<IObservableEntity>());
            ObservablesEntitiesAdapter.Instance.SaveChanges();
        }

        public override Task SaveAsync()
        {
            return Task.Factory.StartNew(() =>
            {
                Save();
            });
        }

        public override void Delete()
        {
            String tabelName = this.GetType().GetDALName();
            DbSet<T> dbSet = typeof(RemoteDB).GetProperty(tabelName).GetValue(ObservablesEntitiesAdapter.Instance.Context) as DbSet<T>;
            dbSet.Remove(Entity);
            ObservablesEntitiesAdapter.Instance.SaveChanges();
        }

        public override void SoftDelete()
        {
            this.Deleted = true;
            Save();
        }

        public override Task SoftDeleteAsync()
        {
            return Task.Factory.StartNew(() =>
            {
                SoftDelete();
            });
        }

        internal override void Save(List<IObservableEntity> savedEntities)
        {
            savedEntities.Add(this);

            //Update last updated...
            this.LastUpdated = DateTime.UtcNow;

            //Match guids..

            foreach (var prop in this.GetType().GetProperties().Where(x => !x.PropertyType.IsGenericType && x.PropertyType.IsClass && x.PropertyType != typeof(String) && x.PropertyType != typeof(DateTime)))
            {
                IObservableEntity propObservable = prop.GetValue(this) as IObservableEntity;

                if (propObservable != null)
                {
                    var guidProp = this.GetType().GetProperty(prop.Name + "Guid");

                    if (guidProp != null)
                    {
                        guidProp.SetValue(this, propObservable.Guid);
                    }
                    else
                    {
                        guidProp = this.GetType().GetProperty(prop.Name.SingularizeMVC() + "Guid");
                        if (guidProp != null)
                        {
                            guidProp.SetValue(this, propObservable.Guid);
                        }
                    }
                }
            }

            //Match guids..

            using (RemoteDB db = new RemoteDB(SettingsManager.Default.DataBase.SQLServerAddress, false))
            {
                foreach (var prop in this.GetType().GetProperties().OrderBy(x => x.PropertyType.IsPrimitive))
                {

                    String dalName = prop.GetDALName();

                    if (prop.PropertyType.IsGenericType)
                    {
                        foreach (var item in (prop.GetValue(this) as IEnumerable).OfType<ObservableEntity>())
                        {
                            if (!savedEntities.Contains(item))
                            {
                                item.Save(savedEntities);
                            }
                        }
                    }
                    else if (prop.PropertyType.IsClass && prop.PropertyType != typeof(String) && prop.PropertyType != typeof(DateTime))
                    {
                        var item = (prop.GetValue(this) as ObservableEntity);
                        if (!savedEntities.Contains(item))
                        {
                            item.Save(savedEntities);
                        }
                        var propEntityType = prop.PropertyType.GetProperty("Entity", BindingFlags.NonPublic | BindingFlags.Instance);
                        typeof(T).GetProperty(dalName).SetValue(Entity, propEntityType.GetValue((prop.GetValue(this))));
                    }
                    else
                    {
                        typeof(T).GetProperty(dalName).SetValue(Entity, prop.GetValue(this));
                    }
                }

                if (_isNew)
                {
                    String tabelName = this.GetType().GetDALName();
                    DbSet<T> dbSet = typeof(RemoteDB).GetProperty(tabelName).GetValue(ObservablesEntitiesAdapter.Instance.Context) as DbSet<T>;
                    dbSet.Add(Entity);
                }

                if (LoadedObjectsService.Exists(this.Guid))
                {
                    MapEntityToObservable(Entity, this);
                }

                _isNew = false;
            }
        }
    }
}