/// <summary>
 /// constructor
 /// </summary>
 /// <param name="id">id of the user</param>
 /// <param name="name">name of the user</param>
 /// <param name="username">username of the user (represented by email)</param>
 /// <param name="roleId">role represented by the enum</param>
 public User(int id, string name, string username, int roleId)
 {
     this.Id = id;
     this.Name = name;
     this.Username = username;
     Role = (RoleType)roleId;
 }

 public static PaperLetter Create(int creatingPersonId, int organizationId, string fromName,
     string[] replyAddressLines, DateTime receivedDate, int toPersonId, RoleType toPersonInRole, bool personal)
 {
     return FromIdentity(SwarmDb.GetDatabaseForWriting().
         CreatePaperLetter(organizationId, fromName, String.Join("|", replyAddressLines),
                           receivedDate, toPersonId, toPersonInRole, personal, creatingPersonId));
 }

        public bool AuthorizeRequest(HttpContext httpContext, RoleType minimumRoleType)
        {
            try
            {
                // If global admin services, authentication was handled by IIS
                if (ServiceContext.IsAdminServiceHost)
                    return HttpContext.Current.User.Identity.IsAuthenticated;

                // Attempt to obtain token from request
                var token = ExtractAuthorizationToken(httpContext.Request);

                if (token != null)
                {
                    // Create a user context from the token
                    var userContext = CreateUserContextFromToken(httpContext, token, minimumRoleType);

                    if (userContext != null)
                    {
                        // Add token to HTTP context for future reference
                        HttpContext.Current.Items.Add(CommonParameters.UserContext, userContext);
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                ServiceContext.Logger.Error("Error while authenticating user", ex);
            }

            return false;
        }

 /// <summary>
 /// constructor
 /// </summary>
 /// <param name="id">id of the user</param>
 /// <param name="name">name of the user</param>
 /// <param name="username">username of the user (represented by email)</param>
 /// <param name="roleId">role represented by the enum</param>
 public User(int id, string name, string username, int roleId)
 {
     Allowedpages = new List<string>();
     this.Id = id;
     this.Name = name;
     this.Username = username;
     Role = (RoleType)roleId;
     if (RoleId == 1)
     {
         Allowedpages.Add("beheer");
         Allowedpages.Add("inuitrij");
         Allowedpages.Add("reparatie");
         Allowedpages.Add("schoonmaak");
     }
     if (RoleId == 2)
     {
         Allowedpages.Add("inuitrij");
     }
     if (RoleId == 3)
     {
         Allowedpages.Add("beheer");
     }
     if (RoleId == 4)
     {
         Allowedpages.Add("reparatie");
     }
     if (RoleId == 5)
     {
         Allowedpages.Add("schoonmaak");
     }
 }

        public DocumentShare ShareDocument(Guid dlId, Guid usId, string message = "", RoleType linkRole = RoleType.Viewer)
        {
            if (dlId.Equals(Guid.Empty))
            {
                throw new ArgumentException("dlId is required but was an empty Guid", "dlId");
            }
            if (usId.Equals(Guid.Empty))
            {
                throw new ArgumentException("dlId is required but was an empty Guid", "usId");
            }

            switch (linkRole)
            {
                case RoleType.Owner:
                case RoleType.Editor:
                    linkRole = RoleType.Editor;
                    break;
                default:
                    linkRole = RoleType.Viewer;
                    break;
            }

            dynamic postData = new ExpandoObject();
            postData.users = usId;
            postData.message = message;
            postData.baseUrl = ShareUrl;
            postData.isPublic = "true";
            postData.linkRole = linkRole.ToString().ToLower();

            return HttpHelper.Put<DocumentShare>(VVRestApi.GlobalConfiguration.Routes.DocumentsIdShares, "", GetUrlParts(), this.ClientSecrets, this.ApiTokens, postData, dlId, usId);
        }

        private object AddRoleSyncRoot(RoleType roleType)
        {
            var roleSyncRoot = new object();

            RoleSyncRoots.Add(roleType, roleSyncRoot);

            return roleSyncRoot;
        }

 /// <summary>
 /// Normal constructor.
 /// </summary>
 /// <param name="personId">The person Id.</param>
 /// <param name="roleType">The node-specific role.</param>
 /// <param name="organizationId">The organization Id.</param>
 /// <param name="geographyId">The node Id.</param>
 public BasicPersonRole (int roleId, int personId, RoleType type, int organizationId, int geographyId)
 {
     this.roleId = roleId;
     this.personId = personId;
     this.type = type;
     this.organizationId = organizationId;
     this.geographyId = geographyId;
 }

        public void ParseRoleType_ReturnsCorrectString(RoleType roleType, string expected)
        {
            //act
            var result = EnumFactory.ParseRoleType(roleType);

            //assert
            result.Should().Be(expected);
        }

        /// <summary>
        /// Gets the business account for an Id.
        /// It will return one entity as an IQueryable for performance.
        /// Returns null if the user does not have access to the BusinessAccount.
        /// </summary>
        /// <param name="coreEntitiesContainer">The core entities container.</param>
        /// <param name="businessAccountId">The businessAccount Id.</param>
        /// <param name="allowedRoleTypes">Return null if the user does not have access to one of these role types.</param>
        public static IQueryable<BusinessAccount> BusinessAccount(this CoreEntitiesContainer coreEntitiesContainer, Guid businessAccountId, RoleType[] allowedRoleTypes)
        {
            var ownerParty = from role in RolesCurrentUserHasAccessTo(coreEntitiesContainer, allowedRoleTypes)
                             where role.OwnerBusinessAccountId == businessAccountId
                             select role.OwnerBusinessAccount;

            return ownerParty;
        }

        public void EnumHelper_Parse_ReturnsCorrectEnum(string value, RoleType roleType)
        {
            //act
            var result = EnumHelper<RoleType>.Parse(value);

            //assert
            result.Should().Be(roleType);
        }

    string PrintGeography (Geography geo)
    {
        StringBuilder sbl = new StringBuilder();
        RoleType[] rolesToShow = new RoleType[] { RoleType.OrganizationChairman, RoleType.OrganizationVice1, RoleType.OrganizationSecretary, RoleType.LocalLead, RoleType.LocalDeputy };
        Organizations orgs = Organizations.GetOrganizationsAvailableAtGeography(geo.Identity);
        foreach (Organization org in orgs)
        {
            Dictionary<int, bool> listedPersons = new Dictionary<int, bool>();
            if (org.IsOrInherits(Organization.UPSEid))
            {
                if (org.AnchorGeographyId == geo.Identity || org.UptakeGeographies.Contains(geo))
                {
                    RoleLookup officers = RoleLookup.FromOrganization(org);
                    bool foundRole = false;
                    foreach (RoleType rt in rolesToShow)
                    {
                        foundRole |= officers[rt].Count > 0;
                        if (foundRole) break;
                    }

                    if (foundRole)
                    {
                        sbl.Append("<br><br><b>" + HttpUtility.HtmlEncode(org.Name) + ":</b>");
                        foreach (RoleType rt in rolesToShow)
                            foreach (Activizr.Logic.Pirates.PersonRole r in officers[rt])
                            {
                                if (!listedPersons.ContainsKey(r.PersonId))
                                {
                                    sbl.Append(PrintOfficer(r));
                                    listedPersons[r.PersonId] = true;
                                }
                            }

                        sbl.Append("<br>");
                    }
                }
            }
            else
            {
                RoleLookup officers = RoleLookup.FromGeographyAndOrganization(geo, org);

                if (officers[RoleType.LocalLead].Count > 0 || officers[RoleType.LocalDeputy].Count > 0)
                {
                    sbl.Append("<br><br><b>" + HttpUtility.HtmlEncode(org.Name) + ", " + HttpUtility.HtmlEncode(geo.Name) + ":</b>");
                    foreach (RoleType rt in rolesToShow)
                        foreach (Activizr.Logic.Pirates.PersonRole r in officers[rt])
                            if (!listedPersons.ContainsKey(r.PersonId))
                            {
                                sbl.Append(PrintOfficer(r));
                                listedPersons[r.PersonId] = true;
                            }

                    sbl.Append("<br>");
                }
            }
        }
        return sbl.ToString();
    }

 public bool HasAnyRole(RoleType[] types)
 {
     foreach (var role in types)
     {
         if (HasRole(role))
             return true;
     }
     return false;
 }

		public virtual ViewResult Create(RoleType roleType)
		{
			if(roleType != RoleType.Admin && roleType != RoleType.Broker && roleType != RoleType.Manager)
			{
				throw new NotSupportedException();
			}

			return View();
		}

 public Role GetRoleByType(RoleType type)
 {
     using (var db = new BlogContext())
     {
         return (from p in db.Roles
         where p.Type == type
         select p).FirstOrDefault();
     }
 }

        public static bool IsInRole(this IPrincipal principal, RoleType roleType)
        {
            if (principal == null)
            {
                throw new ArgumentNullException("principal");
            }

            return principal.IsInRole(Enum.GetName(typeof(RoleType), roleType));
        }

 /// <summary>
 /// 检验当前登录用户的权限
 /// </summary>
 /// <param name="role"></param>
 /// <returns></returns>
 public bool CheckRole(RoleType role)
 {
     AdminUser user = GetUser();
     CommonLoger.Info(role.ToString() + user.RoleType.ToString());
     if (user == null || (int)user.RoleType != (int)role)
         return false;
     else
         return true;
 }

        public Role GetRole(RoleType roleType)
        {
            if (!Enum.IsDefined(typeof(RoleType), roleType))
            {
                throw new ArgumentOutOfRangeException("roleType");
            }

            return _cache[CreateRoleKey(roleType)] as Role;
        }

		public bool CanModify(RoleType userRole, RoleType editUserRole)
		{
			var canModify = (userRole == RoleType.DvsSuperAdmin || userRole == RoleType.DvsAdmin);
			if (userRole != RoleType.DvsSuperAdmin && editUserRole == RoleType.DvsSuperAdmin)
			{
				canModify = false;
			}

			return canModify;
		}

 //获取存活物体索引号
 public List<int> GetAliveItemIndex(RoleType type)
 {
     List<int> alive = new List<int>();
     for (int i = 0; i < BattleRoleList.Count; i++) {
         if (BattleRoleList[i].roleType == type && BattleRoleList[i].hp > 0) {
             alive.Add(i);
         }
     }
     return alive;
 }

 public static ICurrentUser GetFakeUser(RoleType roleType)
 {
     return new CurrentUser()
     {
         Role = roleType,
         Name = "name",
         ServicerId = 1,
         OrganizationId = 2
     };
 }