public void Two_keys_with_same_value()
        {
            var one = new UserKey("one");
            var two = new UserKey("one");

            one.ShouldBe(two);
        }

        public void Two_different_keys()
        {
            var one = new UserKey("one");
            var two = new UserKey("two");

            one.ShouldNotBe(two);
        }

		private async Task GetUserDetails(IOwinContext context)
		{
			var key = new UserKey(context.GetRouteValue("key"));
			var user = _collectionsReadModel.Users.Single(r => r.Key == key);

			await context.WriteJson(user, _settings);
		}

 /// <summary>
 /// Gets a specific access for a user.
 /// </summary>
 /// <param name="aUserKey">A user key composite.</param>
 /// <param name="aFunction">A function.</param>
 /// <returns></returns>
 public static Access GetAccess(UserKey aUserKey, string aFunction)
 {
     UserFunctionAccess vUserFunctionAccess = new UserFunctionAccess() { UsrKey = aUserKey.UsrKey };
     vUserFunctionAccess.FunctionAccess.Function = aFunction;
     Load(vUserFunctionAccess);
     return vUserFunctionAccess.FunctionAccess.Access;
 }

 public UserCreatedEvent(Operator @operator, Guid id, UserKey key, string name)
     : base(@operator)
 {
     ID = id;
     Key = key;
     Name = name;
 }

        public void Two_keys_with_different_values_by_case()
        {
            var one = new UserKey("one");
            var two = new UserKey("ONE");

            one.ShouldBe(two);
        }

        public void When_serializing()
        {
            var input = new UserKey("one");
            var json = JsonConvert.SerializeObject(input);
            var output = JsonConvert.DeserializeObject<UserKey>(json);

            output.ShouldBe(input);
        }

        internal User GetUser(UserKey key, bool manageRole = true)
        {
            User user = _userModule.Get(key);

            if(user != null && manageRole)
                CompleteUserRole(user);

            return user;
        }

 /// <summary>
 ///   The <c>AddUser</c> implementation method deserializes an incoming XML Argument <see cref="string"/> as a new <see cref="User"/> object.
 ///   It invokes the <c>Insert</c> method of <see cref="UserBusiness"/> with the newly deserialized <see cref="User"/> object.
 ///   Finally, it returns the inserted object (now with an assigned User Key) as a serialized <see cref="string"/> of XML.
 /// </summary>
 /// <param name="aXmlArgument">XML Argument <see cref="string"/>.</param>
 /// <returns><see cref="User"/> as XML <see cref="string"/>.</returns>
 /// <exception cref="ArgumentNullException">If <c>aXmlArgument</c> is <c>null</c>.</exception>
 public static string AddUser(UserKey aUserKey, string aXmlArgument)
 {
     if (aXmlArgument == null)
     {
         throw new ArgumentNullException("aXmlArgument of AddUser");
     }
     User vUser = new User();
     vUser = XmlUtils.Deserialize<User>(aXmlArgument);
     UserBusiness.Insert(aUserKey, vUser);
     return XmlUtils.Serialize<User>(vUser, true);
 }

 /// <summary>
 ///   The <c>AddRoleFunction</c> implementation method deserializes an incoming XML Argument <see cref="string"/> as a new <see cref="RoleFunction"/> object.
 ///   It invokes the <c>Insert</c> method of <see cref="RoleFunctionBusiness"/> with the newly deserialized <see cref="RoleFunction"/> object.
 ///   Finally, it returns the inserted object (now with an assigned RoleFunction Key) as a serialized <see cref="string"/> of XML.
 /// </summary>
 /// <param name="aXmlArgument">XML Argument <see cref="string"/>.</param>
 /// <returns><see cref="RoleFunction"/> as XML <see cref="string"/>.</returns>
 /// <exception cref="ArgumentNullException">If <c>aXmlArgument</c> is <c>null</c>.</exception>
 public static string AddRoleFunction(UserKey aUserKey, string aXmlArgument)
 {
     if (aXmlArgument == null)
     {
         throw new ArgumentNullException("aXmlArgument of AddRoleFunction");
     }
     RoleFunction vRoleFunction = new RoleFunction();
     vRoleFunction = XmlUtils.Deserialize<RoleFunction>(aXmlArgument);
     RoleFunctionBusiness.Insert(aUserKey, vRoleFunction);
     return XmlUtils.Serialize<RoleFunction>(vRoleFunction, true);
 }

 /// <summary>
 ///   The <c>AddDocument</c> implementation method deserializes an incoming XML Argument <see cref="string"/> as a new <see cref="Document"/> object.
 ///   It invokes the <c>Insert</c> method of <see cref="DocumentBusiness"/> with the newly deserialized <see cref="Document"/> object.
 ///   Finally, it returns the inserted object (now with an assigned Document Key) as a serialized <see cref="string"/> of XML.
 /// </summary>
 /// <param name="aXmlArgument">XML Argument <see cref="string"/>.</param>
 /// <returns><see cref="Document"/> as XML <see cref="string"/>.</returns>
 /// <exception cref="ArgumentNullException">If <c>aXmlArgument</c> is <c>null</c>.</exception>
 public static string AddDocument(UserKey aUserKey, string aXmlArgument)
 {
     if (aXmlArgument == null)
     {
         throw new ArgumentNullException("aXmlArgument of AddDocument");
     }
     Document vDocument = new Document();
     vDocument = XmlUtils.Deserialize<Document>(aXmlArgument);
     DocumentBusiness.Insert(aUserKey, vDocument);
     return XmlUtils.Serialize<Document>(vDocument, true);
 }

 /// <summary>
 ///   The <c>AddContributor</c> implementation method deserializes an incoming XML Argument <see cref="string"/> as a new <see cref="Contributor"/> object.
 ///   It invokes the <c>Insert</c> method of <see cref="ContributorBusiness"/> with the newly deserialized <see cref="Contributor"/> object.
 ///   Finally, it returns the inserted object (now with an assigned Contributor Key) as a serialized <see cref="string"/> of XML.
 /// </summary>
 /// <param name="aXmlArgument">XML Argument <see cref="string"/>.</param>
 /// <returns><see cref="Contributor"/> as XML <see cref="string"/>.</returns>
 /// <exception cref="ArgumentNullException">If <c>aXmlArgument</c> is <c>null</c>.</exception>
 public static string AddContributor(UserKey aUserKey, string aXmlArgument)
 {
     if (aXmlArgument == null)
     {
         throw new ArgumentNullException("aXmlArgument of AddContributor");
     }
     Contributor vContributor = new Contributor();
     vContributor = XmlUtils.Deserialize<Contributor>(aXmlArgument);
     ContributorBusiness.Insert(aUserKey, vContributor);
     return XmlUtils.Serialize<Contributor>(vContributor, true);
 }

 /// <summary>
 ///   The <c>AddContributorLanguage</c> implementation method deserializes an incoming XML Argument <see cref="string"/> as a new <see cref="ContributorLanguage"/> object.
 ///   It invokes the <c>Insert</c> method of <see cref="ContributorLanguageBusiness"/> with the newly deserialized <see cref="ContributorLanguage"/> object.
 ///   Finally, it returns the inserted object (now with an assigned ContributorLanguage Key) as a serialized <see cref="string"/> of XML.
 /// </summary>
 /// <param name="aXmlArgument">XML Argument <see cref="string"/>.</param>
 /// <returns><see cref="ContributorLanguage"/> as XML <see cref="string"/>.</returns>
 /// <exception cref="ArgumentNullException">If <c>aXmlArgument</c> is <c>null</c>.</exception>
 public static string AddContributorLanguage(UserKey aUserKey, string aXmlArgument)
 {
     if (aXmlArgument == null)
     {
         throw new ArgumentNullException("aXmlArgument of AddContributorLanguage");
     }
     ContributorLanguage vContributorLanguage = new ContributorLanguage();
     vContributorLanguage = XmlUtils.Deserialize<ContributorLanguage>(aXmlArgument);
     ContributorLanguageBusiness.Insert(aUserKey, vContributorLanguage);
     return XmlUtils.Serialize<ContributorLanguage>(vContributorLanguage, true);
 }

        /// <summary>
        /// Delete data in database
        /// </summary>
        /// <param name="key">Primary Key</param>
        public void Delete(UserKey key)
        {
            if (key == null || string.IsNullOrWhiteSpace(key.Id))
                return;

            var row = _dbContext.Users.Where(m => m.Id == key.Id).FirstOrDefault();
            if (row != null)
            {
                _dbContext.Users.Remove(row);
                _dbContext.SaveChanges();
            }
        }

        /// <summary>
        ///   The overloaded Load method that will return a <see cref="LanguageCollection"/>.
        /// </summary>
        /// <param name="aUserKey">A <see cref="UserKey"/> object.</param>
        /// <param name="aLanguageCollection">A <see cref="LanguageCollection"/> object.</param>
        /// <exception cref="ArgumentNullException">If <c>aLanguageCollection</c> argument is <c>null</c>.</exception>
        public static void Load(UserKey aUserKey, LanguageCollection aLanguageCollection)
        {
            if (aLanguageCollection == null)
            {
                throw new ArgumentNullException("Load Language Business");
            }

            if (!UserFunctionAccessData.HasModeAccess(aUserKey, "Language", AccessMode.List))
            {
                throw new ZpAccessException("Access Denied", String.Format("{0}", aUserKey.UsrKey), AccessMode.List, "Language");
            }

            LanguageData.Load(aLanguageCollection);
        }

        /// <summary>
        ///   Delete a <see cref="User"/> object passed as an argument.
        /// </summary>
        /// <param name="aUserKey">A <see cref="UserKey"/> object.</param>
        /// <param name="aUser">A <see cref="User"/> object.</param>
        /// <exception cref="ArgumentNullException">If <c>aUser</c> argument is <c>null</c>.</exception>
        public static void Delete(UserKey aUserKey, User aUser)
        {
            if (aUser == null)
            {
                throw new ArgumentNullException("Delete User Business");
            }

            if (!UserFunctionAccessData.HasModeAccess(aUserKey, "User", AccessMode.Delete))
            {
                throw new ZpAccessException("Access Denied", String.Format("{0}", aUserKey.UsrKey), AccessMode.Delete, "User");
            }

            UserData.Delete(aUser);
        }

        /// <summary>
        ///   Insert a <see cref="Contributor"/> object passed as an argument via Stored Procedure that returns the newly inserted <i>Contributor Key</i>.
        /// </summary>
        /// <param name="aUserKey">A <see cref="UserKey"/> object.</param>
        /// <param name="aContributor">A <see cref="Contributor"/> object.</param>
        /// <exception cref="ArgumentNullException">If <c>aContributor</c> argument is <c>null</c>.</exception>
        public static void Insert(UserKey aUserKey, Contributor aContributor)
        {
            if (aContributor == null)
            {
                throw new ArgumentNullException("Insert Contributor Business");
            }

            if (!UserFunctionAccessData.HasModeAccess(aUserKey, "Contributor", AccessMode.Create))
            {
                throw new ZpAccessException("Access Denied", String.Format("{0}", aUserKey.UsrKey), AccessMode.Create, "Contributor");
            }

            ContributorData.Insert(aContributor);
        }

        /// <summary>
        ///   The overloaded Load method that will return a specific <see cref="ContributorLanguage"/> object, with keys in <c>aContributorLanguage</c>.
        /// </summary>
        /// <param name="aUserKey">A <see cref="UserKey"/> object.</param>
        /// <param name="aContributorLanguage">A <see cref="ContributorLanguage"/>.</param>
        /// <exception cref="ArgumentNullException">If <c>aContributorLanguage</c> is <c>null</c>.</exception>
        public static void Load(UserKey aUserKey, ContributorLanguage aContributorLanguage)
        {
            if (aContributorLanguage == null)
            {
                throw new ArgumentNullException("Load ContributorLanguage Business");
            }

            if (!UserFunctionAccessData.HasModeAccess(aUserKey, "ContributorLanguage", AccessMode.Read))
            {
                throw new ZpAccessException("Access Denied", String.Format("{0}", aUserKey.UsrKey), AccessMode.Read, "ContributorLanguage");
            }

            ContributorLanguageData.Load(aContributorLanguage);
        }

        /// <summary>
        ///   The overloaded Load method that will return a specific <see cref="WorkItem"/> object, with keys in <c>aWorkItem</c>.
        /// </summary>
        /// <param name="aUserKey">A <see cref="UserKey"/> object.</param>
        /// <param name="aWorkItem">A <see cref="WorkItem"/>.</param>
        /// <exception cref="ArgumentNullException">If <c>aWorkItem</c> is <c>null</c>.</exception>
        public static void Load(UserKey aUserKey, WorkItem aWorkItem)
        {
            if (aWorkItem == null)
            {
                throw new ArgumentNullException("Load WorkItem Business");
            }

            if (!UserFunctionAccessData.HasModeAccess(aUserKey, "WorkItem", AccessMode.Read))
            {
                throw new ZpAccessException("Access Denied", String.Format("{0}", aUserKey.UsrKey), AccessMode.Read, "WorkItem");
            }

            WorkItemData.Load(aWorkItem);
        }

        /// <summary>
        ///   The overloaded Load method that will return a specific <see cref="Document"/> object, with keys in <c>aDocument</c>.
        /// </summary>
        /// <param name="aUserKey">A <see cref="UserKey"/> object.</param>
        /// <param name="aDocument">A <see cref="Document"/>.</param>
        /// <exception cref="ArgumentNullException">If <c>aDocument</c> is <c>null</c>.</exception>
        public static void Load(UserKey aUserKey, Document aDocument)
        {
            if (aDocument == null)
            {
                throw new ArgumentNullException("Load Document Business");
            }

            if (!UserFunctionAccessData.HasModeAccess(aUserKey, "Document", AccessMode.Read))
            {
                throw new ZpAccessException("Access Denied", String.Format("{0}", aUserKey.UsrKey), AccessMode.Read, "Document");
            }

            DocumentData.Load(aDocument);
        }