IPartialRedDotObject.cs

Go to the documentation of this file.

// SmartAPI - .Net programmatic access to RedDot servers
//  
// Copyright (C) 2013 erminas GbR
// 
// This program is free software: you can redistribute it and/or modify it 
// under the terms of the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License along with this program.
// If not, see <http://www.gnu.org/licenses/>.

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Xml;
using erminas.SmartAPI.CMS.Project;
using erminas.SmartAPI.CMS.Project.ContentClasses;
using erminas.SmartAPI.Utils;

namespace erminas.SmartAPI.CMS
{
    public interface IPartialRedDotObject : IRedDotObject
    {
        void EnsureInitialization();
        void Refresh();
    }

    public interface IPartialRedDotProjectObject : IPartialRedDotObject, IProjectObject
    {
    }

    //public interface ILanguageDependentPartialRedDotObject : IPartialRedDotProjectObject,
    //                                                         ILanguageDependentXmlBasedObject
    //{

    //}

    internal abstract class PartialRedDotObject : RedDotObject, IPartialRedDotObject
    {
        protected PartialRedDotObject(ISession session, XmlElement xmlElement) : base(session, xmlElement)
        {
            IsInitialized = true;
        }

        protected PartialRedDotObject(ISession session, Guid guid) : base(session, guid)
        {
            IsInitialized = false;
        }

        protected PartialRedDotObject(ISession session) : base(session)
        {
            IsInitialized = false;
        }

        public bool IsInitialized { get; set; }

        protected T LazyLoad<T>(ref T value)
        {
            if (IsInitialized || !Equals(value, default(T)))
            {
                return value;
            }
            Refresh();
            return value;
        }

        protected abstract void LoadWholeObject();

        protected abstract XmlElement RetrieveWholeObject();

        #region IPartialRedDotObject Members

        public void EnsureInitialization()
        {
            if (!IsInitialized)
            {
                Refresh();
            }
        }

        public override sealed string Name
        {
            get { return LazyLoad(ref _name); }
            internal set { base.Name = value; }
        }

        public virtual void Refresh()
        {
            XmlElement = (XmlElement) RetrieveWholeObject().Clone();
            InitGuidAndName();
            LoadWholeObject();

            IsInitialized = true;
        }

        public override sealed XmlElement XmlElement
        {
            get
            {
                EnsureInitialization();
                return base.XmlElement;
            }
            protected internal set
            {
                base.XmlElement = value;
                _readWriteWrapper = new XmlReadWriteWrapper(_xmlElement, new Dictionary<string, string>());
            }
        }

        protected override sealed T GetAttributeValue<T>([CallerMemberName] string callerName = "")
        {
            EnsureInitialization();
// ReSharper disable ExplicitCallerInfoArgument
            return base.GetAttributeValue<T>(callerName);
// ReSharper restore ExplicitCallerInfoArgument
        }

        protected override sealed void SetAttributeValue<T>(T value, [CallerMemberName] string callerName = "")
        {
            EnsureInitialization();
// ReSharper disable ExplicitCallerInfoArgument
            base.SetAttributeValue(value, callerName);
// ReSharper restore ExplicitCallerInfoArgument
        }

        #endregion
    }

    internal abstract class LanguageDependentPartialRedDotProjectObject : PartialRedDotProjectObject,
                                                                          ILanguageDependentXmlBasedObject
    {
        //protected readonly Dictionary<string, object> _languageDependendValues = new Dictionary<string, object>();

        //private readonly Dictionary<string, XmlElement> _languageDependentWriteXmlElements =
        //    new Dictionary<string, XmlElement>();

        //private readonly Dictionary<string, XmlElement> _languageDependentXmlElements =
        //    new Dictionary<string, XmlElement>();

        private readonly Dictionary<string, XmlReadWriteWrapper> _languageDepdentXmlElements =
            new Dictionary<string, XmlReadWriteWrapper>();

        protected LanguageDependentPartialRedDotProjectObject(IProject project, XmlElement xmlElement)
            : base(project, xmlElement)
        {
        }

        protected LanguageDependentPartialRedDotProjectObject(IProject project, Guid guid) : base(project, guid)
        {
        }

        protected LanguageDependentPartialRedDotProjectObject(IProject project) : base(project)
        {
        }

        public IXmlReadWriteWrapper GetElementForLanguage(string languageAbbreviation)
        {
            var element = _languageDepdentXmlElements.GetOrAdd(languageAbbreviation, () =>
                {
                    using (new LanguageContext(Project.LanguageVariants[languageAbbreviation]))
                    {
                        var read = (XmlElement) RetrieveWholeObject().Clone();
                        return new XmlReadWriteWrapper(read, _readWriteWrapper.WrittenValues);
                    }
                });

            return element;
        }

        public override void Refresh()
        {
            _languageDepdentXmlElements.Clear();
            base.Refresh();
        }

        //public XmlElement XmlElementForCurrentLanguage
        //{
        //    get { return GetXmlElementForLanguage(Project.LanguageVariants.Current.Abbreviation); }
        //}

        //public XmlElement XmlElementForMainLanguage
        //{
        //    get { return GetXmlElementForLanguage(Project.LanguageVariants.Main.Abbreviation); }
        //}

        //private static XmlElement GetWriteMergedIntoRead(XmlElement writeElement, XmlElement readElement)
        //{
        //    var mergedElement = (XmlElement) readElement.Clone();
        //    foreach (XmlAttribute curAttribute in writeElement.Attributes)
        //    {
        //        mergedElement.SetAttributeValue(curAttribute.Name, curAttribute.Value);
        //    }

        //    return mergedElement;
        //}
    }
}