protected override XElement Validate(XElement item)
        {
            // Validate with XSD
            XElement xsdErrors = this.ValidateXSD(item, HttpContext.Current.Server.MapPath(@"~\Xslt\Senior\Senior.xsd"));
            if (xsdErrors != null && xsdErrors.Elements("Error").Count() > 0)
            {
                return xsdErrors;
            }

            // Validate with Stored Proc
            string result = string.Empty;
            using (Persistence oDB = new Persistence())
            {
                Persistence.ParameterCollection parameters = new Persistence.ParameterCollection();
                parameters.Add("InputXml");
                parameters[0].Value = item.ToString();
                oDB.Execute("Masters_ConnectionString", "ValidateSeniorData", parameters, out result);
            }

            if (!string.IsNullOrEmpty(result))
            {
                XElement spErrors = XElement.Parse(result);
                spErrors.Elements("Error").Where(e => string.IsNullOrEmpty(e.Value)).Remove();

                if (spErrors.Elements("Error").Count() > 0)
                {
                    return spErrors;
                }
            }

            // SUCCESS!
            return null;

        }

 public void Export(Persistence.Lookup settings)
 {
     settings.Add("AgeSpecies", mKey.mAgeSpecies.ToString());
     settings.Add("Occult", mKey.mOccult.ToString());
     settings.Add("Commodity", mKey.mKind.ToString());
     settings.Add("Value", mValue);
 }

        private static void ConvertLayoutTypes(TypeVisualiserLayoutFile oldDiagram, Persistence.CanvasLayoutData canvasLayoutv105)
        {
            foreach (TypeLayoutData oldType in oldDiagram.ViewportSaveData.CanvasLayout.Types)
            {
                TypeLayoutData copyOfOldType = oldType;
                AssociationData association = oldDiagram.ViewportSaveData.Subject.Associations.FirstOrDefault(x => x.AssociatedTo.Id == copyOfOldType.Id);
                if (association == null)
                {
                    if (oldDiagram.ViewportSaveData.Subject.Implements != null)
                    {
                        association = oldDiagram.ViewportSaveData.Subject.Implements.FirstOrDefault(x => x.AssociatedTo.Id == oldType.Id);
                    }

                    if (association == null && oldDiagram.ViewportSaveData.Subject.Parent != null)
                    {
                        association = oldDiagram.ViewportSaveData.Subject.Parent.AssociatedTo.Id == oldType.Id ? oldDiagram.ViewportSaveData.Subject.Parent : null;
                    }
                }

                if (association == null)
                {
                    throw new NotSupportedException("Association Id " + oldType.Id + " not found in the Subject's data. Cannot deserialise from this data.");
                }

                var newType = new Persistence.TypeLayoutData { Id = oldType.Id.ToString(), TopLeft = oldType.TopLeft, Visible = oldType.Visible, ContentType = association.GetType().FullName, };
                canvasLayoutv105.Types.Add(newType);
            }
        }

        public void Import(Persistence.Lookup settings)
        {
            MasterController.Settings.SkillStamps.Clear();
            MasterController.Settings.SkillStamps.AddRange(settings.GetList<SkillStamp>(""));

            MasterController.Settings.UpdateStamp();
        }

 public Tracker(Persistence.IPersister persister, Persistence.Finder.IItemFinder find, N2.Web.IUrlParser urlParser, N2.Web.IErrorHandler errorHandler)
 {
     this.persister = persister;
     this.find = find;
     this.urlParser = urlParser;
     this.errorHandler = errorHandler;
 }

        public void Clear_ShouldClearAllAndLog(
            [Frozen]Mock<ILogger> logger,
            [Frozen]Mock<IEntityFrameworkContext> efContext,
            [Frozen]Mock<IAzureQueueContext> aqContext,
            [Frozen]Mock<IAzureTableContext> atContext,
            [Frozen]Mock<IAzureBlobContext> abContext,
            [Frozen]Mock<IEntityFrameworkChangeTracker> changeTracker,
            Persistence.UnitOfWork uow)
        {
            EntityFrameworkContextExtensions.Factory = efc => changeTracker.Object;

            // Act

            uow.Clear();

            // Assert

            changeTracker.Verify(t => t.Clear(), Times.Once);
            aqContext.Verify(c => c.Clear(), Times.Once);
            atContext.Verify(c => c.Clear(), Times.Once);
            abContext.Verify(c => c.Clear(), Times.Once);

            logger.Verify(l => l.Log("Clearing Entity Framework context..."), Times.Once);
            logger.Verify(l => l.Log("Clearing Azure Queue context..."), Times.Once);
            logger.Verify(l => l.Log("Clearing Azure Table context..."), Times.Once);
            logger.Verify(l => l.Log("Clearing Azure Blob context..."), Times.Once);
        }

 public SecurityEnforcer(Persistence.IPersister persister, ISecurityManager security, Definitions.IDefinitionManager definitions, Web.IUrlParser urlParser, Web.IWebContext webContext)
 {
     this.webContext = webContext;
     this.persister = persister;
     this.security = security;
     this.definitions = definitions;
     this.urlParser = urlParser;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Recommendation"/> class.
 /// </summary>
 /// <param name="recommendation">The recommendation.</param>
 public Recommendation(Persistence.Recommendation recommendation)
 {
     this.ID = recommendation.ID;
     this.UserID = recommendation.UserID;
     this.OperatingSystem = recommendation.OSID;
     this.Description = recommendation.Description;
     this.AppName = recommendation.AppDesignation;
 }

        public void Export(Persistence.Lookup settings)
        {
            if (mName == null) return;

            settings.Add("Name", mName);

            settings.Add("Criteria", mElements);
        }

 public SecurityEnforcer(Persistence.IPersister persister, ISecurityManager security, ContentActivator activator, Web.IUrlParser urlParser, Web.IWebContext webContext)
 {
     this.webContext = webContext;
     this.persister = persister;
     this.security = security;
     this.activator = activator;
     this.urlParser = urlParser;
 }

 public static Persistence getInstance()
 {
     if(_instance == null)
     {
         _instance = GameObject.FindObjectOfType<Persistence>();
     }
     return _instance;
 }

        public override void Export(Persistence.Lookup settings)
        {
            base.Export(settings);

            if (mValue != null)
            {
                settings.Add("Value", mValue.ToString());
            }
        }

 public void Import(Persistence.Lookup settings)
 {
     mKey = new MotiveKey(
         settings.GetEnum<CASAgeGenderFlags>("AgeSpecies", CASAgeGenderFlags.None),
         settings.GetEnum<OccultTypes>("Occult", OccultTypes.None),
         settings.GetEnum<CommodityKind>("Commodity", CommodityKind.None)
     );
     mValue = settings.GetFloat("Value", 1);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="User"/> class.
 /// </summary>
 /// <param name="user">The user.</param>
 public User(Persistence.User user)
 {
     this.ID = user.ID;
     this.FirstName = user.FirstName;
     this.Lastname = user.LastName;
     this.Children = user.Children;
     this.CountryOfOriginID = user.CountryOfOriginID;
     this.IsAdmin = user.Admin != null;
 }

 public SecurityEnforcer(Persistence.IPersister persister, ISecurityManager security, ContentActivator activator, Web.IUrlParser urlParser, Web.IWebContext webContext, Configuration.HostSection config)
 {
     this.webContext = webContext;
     this.persister = persister;
     this.security = security;
     this.activator = activator;
     this.urlParser = urlParser;
     this.permissionDeniedHttpCode = config.Web.PermissionDeniedHttpCode;
 }

 /// <summary>
 /// Initializes a new instance of Recention
 /// </summary>
 /// <param name="recention">The recention (Database entity)</param>
 internal Recention(Persistence.Recention recention)
 {
     this.ID = recention.ID;
     this.Rating = recention.Rating;
     this.Comment = recention.Comment;
     this.Date = recention.Date;
     this.User = string.Format("{0} {1}", recention.User.FirstName , recention.User.LastName);
     this.UserID = recention.UserID;
     this.AppID = recention.AppID;
 }

 protected override void Commit(XElement item)
 {
     // Save it
     using (Persistence oDB = new Persistence())
     {
         Persistence.ParameterCollection parameters = new Persistence.ParameterCollection();
         parameters.Add("InputXml");
         parameters[0].Value = item.ToString();
         oDB.Execute("Masters_ConnectionString", "SaveSeniorData", parameters);
     }
 }

        /// <summary>
        /// Loads service object fields values (parameter) into the current business object 
        /// fields. Curent business object is a transient one. It may be persisted some time
        /// somewhere but for the moment we assume it is not and deal with it like transient.
        /// </summary>
        /// <param name="entity">The source.</param>
        protected void DataPortal_Create(Persistence.Model.VacationRequestEntity entity)
        {
            _requestNumber = entity.Id;
            _submissionDate = entity.CreationDate;
            _stateId = entity.State;
            _employeeFullName = entity.Employee.Firstname + " " + entity.Employee.LastName;

            EmployeeId = entity.Employee.Id;
            StartDate = entity.StartDate;
            EndDate = entity.EndDate;
        }

 private static void ConvertLayoutAnnotations(TypeVisualiserLayoutFile oldDiagram, Persistence.CanvasLayoutData canvasLayoutv105)
 {
     foreach (AnnotationData oldAnnotation in oldDiagram.ViewportSaveData.CanvasLayout.Annotations)
     {
         canvasLayoutv105.Types.Add(new Persistence.TypeLayoutData
                                        {
                                            ContentType = typeof(Persistence.AnnotationData).FullName,
                                            Id = oldAnnotation.Id.ToString(),
                                            TopLeft = oldAnnotation.TopLeft,
                                            Visible = oldAnnotation.Show,
                                            Data = oldAnnotation.Text,
                                        });
     }
 }

        public override void Import(Persistence.Lookup settings)
        {
            base.Import(settings);

            FieldInfo field = GetFieldInfo();
            if (field != null)
            {
                ITunableConvertOption converter = TunableTypeOption.GetFieldOption(GetParsingType(field));
                if (converter != null)
                {
                    mValue = converter.Clone(GetTunableFieldInfo ()).Convert(settings.GetString("Value"), false);
                }
            }
        }