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

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Data.Entity;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Data;
using System.Windows.Threading;
using Tango.Core;
using Tango.DAL.Remote.DB;
using Tango.Settings;

namespace Tango.DAL.Observables
{
    public partial class ObservablesEntitiesAdapter : ExtendedObject
    {
        public event Action Initialized;

        private static object _syncLock;

        private static ObservablesEntitiesAdapter _instance;

        public static ObservablesEntitiesAdapter Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new ObservablesEntitiesAdapter();
                }
                return _instance;
            }
        }

        public RemoteDB Context { get; private set; }

        public static implicit operator DbContext(ObservablesEntitiesAdapter instance)
        {
            return instance.Context;
        }

        private ObservablesEntitiesAdapter()
        {
            Context = new RemoteDB(SettingsManager.Default.DataBase.SQLServerAddress, false);
        }

        public void Initialize()
        {
            Invalidate(true);
            Initialized?.Invoke();
        }

        public void SaveChanges()
        {
            try
            {
                Context.SaveChanges();
            }
            catch
            {
                throw;
            }
            finally
            {
                Invalidate();
            }
        }

        public void Invoke(Action action)
        {
            lock (_syncLock)
            {
                action();
            }
        }

        public void Invalidate(bool initializing = false)
        {
            _syncLock = new object();

            LoadedObjectsService.Reset();

            if (initializing)
            {
                //Remove Unlinked Configurations..
                List<CONFIGURATION> remove_configurations = new List<CONFIGURATION>();

                foreach (var config in Context.CONFIGURATIONS)
                {
                    if (Context.MACHINE_VERSIONS.FirstOrDefault(x => x.DEFAULT_CONFIGURATION_GUID == config.GUID) != null)
                    {
                        continue;
                    }

                    if (Context.MACHINES_CONFIGURATIONS.FirstOrDefault(x => x.CONFIGURATION_GUID == config.GUID) != null)
                    {
                        continue;
                    }

                    if (Context.MACHINES.FirstOrDefault(x => x.CONFIGURATION_GUID == config.GUID) != null)
                    {
                        continue;
                    }

                    remove_configurations.Add(config);
                }

                foreach (var config in remove_configurations)
                {
                    Context.CONFIGURATIONS.Remove(config);
                }

                Context.SaveChanges();
                //Remove Unlinked Configurations..
            }

            Organizations = Context.ORGANIZATIONS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<Organization>(x)).ToObservableCollection();

            OrganizationsViewSource = CreateCollectionView(Organizations);

            Machines = Context.MACHINES.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<Machine>(x)).ToObservableCollection();

            foreach (var machine in Machines)
            {
                machine.MachinesConfigurations = machine.MachinesConfigurations.OrderByDescending(x => x.Configuration.CreationDate).Take(30).ToObservableCollection();
            }

            MachinesConfigurations = Context.MACHINES_CONFIGURATIONS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<MachinesConfiguration>(x)).ToObservableCollection();

            MachineVersions = Context.MACHINE_VERSIONS.Where(x => !x.DELETED).ToList().OrderBy(x => x.VERSION).Select(x => ObservableEntity.CreateObservableFromEntity<MachineVersion>(x)).ToObservableCollection();

            Addresses = Context.ADDRESSES.Where(x => !x.DELETED).ToList().OrderBy(x => x.ADDRESS_STRING).Select(x => ObservableEntity.CreateObservableFromEntity<Address>(x)).ToObservableCollection();
            Contacts = Context.CONTACTS.Where(x => !x.DELETED).ToList().OrderBy(x => x.FULL_NAME).Select(x => ObservableEntity.CreateObservableFromEntity<Contact>(x)).ToObservableCollection();

            Roles = Context.ROLES.Where(x => !x.DELETED).ToList().OrderBy(x => x.NAME).Select(x => ObservableEntity.CreateObservableFromEntity<Role>(x)).ToObservableCollection();

            Permissions = Context.PERMISSIONS.Where(x => !x.DELETED).ToList().OrderBy(x => x.NAME).Select(x => ObservableEntity.CreateObservableFromEntity<Permission>(x)).ToObservableCollection();

            Users = Context.USERS.Where(x => !x.DELETED).ToList().OrderBy(x => x.CONTACT.FULL_NAME).Select(x => ObservableEntity.CreateObservableFromEntity<User>(x)).ToObservableCollection();

            foreach (var user in Users)
            {
                user.UsersRoles = user.UsersRoles.Where(x => !x.Deleted).ToObservableCollection();
            }

            foreach (var role in Roles)
            {
                role.RolesPermissions = role.RolesPermissions.Where(x => !x.Deleted).ToObservableCollection();
            }

            Configurations = Context.CONFIGURATIONS.Where(x => !x.DELETED).ToList().OrderBy(x => x.LAST_UPDATED).Select(x => ObservableEntity.CreateObservableFromEntity<Configuration>(x)).ToObservableCollection();

            foreach (var config in Configurations)
            {
                config.IdsPacks = config.IdsPacks.Where(x => !x.Deleted).ToObservableCollection();
            }

            ApplicationVersions = Context.APPLICATION_VERSIONS.Where(x => !x.DELETED).ToList().OrderBy(x => x.VERSION).Select(x => ObservableEntity.CreateObservableFromEntity<ApplicationVersion>(x)).ToObservableCollection();

            ApplicationOsVersions = Context.APPLICATION_OS_VERSIONS.Where(x => !x.DELETED).ToList().OrderBy(x => x.VERSION).Select(x => ObservableEntity.CreateObservableFromEntity<ApplicationOsVersion>(x)).ToObservableCollection();

            ApplicationFirmwareVersions = Context.APPLICATION_FIRMWARE_VERSIONS.Where(x => !x.DELETED).ToList().OrderBy(x => x.VERSION).Select(x => ObservableEntity.CreateObservableFromEntity<ApplicationFirmwareVersion>(x)).ToObservableCollection();

            ApplicationDisplayPanelVersions = Context.APPLICATION_DISPLAY_PANEL_VERSIONS.Where(x => !x.DELETED).ToList().OrderBy(x => x.VERSION).Select(x => ObservableEntity.CreateObservableFromEntity<ApplicationDisplayPanelVersion>(x)).ToObservableCollection();

            EmbeddedFirmwareVersions = Context.EMBEDDED_FIRMWARE_VERSIONS.Where(x => !x.DELETED).ToList().OrderBy(x => x.VERSION).Select(x => ObservableEntity.CreateObservableFromEntity<EmbeddedFirmwareVersion>(x)).ToObservableCollection();

            EmbeddedSoftwareVersions = Context.EMBEDDED_SOFTWARE_VERSIONS.Where(x => !x.DELETED).ToList().OrderBy(x => x.VERSION).Select(x => ObservableEntity.CreateObservableFromEntity<EmbeddedSoftwareVersion>(x)).ToObservableCollection();

            HardwareVersions = Context.HARDWARE_VERSIONS.Where(x => !x.DELETED).ToList().OrderBy(x => x.VERSION).Select(x => ObservableEntity.CreateObservableFromEntity<HardwareVersion>(x)).ToObservableCollection();

            IdsPacks = Context.IDS_PACKS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<IdsPack>(x)).ToObservableCollection();

            Dispensers = Context.DISPENSERS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<Dispenser>(x)).ToObservableCollection();

            DispenserTypes = Context.DISPENSER_TYPES.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<DispenserType>(x)).ToObservableCollection();

            LiquidTypes = Context.LIQUID_TYPES.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<LiquidType>(x)).ToObservableCollection();

            Cartridges = Context.CARTRIDGES.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<Cartridge>(x)).ToObservableCollection();

            CartridgeTypes = Context.CARTRIDGE_TYPES.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<CartridgeType>(x)).ToObservableCollection();

            MidTankTypes = Context.MID_TANK_TYPES.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<MidTankType>(x)).ToObservableCollection();

            ActionTypes = Context.ACTION_TYPES.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<ActionType>(x)).ToObservableCollection();

            EventTypes = Context.EVENT_TYPES.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<EventType>(x)).ToObservableCollection();

            foreach (var eventType in EventTypes)
            {
                eventType.EventTypesActions = eventType.EventTypesActions.Where(x => !x.Deleted).ToObservableCollection();
            }

            MediaMaterials = Context.MEDIA_MATERIALS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<MediaMaterial>(x)).ToObservableCollection();

            MediaColors = Context.MEDIA_COLORS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<MediaColor>(x)).ToObservableCollection();

            MediaPurposes = Context.MEDIA_PURPOSES.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<MediaPurpos>(x)).ToObservableCollection();

            MediaConditions = Context.MEDIA_CONDITIONS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<MediaCondition>(x)).ToObservableCollection();

            LinearMassDensityUnits = Context.LINEAR_MASS_DENSITY_UNITS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<LinearMassDensityUnit>(x)).ToObservableCollection();

            FiberShapes = Context.FIBER_SHAPES.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<FiberShape>(x)).ToObservableCollection();

            FiberSynths = Context.FIBER_SYNTHS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<FiberSynth>(x)).ToObservableCollection();

            Rmls = Context.RMLS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<Rml>(x)).ToObservableCollection();

            Ccts = Context.CCTS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<Cct>(x)).ToObservableCollection();

            Cats = Context.CATS.Where(x => !x.DELETED).ToList().Select(x => ObservableEntity.CreateObservableFromEntity<Cat>(x)).ToObservableCollection();

            InitCollectionSources();

            //BindingOperations.EnableCollectionSynchronization(Machines, _syncLock);
            //BindingOperations.EnableCollectionSynchronization(MachinesViewSource, _syncLock);

            //BindingOperations.EnableCollectionSynchronization(MachinesConfigurations, _syncLock);
            //BindingOperations.EnableCollectionSynchronization(MachinesConfigurationsViewSource, _syncLock);
        }

        private ICollectionView CreateCollectionView<T>(ObservableCollection<T> collection)
        {
            var view = CollectionViewSource.GetDefaultView(collection);
            return view;
        }
    }
}