/DMS/Implementacion/PaucarpataSolution/PPR.Data/PersonalDBModel.cs

//------------------------------------------------------------------------------

// <auto-generated>

//     This code was generated from a template.

//

//     Changes to this file may cause incorrect behavior and will be lost if

//     the code is regenerated.

// </auto-generated>

//------------------------------------------------------------------------------



using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Collections.Specialized;

using System.ComponentModel;

using System.Globalization;

using System.Runtime.Serialization;



namespace PPR.Data

{

    // Helper class that captures most of the change tracking work that needs to be done

    // for self tracking entities.

    [DataContract(IsReference = true)]

    public class ObjectChangeTracker

    {

        #region  Fields

    

        private bool _isDeserializing;

        private ObjectState _objectState = ObjectState.Added;

        private bool _changeTrackingEnabled;

        private OriginalValuesDictionary _originalValues;

        private ExtendedPropertiesDictionary _extendedProperties;

        private ObjectsAddedToCollectionProperties _objectsAddedToCollections = new ObjectsAddedToCollectionProperties();

        private ObjectsRemovedFromCollectionProperties _objectsRemovedFromCollections = new ObjectsRemovedFromCollectionProperties();

    

        #endregion

    

        #region Events

    

        public event EventHandler<ObjectStateChangingEventArgs> ObjectStateChanging;

    

        #endregion

    

        protected virtual void OnObjectStateChanging(ObjectState newState)

        {

            if (ObjectStateChanging != null)

            {

                ObjectStateChanging(this, new ObjectStateChangingEventArgs(){ NewState = newState });

            }

        }

    

        [DataMember]

        public ObjectState State

        {

            get { return _objectState; }

            set

            {

                if (_isDeserializing || _changeTrackingEnabled)

                {

                    OnObjectStateChanging(value);

                    _objectState = value;

                }

            }

        }

    

        public bool ChangeTrackingEnabled

        {

            get { return _changeTrackingEnabled; }

            set { _changeTrackingEnabled = value; }

        }

    

        // Returns the removed objects to collection valued properties that were changed.

        [DataMember]

        public ObjectsRemovedFromCollectionProperties ObjectsRemovedFromCollectionProperties

        {

            get

            {

                if (_objectsRemovedFromCollections == null)

                {

                    _objectsRemovedFromCollections = new ObjectsRemovedFromCollectionProperties();

                }

                return _objectsRemovedFromCollections;

            }

        }

    

        // Returns the original values for properties that were changed.

        [DataMember]

        public OriginalValuesDictionary OriginalValues

        {

            get

            {

                if (_originalValues == null)

                {

                    _originalValues = new OriginalValuesDictionary();

                }

                return _originalValues;

            }

        }

    

        // Returns the extended property values.

        // This includes key values for independent associations that are needed for the

        // concurrency model in the Entity Framework

        [DataMember]

        public ExtendedPropertiesDictionary ExtendedProperties

        {

            get

            {

                if (_extendedProperties == null)

                {

                    _extendedProperties = new ExtendedPropertiesDictionary();

                }

                return _extendedProperties;

            }

        }

    

        // Returns the added objects to collection valued properties that were changed.

        [DataMember]

        public ObjectsAddedToCollectionProperties ObjectsAddedToCollectionProperties

        {

            get

            {

                if (_objectsAddedToCollections == null)

                {

                    _objectsAddedToCollections = new ObjectsAddedToCollectionProperties();

                }

                return _objectsAddedToCollections;

            }

        }

    

        #region MethodsForChangeTrackingOnClient

    

        [OnDeserializing]

        public void OnDeserializingMethod(StreamingContext context)

        {

            _isDeserializing = true;

        }

    

        [OnDeserialized]

        public void OnDeserializedMethod(StreamingContext context)

        {

            _isDeserializing = false;

        }

    

        // Resets the ObjectChangeTracker to the Unchanged state and

        // clears the original values as well as the record of changes

        // to collection properties

        public void AcceptChanges()

        {

            OnObjectStateChanging(ObjectState.Unchanged);

            OriginalValues.Clear();

            ObjectsAddedToCollectionProperties.Clear();

            ObjectsRemovedFromCollectionProperties.Clear();

            ChangeTrackingEnabled = true;

            _objectState = ObjectState.Unchanged;

        }

    

        // Captures the original value for a property that is changing.

        internal void RecordOriginalValue(string propertyName, object value)

        {

            if (_changeTrackingEnabled && _objectState != ObjectState.Added)

            {

                if (!OriginalValues.ContainsKey(propertyName))

                {

                    OriginalValues[propertyName] = value;

                }

            }

        }

    

        // Records an addition to collection valued properties on SelfTracking Entities.

        internal void RecordAdditionToCollectionProperties(string propertyName, object value)

        {

            if (_changeTrackingEnabled)

            {

                // Add the entity back after deleting it, we should do nothing here then

                if (ObjectsRemovedFromCollectionProperties.ContainsKey(propertyName)

                    && ObjectsRemovedFromCollectionProperties[propertyName].Contains(value))

                {

                    ObjectsRemovedFromCollectionProperties[propertyName].Remove(value);

                    if (ObjectsRemovedFromCollectionProperties[propertyName].Count == 0)

                    {

                        ObjectsRemovedFromCollectionProperties.Remove(propertyName);

                    }

                    return;

                }

    

                if (!ObjectsAddedToCollectionProperties.ContainsKey(propertyName))

                {

                    ObjectsAddedToCollectionProperties[propertyName] = new ObjectList();

                    ObjectsAddedToCollectionProperties[propertyName].Add(value);

                }

                else

                {

                    ObjectsAddedToCollectionProperties[propertyName].Add(value);

                }

            }

        }

    

        // Records a removal to collection valued properties on SelfTracking Entities.

        internal void RecordRemovalFromCollectionProperties(string propertyName, object value)

        {

            if (_changeTrackingEnabled)

            {

                // Delete the entity back after adding it, we should do nothing here then

                if (ObjectsAddedToCollectionProperties.ContainsKey(propertyName)

                    && ObjectsAddedToCollectionProperties[propertyName].Contains(value))

                {

                    ObjectsAddedToCollectionProperties[propertyName].Remove(value);

                    if (ObjectsAddedToCollectionProperties[propertyName].Count == 0)

                    {

                        ObjectsAddedToCollectionProperties.Remove(propertyName);

                    }

                    return;

                }

    

                if (!ObjectsRemovedFromCollectionProperties.ContainsKey(propertyName))

                {

                    ObjectsRemovedFromCollectionProperties[propertyName] = new ObjectList();

                    ObjectsRemovedFromCollectionProperties[propertyName].Add(value);

                }

                else

                {

                    if (!ObjectsRemovedFromCollectionProperties[propertyName].Contains(value))

                    {

                        ObjectsRemovedFromCollectionProperties[propertyName].Add(value);

                    }

                }

            }

        }

        #endregion

    }

    

    #region EnumForObjectState

    [Flags]

    public enum ObjectState

    {

        Unchanged = 0x1,

        Added = 0x2,

        Modified = 0x4,

        Deleted = 0x8

    }

    #endregion

    

    [CollectionDataContract (Name = "ObjectsAddedToCollectionProperties",

        ItemName = "AddedObjectsForProperty", KeyName = "CollectionPropertyName", ValueName = "AddedObjects")]

    public class ObjectsAddedToCollectionProperties : Dictionary<string, ObjectList> { }

    

    [CollectionDataContract (Name = "ObjectsRemovedFromCollectionProperties",

        ItemName = "DeletedObjectsForProperty", KeyName = "CollectionPropertyName",ValueName = "DeletedObjects")]

    public class ObjectsRemovedFromCollectionProperties : Dictionary<string, ObjectList> { }

    

    [CollectionDataContract(Name = "OriginalValuesDictionary",

        ItemName = "OriginalValues", KeyName = "Name", ValueName = "OriginalValue")]

    public class OriginalValuesDictionary : Dictionary<string, Object> { }

    

    [CollectionDataContract(Name = "ExtendedPropertiesDictionary",

        ItemName = "ExtendedProperties", KeyName = "Name", ValueName = "ExtendedProperty")]

    public class ExtendedPropertiesDictionary : Dictionary<string, Object> { }

    

    [CollectionDataContract(ItemName = "ObjectValue")]

    public class ObjectList : List<object> { }

    // The interface is implemented by the self tracking entities that EF will generate.

    // We will have an Adapter that converts this interface to the interface that the EF expects.

    // The Adapter will live on the server side.

    public interface IObjectWithChangeTracker

    {

        // Has all the change tracking information for the subgraph of a given object.

        ObjectChangeTracker ChangeTracker { get; }

    }

    

    public class ObjectStateChangingEventArgs : EventArgs

    {

        public ObjectState NewState { get; set; }

    }

    

    public static class ObjectWithChangeTrackerExtensions

    {

        public static T MarkAsDeleted<T>(this T trackingItem) where T : IObjectWithChangeTracker

        {

            if (trackingItem == null)

            {

                throw new ArgumentNullException("trackingItem");

            }

    

            trackingItem.ChangeTracker.ChangeTrackingEnabled = true;

            trackingItem.ChangeTracker.State = ObjectState.Deleted;

            return trackingItem;

        }

    

        public static T MarkAsAdded<T>(this T trackingItem) where T : IObjectWithChangeTracker

        {

            if (trackingItem == null)

            {

                throw new ArgumentNullException("trackingItem");

            }

    

            trackingItem.ChangeTracker.ChangeTrackingEnabled = true;

            trackingItem.ChangeTracker.State = ObjectState.Added;

            return trackingItem;

        }

    

        public static T MarkAsModified<T>(this T trackingItem) where T : IObjectWithChangeTracker

        {

            if (trackingItem == null)

            {

                throw new ArgumentNullException("trackingItem");

            }

    

            trackingItem.ChangeTracker.ChangeTrackingEnabled = true;

            trackingItem.ChangeTracker.State = ObjectState.Modified;

            return trackingItem;

        }

    

        public static T MarkAsUnchanged<T>(this T trackingItem) where T : IObjectWithChangeTracker

        {

            if (trackingItem == null)

            {

                throw new ArgumentNullException("trackingItem");

            }

    

            trackingItem.ChangeTracker.ChangeTrackingEnabled = true;

            trackingItem.ChangeTracker.State = ObjectState.Unchanged;

            return trackingItem;

        }

    

        public static void StartTracking(this IObjectWithChangeTracker trackingItem)

        {

            if (trackingItem == null)

            {

                throw new ArgumentNullException("trackingItem");

            }

    

            trackingItem.ChangeTracker.ChangeTrackingEnabled = true;

        }

    

        public static void StopTracking(this IObjectWithChangeTracker trackingItem)

        {

            if (trackingItem == null)

            {

                throw new ArgumentNullException("trackingItem");

            }

    

            trackingItem.ChangeTracker.ChangeTrackingEnabled = false;

        }

    

        public static void AcceptChanges(this IObjectWithChangeTracker trackingItem)

        {

            if (trackingItem == null)

            {

                throw new ArgumentNullException("trackingItem");

            }

    

            trackingItem.ChangeTracker.AcceptChanges();

        }

    }

    

    // An System.Collections.ObjectModel.ObservableCollection that raises

    // individual item removal notifications on clear and prevents adding duplicates.

    public class TrackableCollection<T> : ObservableCollection<T>

    {

        protected override void ClearItems()

        {

            new List<T>(this).ForEach(t => Remove(t));

        }

    

        protected override void InsertItem(int index, T item)

        {

            if (!this.Contains(item))

            {

                base.InsertItem(index, item);

            }

        }

    }

    

    // An interface that provides an event that fires when complex properties change.

    // Changes can be the replacement of a complex property with a new complex type instance or

    // a change to a scalar property within a complex type instance.

    public interface INotifyComplexPropertyChanging

    {

        event EventHandler ComplexPropertyChanging;

    }

    

    public static class EqualityComparer

    {

        // Helper method to determine if two byte arrays are the same value even if they are different object references

        public static bool BinaryEquals(object binaryValue1, object binaryValue2)

        {

            if (Object.ReferenceEquals(binaryValue1, binaryValue2))

            {

                return true;

            }

    

            byte[] array1 = binaryValue1 as byte[];

            byte[] array2 = binaryValue2 as byte[];

    

            if (array1 != null && array2 != null)

            {

                if (array1.Length != array2.Length)

                {

                    return false;

                }

    

                for (int i = 0; i < array1.Length; i++)

                {

                    if (array1[i] != array2[i])

                    {

                        return false;

                    }

                }

    

                return true;

            }

    

            return false;

        }

    }

}