public void UpdateProcessPermissions(string userName)
{
// Create instance of the Permissions and ProcSetPermissions class
Permissions permissions = new Permissions();
ProcSetPermissions procPermissions = new ProcSetPermissions();
// Set the required permission properties
procPermissions.ProcSetID = 1;
procPermissions.UserName = userName;
procPermissions.Admin = true;
procPermissions.Start = true;
procPermissions.View = false;
procPermissions.ViewPart = false;
procPermissions.ServerEvent = false;
// Add the ProcSetPermissions object to the Permissions object
permissions.Add(procPermissions);
// Multiple permissions can also be added
// for other process sets
ProcSetPermissions procPerms2 = new ProcSetPermissions();
procPerms2.ProcSetID = 2;
procPerms2.UserName = userName;
procPerms2.Admin = true;
procPerms2.Start = true;
procPerms2.View = false;
procPerms2.ViewPart = false;
procPerms2.ServerEvent = false;
permissions.Add(procPerms2);
// Update the permissions
bool updated = ManagementServer.UpdateUserPermissions(userName, permissions);
}
private void GetAllPermissions()
{
if (Permissions == null)
{
Permissions = new BindingList <Permission>();
}
IList <Permission> perms = repos.PermissionRepo.GetAll();
foreach (var p in perms)
{
string id = "SecurityPrivilege_" + p.Name;
StringResource?res = Program.LanguageManager.FindById(typeof(StringResources), id);
if (res != null)
{
p.NameTranslation = Program.LanguageManager.GetString((StringResource)res);
}
else
{
var ex = new ApplicationException("No resource description defined for " + id);
log.Error(ex.Message);
throw ex;
}
Permissions.Add(p);
}
}
/// <summary>
/// Add a permission to the permissions list
/// </summary>
public void addPermission(string permission)
{
if (Permissions != null)
{
Permissions.Add(permission);
}
}
public bool HasPermission(string key)
{
key = key.ToUpper();
if (UserPermissions.Contains(key))
{
return(true);
}
if (Permissions.Contains(key))
{
return(false);
}
var query = DataQuery.Create("Security", "ws_Permissions_Create", new { Key = key });
var ds = this.Execute(query);
if (ds == null)
{
UI.ShowError(this.LastError);
}
Permissions.Add(key);
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="permission"></param>
public void Add(UserPermission permission)
{
if (!Permissions.ContainsKey(permission.Name))
{
Permissions.Add(permission.Name, permission);
}
}
/// <summary>
/// Add Permission to a group for a product and object
/// </summary>
/// <param name="pProduct"></param>
/// <param name="pObj"></param>
/// <param name="pPermission"></param>
/// <param name="pGroup"></param>
/// <remarks></remarks>
/// <returns>A boolean meaning if the group have permission</returns>
public bool AddPermission(string pProduct, string pObj, string pPermission, string pGroup)
{
//--- Check if Permissions is not null ----------------
if (Permissions == null)
{
Permissions = new Dictionary <string, Dictionary <string, Dictionary <string, Dictionary <string, HashSet <string> > > > >();
}
//--- Check if we have the product -----------
if (!Permissions.ContainsKey(pProduct))
{
Permissions.Add(pProduct, new Dictionary <string, Dictionary <string, Dictionary <string, HashSet <string> > > >());
}
//--- Check if we have the object ------------
if (!Permissions[pProduct].ContainsKey(pObj))
{
Permissions[pProduct].Add(pObj, new Dictionary <string, Dictionary <string, HashSet <string> > >());
}
//--- Check if we have the permission --------
if (!Permissions[pProduct][pObj].ContainsKey(pPermission))
{
Permissions[pProduct][pObj].Add(pPermission, new Dictionary <string, HashSet <string> >());
}
//--- Check if we have the group -------------
if (!Permissions[pProduct][pObj][pPermission].ContainsKey(pGroup))
{
Permissions[pProduct][pObj][pPermission].Add(pGroup, null);
}
return(true);
}
private void AddPermission(Permission permission)
{
Permissions.Add(permission);
using (con = new SQLiteConnection(connectionString))
{
con.Open();
try
{
using (SQLiteCommand insertSQL = con.CreateCommand())
{
insertSQL.CommandText = "INSERT INTO Uprawnienia(IdUprawnienia, NazwaUprawnienia) VALUES (@id,@name)";
insertSQL.Parameters.Add(new SQLiteParameter("@id", SqlDbType.Int)
{
Value = permission.Id
});
insertSQL.Parameters.AddWithValue("@name", permission.Name);
insertSQL.ExecuteNonQuery();
}
con.Close();
}
catch (Exception ex)
{
MessageBox.Show("Błąd połączenia z bazą: " + ex);
}
}
}
private void ProcessLoginResponse(JToken jt)
{
//Response for login request. We have to also check authorization for trading
bool ok = jt["result"].Value <string>("tag") == "ok";
//Handle the messages enqueued for not being logged in yet
if (ok)
{
Permissions.Clear();
foreach (var permission in jt["result"]["value"]["permissions"])
{
Permissions.Add(permission.ToString());
}
LoggedIn = true;
while (_queuedMessages.Count > 0)
{
string msgOut = _queuedMessages[0];
_queuedMessages.RemoveAt(0);
Send(msgOut);
}
}
else
{
LoggedIn = false;
}
}
public AdminUser(long userid, int coins = 0, bool IsSubscribe = false) : base(userid, coins, IsSubscribe)
{
Permissions.Add("commandpermission.admin.addhomework");
Permissions.Add("commandpermission.admin.edithomework");
Permissions.Add("commandpermission.admin.deletehomework");
Permissions.Add("commandpermission.admin.shopitem");
}
public void AddPermission(string permission)
{
if (Permissions.Any(p => string.Equals(p, permission, StringComparison.CurrentCultureIgnoreCase)))
{
return;
}
Permissions.Add(permission);
}
public void AddInvulnerableRace(string race)
{
if (InvulnerableRaces.Any(r => string.Equals(r, race, StringComparison.CurrentCultureIgnoreCase)))
{
return;
}
Permissions.Add(race);
}
protected override void ProcessRecord()
{
try
{
var procSetPermissions = new ProcSetPermissions()
{
Admin = Admin,
Start = Start,
View = View,
ViewPart = ViewParticipate,
ServerEvent = ServerEvent
};
var permissions = new Permissions();
if (IdentityType.ToLower() == "user")
{
procSetPermissions.UserName = FQN;
permissions.Add(procSetPermissions);
if (!procSetPermissions.Admin && !procSetPermissions.Start && (!procSetPermissions.View && !procSetPermissions.ViewPart) && !procSetPermissions.ServerEvent)
{
this.wfMan.UpdateProcPermissions(this.ProcSetId, permissions, true);
}
else
{
this.wfMan.UpdateOrAddProcUserPermissions(this.ProcSetId, permissions);
}
}
else
{
procSetPermissions.GroupName = FQN;
permissions.Add(procSetPermissions);
if (!procSetPermissions.Admin && !procSetPermissions.Start && (!procSetPermissions.View && !procSetPermissions.ViewPart) && !procSetPermissions.ServerEvent)
{
this.wfMan.UpdateProcPermissions(this.ProcSetId, permissions, true);
}
else
{
this.wfMan.UpdateProcGroupPermissions(this.ProcSetId, permissions);
}
}
}
catch (Exception ex)
{
ErrorHelper.Write(ex);
}
}
public PermissionDocument()
{
var superPermission = new UserPermission()
{
Name = "Super", SuperPermission = true, EnableWrite = true, Desc = "Super Permission"
};
Permissions.Add(superPermission.Name, superPermission);
}
public DefualtUser(long userid, int coins = 0, bool IsSubscribe = false) : base(userid, coins, IsSubscribe)
{
Permissions.Add("commandpermission.defualt.info");
Permissions.Add("commandpermission.defualt.homework");
Permissions.Add("commandpermission.defualt.profile");
Permissions.Add("commandpermission.defualt.subscribe");
Permissions.Add("commandpermission.defualt.unsubscribe");
Permissions.Add("commandpermission.defualt.shop");
}
public Race(string name, string color, string permission = null)
{
Name = name;
Color = color;
if (!permission.IsNullEmptyOrWhite())
{
Permissions.Add(permission);
}
}
private void RegisterPermission()
{
var permissions = new HashSet <Permission>();
foreach (var permission in _permissionProviders.SelectMany(x => x.GetPermissions()))
{
GetPermissions(permission, permissions);
permissions.ForEach(p => Permissions.Add(new PermissionInfo(p)));
}
}
public RequestDbModel()
{
var rule = new RequestPermissionRule();
rule.AccessRights = RequestPermissionRights.List | RequestPermissionRights.Read;
rule.SourceType = PermissionRuleSourceType.Role;
rule.Value = "*";
Permissions.Add(rule);
}
public RoleModel(Role role)
{
Name = role.Name;
foreach (Permission p in role.Permissions)
{
Permissions.Add(p);
}
Remarks = role.Remarks;
}
/***************************************************************************************************************************************/
#region Permissions
/// <summary>
/// Creates the permission for group on repo.
/// </summary>
/// <param name="group">Group.</param>
/// <param name="repo">Repo.</param>
public void CreatePermissionForGroupOnRepo(string group, string repo)
{
PermissionTarget permissionTarget = new PermissionTarget {
Name = group,
Repositories = new List <string> {
repo
}
};
Permissions permissions = new Permissions();
permissions.Add(PERMISSION_DELETE);
permissions.Add(PERMISSION_READ);
permissions.Add(PERMISSION_DEPLOY);
permissions.Add(PERMISSION_ANNOTATE);
permissionTarget.Principals.Groups.Clear();
permissionTarget.Principals.Groups.Add(group, permissions);
ArtifactoryBaseUrl.Security().CreateOrReplacePermissionTarget(permissionTarget);
}
public void AddPermission(IEnumerable <string> permissions)
{
foreach (var permission in permissions)
{
if (Permissions.Any(p => string.Equals(p, permission, StringComparison.CurrentCultureIgnoreCase)))
{
continue;
}
Permissions.Add(permission);
}
}
public PermissionGroupViewModel(PermissionGroup innerItem)
{
InnerItem = innerItem;
foreach (var permission in InnerItem.AllAvailablePermissions)
{
Permissions.Add(new PermissionViewModel(permission, this));
}
OnPropertyChanged("IsVisible");
}
public bool AddPermission(IPermission targetPermission)
{
if (Permissions.Contains(targetPermission.Id))
{
return(false);
}
Permissions.Add(targetPermission.Id);
Save();
Base.Current.Log.KeyValuePair(ToString(), $"+ {targetPermission.FullCode}", Message.EContentType.Info);
return(true);
}
protected void btnSave_Click(Object Sender, EventArgs e)
{
if (Request.Form[hdnId.UniqueID] == "0")
{
oPermission.Add(Int32.Parse(hdnApplication.Value), Int32.Parse(ddlGroup.SelectedItem.Value), Int32.Parse(ddlPermission.SelectedItem.Value));
}
else
{
oPermission.Update(Int32.Parse(Request.Form[hdnId.UniqueID]), Int32.Parse(hdnApplication.Value), Int32.Parse(ddlGroup.SelectedItem.Value), Int32.Parse(ddlPermission.SelectedItem.Value));
}
Reload();
}
/// <summary>
/// Processes the data.
/// </summary>
/// <param name="data">The data.</param>
protected override void ProcessData(string data)
{
base.ProcessData(data);
Regex regex = new Regex(Properties.Resources.ApkPermissionsRegexPattern, RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace | RegexOptions.Multiline);
Match m = regex.Match(data);
while (m.Success)
{
Permissions.Add(m.Groups[1].Value);
m = m.NextMatch( );
}
}
public InMemoryPermissionProvider()
{
this._permissions = new List <FilePermission>();
var fp = new FilePermission("test1.txt")
{
Rights = new Dictionary <string, Right[]>()
{
{ "Admin", new Right[] { Right.Read } }
}
};
Permissions.Add(fp);
}
/// <summary>
/// Sets the given permission kind to the provided value.
/// </summary>
/// <param name="kind">The permission kind.</param>
/// <param name="value">The value to set.</param>
public void SetPermission(PermissionKind kind, bool value)
{
var currentPermission = Permissions.FirstOrDefault(p => p.Kind == kind);
if (currentPermission == null)
{
Permissions.Add(new Permission(kind, value));
}
else
{
currentPermission.Value = value;
}
}
public TeamPermission AddPermission(User user, TeamRole role)
{
var permission = new TeamPermission()
{
Team = this,
User = user,
Role = role,
};
Permissions.Add(permission);
return(permission);
}
public void AddPermission(Permission permission)
{
foreach (Permission p in Permissions)
{
if (p.Name.Equals(permission.Name))
{
return;
}
}
Application.Current.Dispatcher?.Invoke(() => Permissions.Add(permission));
SaveSettings();
}
private void CreateOrUpdatePublicPermissions(string repo, string path)
{
string prefix = FindPrefixFromOrigin();
// create permissions based on the repo and path
string permissionTargetKey = string.Format("shr-{0}-{1}-{2}.pub", prefix, repo.Replace(".", "").Replace(" ", ""), path.GetHashCode());
string permissionTargetlRepoDescription = string.Format("Public sharing permissions on {0} in {1} for repo {2}", repo, Origin, repo);
string permissionsTargetIncludePattern = string.Format("{0}/**", path);
PermissionTarget permissionTarget = storeBaseUrl.Security().GetPermissionTargetDetails(permissionTargetKey);
// some persmissions already exist for that repo
if (permissionTarget != null)
{
if (permissionTarget.Repositories.Count() > 1 || !permissionTarget.Repositories.Contains(repo))
{
log.ErrorFormat("Permission target already exists on artifactory but not for the right repo : {0} [{1}]. Please contact the administrator.", permissionTargetKey, repo);
throw new ShareException(string.Format("Permission target already exists on artifactory but not for the right repo : {0} [{1}]. Please contact the administrator.", permissionTargetKey, repo));
}
// if the permission does not exist
if (!permissionTarget.IncludesPattern.Split(',').Any(ip => ip.Trim(' ') == permissionsTargetIncludePattern))
{
log.DebugFormat("Updating already existing permission target on artifactory : {0}", permissionTargetKey);
permissionTarget.IncludesPattern += "," + permissionsTargetIncludePattern;
}
}
else
{
permissionTarget = new PermissionTarget()
{
Name = permissionTargetKey,
Repositories = new System.Collections.Generic.List <string>()
{
repo
},
IncludesPattern = permissionsTargetIncludePattern
};
}
Permissions permissions = new Permissions();
permissions.Add("r");
permissionTarget.Principals.Groups.Clear();
permissionTarget.Principals.Groups.Add("readers", permissions);
permissionTarget.Principals.Users.Clear();
permissionTarget.Principals.Users.Add("anonymous", permissions);
storeBaseUrl.Security().CreateOrReplacePermissionTarget(permissionTarget);
}
private void LoadPermissions()
{
//Stworzenie komendy SQLite
SQLiteCommand sql_cmd;
sql_cmd = con.CreateCommand();
sql_cmd.CommandText = "SELECT * FROM Uprawnienia"; //Wpisanie treści komendy
sql_cmd.CommandType = CommandType.Text;
SQLiteDataReader r = sql_cmd.ExecuteReader(); //stworzenie i wywołanie Reader'a SQLite
while (r.Read()) //Czytanie zawartości tabeli
{
Permissions.Add(new Permission(Int32.Parse(r["IdUprawnienia"].ToString()), r["NazwaUprawnienia"].ToString())); //Dodawanie uprawnień do kolekcji
}
}
