public CommonMessage(Msg msg, PermissionLevel level = PermissionLevel.Public) { Message = msg.Message; UserId = msg.UserId.ToString(); MessageId = msg.MessageId; PermissionLevel = level; switch (msg) { case PrivateMsg privateMsg: MessageType = MessageType.Private; Private = privateMsg; break; case DiscussMsg discussMsg: MessageType = MessageType.Discuss; Discuss = discussMsg; DiscussId = discussMsg.DiscussId.ToString(); break; case GroupMsg groupMsg: MessageType = MessageType.Group; Group = groupMsg; GroupId = groupMsg.GroupId.ToString(); break; } }
/// <summary> /// File constructor /// </summary> /// <param name="str">GUID string</param> public File(string str) { Guid guid; if (!Guid.TryParse(str, out guid)) throw new ArgumentException(); _guid = str.ToUpper(); var si = new SqlIntegrate(Utility.ConnStr); si.AddParameter("@GUID", SqlIntegrate.DataType.VarChar, str.ToUpper()); var fileInfo = si.Reader("SELECT * FROM [File] WHERE [GUID] = @GUID"); _name = fileInfo["name"].ToString(); _info = fileInfo["info"].ToString(); _extension = fileInfo["extension"].ToString(); _size = Convert.ToInt32(fileInfo["size"]); _uploader = new User(Guid.Parse(fileInfo["uploader"].ToString())); _downloadCount = Convert.ToInt32(fileInfo["downloadCount"]); _uploadTime = Convert.ToDateTime(fileInfo["uploadTime"]); _savePath = StoragePath + str.ToUpper(); _permission = (PermissionLevel)Convert.ToInt32(fileInfo["permission"]); _mediaId = fileInfo["media_id"].ToString(); Tag = new List<string>(); si.ResetParameter(); si.AddParameter("@FUID", SqlIntegrate.DataType.VarChar, str.ToUpper()); var tagList = si.Adapter("SELECT [name] FROM [Filetag] WHERE FUID = @FUID"); for (var i = 0; i < tagList.Rows.Count; i++) Tag.Add(tagList.Rows[i]["name"].ToString()); }
public void AddPermission(PermissionLevel perm) { if (!_permissions.Contains(perm)) { _permissions.Add(perm); } }
public void RemovePermission(PermissionLevel perm) { if (_permissions.Contains(perm)) { _permissions.Remove(perm); } }
public static bool HasPermissionLevel(SocketGuildUser user, PermissionLevel level) { switch (level) { case PermissionLevel.MUTED: return(IsSilenced(user)); case PermissionLevel.USER: return(!IsSilenced(user)); case PermissionLevel.TRUSTED: if (IsTrusted(user)) { return(true); } goto case PermissionLevel.MODERATOR; case PermissionLevel.MODERATOR: if (IsModerator(user)) { return(true); } goto case PermissionLevel.ADMIN; case PermissionLevel.ADMIN: if (IsAdmin(user)) { return(true); } return(false); default: return(false); } }
public static bool HasUserPermission(User user, int?CountryID, PermissionLevel requiredLevel, UserPermissionsContainer userPermissions = null) { if (user != null) { if (!String.IsNullOrEmpty(user.Permissions)) { if (userPermissions == null) { userPermissions = JsonConvert.DeserializeObject <UserPermissionsContainer>(user.Permissions); } if (userPermissions.Permissions != null) { if (userPermissions.Permissions.Any(p => p.Level == PermissionLevel.Admin && (p.CountryID == null || p.CountryID == CountryID))) { //user is admin (for given country or all countries) return(true); } if (userPermissions.Permissions.Any(p => p.Level == requiredLevel && (p.CountryID == null || p.CountryID == CountryID))) { //user has required level of access (for given country or all countries) return(true); } } } } return(false); }
public static bool HasUserPermission(User user, int? CountryID, PermissionLevel requiredLevel, UserPermissionsContainer userPermissions = null) { if (user != null) { if (!String.IsNullOrEmpty(user.Permissions)) { if (userPermissions == null) { userPermissions = JsonConvert.DeserializeObject<UserPermissionsContainer>(user.Permissions); } if (userPermissions.Permissions != null) { if (userPermissions.Permissions.Any(p => p.Level == PermissionLevel.Admin && (p.CountryID == null || p.CountryID == CountryID))) { //user is admin (for given country or all countries) return true; } if (userPermissions.Permissions.Any(p => p.Level == requiredLevel && (p.CountryID == null || p.CountryID == CountryID))) { //user has required level of access (for given country or all countries) return true; } } } } return false; }
public async Task SetPermissionAsync(string commandName, PermissionLevel level) { var competition = Service.GetOrCreateCompetition(Context.Guild.Id); var match = CommandService.Commands.FirstOrDefault(x => x.Name.Equals(commandName, System.StringComparison.OrdinalIgnoreCase) || x.Aliases.Any(a => a.Equals(commandName, System.StringComparison.OrdinalIgnoreCase))); if (match == null) { await SimpleEmbedAsync("Unknown command name.", Color.Red); return; } if (!match.Preconditions.Any(x => x is RequirePermission)) { await SimpleEmbedAsync("This command cannot have it's permission overwritten."); return; } competition.Permissions[match.Name.ToLower()] = level; Service.PermissionCache[Context.Guild.Id] = new ELOService.CachedPermission { AdminRoleId = competition.AdminRole, ModeratorRoleId = competition.ModeratorRole, CachedPermissions = competition.Permissions }; Service.SaveCompetition(competition); await SimpleEmbedAsync($"{match.Name} permission level set to: {level}", Color.Blue); }
/// <summary> /// Проверить входные параметры SetInspection. /// </summary> /// <param name="login">Логин проверяющего</param> /// <param name="assignDate">Дата операции</param> /// <param name="timeZone">Часовой пояс проверяющего</param> private void SetInspectionCheckParams(string login, DateTime assignDate, int timeZone) { if (string.IsNullOrEmpty(login)) { LogAndThrowException <ArgumentNullException, EFServiceInspecting>( _Logger, nameof(login), "Не задан логин проверяющего сотрудника./* Метод {methodName}.*/", "SetInspectionCheckParams"); } if (assignDate == default) { LogAndThrowException <ArgumentNullException, EFServiceInspecting>( _Logger, nameof(assignDate), "Не задана дата операции./* Метод {methodName}.*/", "SetInspectionCheckParams"); } if (timeZone == default) { LogAndThrowException <ArgumentNullException, EFServiceInspecting>( _Logger, nameof(timeZone), "Не задан часовой пояс проверяющего./* Метод {methodName}.*/", "SetInspectionCheckParams"); } if (PermissionLevel.Get(login) != PermissionLevelE.Security) { LogAndThrowException <Exception, EFServiceInspecting>( _Logger, "", "У пользователя нет прав осуществлять проверку./* Метод {methodName}, пользователь {login}.*/", "SetInspectionCheckParams", login); } }
public virtual async Task SetPermissionAsync(string commandName, PermissionLevel level) { using (var db = new Database()) { var match = CommandService.Commands.FirstOrDefault(x => x.Name.Equals(commandName, System.StringComparison.OrdinalIgnoreCase) || x.Aliases.Any(a => a.Equals(commandName, System.StringComparison.OrdinalIgnoreCase))); if (match == null) { await SimpleEmbedAsync("Unknown command name.", Color.Red); return; } if (!match.Preconditions.Any(x => x is RequirePermission)) { await SimpleEmbedAsync("This command cannot have it's permission overwritten."); return; } var permission = new CommandPermission { GuildId = Context.Guild.Id, CommandName = match.Name.ToLower(), Level = level }; db.Permissions.Add(permission); if (PermissionService.PermissionCache.TryGetValue(Context.Guild.Id, out var cache)) { cache.Cache.Remove(match.Name.ToLower()); } db.SaveChanges(); await SimpleEmbedAsync($"{match.Name} permission level set to: {level}", Color.Blue); } }
private void ClientOnGetAllSecurityGroupsCompleted(object sender, GetAllSecurityGroupsCompletedEventArgs e) { if (!e.Result.HasError) { foreach (var pair in e.Result.Result) { SecurityGroups.Add(PermissionLevel.Convert(pair.Key), pair.Value); } foreach (var valuePair in SecurityGroups) { foreach (var item in valuePair.Value) { if (AllSecurityGroups.All(q => q.GroupId != item.GroupId)) { AllSecurityGroups.Add(item); } } } MapManager.QueryDomainsCompleted.RegisterEvent(OnAcquireDomainsCompleted); MapManager.QueryDomainsAsync(); } else { SuperMessageBoxService.ShowError("Error Occurred", "An error occurred while retrieving the groups with Glyma permissions.", Close); } }
private ExternalUser ApplyPermission(MailboxSession mailboxSession, SmtpAddress smtpAddress, SharingContext context) { ExternalUser externalUser = null; ExternalUser externalUser2; using (ExternalUserCollection externalUsers = mailboxSession.GetExternalUsers()) { externalUser2 = externalUsers.FindReachUserWithOriginalSmtpAddress(smtpAddress); externalUser = externalUsers.FindFederatedUserWithOriginalSmtpAddress(smtpAddress); if (externalUser2 == null) { externalUser2 = externalUsers.AddReachUser(smtpAddress); externalUsers.Save(); } } using (FolderPermissionContext current = FolderPermissionContext.GetCurrent(mailboxSession, context)) { FreeBusyAccess freeBusy = this.GetFreeBusy(context); PermissionSecurityPrincipal principal = new PermissionSecurityPrincipal(externalUser2); PermissionLevel permissionLevel = (context.SharingDetail == SharingContextDetailLevel.FullDetails) ? PermissionLevel.Reviewer : PermissionLevel.None; current.AddOrChangePermission(principal, permissionLevel, new FreeBusyAccess?(freeBusy)); if (externalUser != null) { current.RemovePermission(new PermissionSecurityPrincipal(externalUser)); } } return(externalUser2); }
private void LoadAdmin() { panModifyUser.Visibility = Visibility.Hidden; //Hide the modification panels as they are not needed yet panModifyFarm.Visibility = Visibility.Hidden; // lstFarms.Items.Clear(); //Clean the list views lstUsers.Items.Clear(); // cboModuserRoles.Items.Clear(); //Clean the combo boxes associated with modifying the users/farms cboModuserfarmlist.Items.Clear(); // foreach (User u in DownloadData.GetAllUsers()) //get all users currently on server { lstUsers.Items.Add(u); //add them into the list view } cboModuserfarmlist.Items.Add("NONE"); //Make the default/first option be nil foreach (FullFarm ff in DownloadData.GetAllFullFarms()) //get all farms currently on server { lstFarms.Items.Add(ff); //add the farms into the list view cboModuserfarmlist.Items.Add(ff.name); //add the farm names into the combo box on modifying farms panel } for (PermissionLevel p = PermissionLevel.Admin; p < PermissionLevel.Guest + 1; p++) //increment through all the roles possible { cboModuserRoles.Items.Add(p); //add the roles to the combo box for the user to select on modify user } }
/// <summary> /// Event that occurs when the login button is pressed on the Login form /// </summary> /// <param name="email">the input email</param> /// <param name="password">the hashed input password</param> /// <param name="f">reference to the login form</param> void HandleLoginButton(string email, string password, Form f) { userEmail = email; userPermissionLevel = PermissionLevel.Invalid; connection.Send(new LoginRequest(email, password)); }
/** * Basic constructor for User * * @param permissionLevel * The permission level of the user * @param branch * The branch of the military this user is playing for * @param team * The team that this user logs onto * @param username * The name of the user * @param unit * null for non-sub players * The GUID/NetworkID of the sub controlled by this player. */ public User(PermissionLevel permissionLevel, MilitaryBranch branch, int team, string username, string unit) { // Set the permission level MyPermissionLevel = permissionLevel; // Set the military branch MyBranch = branch; // Set the team TeamNumber = team; // Set the username Username = username; // Check if there is not an associated sub if (unit == null) { // If there is not // Set sub player to false SubPlayer = false; } else { // If there is an associated sub // Set sub player to true SubPlayer = true; // Record the GUID/NetworkID of the Sub SubUnit = unit; } }
public static MemberRights GetMemberRights(PermissionLevel permissionLevel) { switch (permissionLevel) { case PermissionLevel.None: return(MemberRights.None); case PermissionLevel.Owner: return(MemberRights.ReadAny | MemberRights.Create | MemberRights.EditOwned | MemberRights.DeleteOwned | MemberRights.EditAny | MemberRights.DeleteAny | MemberRights.CreateSubfolder | MemberRights.Owner | MemberRights.Contact | MemberRights.Visible); case PermissionLevel.PublishingEditor: return(MemberRights.ReadAny | MemberRights.Create | MemberRights.EditOwned | MemberRights.DeleteOwned | MemberRights.EditAny | MemberRights.DeleteAny | MemberRights.CreateSubfolder | MemberRights.Visible); case PermissionLevel.Editor: return(MemberRights.ReadAny | MemberRights.Create | MemberRights.EditOwned | MemberRights.DeleteOwned | MemberRights.EditAny | MemberRights.DeleteAny | MemberRights.Visible); case PermissionLevel.PublishingAuthor: return(MemberRights.ReadAny | MemberRights.Create | MemberRights.EditOwned | MemberRights.DeleteOwned | MemberRights.CreateSubfolder | MemberRights.Visible); case PermissionLevel.Author: return(MemberRights.ReadAny | MemberRights.Create | MemberRights.EditOwned | MemberRights.DeleteOwned | MemberRights.Visible); case PermissionLevel.NonEditingAuthor: return(MemberRights.ReadAny | MemberRights.Create | MemberRights.DeleteOwned | MemberRights.Visible); case PermissionLevel.Reviewer: return(MemberRights.ReadAny | MemberRights.Visible); case PermissionLevel.Contributor: return(MemberRights.Create | MemberRights.Visible); default: throw new EnumOutOfRangeException("PermissionLevel", ServerStrings.BadEnumValue(typeof(PermissionLevel))); } }
internal void AddOrChangePermission(PermissionSecurityPrincipal principal, PermissionLevel permissionLevel, FreeBusyAccess?freeBusyAccess) { this.CheckDisposed(); Util.ThrowOnNullArgument(principal, "principal"); Permission permission; if (freeBusyAccess == null) { permission = new Permission(principal, MemberRights.None); } else { permission = new CalendarFolderPermission(principal, MemberRights.None) { FreeBusyAccess = freeBusyAccess.Value }; } permission.PermissionLevel = permissionLevel; if (freeBusyAccess != null) { permission.MemberRights |= MemberRights.Visible; } if (this.permissionsToRemove.Remove(principal)) { ExTraceGlobals.SharingTracer.TraceDebug <IExchangePrincipal, PermissionSecurityPrincipal>((long)this.GetHashCode(), "{0}: Removed {1} from permissionsToRemove list.", this.mailboxSession.MailboxOwner, principal); } if (!this.permissionsToAddOrChange.ContainsKey(principal)) { this.permissionsToAddOrChange.Add(principal, permission.MemberRights); ExTraceGlobals.SharingTracer.TraceDebug <IExchangePrincipal, PermissionSecurityPrincipal, MemberRights>((long)this.GetHashCode(), "{0}: Added {1} to permissionsToAddOrChange list: MemberRights = {2}.", this.mailboxSession.MailboxOwner, principal, permission.MemberRights); return; } this.permissionsToAddOrChange[principal] = permission.MemberRights; ExTraceGlobals.SharingTracer.TraceDebug <IExchangePrincipal, PermissionSecurityPrincipal, MemberRights>((long)this.GetHashCode(), "{0}: Changed {1} in permissionsToAddOrChange list: MemberRights = {2}.", this.mailboxSession.MailboxOwner, principal, permission.MemberRights); }
//----------------------------------------------------------------------------- Permission queries private IEnumerable <Node> GetRelatedIdentitiesPrivate(string contentPath, PermissionLevel level, IdentityKind identityKind) { if (level != PermissionLevel.AllowedOrDenied) { throw new NotImplementedException("Not implemented. Use 'AllowedOrDenied'"); } var firstPermInfo = GetFirstInfo(contentPath); var identityIds = new List <int>(); if (contentPath == firstPermInfo.Path) { SearchRelatedIdentitiesInTree(level, identityKind, firstPermInfo, identityIds); } else { var contentPathSlash = contentPath + "/"; foreach (var childPi in firstPermInfo.Children) { if (childPi.Path == contentPath || childPi.Path.StartsWith(contentPathSlash)) { SearchRelatedIdentitiesInTree(level, identityKind, childPi, identityIds); } } } var identities = new NodeList <Node>(identityIds); return(Filter(identities, identityKind)); }
private void SearchRelatedIdentitiesInTree(PermissionLevel level, PermissionInfo node, IdentityKind identityKind, List <int> ids, int permissionMask) { // if breaked, adding existing parent-s effective identities if (!node.Inherits) { if (node.Parent != null) { foreach (var entry in GetEffectiveEntries(node.Parent.Path)) { if (!ids.Contains(entry.PrincipalId)) { ids.Add(entry.PrincipalId); } } } } // adding explicite identities recursive foreach (var ps in node.PermissionSets) { if (((ps.AllowBits | ps.DenyBits) & permissionMask) != 0) { if (!ids.Contains(ps.PrincipalId)) { ids.Add(ps.PrincipalId); } } } foreach (var childNode in node.Children) { SearchRelatedIdentitiesInTree(level, childNode, identityKind, ids, permissionMask); } }
public string CreateAuthenticationUrl(PermissionLevel permissionLevel, string frob) { var permissionName = _permissionLevelConverter.ToString(permissionLevel); var authUrlBuilder = _urlBuilderFactory.CreateAuthUrlBuilder(permissionName, frob); return(authUrlBuilder.BuildUrl()); }
public PermissionAttribute( PermissionType[] permissionTypes, PermissionLevel permissionLevel) { _permissionTypes = permissionTypes.ToList(); _permissionLevel = permissionLevel; }
private void GetUsersPermissionLevelNameCompleted(object sender, GetUsersPermissionLevelNameCompletedEventArgs e) { if (!e.Result.HasError) { var permission = PermissionLevel.Convert(e.Result.Result); App.PermissionLevel = permission; if (permission != PermissionLevel.None) { SuperGraph.ExplorerOnly = permission < PermissionLevel.Author; DebugLogger.Instance.LogMsg("User Permission Loaded: " + permission); if (IsLoadMapByGuid) { DebugLogger.Instance.LogMsg(string.Format("Loading map through URL: NodeId[{0}],MapId[{1}],DomainId[{2}]", NodeId, MapId, DomainId)); PreLoader.ReadyToInitialiseControllers += OnReadyToInitialiseControllers; PreLoader.Load(DomainId, NodeId, MapId); } else { Loader.Visibility = Visibility.Collapsed; HomeScreen(); } } else { SuperMessageBoxService.Show("Access Denied", "It seems that you don't have permission to access Glyma, please contact your system administrator for assistance.", MessageBoxType.ErrorWithNoInput); } } else { SuperMessageBoxService.ShowError("Error Occurred", "There was a problem reading Glyma permissions, please try again later"); } }
private void ClientOnGetHighestPermissionNameCompleted(object sender, GetPermissionNameForObjectCompletedEventArgs e) { var item = DataContext as IManagementConsoleObject; if (!e.Result.HasError && item != null) { var id = sender as Guid?; if (id != null && id == item.Id) { item.CurrentUserPermissionLevel = PermissionLevel.Convert(e.Result.Result); //todo: if the user is security manager, needs to be returned as well if (item.CurrentUserPermissionLevel >= PermissionLevel.Author || App.PermissionLevel == PermissionLevel.SecurityManager) { NewMapButton.IsEnabled = true; if (item.CurrentUserPermissionLevel >= PermissionLevel.MapManager || App.PermissionLevel == PermissionLevel.SecurityManager) { DeleteButton.IsEnabled = true; } } if (App.PermissionLevel != PermissionLevel.SecurityManager) { item.IsLoaded = true; } } } else { SuperMessageBoxService.ShowError("Error Occurred", "There was a problem reading Glyma permissions, please try again later"); } }
/* ----------------------------------------------------------------------------------- * Create new an EmrDocument. * Parameter: * registryID -- The registry identifier of a patient for a visit to the hospital. * permission -- The current operator has what privilege on this EmrDocument. * Attributes: * inUse directs that the array element is in use. * inNew directs that the document has not been created and is empty. * Return: * index -- Direct to the new EmrDocument if successful. * -1 -- No new EmrDocument is created. * ------------------------------------------------------------------------------------- */ public int open(string registryID, PermissionLevel permission, string archiveNum) { int index = AvailableIndex(); if (index < 0) { return(-1); } if (emrDocuments[index] == null) { emrDocuments[index] = new EmrDocument(); } int errno = emrDocuments[index].Create(registryID, archiveNum); if (errno == 0 || errno == -3) { inUse[index] = true; permissionLevel[index] = permission; if (errno == -3) { permissionLevel[index] = PermissionLevel.ReadOnly; } if (emrDocuments[index].Get().DocumentElement.Attributes[AttributeNames.Series].Value == "0") { isNew[index] = true; } else { isNew[index] = false; } return(index); } return(errno); }
/// <summary> /// Valida si un objeto tipo PermissionLevel con los filtros actuales /// </summary> /// <param name="permissionLevel">Objeto a validar</param> /// <returns>True. Si cumple | False. No cumple</returns> /// <history> /// [emoguel] created 11/04/2016 /// </history> private bool ValidateFilter(PermissionLevel permissionLevel) { if (_nStatus != -1)//Filtro por estatus { if (permissionLevel.plA != Convert.ToBoolean(_nStatus)) { return(false); } } if (_permissionLevelFilter.plID > 0)//FIltro por ID { if (permissionLevel.plID != _permissionLevelFilter.plID) { return(false); } } if (!string.IsNullOrWhiteSpace(_permissionLevelFilter.plN))//filtro por descripción { if (!permissionLevel.plN.Contains(_permissionLevelFilter.plN, StringComparison.OrdinalIgnoreCase)) { return(false); } } return(true); }
/// <summary> /// Muestra la ventana detalle /// </summary> /// <history> /// [emoguel] 11/04/2016 Created /// </history> private void Cell_DoubleClick(object sender, RoutedEventArgs e) { PermissionLevel permissionLevel = (PermissionLevel)dgrPermissionsLevels.SelectedItem; frmPermissionLevelDetail frmPermissionLevelDetail = new frmPermissionLevelDetail(); frmPermissionLevelDetail.Owner = this; frmPermissionLevelDetail.enumMode = EnumMode.Edit; frmPermissionLevelDetail.oldPermissionLevel = permissionLevel; if (frmPermissionLevelDetail.ShowDialog() == true) { int nIndex = 0; List <PermissionLevel> lstPermissionsLevels = (List <PermissionLevel>)dgrPermissionsLevels.ItemsSource; if (ValidateFilter(frmPermissionLevelDetail.permissionLevel)) { ObjectHelper.CopyProperties(permissionLevel, frmPermissionLevelDetail.permissionLevel); //Actualizamos los datos lstPermissionsLevels.Sort((x, y) => string.Compare(x.plN, y.plN)); //ordenamos la lista nIndex = lstPermissionsLevels.IndexOf(permissionLevel); //obtenemos la posición } else { lstPermissionsLevels.Remove(permissionLevel); //Elminamos el registro } dgrPermissionsLevels.Items.Refresh(); //actualizamos la lista GridHelper.SelectRow(dgrPermissionsLevels, nIndex); //seleccionamos el registro StatusBarReg.Content = lstPermissionsLevels.Count + " Permission Levels."; } }
public static bool IsAuthorized(PermissionLevel permission, User user) { if (permission == PermissionLevel.None) return true; return IsRegistered(user) != null && IsAuthorised(permission, IsRegistered(user)); }
private void WebSocketServer_NewSessionConnected(WebSocketSession session) { PermissionLevel defaultPermission = (PermissionLevel)config["defaultpermission"].Value <int>(); while (!clients.TryAdd(session.SessionID, (PermissionLevel)config["defaultpermission"].Value <int>())) { Thread.Sleep(1); } session.Send(new WebSocketPackets.InfoPacket() { Level = defaultPermission }.SerializeJson()); if (defaultPermission >= PermissionLevel.Workers) { session.Send(new WebSocketPackets.GeneralInfoPacket() { TasksCount = dataController.TaskQueueGetCount(), WorkerCount = workers.Count }.SerializeJson()); session.Send(new WebSocketPackets.StartCPanelPacket() { Workers = workers.Values.Select(x => new WebSocketPackets.WorkerInfo() { WorkerProgress = x.LastProgress, WorkerId = x.GetId(), WorkerStatus = x.Status, WorkerSystem = x.System, CurrentTask = (defaultPermission < PermissionLevel.WorkersTasks ? null : (dataController.CurrentTasksGetByKey(x.GetId()) != null ? new WebSocketPackets.TaskInfo(dataController.CurrentTasksGetByKey(x.GetId()), WebSocketPackets.TaskStatus.Processing) : null)) }).ToArray(), ReadyTasks = dataController.ReadyTasksGetAll().Select(x => new WebSocketPackets.TaskInfo(x, WebSocketPackets.TaskStatus.Ready)).ToArray(), InQueueTasks = dataController.TaskQueueGetAll().Select(x => new WebSocketPackets.TaskInfo(x, WebSocketPackets.TaskStatus.InQueue)).ToArray() }.SerializeJson()); } }
public async Task GetAllListsAsync_SufficientPermissions_ReturnsRtmLists(PermissionLevel permissionLevel) { // Setup var expectedLists = new List <IRtmList> { Substitute.For <IRtmList>() }; var fakeAuthToken = new AuthenticationToken { Id = "My Fake Token ID", Permissions = permissionLevel }; const string fakeListsUrl = "My Fake URL"; var fakeUrlFactory = Substitute.For <IListsUrlFactory>(); fakeUrlFactory.CreateGetListsUrl(fakeAuthToken.Id).Returns(fakeListsUrl); var fakeResponseData = new GetListResponseData(); var fakeApiClient = Substitute.For <IApiClient>(); fakeApiClient.GetAsync <GetListResponseData>(fakeListsUrl).Returns(Task.FromResult(fakeResponseData)); var fakeResponseParser = Substitute.For <IResponseParser>(); fakeResponseParser.GetLists(fakeResponseData).Returns(expectedLists); // Execute var listRepository = GetItemUnderTest(fakeUrlFactory, fakeApiClient, fakeResponseParser, fakeAuthToken); var actual = await listRepository.GetAllListsAsync().ConfigureAwait(false); // Verify Assert.AreSame(expectedLists, actual); }
public static string GetCalendarPermissionsLog(MailboxSession mailboxSession, Folder folder) { if (mailboxSession == null || folder == null) { return(string.Empty); } SecurityIdentifier arg = IdentityHelper.SidFromLogonIdentity(mailboxSession.Identity); StringBuilder stringBuilder = new StringBuilder(); stringBuilder.Append(string.Format("Folder Name: {0} Security Descriptor: {1}\n", folder.DisplayName, arg)); PermissionSet permissionSet = folder.GetPermissionSet(); if (permissionSet.AnonymousPermission != null) { PermissionLevel permissionLevel = permissionSet.AnonymousPermission.PermissionLevel; MemberRights memberRights = permissionSet.AnonymousPermission.MemberRights; stringBuilder.Append(string.Format("Anonymous Permission:{0} Member Rights:{1}", permissionLevel, memberRights)); } if (permissionSet.DefaultPermission != null) { PermissionLevel permissionLevel2 = permissionSet.DefaultPermission.PermissionLevel; MemberRights memberRights2 = permissionSet.DefaultPermission.MemberRights; stringBuilder.Append(string.Format("\nDefault Permission:{0} Member Rights:{1}", permissionLevel2, memberRights2)); } foreach (Permission permission in permissionSet) { MemberRights memberRights3 = permission.MemberRights; PermissionLevel permissionLevel3 = permission.PermissionLevel; if (permission.Principal != null) { string text = permission.Principal.ToString(); string text2 = permission.Principal.Type.ToString(); if (permission.Principal.Type == PermissionSecurityPrincipal.SecurityPrincipalType.ADRecipientPrincipal) { if (permission.Principal.ADRecipient != null) { SmtpAddress primarySmtpAddress = permission.Principal.ADRecipient.PrimarySmtpAddress; text = permission.Principal.ADRecipient.PrimarySmtpAddress.ToString(); } } else if (permission.Principal.Type == PermissionSecurityPrincipal.SecurityPrincipalType.SpecialPrincipal) { text2 = permission.Principal.SpecialType.ToString(); } stringBuilder.Append(string.Format("\nPermission:{0} UserType:{1} User:{2} Member Rights:{3}", new object[] { permissionLevel3, text2, text, memberRights3 })); } else { stringBuilder.Append(string.Format("\nPermission:{0} UserType:'Unknown' User:'******' Member Rights:{1}", permissionLevel3, memberRights3)); } } return(stringBuilder.ToString()); }
public string GetSharePointFaqPageWithAnchor(PermissionLevel permissionLevel) { return(permissionLevel switch { PermissionLevel.ReadOnly => $"{_externalLinks.SharePointFAQPage}#why-do-i-not-have-permission-to-edit-a-record", PermissionLevel.None => $"{_externalLinks.SharePointFAQPage}#why-can’t-i-view-the-full-details-of-a-record", _ => null });
private static bool IsWritePermission(PermissionLevel permission) { if (permission == PermissionLevel.Read) { return(false); } return(permission != PermissionLevel.ReadAcl); }
protected AccountBasedManagement(IDatabaseContext context, int personId, int accountId) : base(context, personId) { var permission = MyPermissions.Single(x => x.Key.Id == accountId); AccountGroup = permission.Key; AccountGroupPermission = permission.Value; }
/// <summary> /// Initializes a new instance of the <see cref="CommandModel" /> class. /// </summary> /// <param name="familiarName"> /// The familiar name. /// </param> /// <param name="serverName"> /// The server name. /// </param> /// <param name="paramaterNames"> /// The paramater names. /// </param> /// <param name="typeOfCommand"> /// The type of command. /// </param> /// <param name="permissionLevel"> /// The permission level. /// </param> public CommandModel( string familiarName, string serverName, IList<string> paramaterNames = null, CommandTypes typeOfCommand = CommandTypes.SingleSentence, PermissionLevel permissionLevel = PermissionLevel.User) { this.familiarName = familiarName; ServerName = serverName; CommandType = typeOfCommand; PermissionsLevel = permissionLevel; ArgumentNames = paramaterNames; }
public static void CreateDynCommands(this ModuleManager manager, string prefix, PermissionLevel defaultPermissionsLevel, Action<CommandGroupBuilder> builder) { CommandService commandService = manager.Client.GetService<CommandService>(); commandService.CreateGroup(prefix, x => { x.Category(manager.Name); x.AddCheck((ModuleChecker) Activator.CreateInstance(typeof (ModuleChecker), _moduleCheckerActivatorFlags, null, new object[] {manager}, null)); x.MinDynPermissions((int) defaultPermissionsLevel); builder(x); }); }
private static FileSystemRights GetRightsFromPermissionLevel(PermissionLevel level) { if (level == PermissionLevel.Full) return FileSystemRights.FullControl; if (level == PermissionLevel.Modify) return FileSystemRights.Modify; if (level == PermissionLevel.Write) return FileSystemRights.Write; if (level == PermissionLevel.ReadAndExecute) return FileSystemRights.ReadAndExecute; return FileSystemRights.Read; }
public void RemovePermission(PermissionLevel perm) { if (_permissions.Contains(perm)) _permissions.Remove(perm); }
public void AddPermission(PermissionLevel perm) { if (!_permissions.Contains(perm)) _permissions.Add(perm); }
/// <summary> /// Check whether a user has the permission to a file (static function) /// </summary> /// <param name="permission">Permission setting</param> /// <param name="uuid">UUID (of uploader)</param> /// <param name="group">Group (of uploader)</param> /// <param name="user">User (current one most possibly)</param> /// <returns>whether a user has the permission to a file</returns> public static bool Visible(PermissionLevel permission, string uuid, int group, User user) { if (uuid == user.UUID) return true; switch (permission) { case PermissionLevel.All: return true; case PermissionLevel.SelfGroupOnly: if (group == user.Group) return true; break; case PermissionLevel.SeniorTwoOnly: if (user.Senior == 2) return true; break; case PermissionLevel.ImptMembOnly: if (user.IsExecutive) return true; break; default: return false; } return false; }
private bool CheckLogin(string login, string password) { //this.statusbarLogin.Text = "ChristianT"; //return true; //ConfigurationSettings config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None).AppSettings.Set; //System.Configuration.Configuration config = System.Configuration.ConfigurationManager.OpenExeConfiguration(System.Configuration.ConfigurationUserLevel.None); //TeamManagement_Tool.Properties.Settings.Default; // System.Configuration.ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); //Configuration config = ConfigurationManager.OpenMappedExeConfiguration( //Configuration config = Configuration try { MySqlCommand sqlCmd = new MySqlCommand("Select Password,PermissionLevel from User where login = '******'", sqlConnection); sqlConnection.Open(); MySqlDataReader sqlRead = sqlCmd.ExecuteReader(); //if (sqlRead.Read()) { Console.WriteLine("Eingabe = " + MD5_Crypto.GetMd5Hash(password)); //Console.WriteLine("Gespeichert = " + sqlRead.GetValue(0).ToString()); //if (sqlRead.Read() && sqlRead.GetValue(0).ToString() == password) if (sqlRead.Read() && sqlRead.GetValue(0).ToString() == MD5_Crypto.GetMd5Hash(password)) { this.statusbarLogin.Text = login; currentPermission = (PermissionLevel)sqlRead.GetInt32("PermissionLevel"); this.statusbarPermission.Text = Enum.GetName(typeof(PermissionLevel), currentPermission); sqlRead.Close(); sqlConnection.Close(); return true; } else { sqlRead.Close(); sqlConnection.Close(); } /*} else { sqlRead.Close(); sqlCon.Close(); }*/ return false; } catch (MySqlException e) { MessageBox.Show(e.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Stop); return false; } }
public Task ChangePermissionLevel(IBoardId board, PermissionLevel permissionLevel) { return _restClient.RequestAsync(new BoardsChangePermissionLevelRequest(board, permissionLevel)); }
public static void SetFilePermission(string path, string accountName, PermissionLevel permissionLevel) { AddFileSecurity(path, accountName, GetRightsFromPermissionLevel(permissionLevel)); }
public static bool IsAuthorised(PermissionLevel level, ChatUser user) { return level == user.PermissionLevel; }
/// <summary> /// A new bot Command with the permissionLevel permissionLevel, and the evaluate action of action /// </summary> public BotCommand(PermissionLevel permissionLevel, string helpText, Action<CommandArgs> action) { PermissionLevel = permissionLevel; HelpText = helpText; Action = action; }
public Permission(string node, string description, PermissionLevel level) { this.node = node.ToLower(); this.description = description; this.level = level; }
public Permission(string node) { this.node = node.ToLower(); this.description = null; this.level = PermissionLevel.All; }
private void LoadPermissionlevels() { _groupServiceAgent.GetPermissionLevels((roleDefs, e) => { _dispatcher.BeginInvoke(new Action(() => { if (roleDefs != null && roleDefs.Count > 0) { EditGroupPermissionLevels.Clear(); foreach (RoleDefinition r in roleDefs) { PermissionLevel p = new PermissionLevel() { Description = r.Description, Mask = r.Id, LevelName = r.Name, IsEditable = !r.Hidden, IsLevelEnabled = !r.Hidden }; EditGroupPermissionLevels.Add(p); } if (EditGroupPermissionLevels != null && EditGroupPermissionLevels.Count > 0) { NewGroupPermissionLevels.Clear(); foreach (PermissionLevel p in EditGroupPermissionLevels) { if (p.IsLevelEnabled == true) //Add only non-Hidden { NewGroupPermissionLevels.Add(p); } } } } })); }); }
public AdaCommand(bool isCommand, PermissionLevel permission, Action<string, string, User, Room, Client> action) { IsCommand = isCommand; Action = action; permissionLevel = permission; }
public BoardsChangePermissionLevelRequest(IBoardId board, PermissionLevel permissionLevel) : base(board, "prefs/permissionLevel", Method.PUT) { this.AddValue(permissionLevel.ToTrelloString()); }
public static void SetDirectoryPermission(string path, string accountName, PermissionLevel permissionLevel) { AddDirectorySecurity(path, accountName, GetRightsFromPermissionLevel(permissionLevel)); }
public Certificate() { this.permissionLevelField = PermissionLevel.limitedOrElevated; }
public void ChangePermissionLevel(IBoardId board, PermissionLevel permissionLevel) { _restClient.Request(new BoardsChangePermissionLevelRequest(board, permissionLevel)); }