eXpandFrameWork Bloggers

BLOG by Dennis Garavsky: How to enable the Conditional Formatting feature of the WinForms GridControl in the XAF GridListEditor and preserve ListView formatting settings between runs?

Dennis Garavsky — Thu, 17 Sep 2015 10:34:00 +0000

In short, this feature allows your end-user to sort or group the data inside the grid AND to visualize selected cells, rows with data bars, icons and predefined or custom appearance schemes. Refer to the following XtraGrid documentation for more information on this feature:

WinForms Controls > Controls and Libraries > Data Grid > Conditional Formatting

GridOptionsMenu.ShowConditionalFormattingItem Property

In general, accomplishing this task in an XAF app consists of several independent parts:

1. Enabling, saving and restoring GridFormatRule objects using the standard XtraGrid as per What is the best way to save and restore information just about Conditional Formatting rules in GridControl without using the RestoreLayoutFromXXX and SaveLayoutToXXX methods?

2. Integrating this solution in the GridListEditor using a ViewController as described in the Access Grid Control Properties help topic.

3. Serializing the grid's formatting rules information, taking into account the fact that it uses a different mechanism for storing settings, which is based on the Application Model. In XAF, it is best to extend the ListView node with a string property that will hold a serialization representation of formatting rules. Refer to the How to: Extend the Application Model article for more details.

This C# source file (include it into YourSolutionName.Module project) illustrates how these parts can be joined together in XAF v15.1.6 (vb.net guys can either use this approach OR convert this code into their language using free tools). It is also possible that this code can be simplified in future versions. I will try to keep this Gist updated as well as the corresponding Support Center thread.

As always, I am looking forward to hearing from you on whether you find this feature helpful for your apps.
Thanks!

UPDATE:
Starting with v15.1.7+, the source code will be 3 lines simpler;-) Refer to this Support Center thread for more details.

BLOG by Dennis Garavsky: How to reset View customizations made by end-users (UPDATE)

Dennis Garavsky — Wed, 09 Sep 2015 07:38:00 +0000

I invite you to test an updated version of the previous E1897 solution (it is now marked as obsolete), which we are planning to include in v15.2 by default. The new solution supports both WinForms and ASP.NET apps and also works for both the root and nested Views (e.g., the ones embedded into ListPropertyEditor and DetailPropertyEditor):

Testing

To test this new solution in the current v15.1, include this C# source file into YourSolutionName.Module project (vb.net guys can either use this approach OR convert this code into their language using free tools).

Poll question

I also have a question to you: what is the best location for the Reset View Settings command?

1. In a separate Tools sub-menu (one per root form);

2. In the toolbar accompanying each View (may be too noisy);

3. Suggest other locations and demonstrate them with screenshots (e.g., context menu).

I am looking forward to hearing from you.

BLOG by Dennis Garavsky: Getting ready the ConditionalAppearance module infrastructure for custom options of the extended AppearanceAttribute (e.g., tooltip)

Dennis Garavsky — Tue, 25 Aug 2015 10:52:00 +0000

First of all, this piece of information is quite advanced, so be sure you are well-aware of the module's basic functions and main extensibility and customization points, at least through AppearanceController. If not, check out the related online documentation before reading further.

Customer scenario

Would it be possible to add in the conditional appearance module the possibility to show a tooltip in the cell in listView when the

condition is satisfied? (you get different color based on criteria and when you move to the cell a tooltip is shown telling you why the color is different ), example:

[C#]

[Appearance("CategoryColoredInListView", AppearanceItemType = "ViewItem", TargetItems = "Category", Criteria = "Category = 'Seafood'", Context = "ListView",FontColor = "Blue", Priority = 1, ToolTip="the tooltiptext!!!!")]

Alternative solution considerations

If there were no ready built-in module in XAF, you could solve this by using the pure means available for the underlying grid control for a target platform. For instance, in WinForms, you could employ the ToolTipController API, while for ASP.NET WebForms you could handle the ASPxGridView events to programmatically assign a tooltip text to required data cells. Apparently, making these custom-tailored control-based solutions universal would require effort without XAF, and XAF users could even see this work as a duplication of the perfect existent infrastructure ConditionalAppearance provides. So, let's describe how to do things the XAF way!

XAF way

Let me repost the answer my colleague provided in the original SC ticket and then elaborate more on the technical aspects of this solution:

We designed the Conditional Appearance module to control various properties of controls and provided implementation for the most useful properties of DevExpress ASP.NET and WinForms controls: Enabled, Visible, BackColor, FontColor and FontStyle. However, there are other controls and properties that can be managed using the Conditional Appearance module capabilities.

We reviewed our implementation and made a few changes in our code to support new properties, so you can request a hotfix right now, and we will publish it for you. This change will be included into the next public release/update for the 14.2 release.

The attached project demonstrates how to introduce an additional string value to the 'AppearanceAttribute' class and apply this string to the ASPxGridView cell as a tooltip in accordance with the Conditional Appearance rules. Note that other controls and properties may require other code to show a specified string as a tooltip. Please review the corresponding documentation for a necessary control for more details on how to implement this scenario.

T248959.ZIP

Technical details

Solution26.Module:

AppearanceWithToolTipAttribute.cs - contains a definition of an AppearanceAttribute descendant with a custom ToolTip property (its sample use is shown in the Class1.cs file) as well as several required service classes to propagate this new option through the Application Model and the whole ConditionalAppearance module infrastructure. For instance, the AppearanceItemToolTip class is an AppearanceItemBase descendant that serves the same role as AppearanceItemEnabled, AppearanceItemFontColor and other built-in implementations (here it solely holds a tooltip value).

The IModelAppearanceWithToolTipRule interface and its domain logic define a custom Application Model element that extends the built-in IModelAppearanceRule with the ToolTip property (see the Module.cs file for the registration code).

Finally, the ToolTipAppearanceRule class is a descendant of the service AppearanceRule class with a single overridden method that instantiates AppearanceItemToolTip objects for IModelAppearanceWithToolTipRule nodes defined by a user in the Application Model.

Solution26.Module.Web:

AppearanceGridViewToolTipController.cs - contains a ViewController that handles the CustomCreateAppearanceRule and ApperanceApplied events of the built-in AppearanceController for connecting rule metadata information with the underlying control customizations. In other words, the information from the AppearanceItemToolTip entity is propagated to the built-in TableCellAppearanceAdapter object, which represents a precise implementation of the IAppearanceFormat interface (there are various implementations for different UI entities in XAF). Or, simply, a link between the underlying UI control and its TableCell object to which various appearance options (font, color, tooltip) can be applied.

BLOG by Dennis Garavsky: A more straightforward and convenient way to query data using LINQ with ObjectSpace

Dennis Garavsky — Mon, 24 Aug 2015 15:10:00 +0000

First of all, it is important to note that the capability to query data using LINQ has been available for a long time in the current version of XAF (or better said, in the underlying Entity Framework and XPO ORM libraries). So, this improvement in v15.2 is all about improving developer usability by exposing a helper method for the IObjectSpace interface representing one of the main XAF entities (learn more...).

As noted in the corresponding SC ticket (from here you can also learn on the current solution):

The IObjectSpace interface now declares the following method:

[C#]IQueryable<T> GetObjectsQuery<T>(Boolean inTransaction = false);

This method is implemented in the XPObjectSpace, EFObjectSpace and NonPersistentObjectSpace classes.

The inTransaction parameter has effect in XPO only and enables the mode in which querying a data store for objects includes all in-memory changes into query results.

In the NonPersistentObjectSpace, the GetObjectsQuery method casts the collection of objects created in the ObjectsGetting event to IQueryable and returns the result.

For XPObjectSpace, this method just returns a new XPQuery<T> from the underlying Session, while for the EFObjectSpace, the GetObjectsQuery method returns a new instance of ObjectQuery<T> with the help of the associated DbContext.

Here are a few usage examples from our unit tests (using the method-based query syntax):
EF:
IQueryable<Product> objectsQuery = objectSpaceB.GetObjectsQuery<Product>().Where(p => (p.Supplier.ID == supplier_A.ID));
Assert.AreEqual(5, objectsQuery.Count());
Assert.AreEqual(3, objectsQuery.Where(p => (p.Name == "A")).Count());
Assert.AreEqual(2, objectsQuery.Where(p => (p.Name == "B")).Count());

XPO:
IQueryable<TestObject> query = objectSpaceB.GetObjectsQuery<TestObject>();
Assert.AreEqual(5, query.Count());
Assert.AreEqual(3, query.Where(t => t.StringProperty == "A").Count());
Assert.AreEqual(2, query.Where(t => t.StringProperty == "B").Count());

I hope you will appreciate this minor improvement and it will save you from polluting your code by the casts to the XPObjectSpace/EFObjectSpace types to access the underlying ORM data context LINQ features.

BLOG by Dennis Garavsky: How to place an Action in a different location programmatically

Dennis Garavsky — Mon, 24 Aug 2015 14:39:00 +0000

I think that many people know that they can control this visually by drag&drop under the ActionDesign | ActionToContainerMapping node in the Model Editor, but just a few know of the best code solution. A good scenario when it is necessary to handle this requirement in code is described by our customer in this Support Center ticket (more real user scenarios can be found here).

After receiving enough requests for this, we decided to put a full example solution in our docs. It is based on handling a single CustomizeContainerActions event of the built-in ActionControlsSiteController (or FillActionContainersController class, if your form template does not support the IActionControlsSite interface).

Do not miss this new online documentation and hopefully, it will help you spend less effort on accomplishing your advanced business requirements in our framework.

BLOG by Dennis Garavsky: Refreshing UI according to the security permission changes done through the application or directly in the database

Dennis Garavsky — Fri, 31 Jul 2015 02:24:00 +0000

UPDATE:

Starting with version 15.1.6, the DevExpress.ExpressApp.Security.Adapters.IsGrantedAdapter class and its static Enable(ReloadPermissionStrategy reloadPermissionStrategy) method are used instead of the CanRefreshPermissions property, which became obsolete. The ReloadPermissionStrategy enumeration has the following values:
OnEachTransaction - the latest security permissions are loaded from the database for each new Session. Based on this info, permission request results are calculated and cached. Subsequent permission requests are evaluated using the cache if the Session object was not changed.
OnLogon - the latest security permissions are loaded from the database only once, on the logon, and are used until the log off or next logon event. Permission request behavior is the same as in the previous mode. This helps avoid extra queries to the database while keeping the correct evaluation of object access permissions.

I want to repost my recent answer from this Support Center thread to collect more feedback from users:

To ensure better performance, security permissions are cached on the first request by default, so that subsequent requests for object access rights are taken from the internal cache. We have received several customer requests to modify this behavior so that the most recent permission info was considered without the cache. In those scenarios, permission data was changed externally by an application administrator who wanted it to be applied immediately without forcing the user to restart his or her app.

To enable the new mode, set the static SecuritySystem.CanRefreshPermissions property to True before a user is logged in, e.g. within the static constructor of your platform-agnostic module (YourSolutionName.Module) or within the Main function of the WinForms app or from the Application_Start method of your ASP.NET app respectively:


[C#]

...
namespace MainDemo.Module {
    public sealed partial class MainDemoModule : ModuleBase {
        static MainDemoModule() {
            SecuritySystem.CanRefreshPermissions = true;
        }
        ...
    }
}

Once you do this, security permission changes will be queried after the built-in Refresh Action is executed or when a new object DetailView is opened. This guarantees that an end-user will see the application screens updated according to the most recent information. Additionally, the object access permissions by criteria will also be correctly re-evaluated according to the latest data changes. Consider the following scenario: there is a TestObject class with the Name and Description properties. Reading the Name property is always available, while the Description can be read only if Name equals "1":

Previously, to be able to see the effect of a permission after changing the Name property, you had to re-logon the current user as per How do I reset the security permissions cache without logging in again after an administrator has changed user rights?
Now, with the SecuritySystem.CanRefreshPermissions option set to True, it is sufficient to press the Refresh button.

We would greatly appreciate you downloading the most recent 15.1.5+ hot-fix build (or wait for the official v15.1.6) and testing this behavior in action with your project to see if it meets your needs.
If this does not fully suit you, please describe the most important use-case scenarios and expected results that you wish to achieve with the security permission checking mechanism.

BLOG by Dennis Garavsky: Making the AuditTrail functionality operate correctly with several XPObjectSpaceProviders when storing data in separate databases (15.1.6)

Dennis Garavsky — Thu, 23 Jul 2015 04:48:00 +0000

I wanted to inform the community of a solution we have just finished testing for the next XAF version in response to the following customer's business scenario:

"i followed this instruction to work with two databases in one application. so far so good.

i also managed to include the security module and get it working, but now i don't know how to use the "audit trail" module! it doesn't seem to matter in which project i include it, but it will not save anything to the database."

As you probably know, XAF supports connecting to several databases and even using both Entity Framework (EF) and eXpress Persistent Objects (XPO) at the same time (examples: one, two, three), although it is not the primary scenario, to be honest.

In short, if you were in need of such a configuration and wanted to have AuditTrail capabilities, it would "just work" starting with v15.1.6. If you feel confident to check technical details on this, see my description in the T263982 - AuditTrail - Ensure support for scenarios with several XPObjectSpaceProviders ticket.

By providing support for this module, we continue working in the direction we took in the past, which I also discussed in the past blog. As always, our team is looking forward to hearing your feedback in this regard.