static void ApplicationOnLoggedOn(object sender, LogonEventArgs logonEventArgs)
{
var xafApplication = ((XafApplication)sender);
var modelWinLayoutManagerOptions = ((IModelWinLayoutManagerOptions)xafApplication.Model.Options.LayoutManagerOptions);
modelWinLayoutManagerOptions.CustomizationEnabled = SecuritySystem.IsGranted(new OverallCustomizationAllowedPermissionRequest());
}
protected override void OnActivated()
{
base.OnActivated();
saImportData.Active.SetItemValue("Security",
SecuritySystem.IsGranted(View.ObjectSpace, typeof(InternalInvoice), SecurityOperations.Create, null,
null));
}
protected override void OnActivated()
{
base.OnActivated();
if (!SecuritySystem.IsGranted(new IsAdministratorPermissionRequest()))
{
var isGranted = SecuritySystem.IsGranted(new MyDetailsOperationRequest(new MyDetailsPermission(Modifier.Allow)));
_myDetailsController = Frame.GetController <MyDetailsController>();
if (_myDetailsController != null)
{
_myDetailsController.Active.SetItemValue(KeyDisable, !isGranted);
}
_showNavigationItemController = Frame.GetController <ShowNavigationItemController>();
if (_showNavigationItemController != null)
{
_myDetailsItem = FindMyDetailsItem(_showNavigationItemController.ShowNavigationItemAction.Items);
if (_myDetailsItem != null)
{
_myDetailsItem.Active.SetItemValue(KeyDisable, !isGranted);
}
}
}
else
{
Active["IsAdmin"] = false;
}
}
public XafApplication Build()
{
try {
var typesInfo = _buildTypesInfoSystem.Invoke(_moduleName);
ReflectionHelper.AddResolvePath(_assemblyPath);
var assembly = ReflectionHelper.GetAssembly(Path.GetFileNameWithoutExtension(_moduleName), _assemblyPath);
var assemblyInfo = typesInfo.FindAssemblyInfo(assembly);
typesInfo.LoadTypes(assembly);
var findTypeInfo = typesInfo.FindTypeInfo(typeof(XafApplication));
var findTypeDescendants = ReflectionHelper.FindTypeDescendants(assemblyInfo, findTypeInfo, false);
var instance = SecuritySystem.Instance;
var info = XafTypesInfo.Instance;
typesInfo.AssignAsInstance();
var xafApplication = ((XafApplication)Enumerator.GetFirst(findTypeDescendants).CreateInstance(new object[0]));
SecuritySystem.SetInstance(instance);
SetConnectionString(xafApplication);
if (!_withOutObjectSpaceProvider)
{
var objectSpaceProviders = ((IList <IObjectSpaceProvider>)xafApplication.GetFieldValue("objectSpaceProviders"));
objectSpaceProviders.Add(new MyClass(xafApplication));
}
info.AssignAsInstance();
return(xafApplication);
} finally {
ReflectionHelper.RemoveResolvePath(_assemblyPath);
}
}
public void CommunicationMonitor_HearthBeat()
{
var testDp = new TestDp(DatabaseStorage.CreateEmpty());
var messageProvider = new DefaultMessageProvider(new MessageSenderManager());
var missingEntityHandler = new MissingEntityHandler();
var messagingOptions = Options.Create(new MessagingOptions()
{
CommunicationMonitorRunningPeriodInSeconds = 1
});
var securitySystem = new SecuritySystem(testDp, messageProvider, missingEntityHandler,
new SecurityConfiguration(), messagingOptions.Value);
var dataHandler = new DataHandler(testDp, messagingOptions);
var communicationMonitor = new CommunicationMonitor(dataHandler, messagingOptions);
var activityHistory = new SecurityActivityHistoryController();
var securityActivityQueue = new SecurityActivityQueue(securitySystem, communicationMonitor, dataHandler, activityHistory);
// ACTION
var communicationMonitorAcc = new ObjectAccessor(communicationMonitor);
communicationMonitorAcc.Invoke("Timer_Elapsed");
// ASSERT
Assert.IsTrue(testDp.IsCleanupSecurityActivitiesCalled);
Assert.IsTrue(testDp.IsGetLastSecurityActivityIdCalled);
}
private void CreateButtons()
{
if (IsSelector)
{
DataSelector.Buttons.Buttons.Clear();
if (PropertyValue == null)
{
if (ObjectSpace.CanInstantiate(MemberInfo.MemberType) && SecuritySystem.IsGranted(new ClientPermissionRequest(MemberInfo.MemberType, null, null, SecurityOperations.Create)))
{
DataSelector.Buttons.AddButton("<span class='glyphicon glyphicon-plus text-info'></span>").OnExecution += XafBootstrapDropdownEdit_AddNew;
}
}
else
{
DataSelector.Buttons.AddButton("<span class='glyphicon glyphicon-trash text-danger'></span>").OnExecution += XafBootstrapDropdownEdit_Remove;
}
}
else
{
DropDown.Buttons.Buttons.Clear();
if (PropertyValue == null)
{
if (ObjectSpace.CanInstantiate(MemberInfo.MemberType) && SecuritySystem.IsGranted(new ClientPermissionRequest(MemberInfo.MemberType, null, null, SecurityOperations.Create)))
{
DropDown.Buttons.AddButton("<span class='glyphicon glyphicon-plus text-info'></span>").OnExecution += XafBootstrapDropdownEdit_AddNew;
}
}
else
{
DropDown.Buttons.AddButton("<span class='glyphicon glyphicon-trash text-danger'></span>").OnExecution += XafBootstrapDropdownEdit_Remove;
}
}
}
private static void DeleteCheckPermission(int id, SecuritySystem securitySystem)
{
Trace.WriteLine("SECDEL> Start check thread id " + id);
var ctx = new SecurityContext(TestUser.User1, securitySystem);
var eid = Id("E99");
var caught = false;
var count = 0;
while (!_stopped)
{
try
{
var hp = ctx.HasPermission(eid, PermissionType.See);
if (hp)
{
_errors++;
}
count++;
}
catch (EntityNotFoundException)
{
// the entity was deleted in the meantime
_stopped = true;
caught = true;
}
}
Trace.WriteLine("SECDEL> End check thread id " + id + ". Catched: " + caught + ". Count: " + count);
}
internal static SecuritySystem StartTheSystem(ISecurityDataProvider securityDataProvider)
{
var messageSenderManager = new MessageSenderManager("asdf");
// Call SecurityContext starter method.
//var securitySystem = SecurityContextForConcurrencyTests.StartTheSystem(new SecurityConfiguration
//{
// SecurityDataProvider = securityDataProvider,
// MessageProvider = new DefaultMessageProvider(messageSenderManager),
// CommunicationMonitorRunningPeriodInSeconds = 31
//});
var config = new SecurityConfiguration();
var messagingOptions = new MessagingOptions {
CommunicationMonitorRunningPeriodInSeconds = 31
};
var securitySystem = new SecuritySystem(securityDataProvider,
new DefaultMessageProvider(messageSenderManager),
new MissingEntityHandler(), config, messagingOptions);
securitySystem.Start();
// legacy logic
// original line: MessageSender.Initialize("asdf");
//securitySystem.MessageSenderManager = messageSenderManager;
return(securitySystem);
}
private static void SaqExercise1(int id, SecuritySystem securitySystem)
{
var name = "WaitB-" + id;
var count = 0;
while (!_stopped)
{
Thread.Sleep(10);
if (0 == count % 100)
{
Console.WriteLine("Running time: {0}, errors: {1}. {2} {3}", DateTime.UtcNow - _started, _errors, name, count);
}
var _ = new SecurityContext(TestUser.User2, securitySystem);
var activity = new TestWaitActivity(_rnd.Next(1, 3));
securitySystem.DataHandler.SaveActivity(activity);
var method = typeof(SecuritySystem).GetMethod("MessageProvider_MessageReceived", BindingFlags.Instance | BindingFlags.NonPublic);
if (method == null)
{
throw new ApplicationException("Method not found: MessageProvider_MessageReceived");
}
method.Invoke(securitySystem, new object[] { null, new MessageReceivedEventArgs(activity) });
count++;
}
}
private static void MoveExerciseWriter(int id, SecuritySystem securitySystem)
{
var name = "Writer-" + id;
var count = 0;
while (!_stopped)
{
//Thread.Sleep(1);
if (0 == count % 10000000)
{
Console.WriteLine("Running time: {0}, errors: {1}. {2} {3}", DateTime.UtcNow - _started, _errors, name, count);
}
//---------------------- work
var ctx = securitySystem.GeneralSecurityContext;
var entities = ctx.Cache.Entities;
var source = entities[3];
var target0 = entities[1];
var target1 = entities[52];
var target = source.Parent == target0 ? target1 : target0;
ctx.SecuritySystem.EntityManager.MoveEntity(source.Id, target.Id);
//----------------------
count++;
}
}
private static void AclExercise2(int id, SecuritySystem securitySystem)
{
var name = "Writer-" + id;
var ctx = new SecurityContext(TestUser.User2, securitySystem);
var count = 0;
var permTypes = new[] { PermissionType.Custom01, PermissionType.Custom02 };
while (!_stopped)
{
Thread.Sleep(10);
if (0 == count % 1000)
{
Console.WriteLine("Running time: {0}, errors: {1}. {2} {3}", DateTime.UtcNow - _started, _errors, name, count);
}
var i = count % 2;
var perm1 = permTypes[i];
var perm2 = permTypes[1 - i];
new AclEditor(ctx)
.Allow(5, TestUser.User1.Id, false, perm1)
.Allow(5, TestUser.User1.Id, false, perm2)
.Apply();
count++;
}
}
private static void AclExercise1(int id, SecuritySystem securitySystem)
{
var name = "Reader-" + id;
var ctx = new SecurityContext(TestUser.User2, securitySystem);
var count = 0;
while (!_stopped)
{
Thread.Sleep(1);
if (0 == count % 10000)
{
Console.WriteLine("Running time: {0}, errors: {1}. {2} {3}", DateTime.UtcNow - _started, _errors, name, count);
}
var ok = ctx.HasPermission(52, PermissionType.See);
if (!ok)
{
Console.WriteLine("Running time: {0}, errors: {1}. {2} {3} ERROR", DateTime.UtcNow - _started, ++_errors, name, count);
}
count++;
}
}
//============================================================================================= Static API
public static SecuritySystem StartSecurity(ISecurityDataProvider securityDataProvider,
IMessageProvider messageProvider,
IMissingEntityHandler missingEntityHandler,
MessagingOptions messagingOptions)
{
var securityConfig = new SecurityConfiguration
{
SystemUserId = Identifiers.SystemUserId,
VisitorUserId = Identifiers.VisitorUserId,
EveryoneGroupId = Identifiers.EveryoneGroupId,
OwnerGroupId = Identifiers.OwnersGroupId
};
var securitySystem = new SecuritySystem(securityDataProvider, messageProvider, missingEntityHandler,
securityConfig, messagingOptions);
securitySystem.Start();
SnLog.WriteInformation("Security subsystem started in Search service", EventId.RepositoryLifecycle,
properties: new Dictionary <string, object> {
{ "DataProvider", securityDataProvider.GetType().FullName },
{ "MessageProvider", messageProvider.GetType().FullName }
});
return(securitySystem);
}
public SimpleSession(SecuritySystem security, FileSystem filesystem, ShellFactory shells, Terminal terminal, int userID)
{
this.security = security;
this.filesystem = filesystem;
this.terminal = terminal;
this.userID = userID;
//get users home dir
string homepath = security.UserHomeDirectory(userID);
this.homeDir = (Directory)filesystem.Find(homepath);
if (this.homeDir == null)
{
throw new Exception("Failed to home users home directory: " + homepath);
}
//get shell
string shellname = security.UserPreferredShell(userID);
shell = shells.CreateShell(shellname, this);
if (shell == null)
{
throw new Exception("Failed to find user's preferred shell");
}
//TODO get the shell from a factory
}
void Start()
{
if (parentSystem == null)
{
parentSystem = this.transform.GetComponentInParent <SecuritySystem>();
}
}
public void ShouldHaveAtLeastOneChip()
{
List<Chip> chips = new List<Chip>();
SecuritySystem system = new SecuritySystem(SecurityColor.Blue, SecurityColor.Blue);
Assert.IsFalse(system.CanBeUnlocked(chips));
}
public void ShouldHaveAtLeastOneChip()
{
List <Chip> chips = new List <Chip>();
SecuritySystem system = new SecuritySystem(SecurityColor.Blue, SecurityColor.Blue);
Assert.IsFalse(system.CanBeUnlocked(chips));
}
bool IsGranted()
{
if (((ISecurityComplex)SecuritySystem.Instance).IsNewSecuritySystem())
{
return(SecuritySystem.IsGranted(new ModelCombinePermissionRequest(ApplicationModelCombineModifier.Allow)));
}
return(SecuritySystemExtensions.IsGranted(new ModelCombinePermission(ApplicationModelCombineModifier.Allow), false));
}
public void ShouldHaveChipsDefined()
{
List<Chip> chips = null;
SecuritySystem system = new SecuritySystem(SecurityColor.Blue, SecurityColor.Blue);
Assert.IsFalse(system.CanBeUnlocked(chips));
}
public void ShouldHaveChipsDefined()
{
List <Chip> chips = null;
SecuritySystem system = new SecuritySystem(SecurityColor.Blue, SecurityColor.Blue);
Assert.IsFalse(system.CanBeUnlocked(chips));
}
protected void LoginUser_LoggedIn(object sender, EventArgs e)
{
//WebApplication.Instance.Start();
//OR
using (IObjectSpace os = WebApplication.Instance.CreateObjectSpace())
{
SecuritySystem.Logon(os); //Da load o tren
}
}
public override void Dispose()
{
if (SecuritySystem.Instance is IDisposable security)
{
security.Dispose();
}
SecuritySystem.SetInstance(null);
base.Dispose();
}
protected override void OnActivated()
{
base.OnActivated();
// Perform various tasks depending on the target View.
bool isPermitted = SecuritySystem.IsGranted(new PermissionRequest(ObjectSpace, typeof(News), "RelatedOrganizations", null, SecurityOperations.Write));
ShowRelatedCustomerAction.Active.SetItemValue("Security", isPermitted);
RemoveRelatedOrganizationAction.Active.SetItemValue("Security", isPermitted);
}
protected override void OnActivated()
{
base.OnActivated();
// Perform various tasks depending on the target View.
bool isPermitted = SecuritySystem.IsGranted(new PermissionRequest(ObjectSpace, typeof(News), "ShortDescription", null, SecurityOperations.Write));
AddShortDescriptionAction.Active.SetItemValue("Security", isPermitted);
//AddShortDescriptionAction.Active.SetItemValue("Security", SecuritySystem.IsGranted(new ClientPermissionRequest(typeof(News), "ShortDescription", ObjectSpace.GetObjectHandle(View.CurrentObject), SecurityOperations.Write)));
}
public Menue()
{
securitySystem = new SecuritySystem();
con = new DB_Connection("lia-gaming.de", "POA_2020", "schule", "123");
InitializeComponent();
updateClock();
updateInformation();
}
protected virtual bool IsGranted(ITransition iTransition, bool hide)
{
var permission = new StateMachineTransitionPermission {
StateCaption = iTransition.TargetState.Caption,
StateMachineName = iTransition.TargetState.StateMachine.Name,
Hide = hide,
};
return(SecuritySystem.IsGranted(new NoCacheablePermissionRequest(new StateMachineTransitionOperationRequest(permission))));
}
protected override void Awake()
{
base.Awake();
Transform beamMark1 = transform.Find("BeamMark1");
Transform beamMark2 = transform.Find("BeamMark2");
dAngle = Vector2.SignedAngle(beamMark1.localPosition, beamMark2.localPosition);
baseDirection = Vector2.SignedAngle(Vector2.right, beamMark1.localPosition);
securitySystem = FindObjectOfType <SecuritySystem>();
}
protected override void SynchItemWithSecurity(DevExpress.ExpressApp.Actions.ChoiceActionItem item)
{
if (!SecuritySystem.IsGranted(new NavigationItemPermissionRequest(item.Id)))
{
item.Active[SecurityVisibleKey] = false;
}
else
{
base.SynchItemWithSecurity(item);
}
}
bool IsActive(XpoTransition xpoTransition)
{
var permission = new StateMachineTransitionPermission {
Modifier = StateMachineTransitionModifier.Allow,
StateCaption = xpoTransition.TargetState.Caption,
StateMachineName = xpoTransition.SourceState.StateMachine.Name,
Hide = false
};
return(SecuritySystem.IsGranted(new StateMachineTransitionOperationRequest(permission)));
}
public static SecurityStrategyComplex GetSecurity(string userName)
{
AuthenticationStandard authentication = new AuthenticationStandard();
SecurityStrategyComplex security = new SecurityStrategyComplex(typeof(PermissionPolicyUser), typeof(PermissionPolicyRole), authentication);
//security.RegisterXPOAdapterProviders();
string password = string.Empty;
authentication.SetLogonParameters(new AuthenticationStandardLogonParameters(userName, password));
SecuritySystem.SetInstance(security);
return(security);
}
static bool IsNotGranted(IPermission permission)
{
var securityComplex = ((SecurityBase)SecuritySystem.Instance);
bool isGrantedForNonExistentPermission = securityComplex.IsGrantedForNonExistentPermission;
securityComplex.IsGrantedForNonExistentPermission = true;
bool granted = SecuritySystem.IsGranted(permission);
securityComplex.IsGrantedForNonExistentPermission = isGrantedForNonExistentPermission;
return(granted);
}
void ReloadPermissions()
{
if (SecuritySystem.Instance is ISecurityComplex)
{
if (SecuritySystem.CurrentUser != null && !PermissionsReloaded)
{
SecuritySystem.ReloadPermissions();
PermissionsReloaded = true;
}
}
}
public void BlueLeftMarker_NoChipsWithBlueOnLeftSide_CannotBeUnlocked()
{
List<Chip> chips = new List<Chip>()
{
new Chip(SecurityColor.Green, SecurityColor.Blue),
new Chip(SecurityColor.Orange, SecurityColor.Blue),
new Chip(SecurityColor.Purple, SecurityColor.Blue)
};
SecuritySystem system = new SecuritySystem(SecurityColor.Blue, SecurityColor.Blue);
Assert.IsFalse(system.CanBeUnlocked(chips));
}
public void BlueRightMarker_NoChipsWithBlueOnRightSide_CannotBeUnlocked()
{
List<Chip> chips = new List<Chip>()
{
new Chip(SecurityColor.Blue, SecurityColor.Red),
new Chip(SecurityColor.Blue, SecurityColor.Yellow),
new Chip(SecurityColor.Blue, SecurityColor.Green)
};
SecuritySystem system = new SecuritySystem(SecurityColor.Blue, SecurityColor.Blue);
Assert.IsFalse(system.CanBeUnlocked(chips));
}
// Query of systems in the system table.
public List<GenericSystem> GetSystems()
{
MySqlConnection sqlConnection = new MySqlConnection(connectionString);
MySqlCommand sqlCmd = sqlConnection.CreateCommand();
List<GenericSystem> systemList = new List<GenericSystem>();
try
{
sqlConnection.Open();
sqlCmd.CommandText = "SELECT * FROM SYSTEMS";
MySqlDataReader rdr = sqlCmd.ExecuteReader();
while (rdr.Read())
{
if (rdr.GetInt32(1) == 1)
{
SecuritySystem system = new SecuritySystem(rdr.GetInt32(0));
system.Sensors = GetSensors(-1, system.Id);
system.Alarms = GetAlarms(-1, system.Id);
systemList.Add(system);
}
}
rdr.Close();
}
catch (Exception e)
{
Console.WriteLine("Could not connect to database!");
Console.WriteLine("{0} Exception caught.", e);
}
finally
{
sqlConnection.Close();
}
return systemList;
}
