path: root/Software/Visual_Studio/Tango.Integration/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 System.ComponentModel.DataAnnotations.Schema;
using System.ComponentModel.DataAnnotations;
using System.Runtime.CompilerServices;
using System.Data.Entity.Core.Objects;
using Tango.Serialization;
using System.Xml.Serialization;
using Newtonsoft.Json;

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

        /// <summary>
        /// Occurs after this observable has been saved.
        /// </summary>
        public event EventHandler Saved;

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

        private String _guid;
        /// <summary>
        /// Gets or sets the entity unique identifier.
        /// </summary>
        [Key]
        [Column("GUID")]
        public 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>
        [Column("LAST_UPDATED")]
        [JsonIgnore]
        public DateTime LastUpdated
        {
            get { return _lastUpdated; }
            set { _lastUpdated = value; RaisePropertyChanged(nameof(LastUpdated)); }
        }

        private ReadOnlyObservableCollection<ParameterItem> _parameters;
        /// <summary>
        /// Gets a bind-able observable collection of the component properties.
        /// </summary>
        [NotMapped]
        [XmlIgnore]
        [JsonIgnore]
        public ReadOnlyObservableCollection<ParameterItem> Parameters
        {
            get { return _parameters; }
            set { _parameters = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ObservableEntity{T}"/> class.
        /// </summary>
        public ObservableEntity()
        {
            Guid = System.Guid.NewGuid().ToString();
            LastUpdated = DateTime.UtcNow;
            regExDAL = new Regex(@"
                (?<=[A-Z])(?=[A-Z][a-z]) |
                 (?<=[^A-Z])(?=[A-Z]) |
                 (?<=[A-Za-z])(?=[^A-Za-z])", RegexOptions.IgnorePatternWhitespace);

            if (!DesignMode)
            {
                ThreadsHelper.InvokeWhenAvailable(() =>
                {
                    Parameters = new ReadOnlyObservableCollection<ParameterItem>(this.CreateParametersCollection(ParameterItemMode.Binding));
                });
            }
        }

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

        /// <summary>
        /// Attaches this entity to the proper DbSet.
        /// </summary>
        public virtual void Attach()
        {
            GetDbSet().Add(this as T);
        }

        /// <summary>
        /// Detaches this observable from the proper DbSet.
        /// </summary>
        public virtual void Detach()
        {
            GetDbSet().Remove(this as T);
        }

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

        /// <summary>
        /// Reloads this observable entity.
        /// </summary>
        /// <returns></returns>
        public Task Reload()
        {
            return ObservablesEntitiesAdapter.Instance.Context.Entry(this).ReloadAsync();
        }

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

            if (delProp != null)
            {
                delProp.SetValue(this, true);
                Save();
            }
            else
            {
                GetDbSet().Remove(this as T);
                Save();
            }
        }

        /// <summary>
        /// Deletes this entity without saving changes to data base.
        /// </summary>
        public virtual void DefferedDelete()
        {
            GetDbSet().Remove(this as T);
        }

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

        /// <summary>
        /// Gets the observable database set.
        /// </summary>
        /// <returns></returns>
        public DbSet<T> GetDbSet()
        {
            String tabelName = this.GetType().Name.PluralizeMVC();
            var p = typeof(ObservablesContext).GetProperty(tabelName);
            if (p != null)
            {
                var set1 = p.GetValue(ObservablesEntitiesAdapter.Instance.Context) as DbSet<T>;
                return set1;
            }
            else
            {
                tabelName = this.GetType().BaseType.Name.PluralizeMVC();
                p = typeof(ObservablesContext).GetProperty(tabelName);
                if (p != null)
                {
                    var set2 = p.GetValue(ObservablesEntitiesAdapter.Instance.Context) as DbSet<T>;
                    return set2;
                }
            }

            return null;
        }

        protected virtual void OnSaved()
        {
            Saved?.Invoke(this, new EventArgs());
        }

        public static DbContext GetDbContextFromEntity(object entity)
        {
            var object_context = GetObjectContextFromEntity(entity);

            if (object_context == null)
                return null;

            return new DbContext(object_context, dbContextOwnsObjectContext: false);
        }

        private static ObjectContext GetObjectContextFromEntity(object entity)
        {
            var field = entity.GetType().GetField("_entityWrapper");

            if (field == null)
                return null;

            var wrapper = field.GetValue(entity);
            var property = wrapper.GetType().GetProperty("Context");
            var context = (ObjectContext)property.GetValue(wrapper, null);

            return context;
        }

        public virtual T Clone()
        {
            return (this as T).CloneEntity() as T;
        }

        public void Save(DbContext context)
        {
            context.SaveChanges();
            OnSaved();
        }

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

        public bool CompareUsingJson(T entity)
        {
            String me = JsonConvert.SerializeObject(this);
            String other = JsonConvert.SerializeObject(entity);
            return me == other;
        }

        #region Operator Overloading

        //public static bool operator ==(ObservableEntity<T> observable1, ObservableEntity<T> observable2)
        //{
        //    if (object.ReferenceEquals(observable1, null) || object.ReferenceEquals(observable2, null))
        //    {
        //        return object.ReferenceEquals(observable1, observable2);
        //    }

        //    return observable1.Guid.ToLower() == observable2.Guid.ToLower();
        //}

        //public static bool operator !=(ObservableEntity<T> observable1, ObservableEntity<T> observable2)
        //{
        //    if (object.ReferenceEquals(observable1, null) || object.ReferenceEquals(observable2, null))
        //    {
        //        return !object.ReferenceEquals(observable1, observable2);
        //    }

        //    return observable1.Guid.ToLower() != observable2.Guid.ToLower();
        //}

        //public override bool Equals(object obj)
        //{
        //    if (object.ReferenceEquals(this, null) || object.ReferenceEquals(obj, null))
        //    {
        //        return object.ReferenceEquals(this, obj);
        //    }

        //    if (obj is ObservableEntity<T>)
        //    {
        //        return Guid.ToLower() == (obj as ObservableEntity<T>).Guid.ToLower();
        //    }
        //    else
        //    {
        //        return false;
        //    }
        //}

        //public override int GetHashCode()
        //{
        //    return base.GetHashCode();
        //}

        #endregion
    }
}