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;
using Tango.Core.Helpers;
using Force.DeepCloner;

namespace Tango.DAL.Observables
{
    /// <summary>
    /// Represents an observable entity base class.
    /// </summary>
    /// <seealso cref="Tango.Core.ExtendedObject" />
    /// <seealso cref="Tango.DAL.Observables.IObservableEntity" />
    public abstract class ObservableEntity : ExtendedObject, IObservableEntity
    {
        /// <summary>
        /// Gets or sets the entity identifier.
        /// </summary>
        public abstract int ID { get; set; }

        /// <summary>
        /// Gets or sets the entity unique identifier.
        /// </summary>
        public abstract string Guid { get; set; }

        /// <summary>
        /// Gets or sets the entity last updated data and time.
        /// </summary>
        public abstract DateTime LastUpdated { get; set; }

        /// <summary>
        /// Saves the changes on this entity to database.
        /// </summary>
        public abstract void Save();

        /// <summary>
        /// Internal recursive saving method.
        /// </summary>
        /// <param name="savedEntities">The saved entities.</param>
        internal abstract void Save(List<IObservableEntity> savedEntities);

        /// <summary>
        /// Deletes this entity from the database.
        /// </summary>
        public abstract void Delete();

        /// <summary>
        /// Removed this entity from it's DB SET without saving changes.
        /// </summary>
        public abstract void SoftDelete();

        /// <summary>
        /// Deletes this entity from the database
        /// </summary>
        public abstract Task DeleteAsync();

        /// <summary>
        /// Saves the changes on this entity to database asynchronously.
        /// </summary>
        /// <returns></returns>
        public abstract Task SaveAsync();

        /// <summary>
        /// Converts the specified database conventional name to the observables conventional name.
        /// </summary>
        /// <param name="dalName">DAL name.</param>
        /// <returns></returns>
        public static String DalNameToStandardName(String dalName)
        {
            return String.Join("", dalName.Split('_').Select(x => ToTitleCase(x)));
        }

        /// <summary>
        /// Converts the specified text to title case.
        /// </summary>
        /// <param name="text">The text.</param>
        /// <returns></returns>
        public static string ToTitleCase(string text)
        {
            return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text.ToLower());
        }

        /// <summary>
        /// Maps the database entity to an observable entity.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <param name="observable">The observable.</param>
        protected static void MapEntityToObservable(Object entity, IObservableEntity observable)
        {
            String guid = entity.GetType().GetProperty("GUID").GetValue(entity).ToString();
            LoadedEntitiesService.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);

                    ThreadsHelper.InvokeUINow(() => 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 = LoadedEntitiesService.Get(guid);

                        if (loadedEntity != null)
                        {
                            ThreadsHelper.InvokeUINow(() => observableCollection.GetType().GetMethod("Add").Invoke(observableCollection, new object[] { loadedEntity }));
                        }
                        else
                        {
                            IObservableEntity newObservable = Activator.CreateInstance(genericType, new object[] { item }) as IObservableEntity;
                            LoadedEntitiesService.Add(guid, newObservable);
                            ThreadsHelper.InvokeUINow(() => observableCollection.GetType().GetMethod("Add").Invoke(observableCollection, new object[] { newObservable }));
                        }
                    }
                }
                else if (prop.PropertyType.IsClass && prop.PropertyType != typeof(String) && prop.PropertyType != typeof(DateTime) && prop.PropertyType != typeof(byte[]))
                {
                    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 = LoadedEntitiesService.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;
                        LoadedEntitiesService.Add(guid, newObservable);
                        observable.GetType().GetProperty(name).SetValue(observable, newObservable);
                    }
                }
                else
                {
                    observable.GetType().GetProperty(name).SetValue(observable, prop.GetValue(entity));
                }
            }
        }

        /// <summary>
        /// Creates an observable entity from the specified database entity.
        /// </summary>
        /// <typeparam name="TObservable">The type of the observable.</typeparam>
        /// <param name="entity">The entity.</param>
        /// <returns></returns>
        public static TObservable CreateObservableFromEntity<TObservable>(Object entity) where TObservable : IObservableEntity
        {
            String guid = entity.GetType().GetProperty("GUID").GetValue(entity).ToString();
            var observable = LoadedEntitiesService.Get(guid);

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

        /// <summary>
        /// Gets a collection of entities which are dependent on this entity.
        /// </summary>
        /// <returns>
        /// Collection of entities names and guids
        /// </returns>
        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;
        }
    }

    /// <summary>
    /// Represents a generic observable entity base class.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <seealso cref="Tango.Core.ExtendedObject" />
    /// <seealso cref="Tango.DAL.Observables.IObservableEntity" />
    public abstract class ObservableEntity<T> : ObservableEntity where T : class
    {
        private Regex regExDAL;
        private bool _isNew;

        /// <summary>
        /// Gets or sets the entity.
        /// </summary>
        protected T Entity { get; set; }

        private Int32 _id;
        /// <summary>
        /// Gets or sets the entity identifier.
        /// </summary>
        [EntityFieldName("ID")]
        public override Int32 ID
        {
            get { return _id; }
            set { _id = value; RaisePropertyChanged(nameof(ID)); }
        }

        private String _guid;
        /// <summary>
        /// Gets or sets the entity unique identifier.
        /// </summary>
        [EntityFieldName("GUID")]
        public override String Guid
        {
            get { return _guid; }
            set { _guid = value; RaisePropertyChanged(nameof(Guid)); }
        }

        private DateTime _lastUpdated;
        /// <summary>
        /// Gets or sets the entity last updated data and time.
        /// </summary>
        [EntityFieldName("LAST_UPDATED")]
        public override DateTime LastUpdated
        {
            get { return _lastUpdated; }
            set { _lastUpdated = value; RaisePropertyChanged(nameof(LastUpdated)); }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ObservableEntity{T}"/> class.
        /// </summary>
        public ObservableEntity()
        {
            Entity = Activator.CreateInstance<T>();
            Guid = System.Guid.NewGuid().ToString();
            LastUpdated = DateTime.UtcNow;
            _isNew = true;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ObservableEntity{T}"/> class.
        /// </summary>
        /// <param name="entity">The entity.</param>
        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);
        }

        /// <summary>
        /// Saves the changes on this entity to database.
        /// </summary>
        public override void Save()
        {
            Save(new List<IObservableEntity>());
            ObservablesEntitiesAdapter.Instance.SaveChanges();
        }

        /// <summary>
        /// Saves the changes on this entity to database asynchronously.
        /// </summary>
        /// <returns></returns>
        public override Task SaveAsync()
        {
            return Task.Factory.StartNew(() =>
            {
                Save();
            });
        }

        /// <summary>
        /// Deletes this entity from the database
        /// </summary>
        public override void Delete()
        {
            var delProp = this.GetType().GetProperty("Deleted");

            if (delProp != null)
            {
                delProp.SetValue(this, true);
                Save();
            }
            else
            {
                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();
            }
        }

        /// <summary>
        /// Removed this entity from it's DB SET without saving changes.
        /// </summary>
        public override void SoftDelete()
        {
            var delProp = this.GetType().GetProperty("IsDeleted");

            if (delProp != null)
            {
                delProp.SetValue(this, true);
            }
            else
            {
                String tabelName = this.GetType().GetDALName();
                DbSet<T> dbSet = typeof(RemoteDB).GetProperty(tabelName).GetValue(ObservablesEntitiesAdapter.Instance.Context) as DbSet<T>;
                dbSet.Remove(Entity);
            }
        }

        /// <summary>
        /// Deletes this entity from the database
        /// </summary>
        public override Task DeleteAsync()
        {
            return Task.Factory.StartNew(() => 
            {
                Delete();
            });
        }

        /// <summary>
        /// Internal recursive saving method.
        /// </summary>
        /// <param name="savedEntities">The saved entities.</param>
        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) && x.PropertyType != typeof(byte[])))
            {
                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) && prop.PropertyType != typeof(byte[]))
                    {
                        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 (LoadedEntitiesService.IsLoaded(this.Guid))
                {
                    MapEntityToObservable(Entity, this);
                }

                _isNew = false;
            }
        }
    }
}