public static bool changeConfigFolder(Window parent, ASettings settings, string setting_name,
            string description, string error_message, Permissions required_permissions) {
            string old_path = settings.get(setting_name);
            string new_path = null;
            System.Windows.Forms.FolderBrowserDialog folderBrowser = new System.Windows.Forms.FolderBrowserDialog();
            folderBrowser.ShowNewFolderButton = true;
            folderBrowser.Description = description;
            folderBrowser.SelectedPath = old_path;
            bool try_again = false;
            do {
                if (folderBrowser.ShowDialog(GetIWin32Window(parent)) == System.Windows.Forms.DialogResult.OK) {
                    new_path = folderBrowser.SelectedPath;
                    if (PermissionsHelper.isReadable(new_path)) {
                        if (required_permissions < Permissions.Write 
                            ||PermissionsHelper.isWritable(new_path)) {

                                settings.set(setting_name, new_path);

                            return new_path != old_path;
                        } else {
                            folderBrowser.Description = error_message;
                            try_again = true;
                        }
                    } else {
                        folderBrowser.Description = error_message;
                        try_again = true;
                    }
                } else {
                    try_again = false;
                }
            } while (try_again);
            return false;
        }

        /// <summary>
        /// Converts Permission to string.
        /// </summary>
        /// <param name="permission">Permission to convert.</param>
        /// <returns>String describing permission.</returns>
        public static string GetString(Permissions permission)
        {
            string value = "";

            switch (permission)
            {
                case Permissions.CreateData:
                    value = "create_data";
                    break;
                case Permissions.ReadData:
                    value = "read_data";
                    break;
                case Permissions.ReadOwnData:
                    value = "read_own_data";
                    break;
                case Permissions.UpdateData:
                    value = "update_data";
                    break;
                case Permissions.UpdateOwnData:
                    value = "update_own_data";
                    break;
                case Permissions.DeleteData:
                    value = "delete_data";
                    break;
                case Permissions.DeleteOwnData:
                    value = "delete_own_data";
                    break;
            }

            return value;
        }

 public static string GetAuthenticationUrl(string apiKey, string sharedSecret, string frob, Permissions Permissions)
 {
     var authParams = new Dictionary<string, string>();
     authParams.Add("api_key", apiKey);
     authParams.Add("perms", "delete");
     authParams.Add("frob", frob);
     authParams.Add("api_sig", SignArguments(sharedSecret, authParams));
     return CreateUrl(Constants.AuthorizationUrl, authParams);
 }

        /// <summary>Creates a new admin module attribute for an admin module.</summary>
        /// <param name="location">Location a URL should point to find module.</param>
        /// <param name="title">Title of module.</param>
        /// <param name="description">Description of module.</param>
        public PortletAdminAttribute(string location, string title, string description, Permissions permissions)
            : base(title, description, permissions)
        {
            // checks to see if location is set
            if (location == null || location.Length == 0)
                throw new ArgumentException("Location needs to be set for PortletAdminAttribute.  Cannot be String.Empty or null.", "folderName");

            this._location = location;
        }

        /// <summary>
        /// Adds container-level permission to specified User API client. Requires Backend API key with Admin permission role.
        /// </summary>
        /// <param name="apiClientId">User API client id.</param>
        /// <param name="permission">User API client's permission to add.</param>
        /// <param name="projectId">Project id defining project that permission will be added to.</param>
        /// <returns>Boolen value indicating success of method.</returns>
        public Task<bool> Authorize(string apiClientId, Permissions permission, string projectId)
        {
            if(apiClientId == null || projectId == null)
                throw new ArgumentNullException();

            string permissionString = PermissionsParser.GetString(permission);
            return _syncanoClient.GetAsync("project.authorize",
                new {api_client_id = apiClientId, permission = permissionString, project_id = projectId});
        }

		///<summary>Gets a GroupPermission based on the supplied userGroupNum and permType.  If not found, then it returns null.  Used in FormSecurity when double clicking on a dated permission or when clicking the all button.</summary>
		public static GroupPermission GetPerm(long userGroupNum,Permissions permType) {
			//No need to check RemotingRole; no call to db.
			for(int i=0;i<GroupPermissionC.List.Length;i++){
				if(GroupPermissionC.List[i].UserGroupNum==userGroupNum && GroupPermissionC.List[i].PermType==permType){
					return GroupPermissionC.List[i].Copy();
				}
			}
			return null;
		}

        protected void Page_Load(object sender, EventArgs e)
        {
            if (!this.Page.IsPostBack)
            {
                this.id = base.Request.Params["id"];
                if ((this.id == null) || (this.id.Trim() == ""))
                {
                    base.Response.Redirect("treelist.aspx?TreeType=" + this.TreeType);
                    base.Response.End();
                }
                SysTree tree = new SysTree();
                SysNode node = tree.GetNode(int.Parse(this.id));
                this.lblID.Text = this.id;
                this.lblOrderid.Text = node.OrderID.ToString();
                this.lblName.Text = node.TreeText;
                if (node.ParentID == 0)
                {
                    this.lblTarget.Text = Site.lblRootDirectory;
                }
                else
                {
                    this.lblTarget.Text = tree.GetNode(node.ParentID).TreeText;
                }
                this.lblUrl.Text = node.Url;
                this.Image1.ImageUrl = node.ImageUrl;
                Permissions permissions = new Permissions();
                if (node.PermissionID == -1)
                {
                    this.lblPermission.Text = SysManage.lblPermissionText;
                }
                else
                {
                    this.lblPermission.Text = permissions.GetPermissionName(node.PermissionID);
                }
                switch (node.TreeType)
                {
                    case 0:
                        this.lblTreeType.Text = SysManage.dropBackendSystem;
                        break;

                    case 1:
                        this.lblTreeType.Text = SysManage.dropBackendEnterprise;
                        break;

                    case 2:
                        this.lblTreeType.Text = SysManage.dropBackendAgent;
                        break;

                    case 3:
                        this.lblTreeType.Text = SysManage.dropBackendUser;
                        break;
                }
                this.lblEnable.Text = node.Enabled ? SysManage.lblEnableTrue : SysManage.lblEnableFalse;
                this.lblDescription.Text = node.Comment;
            }
        }

 private void InjectDependencies()
 {
     this.Projects = new Projects(_httpWorker);
     this.Repositories = new Repositories(_httpWorker);
     this.Branches = new Branches(_httpWorker);
     this.Commits = new Commits(_httpWorker);
     this.PullRequests = new PullRequests(_httpWorker);
     Permissions = new Permissions(_httpWorker);
     RepoPermissions = new RepoPermissions(_httpWorker);
 }

 public ServerExplorerItem(string displayName, Guid resourceId, ResourceType resourceType,
                           IList<IExplorerItem> children, Permissions permissions, string resourcePath)
 {
     DisplayName = displayName;
     ResourceId = resourceId;
     ResourceType = resourceType;
     Children = children;
     Permissions = permissions;
     ResourcePath = resourcePath;
 }

        public IEnumerable<Person> FetchPeopleWithASpecificPermission(Permissions permission, int churchId)
        {
            var permissionInt = (int) permission;

            return from pc in Context.PersonChurches
                join pr in Context.PermissionRoles
                    on pc.RoleId equals pr.RoleId
                where pr.PermissionId == permissionInt
                    && pc.ChurchId == churchId
                select pc.Person;
        }

 public static bool HasPermission( Permissions needed , User user )
 {
     if ( user != null )
     {
         return GetPermissions( user ) >= needed;
     }
     else
     {
         return true;
     }
 }

 ///<summary>PatNum can be 0.</summary>
 public static void MakeLogEntry(Permissions permType,long patNum,string logText)
 {
     //No need to check RemotingRole; no call to db.
     SecurityLog securityLog=new SecurityLog();
     securityLog.PermType=permType;
     securityLog.UserNum=Security.CurUser.UserNum;
     securityLog.LogText=logText;//"From: "+Environment.MachineName+" - "+logText;
     securityLog.CompName=Environment.MachineName;
     securityLog.PatNum=patNum;
     SecurityLogs.Insert(securityLog);
 }

		public List<Permission> Get(Permissions role)
		{
			var entities = new List<PermissionEntity>();

			entities = GenericRepository.GetList<PermissionEntity>(AuthAdminDatabase, PermissionsCollection);

			if (entities == null)
				return null;

			return entities.TranslateToResponse();
		}

        public static bool UserHasPermission(string module, Permissions permission)
        {
            if (HttpContext.Current.Session["isAdmin"] != null)
            {
                return true;
            }

            List<ModulePermission> permissions = GetModulePermissionsFromSession();

            return permissions.Exists(e => e.Module == module && e.Permission == permission);
        }

		///<summary>Checks to see if current user is authorized.  It also checks any date restrictions.  If not authorized, it gives a Message box saying so and returns false.</summary>
		public static bool IsAuthorized(Permissions perm,DateTime date,bool suppressMessage){
			//No need to check RemotingRole; no call to db.
			if(Security.CurUser==null) {
				if(!suppressMessage) {
					MessageBox.Show(Lans.g("Security","Not authorized for")+"\r\n"+GroupPermissions.GetDesc(perm));
				}
				return false;
			}
			try {
				return IsAuthorized(perm,date,suppressMessage,curUser.UserGroupNum);
			}
			catch(Exception ex) {
				MessageBox.Show(ex.Message);
				return false;
			}
		}

 public GARITS()
 {
     InitializeComponent();
     permissions = new Permissions();
     try
     {
         settingsFile = new SettingsFile();
         db = new Database(settingsFile.getSetting("dbserver"), settingsFile.getSetting("dbname"), settingsFile.getSetting("dbuser"), settingsFile.getSetting("dbpassword"));
         db.Connect();
         permissions.readPermissions(db);
     }
     catch (Exception ex)
     {
         MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
         Environment.Exit(1);
     }
     permissions.AddComponent(administrationToolStripMenuItem, "Administration Menu Item");
 }

		///<summary></summary>
		public static void RemovePermission(long groupNum,Permissions permType) {
			if(RemotingClient.RemotingRole==RemotingRole.ClientWeb) {
				Meth.GetVoid(MethodBase.GetCurrentMethod(),groupNum,permType);
				return;
			}
			string command;
			if(permType==Permissions.SecurityAdmin){
				//need to make sure that at least one other user has this permission
				command="SELECT COUNT(*) FROM grouppermission WHERE PermType='"+POut.Long((int)permType)+"'";
				DataTable table=Db.GetTable(command);
				if(table.Rows[0][0].ToString()=="1"){//only one, so this would delete the last one.
					throw new Exception(Lans.g("FormSecurity","At least one group must have Security Admin permission."));
				}
			}
			command="DELETE from grouppermission WHERE UserGroupNum='"+POut.Long(groupNum)+"' "
				+"AND PermType='"+POut.Long((int)permType)+"'";
 			Db.NonQ(command);
		}

        protected override void OnInit( EventArgs e )
        {
            base.OnInit( e );

              #region Security check
              currentLoggedInUserPermissions = PermissionService.Instance.GetCurrentLoggedInUserPermissions();
              if ( currentLoggedInUserPermissions == null || !currentLoggedInUserPermissions.HasPermission( StoreSpecificPermissionType.AccessSettings, store.Id ) ) {
            throw new SecurityException();
              }
              #endregion

              AddTab( CommonTerms.Common, PnCommon, SaveButton_Clicked );
              AddTab( StoreTerms.Order, PnOrder, SaveButton_Clicked );
              AddTab( StoreTerms.Product, PnProduct, SaveButton_Clicked );
              AddTab( CommonTerms.GiftCards, PnGiftCard, SaveButton_Clicked );
              AddTab( "UI", PnTemplateRendering, SaveButton_Clicked );

              PPnlName.Text = CommonTerms.Name;
              PPnlDefaultCountry.Text = StoreTerms.DefaultCountry;
              PPnlDefaultVatGroup.Text = StoreTerms.DefaultVatGroup;
              PPnlDefaultOrderStatus.Text = StoreTerms.DefaultOrderStatus;
              PPnlConfirmationEmail.Text = StoreTerms.ConfirmationEmailTemplate;
              PPnlPaymentInconsistencyEmail.Text = StoreTerms.PaymentInconsistencyEmailTemplate;
              PPnlPricesIsSpecifiedWithVat.Text = StoreTerms.PricesIsSpecifiedWithVat;
              PPnlChkPersistOrderId.Text = StoreTerms.UseCookies;
              PPnlChkOrderPersistanceTimeout.Text = StoreTerms.CookieTimeout + "<br /><small>" + StoreTerms.CookieTimeoutHelp + "</small>";

              PPnlCartNumberPrefix.Text = StoreTerms.CartNumberPrefix;
              PPnlOrderNumberPrefix.Text = StoreTerms.OrderNumberPrefix;

              PPnlProductPropertyAliases.Text = StoreTerms.ProductPropertyAliases;
              PPnlProductUniquenessPropertyAliases.Text = StoreTerms.ProductUniquenessPropertyAliases;
              PPnlStockSharingStore.Text = StoreTerms.StockSharingStore + "<br /><small>" + StoreTerms.StockSharingStoreHelp + "</small>";

              PPnlGiftCardLength.Text = StoreTerms.Length;
              PPnlGiftCardDaysValid.Text = StoreTerms.DaysValid;
              PPnlGiftCardPrefix.Text = StoreTerms.Prefix;
              PPnlGiftCardSuffix.Text = StoreTerms.Suffix;

              PPnlEditOrderUIFile.Text = StoreTerms.EditOrderUiFile;
              PPnlTemplateRendering.Text = StoreTerms.AllowedTemplateFilesForRendering + "<br /><small>" + StoreTerms.AllowedTemplateFilesForRenderingHelp + "</small>";
        }

		///<summary></summary>
		public static void RemovePermission(long groupNum,Permissions permType) {
			if(RemotingClient.RemotingRole==RemotingRole.ClientWeb) {
				Meth.GetVoid(MethodBase.GetCurrentMethod(),groupNum,permType);
				return;
			}
			string command;
			if(permType==Permissions.SecurityAdmin){
				//need to make sure that at least one other user has this permission
				command="SELECT COUNT(*) FROM (SELECT DISTINCT grouppermission.UserGroupNum "
					+"FROM grouppermission "
					+"INNER JOIN userod ON userod.UserGroupNum=grouppermission.UserGroupNum AND userod.IsHidden=0 "
					+"WHERE PermType='"+POut.Long((int)permType)+"') t";//This query is Oracle compatable
				if(Db.GetScalar(command)=="1") {//only one, so this would delete the last one.
					throw new Exception(Lans.g("FormSecurity","There must always be at least one user in a user group that has the Security Admin permission."));
				}
			}
			command="DELETE from grouppermission WHERE UserGroupNum='"+POut.Long(groupNum)+"' "
				+"AND PermType='"+POut.Long((int)permType)+"'";
 			Db.NonQ(command);
		}

        protected override void OnInit( EventArgs e )
        {
            base.OnInit( e );

              umbraco.BusinessLogic.User currentUser = umbraco.helper.GetCurrentUmbracoUser();

              #region Security check
              currentUserPermissions = PermissionService.Instance.GetCurrentLoggedInUserPermissions();
              if ( currentUserPermissions == null || !currentUserPermissions.HasPermission( GeneralPermissionType.AccessSecurity ) ) {
            throw new SecurityException();
              } else {
            bool showUser = true;

            umbraco.BusinessLogic.User user = umbraco.BusinessLogic.User.GetUser( int.Parse( HttpContext.Current.Request.QueryString[ "id" ] ) );
            showUser = !user.IsRoot(); //Don't ever show admin user

            if ( showUser ) {
              bool showAllUsers = currentUser.IsRoot() || currentUser.Applications.Any( a => a.alias == "users" );
              showUser = showAllUsers || currentUser.Id == user.Id || ( permissions != null && currentUserPermissions.StoreSpecificPermissions.Any( p => p.Value.HasFlag( StoreSpecificPermissionType.AccessStore ) && permissions.HasPermission( StoreSpecificPermissionType.AccessStore, p.Key ) ) );
            }

            if ( !showUser ) {
              throw new SecurityException();
            }
              }
              #endregion

              AddTab( CommonTerms.Common, PnlCommon, SaveButton_Clicked );

              PPnlAccessSecurity.Text = StoreTerms.Security;
              ImgAccessSecurity.ImageUrl = WebUtils.GetWebResourceUrl( Constants.TreeIcons.Lock );
              PPnlAccessLicenses.Text = DeveloperTerms.Licenses;
              ImgAccessLicenses.ImageUrl = WebUtils.GetWebResourceUrl( Constants.TreeIcons.LicenseKey );
              PPnlCreateAndDeleteStore.Text = CommonTerms.CreateAndDeleteStore;
              ImgCreateAndDeleteStore.ImageUrl = WebUtils.GetWebResourceUrl( Constants.TreeIcons.Store );

              PnStoreSpecificPermissions.Text = CommonTerms.Stores;
              PPnlStoreSpecificPermissions.Text = CommonTerms.StoreSpecificPermissions;
        }