public bool ModifyUser(int userID, AccessLevelEnum newAccessLevel, bool logOff,
int logOffTimeout, int newPrevilages)
{
_logger.Info($"Method for modifying existing user in Db fired. User ID = {userID}, Access level = {newAccessLevel.ToString()}.");
try
{
UserDefinition user = _realm.All <UserDefinition>().ToList().Single(x => x.Identity == userID);
using (var trans = _realm.BeginWrite())
{
user.AccessLevel = GetAccessLevelInt(newAccessLevel);
user.LogoutEnabled = logOff;
user.LogoutTime = logOffTimeout;
user.LanguageEditorPrevilages = newPrevilages;
trans.Commit();
}
_logger.Info($"Modifying exisng user data in DB successfull.");
return(true);
}
catch (Exception ex)
{
_logger.Error($"Error while trying to modify existing user data: {ex.Message}.");
return(false);
}
}
public static bool HasAvailabilityEqualToOrGreaterThan(this AccessLevelEnum compared, AccessLevelEnum comparedTo)
{
if (comparedTo == AccessLevelEnum.Private)
{
return true;
}
if (comparedTo == AccessLevelEnum.Protected)
{
if (compared == AccessLevelEnum.Public
|| compared == AccessLevelEnum.Internal
|| compared == AccessLevelEnum.Protected)
{
return true;
}
}
if (comparedTo == AccessLevelEnum.Internal)
{
if (compared == AccessLevelEnum.Public
|| compared == AccessLevelEnum.Internal)
{
return true;
}
}
if (comparedTo == AccessLevelEnum.Public)
{
if (compared == AccessLevelEnum.Public)
{
return true;
}
}
return false;
}
private static Tuple <AccessLevelEnum, SealedEnum, AbstractEnum> EmitModifiers(Type type)
{
//set defaults
AccessLevelEnum _access = AccessLevelEnum.IsPrivate;
AbstractEnum _abstract = AbstractEnum.NotAbstract;
SealedEnum _sealed = SealedEnum.NotSealed;
// check if not default
if (type.IsPublic)
{
_access = AccessLevelEnum.IsPublic;
}
else if (type.IsNestedPublic)
{
_access = AccessLevelEnum.IsPublic;
}
else if (type.IsNestedFamily)
{
_access = AccessLevelEnum.IsProtected;
}
else if (type.IsNestedFamANDAssem)
{
_access = AccessLevelEnum.IsProtectedInternal;
}
if (type.IsSealed)
{
_sealed = SealedEnum.Sealed;
}
if (type.IsAbstract)
{
_abstract = AbstractEnum.Abstract;
}
return(new Tuple <AccessLevelEnum, SealedEnum, AbstractEnum>(_access, _sealed, _abstract));
}
public void SetAlarmsMenuPrevilages(AccessLevelEnum accessLevel)
{
_canAlarmProfileManager = accessLevel == AccessLevelEnum.Administrator || accessLevel == AccessLevelEnum.Operator;
_canMessageReceiversManager = accessLevel == AccessLevelEnum.Administrator || accessLevel == AccessLevelEnum.Operator;
_canMessageReceiverGroupsManager = accessLevel == AccessLevelEnum.Administrator || accessLevel == AccessLevelEnum.Operator;
_canAlarmManagement = accessLevel != AccessLevelEnum.None;
}
public void SetSettingsMenuPrevilages(AccessLevelEnum accessLevel)
{
_canAlarmsLanguageEdition = accessLevel == AccessLevelEnum.Administrator || accessLevel == AccessLevelEnum.Operator;
_canPLCconnectionSetup = accessLevel == AccessLevelEnum.Administrator;
_canSMSdeviceConnection = accessLevel == AccessLevelEnum.Administrator;
_canNLogParametrization = accessLevel == AccessLevelEnum.Administrator;
}
public List <string> GetPathsByAccessLevel(AccessLevelEnum requiredAccessLevel, List <string> identifiers, List <EmergenyObjectAccessContainer> accessList)
{
List <string> result = new List <string>();
if (identifiers == null || accessList == null)
{
return(result);
}
foreach (var identifier in identifiers)
{
foreach (var accessEntry in accessList)
{
if (IdentifierMatches(identifier, accessEntry.idPattern))
{
/* Identifier passt, Rechte übernehmen */
foreach (var pathLevel in accessEntry.acl)
{
if (pathLevel.level >= requiredAccessLevel)
{
result.Add(pathLevel.path);
}
if (pathLevel.path == "*")
{
return(result);
}
}
}
}
}
return(result);
}
public AccessLevelEnum CheckAccessForPath(string documentPath, List <string> identifiers, List <EmergenyObjectAccessContainer> accessList, AccessLevelEnum requiredAccessLevel = AccessLevelEnum.Grant)
{
AccessLevelEnum level = AccessLevelEnum.None;
foreach (var identifier in identifiers)
{
foreach (var accessEntry in accessList)
{
if (IdentifierMatches(identifier, accessEntry.idPattern))
{
/* Identifier passt, Rechte übernehmen */
foreach (var pathLevel in accessEntry.acl)
{
if (pathLevel.path == "*" || documentPath.StartsWith(pathLevel.path))
{
if (pathLevel.level > level)
{
level = pathLevel.level;
if (level >= requiredAccessLevel)
{
return(level);
}
}
}
}
}
}
}
return(level);
}
public bool AddNewUser(string userName, string password, AccessLevelEnum accessLevel,
bool logOff, int logOffTimeout, int langPrevillages)
{
_logger.Info($"Method for adding new user to DB fired. User name = {userName}, Access level = {accessLevel.ToString()}.");
try
{
(string hashPass, byte[] salt) = EncryptPassword(password);
_realm.Write(() =>
{
_realm.Add(new UserDefinition()
{
Identity = GetNewID(),
UserName = userName,
Password = hashPass,
AccessLevel = GetAccessLevelInt(accessLevel),
Salt = salt,
LogoutEnabled = logOff,
LogoutTime = logOffTimeout,
LanguageEditorPrevilages = langPrevillages,
});
});
_logger.Info($"Adding new user to DB successfull.");
return(true);
}
catch (Exception ex)
{
_logger.Error($"Error while trying to add new user to DB: {ex.Message}.");
return(false);
}
}
public User(long id, String name, String email, String password, AccessLevelEnum accessLevel)
{
Id = id;
Name = name;
Email = email;
AccessLevel = accessLevel;
Password = password;
}
public static Mock<IMethodData> GetMockMethod(string signature,
List<IAttributeData> attributes,
AccessLevelEnum accessLevel)
{
var mock = new Mock<IMethodData>();
mock.SetupGet(x => x.MethodSignature).Returns(signature);
mock.SetupGet(x => x.AttributeData).Returns(attributes);
mock.SetupGet(x => x.AccessLevel).Returns(accessLevel);
return mock;
}
//method for enabling and disabling settings menu options
private void AssignSettingsMenuPrevilages(AccessLevelEnum accessLevel)
{
_logger.Info($"Assign enables for settings menu. Access level: {accessLevel.ToString()}.");
_runtimeData.SetSettingsMenuPrevilages(accessLevel);
CanAlarmsLanguageEdition = _runtimeData.CanAlarmsLanguageEdition;
CanPLCconnectionSetup = _runtimeData.CanPLCconnectionSetup;
CanSMSdeviceConnection = _runtimeData.CanSMSdeviceConnection;
CanNLogParametrization = _runtimeData.CanNLogParametrization;
}
//method for enabling and disabling alarms menu options
private void AssignAlarmsMenuPrevilages(AccessLevelEnum accessLevel)
{
_logger.Info($"Assign enables for alarm management menu. Access level: {accessLevel.ToString()}.");
_runtimeData.SetAlarmsMenuPrevilages(accessLevel);
CanAlarmProfileManager = _runtimeData.CanAlarmProfileManager;
CanMessageReceiversManager = _runtimeData.CanMessageReceiversManager;
CanMessageReceiverGroupsManager = _runtimeData.CanMessageReceiverGroupsManager;
CanAlarmManagement = _runtimeData.CanAlarmManagement;
}
public void AddAccessRight(string path, AccessLevelEnum level)
{
if (acl == null)
{
acl = new List <EmergencyObjectAccess>();
}
acl.Add(new EmergencyObjectAccess()
{
level = level,
path = path
});
}
private void LoginButton_Click(object sender, RoutedEventArgs e)
{
AccessLevelEnum accessLevel = BlValidations.IsLoginValid(idTb.Text, passwordPb.Password);
if (accessLevel == AccessLevelEnum.DeniedAccess)
{
MessageBox.Show("Wrong Details");
}
m_mainWin.AccessLevel = accessLevel;
Close();
}
/// <summary>
/// Create a new request
/// </summary>
/// <param name="required">Level of access required</param>
/// <param name="expireIn">Number of seconds to expire the SAS token</param>
public DiskAccessRequest(AccessLevelEnum required, int expireIn)
{
if (!Enum.IsDefined(typeof(AccessLevelEnum), required))
{
throw new ArgumentOutOfRangeException(nameof(required));
}
if ((expireIn < 1) || (expireIn > 86400))
{
throw new ArgumentOutOfRangeException(nameof(expireIn));
}
AccessLevelRequired = required;
AccessExpireInSeconds = expireIn;
}
public int GetAccessLevelInt(AccessLevelEnum level)
{
switch (level)
{
case AccessLevelEnum.None: return(0);
case AccessLevelEnum.User: return(10);
case AccessLevelEnum.Operator: return(20);
case AccessLevelEnum.Administrator: return(30);
default: return(0);
}
}
public List <string> GetAccessPaths(AccessLevelEnum requiredAccessLevel, EmergencyObject obj, EndpointIdentity id)
{
List <string> res;
bool isOwner = (obj.header.createdBy == id.uid);
if (isOwner)
{
res = new List <string>()
{
"*"
};
return(res);
}
res = access.GetPathsByAccessLevel(requiredAccessLevel, id.accessIdentity, obj.header.Access);
return(res);
}
public static string AccessLevelToString(AccessLevelEnum accessLevelEnum)
{
if (accessLevelEnum == AccessLevelEnum.IsPrivate)
{
return("private");
}
else if (accessLevelEnum == AccessLevelEnum.IsProtected)
{
return("protected");
}
else if (accessLevelEnum == AccessLevelEnum.IsProtectedInternal)
{
return("internal");
}
else
{
return("public");
}
}
//checking if all conditions for user deleting are ok
private bool CheckUserDeletionCnditions(AccessLevelEnum deletedUserAccessLevel)
{
_logger.Info($"Checking cnditions for user deletion procedure started.");
//firs check if it is last user
if (Users.Count <= 1)
{
_logger.Info($"User cannot be deleted - amount of users to small: {Users.Count}.");
return(false);
}
else
{
// if at leas 2 users, and deleted one is not admin, than ok
if (deletedUserAccessLevel != AccessLevelEnum.Administrator)
{
return(true);
}
//if trying to delete admin account
else
{
//if admin accounts amount is == 1, than no, else - ok
int amountOfAdmins = 0;
foreach (var item in Users)
{
if (item.AccessLevel == AccessLevelEnum.Administrator)
{
amountOfAdmins++;
}
}
if (amountOfAdmins <= 1)
{
_logger.Info($"User sannot be deleted, because it is last Administrator account available.");
return(false);
}
else
{
return(true);
}
}
}
}
internal static Enums.AccessLevelEnum ToLogicEnum(this AccessLevelEnum baseEnum)
{
switch (baseEnum)
{
case AccessLevelEnum.IsPrivate:
return(Enums.AccessLevelEnum.IsPrivate);
case AccessLevelEnum.IsProtected:
return(Enums.AccessLevelEnum.IsProtected);
case AccessLevelEnum.IsProtectedInternal:
return(Enums.AccessLevelEnum.IsProtectedInternal);
case AccessLevelEnum.IsPublic:
return(Enums.AccessLevelEnum.IsPublic);
default:
throw new Exception();
}
}
private static Tuple <AccessLevelEnum, AbstractEnum, StaticEnum, VirtualEnum> EmitModifiers(MethodBase method)
{
AccessLevelEnum _access = AccessLevelEnum.IsPrivate;
if (method.IsPublic)
{
_access = AccessLevelEnum.IsPublic;
}
else if (method.IsFamily)
{
_access = AccessLevelEnum.IsProtected;
}
else if (method.IsFamilyAndAssembly)
{
_access = AccessLevelEnum.IsProtectedInternal;
}
AbstractEnum _abstract = AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
_abstract = AbstractEnum.Abstract;
}
StaticEnum _static = StaticEnum.NotStatic;
if (method.IsStatic)
{
_static = StaticEnum.Static;
}
VirtualEnum _virtual = VirtualEnum.NotVirtual;
if (method.IsVirtual)
{
_virtual = VirtualEnum.Virtual;
}
return(new Tuple <AccessLevelEnum, AbstractEnum, StaticEnum, VirtualEnum>(_access, _abstract, _static, _virtual));
}
public LoggedUserData GetUserData()
{
_logger.Info($"Method for getin user data in case of successfull login fored.");
if (_loginSuccessful)
{
try
{
//read all data from DB
UserDefinition userData = _realm.All <UserDefinition>().Single(x => x.UserName == _userName);
//convert access level from number to enum
AccesLevelConverter converter = new AccesLevelConverter();
AccessLevelEnum accessLevel = converter.GetAccesLevelEnum(userData.AccessLevel);
//pass to caller only necessary data
return(new LoggedUserData()
{
Identity = userData.Identity,
UserName = userData.UserName,
AccessLevel = accessLevel.ToString(),
AccessLevelEnum = accessLevel,
LogoutEnabled = userData.LogoutEnabled,
LogoutTime = userData.LogoutTime,
LangEditPrevilages = userData.LanguageEditorPrevilages,
});
}
catch (Exception ex)
{
_logger.Error($"Error while obtaining user data from DB: {ex.Message}.");
return(null);
}
}
else
{
return(null);
}
}
public InterfaceTypeData(ITypeWrapper typeToAnalyze)
{
Name = typeToAnalyze.FullName;
if (!typeToAnalyze.IsInterface)
{
throw new NtegrityException("non-interface type passed to InterfaceTypeData's constructor!");
}
Type = TypeEnum.Interface;
var foundAccessLevel = false;
if (typeToAnalyze.IsNestedPrivate)
{
AccessLevel = AccessLevelEnum.Private;
foundAccessLevel = true;
}
if (!typeToAnalyze.IsVisible && typeToAnalyze.IsNotPublic
|| typeToAnalyze.IsNestedAssembly)
{
AccessLevel = AccessLevelEnum.Internal;
foundAccessLevel = true;
}
if (typeToAnalyze.IsPublic || typeToAnalyze.IsNestedPublic)
{
AccessLevel = AccessLevelEnum.Public;
foundAccessLevel = true;
}
if (typeToAnalyze.IsNestedFamily)
{
AccessLevel = AccessLevelEnum.Protected;
foundAccessLevel = true;
}
if (!foundAccessLevel)
{
throw new NtegrityException("Unable to determine access level for type: " + typeToAnalyze.AssemblyQualifiedName);
}
IsSealed = typeToAnalyze.IsSealed;
IsAbstract = typeToAnalyze.IsAbstract;
// static types are both sealed and abstract. They can neither be inherited from nor instantiated.
IsStatic = IsSealed && IsAbstract;
CollectAttributeData(typeToAnalyze);
AttributeData = AttributeData.OrderBy(x => x.Name).ToList();
CollectConstructorData(typeToAnalyze);
ConstructorData = ConstructorData.OrderBy(x => x.ConstructorSignature).ToList();
CollectMethodData(typeToAnalyze);
MethodData = MethodData.OrderBy(x => x.MethodSignature).ToList();
CollectPropertyData(typeToAnalyze);
PropertyData = PropertyData.OrderBy(x => x.PropertySignature).ToList();
CollectFieldData(typeToAnalyze);
FieldData = FieldData.OrderBy(x => x.FieldSignature).ToList();
if (typeToAnalyze.BaseType != null
&& typeToAnalyze.BaseType.FullName != "System.Object"
&& typeToAnalyze.BaseType.FullName != "System.ValueType"
&& typeToAnalyze.BaseType.FullName != "System.Enum")
{
InheritsFrom = typeToAnalyze.BaseType.FullName;
}
ImplementsInterfaces = typeToAnalyze.GetInterfaces().Select(x => x.FullName).ToList();
}
public InterfaceTypeData(string typeString)
{
var sanitizedTypeInfo = typeString.Replace("\t", "");
var lines = sanitizedTypeInfo.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
var i = 0;
while(lines[i].StartsWith("[") && i < 1000)
{
var attributeName = lines[i].Replace("[", "");
attributeName = attributeName.Replace("]", "");
AttributeData.Add(new AttributeData(attributeName));
i++;
}
var interfaceNameLine = lines[i];
var interfaceNameLineParts = interfaceNameLine.Split(' ');
var accessLevel = interfaceNameLineParts[0];
var type = interfaceNameLineParts[1];
switch (accessLevel)
{
case "public":
AccessLevel = AccessLevelEnum.Public;
break;
case "private":
AccessLevel = AccessLevelEnum.Private;
break;
case "internal":
AccessLevel = AccessLevelEnum.Internal;
break;
case "protected":
AccessLevel = AccessLevelEnum.Protected;
break;
}
if (!type.Equals("interface"))
{
throw new NtegrityException("Non-interface string passed to InterfaceTypeData's constructor!");
}
Type = TypeEnum.Interface;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceAccessDescriptor" /> class.
/// </summary>
/// <param name="ServiceName">ServiceName.</param>
/// <param name="AccessLevel">AccessLevel.</param>
/// <param name="ServiceProperties">ServiceProperties.</param>
public ServiceAccessDescriptor(string ServiceName = default(string), AccessLevelEnum AccessLevel = default(AccessLevelEnum), Object ServiceProperties = default(Object))
{
this.ServiceName = ServiceName;
this.AccessLevel = AccessLevel;
this.ServiceProperties = ServiceProperties;
}
/// <summary>
/// Initialize default instance of role object.
/// </summary>
public Role()
{
_Name = String.Empty;
_AccessLevel = AccessLevelEnum.NoAccess;
}
//Constructors
public Permisson(AccessLevelEnum accessLevel, string id, string password)
{
AccessLevel = accessLevel;
Id = id;
Password = password;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceAccessRequest" /> class.
/// </summary>
/// <param name="AccessLevel">AccessLevel.</param>
/// <param name="ServiceProperties">ServiceProperties.</param>
public ServiceAccessRequest(AccessLevelEnum AccessLevel = default(AccessLevelEnum), Object ServiceProperties = default(Object))
{
this.AccessLevel = AccessLevel;
this.ServiceProperties = ServiceProperties;
}
/// <summary>
/// Verify that user has the minimum access required for specified role.
/// </summary>
/// <param name="role">string: Role name.</param>
/// <param name="minAccess">iCampaign.TACS.AccessLevelEnum: minimum access level.</param>
/// <returns>bool</returns>
public bool HasAccess(string role, AccessLevelEnum minAccess)
{
bool returnStatus = false;
foreach (Role roleItem in this.Roles)
{
if (roleItem.Name == role)
{
if (Convert.ToInt32(roleItem.AccessLevel) >= Convert.ToInt32(minAccess))
returnStatus = true;
}
}
return returnStatus;
}
private bool ServerCommands(Account player, Room room)
{
try
{
if (text.StartsWith("(Ghost)"))
{
text.Replace("(Ghost)", "");
}
if (text.StartsWith("(Fantasma)"))
{
text.Replace("(Fantasma)", "");
}
string Command = text.Substring(1);
if (!Settings.ChatCommandsActive || !player.HaveGMLevel())
{
return(false);
}
if (!text.StartsWith(".") && text.Contains("help"))
{
text = "Olha a merda...capoto o corsa. VRUMMMMM PÁH";
return(true);
}
if (!text.StartsWith("."))
{
return(false);
}
Logger.ChatCommands($" [CHAT] [Commands] PlayerId: {player.playerId} Nick: {player.nickname} Login: {player.login} Ip: {player.ipAddress.ToString()} Text: {text}");
AccessLevelEnum access = player.access;
PacketCommand REQ = null;
if (Command.StartsWith("HELP") && access >= AccessLevelEnum.Moderator)
{
REQ = new CMD_HELP_REQ(1);
}
else if (Command.StartsWith("PCCAFEBASIC ") && access >= AccessLevelEnum.Admin)
{
REQ = new CMD_GAMEMASTER_REQ(Command, 6);
}
else if (Command.StartsWith("PCCAFEPLUS ") && access >= AccessLevelEnum.Admin)
{
REQ = new CMD_GAMEMASTER_REQ(Command, 7);
}
else if (Command.StartsWith("KICK ") && access >= AccessLevelEnum.Moderator)
{
REQ = new CMD_KICK_REQ(Command, 1);
}
else if (Command.StartsWith("KICKALL") && access >= AccessLevelEnum.GameMaster)
{
REQ = new CMD_KICK_REQ(Command, 2);
}
else if (Command.StartsWith("AFKKICK") && access >= AccessLevelEnum.Moderator)
{
REQ = new CMD_KICK_REQ(Command, 2);
}
else if (Command.StartsWith("ONLINE") && access >= AccessLevelEnum.Moderator)
{
REQ = new CMD_SERVERINFO_REQ(1);
}
else if (Command.StartsWith("G1 ") && access >= AccessLevelEnum.Moderator) //ALL
{
REQ = new CMD_ANNOUNCE_REQ(Command, 1);
}
else if (Command.StartsWith("G2 ") && access >= AccessLevelEnum.Moderator) //ROOM
{
REQ = new CMD_ANNOUNCE_REQ(Command, 2);
}
else if (Command.StartsWith("CASH ") && access >= AccessLevelEnum.GameMaster)
{
REQ = new CMD_PLAYERINFO_REQ(Command, 1);
}
else if (Command.StartsWith("GOLD ") && access >= AccessLevelEnum.GameMaster)
{
REQ = new CMD_PLAYERINFO_REQ(Command, 2);
}
else if (Command.StartsWith("RANK ") && access >= AccessLevelEnum.GameMaster)
{
REQ = new CMD_GAMEMASTER_REQ(Command, 3);
}
else if (Command.StartsWith("NICK ") && access >= AccessLevelEnum.GameMaster)
{
REQ = new CMD_GAMEMASTER_REQ(Command, 4);
}
else if (Command.StartsWith("ADDITEM ") && access >= AccessLevelEnum.GameMaster)
{
REQ = new CMD_GAMEMASTER_REQ(Command, 5);
}
else if (Command.StartsWith("GMCOLOR") && access >= AccessLevelEnum.Moderator)
{
REQ = new CMD_GAMEMASTER_REQ(Command, 1);
}
else if (Command.StartsWith("ANTIKICK") && access >= AccessLevelEnum.Moderator)
{
REQ = new CMD_GAMEMASTER_REQ(Command, 2);
}
else if (Command.StartsWith("END") && access == AccessLevelEnum.Developer)
{
REQ = new CMD_DEVELOPER_REQ(Command, 1);
}
else if (Command.StartsWith("ROOMTYPE ") && access == AccessLevelEnum.Developer)
{
REQ = new CMD_DEVELOPER_REQ(Command, 2);
}
else if (Command.StartsWith("ROOMSPECIAL ") && access == AccessLevelEnum.Developer)
{
REQ = new CMD_DEVELOPER_REQ(Command, 3);
}
else if (Command.StartsWith("ROOMWEAPON ") && access == AccessLevelEnum.Developer)
{
REQ = new CMD_DEVELOPER_REQ(Command, 4);
}
else
{
text = "Não foi possivel encontrar o comando digitado.";
}
if (REQ != null)
{
if (REQ.Set(player, room))
{
REQ.RunImplement();
}
text = REQ.GetResponse();
REQ = null;
}
return(true);
}
catch (Exception ex)
{
text = "Ocorreu um problema ao executar o comando.";
Logger.Exception(ex);
return(true);
}
}
private void AssignDataManipulationPrevilages(AccessLevelEnum accessLevel)
{
_runtimeData.SetDatManipulationPrevilages(accessLevel);
DataManipulationEnabled = _runtimeData.DataManipulationEnabled;
}
private List <string> GetAccessablePaths(AccessLevelEnum acl, EmergencyObject obj, EndpointIdentity id)
{
return(access.GetPathsByAccessLevel(acl, id.accessIdentity, obj.header.Access));
}
public ClassTypeData(string typeString)
{
var sanitizedTypeInfo = typeString.Replace("\t", "");
var lines = sanitizedTypeInfo.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
var i = 0;
while(lines[i].StartsWith("[") && i < 1000)
{
var attributeName = lines[i].Replace("[", "");
attributeName = attributeName.Replace("]", "");
AttributeData.Add(new AttributeData(attributeName));
i++;
}
var classNameLine = lines[i];
var lastLineParts = classNameLine.Split(' ');
var accessLevel = lastLineParts[0];
switch (accessLevel)
{
case "public":
AccessLevel = AccessLevelEnum.Public;
break;
case "private":
AccessLevel = AccessLevelEnum.Private;
break;
case "internal":
AccessLevel = AccessLevelEnum.Internal;
break;
case "protected":
AccessLevel = AccessLevelEnum.Protected;
break;
}
}
private void AssignPrevilages()
{
AccessLevelEnum access = _runtimeData.DataOfCurrentlyLoggedUser.AccessLevelEnum;
_canModifyAlarm = access == AccessLevelEnum.Administrator;// || access == AccessLevelEnum.Operator;
}
public void SetDatManipulationPrevilages(AccessLevelEnum accessLevel)
{
_dataManipulationEnabled = accessLevel == AccessLevelEnum.Administrator;
}
/// <summary>
/// Initialize instance of object with role name and access level.
/// </summary>
/// <param name="name">string: Role name.</param>
/// <param name="level">iCampaign.TACS.AccessLevelEnum: enumeration.</param>
public Role(string name, AccessLevelEnum level)
{
_Name = name;
_AccessLevel = level;
}
protected void CanAccess(AccessLevelEnum accessLevel)
{
AccessLevel = accessLevel;
}
private int GetAccessLevelInt(AccessLevelEnum level)
{
AccesLevelConverter converter = new AccesLevelConverter();
return(converter.GetAccessLevelInt(level));
}
