MXMS Wiki - User contributions [en]

MXMS

2026-04-03T07:26:47Z

Bjorn: /* Model driven development */

== What is MXMS ==
[[File:Example-mxms-implementation.png|right|400px|An example implementation using the MXMS framework]]

The MXMS framework enables rapid development of business software solutions by using a structured class entity model in which the database / SQL is maintained and updated by the framework and the UI is built.

MXMS enables rapid development of API's which exposes certain fuctionality of the entity model in a [[JsonRPC]], [[REST]] or a custom format.

Custom scheduled tasks can be created for background processes to execute to create data synchronisation tasks or other custom workflows.

=== .NET Core ===
MXMS uses ASP .NET Core as the development platform and is written in C#. The core libraries are written in .NET Standard 2.0 for maximum portability.

== Model driven development ==
At it's core a MXMS implementation expects a [[model]] definition which is used to generate the application and it's functionality.

A model is a collection of [[class|classes]] which contains properties annotated with [[attribute|attributes]] which provides context to the property and methods which provides functionality to the implementation.

=== Entities ===
=== Properties ===
=== Methods ===

== Configuration ==
[[File:Example-startup.png|right|400px|MXMS being injected into the ASP.NET pipeline]]
MXMS has various ways of changing the application configuration. There is a json file which contains basic configuration which changes from instance to instance. The main way to configure the application is through strongly types configuration classes using the options pattern in the startup.cs. The strongly typed configuration can be further filled by creating a module. A module can be re-used to provide certain functionality to implementations. The application configuration can be accessed using the [[Application|application class]]

=== Application configuration ===
MXMS is injected into the ASP.NET Core pipeline during [[Startup|startup]] of the .NET Core application. MXMS provides injection classes to enable the MXMS application within the ASP.NET Core implementation. Additional [[MXMSConfiguration|ad-hoc configuration]] can be passed during the initial startup of the application. MXMS uses a strongly types class model to confige the application furing startup.

=== Modules ===
For a modular approach [[Module|modules]] can be created which can be injected into the application. A module is a class which injects configuration options to the application. This module can be re-used in various implementations.

=== mxmsSettings.json ===
MXMS uses a json file called [[mxmsSettings.json]] to configure specific items between instances. Each instance of the application can have it's own mxmsSettings.config. The file is using the json format.

The configuration consists of the global mailserver settings which are used to send mails and the connection string which provides storage for the ORM mapper. Additionally MXMS registers when which scheduled process was last run. It uses this information to determine which processes needs executing.

If a [[mxmsSettings.json]] file is not present during application startup an empty configuration file is created which can be edited as required.

=== log4net.config ===
MXMS uses [https://logging.apache.org/log4net/index.html log4net] to provide logging functionality. This module is configured using the [[log4net.config]] file located in the [[MXMSConfiguration#Workingdirectory|workingdirectory]] of the application.

== Data storage ==
MXMS uses [https://nhibernate.info NHibernate] as it's Object Relational Mapper. MXMS feeds NHibernate custom configuration data based on the model which is implemented.

=== ORM ===
=== Updates ===
=== Dialects ===

[[File:Image-editing.png|right|400px|Editing an uploaded image with the image editor in MXMS]]
== File storage ==
MXMS uses a so called [[MXMSConfiguration#Workingdirectory|workingdirectory]] in which MXMS requires full access. This folder is used to store various files which are either generated, loaded by certain modules or manually uploaded by users using the application.

=== Uploaded media ===
Users are able to upload and edit media using the [[EntityImage|entityimage]] class. Files uploaded are stored in the <WORKINGDIRECTORY>/media/ folder.

=== Mail templates ===
The [[MailSender|mail sender]] stores it's templates in the <WORKINGDIRECTORY>/templates/ folder

== User interface ==
MXMS uses [https://vuejs.org/ Vue] as it's javascript client framework to render it's javascript GUI.
=== Pages ===
=== Apps ===
=== Views ===
=== Widgets ===
=== Input controls ===
=== Custom applications ===

== Background processes ==
TODO add background process info

== Security ==
Various concepts are in place to either grant or deny users specific access to the application.

=== Rights by definition type ===
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| [[Entity|Entities]] || Create, Read, Update and Delete
|-
| [[Property|Properties]] || Create, Read and Update
|-
| [[Method|Methods]] || Execute
|}

=== Access modifiers ===
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

In the example above the property maximum availability is read access.

=== Attributes ===
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|availability attribute]]. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

In the example above the property maximum availability is read access.

=== Roles ===
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile. Roles are registered and added to the application using [[Module|modules]].
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllRead();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllUpdate();
}
}
</pre>

In the example above the role has read access to Class1, has full control access to Class2 and update access to Class3. Read access is automatically granted when providing update access.

=== Claims ===
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added. Claims are registered and added to the application using [[Module|modules]].

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

== Filters ==
TODO add filter information

== API development ==
TODO add [[api|APIs]] info.

MXMS

2026-04-03T06:28:47Z

Bjorn: /* Security */

== What is MXMS ==
[[File:Example-mxms-implementation.png|right|400px|An example implementation using the MXMS framework]]

The MXMS framework enables rapid development of business software solutions by using a structured class entity model in which the database / SQL is maintained and updated by the framework and the UI is built.

MXMS enables rapid development of API's which exposes certain fuctionality of the entity model in a [[JsonRPC]], [[REST]] or a custom format.

Custom scheduled tasks can be created for background processes to execute to create data synchronisation tasks or other custom workflows.

=== .NET Core ===
MXMS uses ASP .NET Core as the development platform and is written in C#. The core libraries are written in .NET Standard 2.0 for maximum portability.

== Model driven development ==
At it's core a MXMS implementation expects a [[model]] definition which is used to generate the application and it's functionality.

A model is a collection of [[class|classes]] which contains properties annotated with [[attribute|attributes]] which provides context to the property and methods which provides functionality to the implementation.

== Configuration ==
[[File:Example-startup.png|right|400px|MXMS being injected into the ASP.NET pipeline]]
MXMS has various ways of changing the application configuration. There is a json file which contains basic configuration which changes from instance to instance. The main way to configure the application is through strongly types configuration classes using the options pattern in the startup.cs. The strongly typed configuration can be further filled by creating a module. A module can be re-used to provide certain functionality to implementations. The application configuration can be accessed using the [[Application|application class]]

=== Application configuration ===
MXMS is injected into the ASP.NET Core pipeline during [[Startup|startup]] of the .NET Core application. MXMS provides injection classes to enable the MXMS application within the ASP.NET Core implementation. Additional [[MXMSConfiguration|ad-hoc configuration]] can be passed during the initial startup of the application. MXMS uses a strongly types class model to confige the application furing startup.

=== Modules ===
For a modular approach [[Module|modules]] can be created which can be injected into the application. A module is a class which injects configuration options to the application. This module can be re-used in various implementations.

=== mxmsSettings.json ===
MXMS uses a json file called [[mxmsSettings.json]] to configure specific items between instances. Each instance of the application can have it's own mxmsSettings.config. The file is using the json format.

The configuration consists of the global mailserver settings which are used to send mails and the connection string which provides storage for the ORM mapper. Additionally MXMS registers when which scheduled process was last run. It uses this information to determine which processes needs executing.

If a [[mxmsSettings.json]] file is not present during application startup an empty configuration file is created which can be edited as required.

=== log4net.config ===
MXMS uses [https://logging.apache.org/log4net/index.html log4net] to provide logging functionality. This module is configured using the [[log4net.config]] file located in the [[MXMSConfiguration#Workingdirectory|workingdirectory]] of the application.

== Data storage ==
MXMS uses [https://nhibernate.info NHibernate] as it's Object Relational Mapper. MXMS feeds NHibernate custom configuration data based on the model which is implemented.

=== ORM ===
=== Updates ===
=== Dialects ===

[[File:Image-editing.png|right|400px|Editing an uploaded image with the image editor in MXMS]]
== File storage ==
MXMS uses a so called [[MXMSConfiguration#Workingdirectory|workingdirectory]] in which MXMS requires full access. This folder is used to store various files which are either generated, loaded by certain modules or manually uploaded by users using the application.

=== Uploaded media ===
Users are able to upload and edit media using the [[EntityImage|entityimage]] class. Files uploaded are stored in the <WORKINGDIRECTORY>/media/ folder.

=== Mail templates ===
The [[MailSender|mail sender]] stores it's templates in the <WORKINGDIRECTORY>/templates/ folder

== User interface ==
MXMS uses [https://vuejs.org/ Vue] as it's javascript client framework to render it's javascript GUI.
=== Pages ===
=== Apps ===
=== Views ===
=== Widgets ===
=== Input controls ===
=== Custom applications ===

== Background processes ==
TODO add background process info

== Security ==
Various concepts are in place to either grant or deny users specific access to the application.

=== Rights by definition type ===
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| [[Entity|Entities]] || Create, Read, Update and Delete
|-
| [[Property|Properties]] || Create, Read and Update
|-
| [[Method|Methods]] || Execute
|}

=== Access modifiers ===
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

In the example above the property maximum availability is read access.

=== Attributes ===
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|availability attribute]]. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

In the example above the property maximum availability is read access.

=== Roles ===
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile. Roles are registered and added to the application using [[Module|modules]].
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllRead();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllUpdate();
}
}
</pre>

In the example above the role has read access to Class1, has full control access to Class2 and update access to Class3. Read access is automatically granted when providing update access.

=== Claims ===
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added. Claims are registered and added to the application using [[Module|modules]].

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

== Filters ==
TODO add filter information

== API development ==
TODO add [[api|APIs]] info.

MXMS

2026-04-03T06:26:01Z

Bjorn:

== What is MXMS ==
[[File:Example-mxms-implementation.png|right|400px|An example implementation using the MXMS framework]]

The MXMS framework enables rapid development of business software solutions by using a structured class entity model in which the database / SQL is maintained and updated by the framework and the UI is built.

MXMS enables rapid development of API's which exposes certain fuctionality of the entity model in a [[JsonRPC]], [[REST]] or a custom format.

Custom scheduled tasks can be created for background processes to execute to create data synchronisation tasks or other custom workflows.

=== .NET Core ===
MXMS uses ASP .NET Core as the development platform and is written in C#. The core libraries are written in .NET Standard 2.0 for maximum portability.

== Model driven development ==
At it's core a MXMS implementation expects a [[model]] definition which is used to generate the application and it's functionality.

A model is a collection of [[class|classes]] which contains properties annotated with [[attribute|attributes]] which provides context to the property and methods which provides functionality to the implementation.

== Configuration ==
[[File:Example-startup.png|right|400px|MXMS being injected into the ASP.NET pipeline]]
MXMS has various ways of changing the application configuration. There is a json file which contains basic configuration which changes from instance to instance. The main way to configure the application is through strongly types configuration classes using the options pattern in the startup.cs. The strongly typed configuration can be further filled by creating a module. A module can be re-used to provide certain functionality to implementations. The application configuration can be accessed using the [[Application|application class]]

=== Application configuration ===
MXMS is injected into the ASP.NET Core pipeline during [[Startup|startup]] of the .NET Core application. MXMS provides injection classes to enable the MXMS application within the ASP.NET Core implementation. Additional [[MXMSConfiguration|ad-hoc configuration]] can be passed during the initial startup of the application. MXMS uses a strongly types class model to confige the application furing startup.

=== Modules ===
For a modular approach [[Module|modules]] can be created which can be injected into the application. A module is a class which injects configuration options to the application. This module can be re-used in various implementations.

=== mxmsSettings.json ===
MXMS uses a json file called [[mxmsSettings.json]] to configure specific items between instances. Each instance of the application can have it's own mxmsSettings.config. The file is using the json format.

The configuration consists of the global mailserver settings which are used to send mails and the connection string which provides storage for the ORM mapper. Additionally MXMS registers when which scheduled process was last run. It uses this information to determine which processes needs executing.

If a [[mxmsSettings.json]] file is not present during application startup an empty configuration file is created which can be edited as required.

=== log4net.config ===
MXMS uses [https://logging.apache.org/log4net/index.html log4net] to provide logging functionality. This module is configured using the [[log4net.config]] file located in the [[MXMSConfiguration#Workingdirectory|workingdirectory]] of the application.

== Data storage ==
MXMS uses [https://nhibernate.info NHibernate] as it's Object Relational Mapper. MXMS feeds NHibernate custom configuration data based on the model which is implemented.

=== ORM ===
=== Updates ===
=== Dialects ===

[[File:Image-editing.png|right|400px|Editing an uploaded image with the image editor in MXMS]]
== File storage ==
MXMS uses a so called [[MXMSConfiguration#Workingdirectory|workingdirectory]] in which MXMS requires full access. This folder is used to store various files which are either generated, loaded by certain modules or manually uploaded by users using the application.

=== Uploaded media ===
Users are able to upload and edit media using the [[EntityImage|entityimage]] class. Files uploaded are stored in the <WORKINGDIRECTORY>/media/ folder.

=== Mail templates ===
The [[MailSender|mail sender]] stores it's templates in the <WORKINGDIRECTORY>/templates/ folder

== User interface ==
MXMS uses [https://vuejs.org/ Vue] as it's javascript client framework to render it's javascript GUI.
=== Pages ===
=== Apps ===
=== Views ===
=== Widgets ===
=== Input controls ===
=== Custom applications ===

== Background processes ==
TODO add background process info

== Security ==
Various concepts are in place to either grant or deny users specific access to the application.

=== Rights by definition type ===
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| [[Entity|Entities]] || Create, Read, Update and Delete
|-
| [[Property|Properties]] || Create, Read and Update
|-
| [[Method|Methods]] || Execute
|}

=== Access modifiers ===
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

In the example above the property maximum availability is read access.

=== Attributes ===
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|availability attribute]]. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

In the example above the property maximum availability is read access.

=== Roles ===
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile. Roles are registered and added to the application using [[Module|modules]].
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllRead();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllUpdate();
}
}
</pre>

In the example above the role has read access to Class1, has full control access to Class2 and update access to Class3. Read access is automatically granted when providing update access.

=== Claims ===
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added. Claims are registered and added to the application using [[Module|modules]].

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

== Filters ==
TODO add filter information

== API development ==
TODO add [[api|APIs]] info.

Log4net.config

2026-04-03T06:23:44Z

Bjorn:

To provide a robust logging framework MXMS uses [https://logging.apache.org/log4net/index.html log4net] as it's logging framework. log4net can be configured using their xml configuration file which should be located in the [[MXMSConfiguration#Workingdirectory|workingdirectory]] and is named log4net.config. Appenders can be added to the log4.net logging engine.

== Example configuration ==
<pre>
<?xml version="1.0" encoding="UTF-8"?>
<log4net>
<root>
<priority value="ERROR"/>
<appender-ref ref="rollingFile" />
</root>
<appender name="rollingFile" type="log4net.Appender.RollingFileAppender">
<file type="log4net.Util.PatternString" value="mxms\Logs\trace-log.txt" />
<lockingModel type="log4net.Appender.FileAppender+MinimalLock" />
<appendToFile value="true" />
<rollingStyle value="Date" />
<maximumFileSize value="5MB" />
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value=" %date %-5level %logger - %message%newline" />
</layout>
<encoding value="utf-8" />
</appender>
</log4net>
</pre>

MXMS

2026-04-03T06:22:22Z

Bjorn: /* Mail templates */

Security

2026-04-03T06:14:25Z

Bjorn: /* Attributes */

Various concepts are in place to either grant or deny users specific access to the application.

== Rights by definition type ==
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| [[Entity|Entities]] || Create, Read, Update and Delete
|-
| [[Property|Properties]] || Create, Read and Update
|-
| [[Method|Methods]] || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

In the example above the property maximum availability is read access.

== Attributes ==
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|availability attribute]]. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

In the example above the property maximum availability is read access.

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile. Roles are registered and added to the application using [[Module|modules]].
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllRead();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllUpdate();
}
}
</pre>

In the example above the role has read access to Class1, has full control access to Class2 and update access to Class3. Read access is automatically granted when providing update access.

== Claims ==
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added. Claims are registered and added to the application using [[Module|modules]].

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:13:15Z

Bjorn: /* Access modifiers */

Various concepts are in place to either grant or deny users specific access to the application.

== Rights by definition type ==
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| [[Entity|Entities]] || Create, Read, Update and Delete
|-
| [[Property|Properties]] || Create, Read and Update
|-
| [[Method|Methods]] || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

In the example above the property maximum availability is read access.

== Attributes ==
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|Availability]] attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

In the example above the property maximum availability is read access.

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile. Roles are registered and added to the application using [[Module|modules]].
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllRead();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllUpdate();
}
}
</pre>

In the example above the role has read access to Class1, has full control access to Class2 and update access to Class3. Read access is automatically granted when providing update access.

== Claims ==
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added. Claims are registered and added to the application using [[Module|modules]].

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:12:51Z

Bjorn: /* Attributes */

Various concepts are in place to either grant or deny users specific access to the application.

== Rights by definition type ==
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| [[Entity|Entities]] || Create, Read, Update and Delete
|-
| [[Property|Properties]] || Create, Read and Update
|-
| [[Method|Methods]] || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|Availability]] attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

In the example above the property maximum availability is read access.

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile. Roles are registered and added to the application using [[Module|modules]].
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllRead();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllUpdate();
}
}
</pre>

In the example above the role has read access to Class1, has full control access to Class2 and update access to Class3. Read access is automatically granted when providing update access.

== Claims ==
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added. Claims are registered and added to the application using [[Module|modules]].

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:12:16Z

Bjorn: /* Roles */

Various concepts are in place to either grant or deny users specific access to the application.

== Rights by definition type ==
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| [[Entity|Entities]] || Create, Read, Update and Delete
|-
| [[Property|Properties]] || Create, Read and Update
|-
| [[Method|Methods]] || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|Availability]] attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile. Roles are registered and added to the application using [[Module|modules]].
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllRead();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllUpdate();
}
}
</pre>

In the example above the role has read access to Class1, has full control access to Class2 and update access to Class3. Read access is automatically granted when providing update access.

== Claims ==
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added. Claims are registered and added to the application using [[Module|modules]].

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:09:43Z

Bjorn: /* Rights by definition type */

Various concepts are in place to either grant or deny users specific access to the application.

== Rights by definition type ==
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| [[Entity|Entities]] || Create, Read, Update and Delete
|-
| [[Property|Properties]] || Create, Read and Update
|-
| [[Method|Methods]] || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|Availability]] attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile. Roles are registered and added to the application using [[Module|modules]].
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added. Claims are registered and added to the application using [[Module|modules]].

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:09:06Z

Bjorn: /* Rights by definition type */

Various concepts are in place to either grant or deny users specific access to the application.

== Rights by definition type ==
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| [[Entity|Entities]] || Create, Read, Update and Delete
|-
| Properties || Create, Read and Update
|-
| [[Method|Methods]] || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|Availability]] attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile. Roles are registered and added to the application using [[Module|modules]].
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added. Claims are registered and added to the application using [[Module|modules]].

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:08:21Z

Bjorn: /* Claims */

Various concepts are in place to either grant or deny users specific access to the application.

== Rights by definition type ==
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| Entities || Create, Read, Update and Delete
|-
| Properties || Create, Read and Update
|-
| Methods || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|Availability]] attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile. Roles are registered and added to the application using [[Module|modules]].
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added. Claims are registered and added to the application using [[Module|modules]].

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:08:04Z

Bjorn: /* Roles */

Various concepts are in place to either grant or deny users specific access to the application.

== Rights by definition type ==
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| Entities || Create, Read, Update and Delete
|-
| Properties || Create, Read and Update
|-
| Methods || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|Availability]] attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile. Roles are registered and added to the application using [[Module|modules]].
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:05:39Z

Bjorn:

Various concepts are in place to either grant or deny users specific access to the application.

== Rights by definition type ==
The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| Entities || Create, Read, Update and Delete
|-
| Properties || Create, Read and Update
|-
| Methods || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|Availability]] attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:04:32Z

Bjorn: /* Attributes */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| Entities || Create, Read, Update and Delete
|-
| Properties || Create, Read and Update
|-
| Methods || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the [[Availability (attribute)|Availability]] attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:03:34Z

Bjorn: /* Claims */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| Entities || Create, Read, Update and Delete
|-
| Properties || Create, Read and Update
|-
| Methods || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
[[Claim|Claims]] is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:03:23Z

Bjorn: /* Roles */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| Entities || Create, Read, Update and Delete
|-
| Properties || Create, Read and Update
|-
| Methods || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A [[Role|role]] defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:02:19Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. The following permissions are available for each type.

{| class="wikitable"

|+ Rights by definition type
! Type !! Permissions
|-
| Entities || Create, Read, Update and Delete
|-
| Properties || Create, Read and Update
|-
| Methods || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:02:00Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. The following permissions are available for each type.

{| class="wikitable"

|+ Table Title
! Type !! Permissions
|-
| Entities || Create, Read, Update and Delete
|-
| Properties || Create, Read and Update
|-
| Methods || Execute
|}

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:01:27Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. The following permissions are available for each type.

{| class="wikitable"

|+ Table Title
! Type !! Permissions
|-
| Entities || Row 1, Cell 2
|-
| Properties || Row 2, Cell 2
|-
| Methods || Row 2, Cell 2
|}

This can be Create, Read, Update and Delete rights for [[Entity|entities]].

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:01:08Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. The following permissions are available for each type.

{| class="wikitable"

|+ Table Title
! Type !! Permissions
|-
| Entities || Row 1, Cell 2
|-
| Row 2, Cell 1 || Row 2, Cell 2
|-
| Row 2, Cell 1 || Row 2, Cell 2
|}

This can be Create, Read, Update and Delete rights for [[Entity|entities]].

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:00:58Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. The following permissions are available for each type.

{| class="wikitable"

|+ Table Title
! Type !! Permissions
|-
| Entities || Row 1, Cell 2
|-
| Row 2, Cell 1 || Row 2, Cell 2
|}

This can be Create, Read, Update and Delete rights for [[Entity|entities]].

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:00:45Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. The following permissions are available for each type.

{| class="wikitable"

|+ Table Title
! Type !! Permissions
|-
| Entities || Row 1, Cell 2
|-

| Row 2, Cell 1 || Row 2, Cell 2
|}

This can be Create, Read, Update and Delete rights for [[Entity|entities]].

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:00:30Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. The following permissions are available for each type.

{| class="wikitable"

|+ Table Title
! Type !! Permissions
|-
| Row 1, Cell 1 || Row 1, Cell 2
|-

| Row 2, Cell 1 || Row 2, Cell 2
|}

This can be Create, Read, Update and Delete rights for [[Entity|entities]].

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T06:00:11Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. The following permissions are available for each type.

{| class="wikitable"

|+ Table Title
! Header 1 !! Header 2
|-
| Row 1, Cell 1 || Row 1, Cell 2
|-

| Row 2, Cell 1 || Row 2, Cell 2
|}

This can be Create, Read, Update and Delete rights for [[Entity|entities]].

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T05:59:02Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. This can be Create, Read, Update and Delete rights for [[Entity|entities]].

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T05:58:49Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. This can be Creat, Read, Update and Delete rights for [[Entity|entities]]

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T05:58:36Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. This can be Creat, Read, Update and Deete rights for [[Entity|entities]]

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T05:58:27Z

Bjorn: /* lkjsflkdsf dslkfjdsl f */

= lkjsflkdsf dslkfjdsl f =
Various concepts are in place to either grant or deny users specific access to the application. This can be Creat, Read, Update and Deete rights for [Entity|entities]

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T05:56:30Z

Bjorn:

= lkjsflkdsf dslkfjdsl f =

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T05:56:16Z

Bjorn:

lkjsflkdsf dslkfjdsl f

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T05:54:30Z

Bjorn: /* Claims */

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
Claims is another form to limit access to properties or methods. By adding a claim the entity's state determines if the policy is added.

<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

In the above example the method MyMethod() is denied access if the BooleanCheck value is true.

Security

2026-04-03T05:51:43Z

Bjorn: /* Attributes */

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access if access modifiers are not feasible is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

Security

2026-04-03T05:50:48Z

Bjorn: /* Access modifiers */

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only public access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

Security

2026-04-03T05:50:34Z

Bjorn: /* Access modifiers */

== Access modifiers ==
The maximum allowed permissions for a property or method is based on the access modifiers of the property. Only publisc access modifiers can be accessed by users. This is based on the getter (read access) and the setter (write access).

<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

Security

2026-04-03T05:48:26Z

Bjorn: /* Access modifiers */

== Access modifiers ==
<pre>
public virtual string ExampleProperty
{
get;
protected set;
}
</pre>

== Attributes ==
To further limit access is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

Security

2026-04-03T05:47:36Z

Bjorn:

== Access modifiers ==

== Attributes ==
To further limit access is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

Security

2026-04-03T05:46:08Z

Bjorn: /* Claims */

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
<pre>
public class ExampleClaim : Claim<CustomEntity>
{
protected override bool CanApply(CustomEntity entity)
{
return entity.BooleanCheck;
}

protected override void Set(CodedAccessPolicyBuilder<CustomEntity> policy)
{
policy.DenyMethod(i => i.MyMethod());
}
}
</pre>

== Attributes ==
Another way to limit access is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

Security

2026-04-03T05:45:10Z

Bjorn: /* Claims */

Security

2026-04-03T05:43:03Z

Bjorn: /* Attributes */

== Roles ==
A role defines which classes, properties and methods the user has access to. A user can be added in multiple roles and the cummultative permission set of classes, properties and methods will be the users final access profile.
<pre>
public class ExampleAccessProfile : CodedAccessProfile
{
protected override void Configure()
{

Set<Class1>()
.AllowAllCreate()
.AllowAllUpdate();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();

Set<Class2>()
.AllowAllCreate()
.AllowAllUpdate()
.AllowDelete();
}
}
</pre>

== Claims ==
== Attributes ==
Another way to limit access is by using the Availability attribute. This attribute defines the maximum available permissions for a property. The options are None, Writeonly and Readonly.

<pre>
[Availability(Availability.ReadOnly)]
public virtual string Name
{
get; set;
}
</pre>

Security

2026-04-03T05:40:16Z

Bjorn: /* Attributes */

Security

2026-04-03T05:38:23Z

Bjorn: /* Roles */

Security

2026-04-03T05:36:55Z

Bjorn: /* Roles */

Security

2026-04-03T05:34:22Z

Bjorn: Created page with " == Roles == == Claims == == Attributes =="

== Roles ==
== Claims ==
== Attributes ==

ConditionalAvailability (attribute)

2026-04-03T05:32:29Z

Bjorn:

[[File:Conditional-Availability.png|right|400px|An example usage of the Conditional availability attribute]]
The ConditionalAvailability attribute is used to show a property only when it's attribute condition is met. The condition must be defined in the class where the condition is defined. Determination of the condition is client side only.

== Example ==
<pre>
public virtual bool Enabled
{
get; set;
}

[ConditionalAvailability("Enabled", ConditionalAvailabilityMode.Equals, true)]
public virtual string ConditionalProperty
{
get; set;
}
</pre>

In de example above property ConditionalProperty will be visible only when the Enabled Property is true. If a user changes the Enabled property the ConditionalProperty becomes available immediately without first saving.

File:Conditional-Availability.png

2026-04-03T05:31:19Z

Bjorn:

ConditionalAvailability (attribute)

2026-04-03T05:26:35Z

Bjorn:

The ConditionalAvailability attribute is used to show a property only when it's attribute condition is met. The condition must be defined in the class where the condition is defined. Determination of the condition is client side only.

== Example ==
<pre>
public virtual bool Enabled
{
get; set;
}

[ConditionalAvailability("Enabled", ConditionalAvailabilityMode.Equals, true)]
public virtual string ConditionalProperty
{
get; set;
}
</pre>

In de example above property ConditionalProperty will be visible only when the Enabled Property is true. If a user changes the Enabled property the ConditionalProperty becomes available immediately without first saving.

ConditionalAvailability (attribute)

2026-04-03T05:25:27Z

Bjorn:

The ConditionalAvailability attribute is used to show a property only when it's attribute condition is met.

== Example ==
<pre>
public virtual bool Enabled
{
get; set;
}

[ConditionalAvailability("Enabled", ConditionalAvailabilityMode.Equals, true)]
public virtual string ConditionalProperty
{
get; set;
}
</pre>

In de example above property ConditionalProperty will be visible only when the Enabled Property is true. If a user changes the Enabled property the ConditionalProperty becomes available immediately without first saving.

ConditionalAvailability (attribute)

2026-04-03T05:23:59Z

Bjorn:

ConditionalAvailability (attribute)

2026-04-03T05:02:30Z

Bjorn: Created page with "The ConditionalAvailability attribute is used to show a property only when it's attribute condition is met."

The ConditionalAvailability attribute is used to show a property only when it's attribute condition is met.