Latest Forum Discussions

Linking in Property Codes Drop Down

2017-07-14T19:30:45.6130000

Make sure the WPF project you are adding the Property Codes Drop Down has a reference to the WPF.PropCodeValue assembly. If doesn't, then add the following to your .csproj file:

<Reference Include="WPF.PropCodeValue, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">

<SpecificVersion>False</SpecificVersion>

<HintPath>$(A4DNMaintenanceHintPath)WPF.PropCodeValue.dll</HintPath>

</Reference>

In the WPF XAML, you need to add the namespace for the WPF.PropCodeValue assembly

xmlns:propCodeValue="clr-namespace:WPF.PropCodeValue;assembly=WPF.PropCodeValue"

In the WPF XAML, Add the Property Codes Drop Down XAML. There are 3 different types of Drop Downs to choose from:
- PropCodeValueDropDown - Value is the display member; You can Bind to Value
- PropCodeValueDropDown02 - Code is the display member; You can Bind to Code
- PropCodeValueDropDown03 - Value is the display member, You can Bind to Code

Example using PropCodeValueDropDown03 replacing the IndexerName property with the Property Codes Table STDMIndexerNames:

<propCodeValue:PropCodeValueDropDown03 ap_PropertyMetaData="{x:Static entity:DM_IndexerFormatFieldsEntity.IndexerNameProperty}" Code="{Binding Path=IndexerName, Mode=TwoWay}" DefaultPropertyCodeTable="STDMIndexerNames" ap_BtnNewDetailVisibility="Collapsed" ap_BtnOpenDetailVisibility="Collapsed" ap_BtnSearchAndSelectVisibility="Collapsed" Margin="0,0,2,5" ap_LabelPosition="Left" DockPanel.Dock="Top" HorizontalAlignment="Left" Width="550" />

How to Add the Remarks tab to a module

2017-06-08T19:09:57.2370000

To add the Remarks tab to a module, you must first identity the Reference IDs for both the Content Explorer window and the Detail window. Typically these will be {ModuleName}ExpContent and {ModuleName}Detail. In older systems with WPF check the module's WPF source code; the detail's xaml code-behind sets ap_SubBrowserLoad with the detail's Reference ID, and the ExpContent xaml code-behind filenames may have an _ and the content window ReferenceID appended to them. Note that there may be more than one Reference ID for each window type.

Start up the Maintenance system. If Remarks is not already in your system, go to System, select your system, open the Applications tab, and use the Quick Add to add the Remarks application to your system.

Go to Maintenance > SB Interfaces. For each Reference ID, add a new SB Interface:

Reference ID is set to the reference ID you're adding
Display Sequence = 999 (last tab, before Audit Stamps)
Module Name: Choose Remarks from the dropdown
Name: change to &Remarks for menu shortcut key
Description: leave as Remarks or modify if you wish

Next, go to Maintence > Modules, and use the filter to find the Remarks module. Select the Remarks module and in the preview area open the View References tab. For each Reference ID add a new view reference:

View Name: select FWRKV01 from the dropdown
Select Use as Default View and Auto Load Content Window
Choose Sub Module
Set Parent Component to the Reference ID

NOTE: If you use "Save and New" for the view references, make sure to re-enter RFWRKEBS1 as the Explorer Bar Component. This is set automatically for you if you use "Save and Close" and then click on the New command in the View References sub-browser tab.

Surround Training Courses

2017-05-19T15:01:21.6800000

Surround offers several training courses to help get you started developing with the .NET technology stack. These courses are not Accelerator training courses, but the topics discussed in these training courses is recommended before going through any Accelerator training courses. These courses are instructor lead with Powerpoint slides to discuss concepts and hands on training to reinforce the concept. Visual Studio is required to be installed for these training courses.

Visual C# Programming (4 - 5 Day Course)
- Chapter 1 - Overview of OOP, .NET and C#
  - What is OOP?
  - What is a Class? an Object?
  - What is a Method? a Property? An Event?
  - What is an Interface? an Abstract Class?
  - What is Abstraction? Inheritance? Polymorphism? Encapsulation?
  - What are Access Modifiers?
  - What are Keywords?
  - Evolution of C#
  - Overview of the .NET Framework
- Chapter 2 - C# Program Structure
  - Program Layout
  - Namespaces
  - Keywords and Identifiers
  - A class
  - Class methods
  - Comments
- Chapter 3 - C# Data Types
  - Value and Reference Variables
  - Stack vs. Heap Memory
  - Built-in Data Types
  - User Defined Types
  - Literals and Constants
- Chapter 4 - C# Operators and Type Conversion
  - Operators
  - Assignment Operators
  - Equality Operators
  - Mix-Type Conversion
  - Casting
  - String Operators
  - Named Operations
  - Data Conversion
- Chapter 5 - C# Parameter Passing
  - Pass by Value
  - Pass by Reference
  - Parameter Arrays
- Chapter 6 - C# Conditions and Loops
  - Conditional Statements
  - Loop Statements
- Chapter 7 – Exception Handling
  - What is an Exception?
  - Exception Keywords
  - Exception Classes
  - Exception Example
  - Exception Flow
- Chapter 8 – Defining Your Own Data Types
  - Instance Data
  - Data Scope
  - Constructors/Destructors
  - Properties
  - Enumerations
  - Operators and Indexers
- Chapter 9 – Collections (LINQ and Lambda Expressions)
  - Types of Collections
  - Accessing Collection Data
  - LINQ
  - Lambda Expressions
- Chapter 10 – Inheritance and Polymorphism
  - What is Inheritance?
  - Virtual/override keyword
  - Polymorphism
- Chapter 11 – Delegates and Events
  - What is a Delegate?
  - Delegate Declaration
  - Delegate Example
  - Event Declaration
  - Event Example
- Chapter 12 – Reflection and Attributes
  - .NET Assembly Hierarchy
  - What is Reflection?
  - Reflection Example
  - C# Attributes
  - Predefined Attributes
  - Creating Custom Attributes

Windows Presentation Foundation (WPF) (2 - 3 Day Course)
- Chapter 1 – Introduction to WPF
  - WPF Overview
  - XAML Overview
  - WPF Architecture
  - WPF Class Hierarchy
- Chapter 2 – XAML Syntax
  - XAML Basics
  - Object Element Syntax
  - Properties of Object Elements
  - Processing Attribute Values
  - Collection Syntax
  - XAML Namespaces
- Chapter 3 – Layouts and Controls
  - Sizing Options
  - Alignment
  - Visibility
  - Padding and Margins
  - Layout Controls
  - Built-in Controls
- Chapter 4 – Data Binding
  - What is Data Binding?
  - Data Context
  - Value Converters
- Chapter 5 – Dependency Properties
  - Dependency Property purpose and advantage
  - Value Resolution
  - How to create a Dependency Property
  - Dependency Property Example
- Chapter 6 – Resources
  - Types of Resources
  - Resource Lookup
  - Static vs. Dynamic Resources
- Chapter 7 – Styles and Triggers
  - Styles
  - Triggers
- Chapter 8 – Templates
  - Control Templates
  - Data Templates
- Chapter 9 – Animations
  - Story Boards
  - Timelines
  - Transform
- Chapter 10 – Architecture Patterns
  - What is MVVM?
  - Benefits of MVVM
  - How the Accelerator uses MVVM
  - Attribute Based Validations

Changing the WPF Tab Background Color

2017-05-03T14:37:12.4570000

You can access the TabItems in the WPF Content Window and Detail code behind to set the properties based on business rules.

Here is sample code that sets the background color of a tab to yellow for a specific module number.

Here is what the code looks like in the Content Window code behind if you want to set the color for a sub module tab that shows in the preview pane.

Note: This code assumes you are using the Docking Tabs (Dragablz) and therefore uses the AB_DockingSubBrowserTabItem class. If you are not using Docking Tabs, then this class should be changed to AB_SubBrowserTabItem.

public override void am_SubBrowsersCreated(ObservableCollection<AB_ITabItem> subBrowserTabs)
{
    base.am_SubBrowsersCreated(subBrowserTabs);

    foreach (var tabItem in subBrowserTabs)
    {
        if (tabItem is AB_DockingSubBrowserTabItem subBrowserTabItem)
        {
            if (subBrowserTabItem.ap_SubBrowserModule.ModuleNumber == 6)
            {
                subBrowserTabItem.Background = System.Windows.Media.Brushes.Yellow;
            }
        }
    }
}

Here is what the code looks like in the Detail code behind if you want to set the color for a sub module tab.

protected override void am_OnDataLoaded()
{
    base.am_OnDataLoaded();

    foreach (var tabItem in ap_MainTabControl.ap_TabItems)
    {
        if (tabItem is AB_DockingSubBrowserTabItem subBrowserTabItem)
        {
            if (subBrowserTabItem.ap_SubBrowserModule.ModuleNumber == 6)
            {
                subBrowserTabItem.Background = System.Windows.Media.Brushes.Yellow;
            }
        }
    }

    // Current Loaded Data Entity
    //CustomersEntity currentEntity = ap_CurrentEntity as CustomersEntity;
}

If you are changing the sub module tab properties in both the Content Window and Detail, then I would suggest to create a method in the ViewModule that receives the SubBrowserTabItem from these code behind methods to set the properties in order to eliminate the duplication of business logic code.

Overriding Columns in XAML

2017-05-02T22:17:09.9800000

You can override the display template and edit template of any WPF column in the datagrid within the content window XAML.

The following list explains the various elements and properties that can be used in the XAML.

AB_DataGridColumnOverrideContainer - this notes what column should be overridden and when.
- Properties:
  - ap_PropertyMetaData: Specifies the property this custom column should be used for.
  - ap_ColumnOverrideUse: When this override should be applied. The values can be Editable, ReadOnly, or Always.
AB_DataGridTemplateColumn - The custom column. You can specify anything that inherits from DataGridColumn instead in order to support showing a Hyperlink, image, or something else.
- Properties/Events:
  - SortMemberPath: Specifies the path of the property that should be used when the user clicks the header of this column. If none is provided, the user will not be able to sort with this column.
  - CopyingCellClipboardContent: Specifies a custom event handler that can be used to provide the content of what should be copied to the clipboard.
  - ae_PastingCellClipboardContent: Specifies a custom event handler that can be used to override the behavior when pasting to a particular cell in the datagrid. There is also a PastingCellClipboardContent event that gets signaled, however, the event args for this do not allow for the canceling of the default paste behavior.
AB_DataGridTemplateColumn.CellTemplate - The content of this is a DataTemplate that will be applied when a cell is not currently being edited.
AB_DataGridReadOnlyCellContent - This class supports showing errors and error messages that are generated as a result of validating an entity. It also supports binding to a property that determines the background color of a cell.
- Properties/Events:
  - ap_ContentBinding: The binding which is used to display the content of a cell when it’s not in edit mode.
  - ap_VisualizationType: Specifies how the cell should display data. The values can be Text, Checkbox, Date, or Time. A TextBlock is used to display all visualization types except for Checkbox.
  - ap_BackgroundColorBinding: Used to specify what property to bind to in order to set the background color when not in edit mode.
AB_DataGridTemplateColumn.CellEditingTemplate - The content of this property is a DataTemplate that will be applied when a cell enters Edit mode.

Modifying the RowHeaders in the Datagrid

2017-05-02T21:44:56.9200000

By default, row headers will show an image that is specified by the A4DN_EntityImage property of an entity. By default this is set to the module image. The getter of this property can be modified in the entity to return different values based on business rules. For example, a different image can be used to represent that an order is finalized.

Here is example code taken from a Purchase Order Entity:

public override string A4DN_EntityImage
{
    get
    {
        return IsOrderFinalized == true ? "ok" : "check-mark-gray";
    }
}

If the property IsOrderFInalized is true, the image will use the png name "ok" otherwise it will be "check-mark-gray". You can supply any condition you need as long as you return an image name. The image name can exist in the Acclerator images folder or your own WPF shared images folder. Also, if you defined the key "System.16PixelImageSuffix" in your app.config, then the Acclerator runtime will look for the image name you return with the 16 Pixel Image Suffix before it looks for just the returned image name. In the example above, it will look for check-mark-gray_16_16_32.png before it looks for check-mark-gray.png. It will also hunt your WPF shared images folder before looking in the Acclerator images folder.

Switching between tab controls

2017-04-26T20:20:24.1230000

The Accelerator supports 2 different types of tab item controls in WPF: AB_TabItem and AB_DockingTabItem.

AB_TabItem is a wrapper around the standard WPF TabItem control that does not support dragging or undocking.
AB_DockingTabItem is a wrapper around a 3rd party control called Dragablz. Dragablz is an open source Chrome style draggable & tearable tab for WPF. Dragablz also makes user friendly docking and tool windows achievable very quickly.

The is what Dragablz (AB_DockingTabItem) looks like in the Accelerator:

You can undock and flot tabs with Dragablz.

The is what the standard WPF Control (AB_TabItem) looks like in the Accelerator:

The benefit of using the Dragablz's docking tab is that you can rearrange the tabs as well as undock them. Currently the arrangement of tabs is not remembered after you log out. In a future version we are looking to give the user the ability to remember the tab position and whether it is docked or not. The Docking tab currently only supports the overflow with one line and left/right arrows. If you want to have the multiline tabs and don't care about the docking feature, then you can convert your code back to use the standard WPF tab controls.

If you want to use the standard WPF tabs, you simply need to do an edit/replace for 2 controls throughout all your projects:

Do the following to go from Docking tabs to WPF tabs:

replace AB_DockingTabControl with AB_TabControl
replace AB_DockingTabItem with AB_TabItem
Verify that your WPF app.confing has the following entry
- <add key="Module.TabControl.ClassName" value="A4DN.Core.WPF.Base.AB_TabControl" />
Optional - Remove references to the Dragablz.dll from your WPF projects

Do the following to go from WPF tabs to Docking tabs:

replace AB_TabControl with AB_DockingTabControl
replace AB_TabItem with AB_DockingTabItem
Verify that your WPF app.confing has the following entry
- <add key="Module.TabControl.ClassName" value="A4DN.Core.WPF.Base.AB_DockingTabControl" />
Add references to the Dragablz.dll in your WPF projects (C:\Program Files\Accelerator for .NET\vx_x\Core\DotNet\Dragablz.dll)

Multilingual Support

2017-02-17T21:05:58.9000000

Accelerator has full support for multiple cultures and well defined best practices that are included in the runtime core components, helper classes, wrappers and development tools including the code generation engine.

What we did for you in the Accelerator:

There are 3 different areas that needed to be translated within the Accelerator Product itself. These areas include the:

Accelerator Core Description and Message Resourse Files (.resx)
Accelerator Maintenance Description and Message Resourse Files (.resx)
Accelerator Database MetaData Names and Descriptions

The Accelerator has language packs for several languages which were translated using Google translate and meant for demonstration purposes only. The following languages are Spanish (Spain), French (France), Japanese (Japan), Portuguese (Brazil) and Chinese (Simplified). The Description and Message resources for all these languages is included with the Accelerator Install for both the Accelerator Core and the Accelerator Maintenance. The Language packs for the Accelerator Database Metadata needs to be downloaded and run separately. You can download the SQL script here. All you need to do is unzip and change the "USE" statement at the top and run the script. This will insert data into the AC_MultilingualExt file in your Accelerator Database. Please contact us if you want to use a language in production or need to support additional languages. We will be happy to assist.

Your generated system has 2 different areas that need to be translated. These areas include the:

BOS System Shared Message and Description Resources (.resx)
Accelerator Database MetaData Names and Descriptions

Here is what you need to do to support a new Language:

1) Add a Message Resource and a Description Resource for each language to the BOS System Shared Project and within the Properties folder. You will notice that you already have a MessageResource.resx and a DescriptionResource.resx. That was created when you initially generated the system and contains your default culture text. You can download the following sample resources and add them to the Properties folder. Just make sure to include them in your project. Or you can create the additional resourses (.resx) in Visual Studio. When you add the new Message Resource and Description Resource, you need to add the Culture Name for the language you want to support using this format: MessageResource.<CultureName>.resx and DescriptionResource.<CultureName>.resx. Refer to this link for a list of cultures. Here is an example with several resources added.

2) Translate the Message Resource and the Description Resource. There are several different resx managers out there. I recommend Zeta Resource Editor. All of them allow you to do side by side translation. I like Zeta Resource Editor because you can create Projects that contain a collection of resources and it has the ability to auto translate via Bing or Google Translate. You will need to open all your description resources as a group and translate them and then open all your message resources as a group and translate them. When you open them as a group, you will see that the manager puts your default resource first (That is the .resx without the Culture Name) and then the others follow it. Go ahead and translate and then save it when you are done. Remember you can use Bing or Google Translate.

3) Translate your System MetaData Names and Descriptions that are in the Accelerator Database. You can do this by running the Framework Data Multilingual Translation Tool located within the Tools menu of the Accelerator LuanchPad.

This will open the following window that allows you to 1) Select a table to translate, 2) Select a Language that you want to translate to, 3) Translate by clicking the "Auto Translate Missing" Button or by manually translating the Name and Description in the Grid and 4) Save the Translation. You will need to do this for each Table that is in the drop down from step 1 and for each culture you want to translate to in step 2.

Selecting Data using SQL Functions

2017-02-15T15:49:50.3300000

SQL has many built-in functions for performing calculations on data.

Useful aggregate functions:

AVG() - Returns the average value
COUNT() - Returns the number of rows
FIRST() - Returns the first value
LAST() - Returns the last value
MAX() - Returns the largest value
MIN() - Returns the smallest value
SUM() - Returns the sum

The Accelerator supports this by defining the function expression on the AB_DataSourcePropertyReference class within the DataMaps am_LoadFieldMaps method.

For Example, I have an Order Item file that has a Product ID (YD1I1PID) field and a Unit Price (YD1IPRUN) field. For demonstration purposes, I want to sum the Unit Price for each unique Product ID. To do this I need to Group_by Product ID and use the SUM function on the Unit Price.

We first need to add a property to the Order Item Entity that will hold the Total Price value which will contain the SUM of the Unit Price.

[Display(Name = "TOTALPRICE", ResourceType = typeof(DescriptionResource))]
[AB_Length(8)]
[DataMember]
public decimal? TotalPrice //Map Field: YD1IPRUN
  {
      get { return am_GetPropertyValue(TotalPriceProperty); }
      set { am_SetPropertyValue(TotalPriceProperty, value); }
  }
public static AB_PropertyMetadata<decimal?> TotalPriceProperty = am_CreatePropertyMetaData<decimal?>("TotalPrice", DescriptionResource.TOTALPRICE, null);

Next, we need to add a data map which will contain the SQL function and map the result into the TotalPrice property. Add a map as you normally would, but receive the result into a variable. In this case I am receiving the Type AB_DataSourcePropertyReference into the variable "sum". Then you can set the property ap_FunctionExpression with the SQL function you want to use. Notice that I also added a data category "YD1I_TotalsByProduct". I only want to select this field and do the sum when using this data catagory.

var sum = maps.am_AddDataMap("TotalPrice", OrderItemEntity.TotalPriceProperty, dataCategories: new List<string> { "YD1I_TotalsByProduct" });
sum.ap_FunctionExpression = "SUM(YD1IPRUN) as \"TotalPrice\"";

The data category "YD1I_TotalsByProduct" was also added to the Product Internal ID which is the field I want to group by. You will notice that I also have the data category "*ALL" which means this field will always be selected if no category is applied.

maps.am_AddDataMap("YD1I1PID", OrderItemEntity.ProductInternalIDProperty, dataCategories: new List<string> { "*ALL", "YD1I_TotalsByProduct" });

The last step is to add the Group_By and Category. The Group By will return a single record per Product ID and the Category allows me to select only certain fields (In this case Product Internal ID and Total Price). We can do this on the ap_Query object which is passed with the AB_SelectInputArgs. I generally like to add the Group By and Category in the am_Select of the Business Process class and condition it based on an Accelerator view. You will also notice that I am setting the ap_RecordsPerRequest and the ap_MaxCount to a max value. When running this query we need to return all records as Next Previous is not supported with this Group_BY.

public override AB_SelectReturnArgs am_Select(AB_SelectInputArgs inputArgs)
{
 	if (inputArgs.ap_View == "YD1I_TotalsByProduct")
            {
                inputArgs.ap_Query.am_AddGroupBy(OrderItemDataEntity.OrderItemEntity.ProductInternalIDProperty);
                inputArgs.ap_Category = inputArgs.ap_View;
                inputArgs.ap_RecordsPerRequest  = int.MaxValue;
                inputArgs.ap_MaxCount = int.MaxValue;
            }

        var retArgs = base.am_Select(inputArgs);
        return retArgs;
}

How to Regenerate Service References

2017-01-20T19:22:50.2630000

Sometimes you need to regenerate all your service References. This can be done manullay in Visual Studio, or you can use our tool to regenerate all service references for the View Model and/or the Business Process.

To regenerate the service references, Click on the "Code Generator" located under the tools area in the Accelerator Launch Pad.

Then, 1) Click on the ellipse and navigate to your System Generation Configuration File.

Then, 2) Click the "Regenerate service reference" button.

It will step through each module and regenerate the service references.

"Files corrupt in deployment" message while installing or updating a ClickOnce application

2017-01-05T22:09:47.1000000

This is a generic error that occurs whenever the ClickOnce installer isn't able to download all of the files; it just assumes that one of the files is corrupted.

To investigate the issue, install and run Fiddler so you can monitor the files that are being downloaded, and watch for the failure. Most of the HTTP requests will return an application/octet response type (a binary file) but the last one will not.

A likely issue is that antivirus software, either on the webserver filtering outgoing traffic, on your PC filtering incomming traffic, or in the middle filtering traffic passing through, is getting a false-positive match against one of the dlls. In Fiddler, you'll see that an html page was returned instead of the file. You can see the html in Fiddler, and you can also copy the url to your browser to try to download the file yourself and see the error message. This is also handy for reproducing the error without having to go through the entire install process, and for verifying that it's been fixed.

Use AB_SocialMetaModel in CMS website to generate all social media meta/link/script markup

2016-12-15T14:23:01.5300000

This is a helper class that wraps around the code used for:

Typical usage is to create a shared partial template, often named _META_Elements.cshtml, which gets included in layout templates using RenderPartial(). The contents of the template instantiates an AB_SocialMetaModel object and then renders is using Html.DisplayFor(), which makes use of ~/Views/Shared/DisplayTemplates/AB_SocialMetaModel.cshtml and a few other templates to render out the meta, link, and script tags the model describes.

Several rarely-modified values are defined in overloadable properties, so they can be changed by defining a subclass of AB_SocialMetaModel and using that in _META_Elements.cshtml instead. A subclass's constructor can also be used to add additional tags, or remove some that aren't wanted, though this can also be done in _META_Elements.cshtml.

For meta tags, add new AB_PageMetaEntity objects to ap_PageMetaInfoModel
For link tags, add new AB_PageLinkEntity objects to ap_PageLinkInfoModel
For json-ld script tags, add new AB_PageScriptEntity objects to ap_PageScriptInfoModel

Several of the tags draw their values from the HttpContext.Items[] collection; these are typically set in page-specific controllers or views to provide page-specific tags.

"Meta.Title"
"Meta.Description"
"Meta.Keywords"
"Meta.ModuleImageURL"
"Meta.OGType" - Facebook Open Graph Type
"Meta.ScriptModels" - A List of AB_PageScriptInfoModel object for page-specific Google json-ld

For CMS pages and AB_Listing detail entities, these values are set through the Maintenance application's detail displays.

Excel Export- Adding additional columns to excel export from entity

2016-12-13T16:26:26.6270000

It is possible to add additional columns to the excel export if they are currently not defined as columns in the datagrid. To do this, you need to override the method am_OnDataPresenterCreated in the content window code behind:

protected override void am_OnDataPresenterCreated()
{
     base.am_OnDataPresenterCreated();

     var typedDataPresenter = ap_DataPresenter as AB_DataPresenterBase;
     typedDataPresenter.ap_ExcelColumnSelector =
     (datagrid) =>
         {
            var columns = typedDataPresenter.am_BuildColumnDictionary(datagrid);
            columns.Add(CustomerEntity.EmailProperty.ap_PropertyName, CustomerEntity.EmailProperty.ap_Description);
            return columns;
         };
}

Use the columns.Add method to add each column. The key should be the entity property name and the value should be the entity property description.

Memory Management Best Practices in WPF

2016-11-30T23:10:38.2270000

When a Detail window (or any XAML control) is closed, or otherwise goes out of scope, it must be cleaned up before the memory taken up by it can be released. In most cases this happens automatically, but it is possible to get yourself into a situation where stale references to your object prevent it from being cleaned up. In this situation the object remains in memory for much longer than intended and, if the problem is severe enough, has the potential to make the program unstable/unusable over time.

Memory Leaks like the one described above should be a constant concern for developers. Systems with poor memory managment will appear to degrade with use, which leaves a bad taste in the mouths of Users who often rely on these systems to do their jobs. Because the goal should be to have a system that is predictable and stable, Memory Leaks should be identified and fixed as soon in the development process as possible.

Below are several best practices for managing memory when coding with C#, including some WPF and XAML-specific tips.

Ports for IBM i Access

2016-11-11T20:34:52.6700000

The necessary ports to run the IBM i .NET Data Provider are:

1) 449 – Port Mapper. This is non-SSL, but no data is transferred on it. It is just a request to see what port to use. Client Access can be configured to not need this.

2) 8476 (9476 for SSL) – Signon Verification

3) 8471 (9471 for SSL) – Database Access

For info on all of the Client Access Ports look at http://www-01.ibm.com/support/docview.wss?uid=nas8N1019667.

The best article I found to explain these is http://www.mcpressonline.com/security/ibm-i-os400-i5os/iseries-access-through-a-firewall.html.

This Article explains how the Ports can be changed if you still felt it important to do that.

From this Article I set up Client Access to use the “Standard” ports so that you do not need to also open up port 449 for the Port Mapper. This is non-SSL, but no data is transferred on it. It is just a request to see what port to use.

Add iOS home page icons and startup images to MVC app for Safari and Mobile Safari

2016-10-19T16:59:41.8970000

UPDATE: See "Use AB_SocialMetaModel in CMS website to generate all social media meta/link/script markup" for simplifying wrapper class.

iOS devices can make use of custom icons when a web page is saved as a home page bookmark, and they can also display a custom splash image when loading the initial web page when the home page icon is clicked. If no custom icons/images are specified, iOS will use a screenshot of the website. Android devices, Chromebooks, and the Windows 8+ home page, all have similar behavior.

See Configuring Web Applications for all of the details. Also see Real Favicon Generator for an online service that can produce most of the images and associated markup for all platforms. (It doesn't produce startup splash images for iOS.) If the markup generated by Real Favicon Generator is used, remember to start the urls with ~/ instead of / in _Layout.cshtml so that they will work even if your web application is not deployed at your website root.

Seven images are needed, with specific dimensions:

touch-icon-iphone.png: 60x60
touch-icon-ipad.png: 76x76
touch-icon-iphone-retina.png: 120x120
touch-icon-ipad-retina.png: 152x152
apple-touch-startup-image.png: 320x480
apple-touch-startup-ipad-landscape.png: 1024x784
apple-touch-startup-ipad-portrait.png: 784x1024

These images should be placed in the root of the MVC project, so that they get deployed to the root of the web application. Next add the following tags to _Layout.cshtml inside the <head> element:

    <link rel="apple-touch-icon" href="~/touch-icon-iphone.png">
    <link rel="apple-touch-icon" sizes="76x76" href="~/touch-icon-ipad.png">
    <link rel="apple-touch-icon" sizes="120x120" href="~/touch-icon-iphone-retina.png">
    <link rel="apple-touch-icon" sizes="152x152" href="~/touch-icon-ipad-retina.png">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black">
    <link rel="apple-touch-startup-image" href="~/apple-touch-startup-ipad-landscape.png" media="screen and (min-device-width: 481px) and (max-device-width: 1024px) and (orientation:landscape)">
    <link rel="apple-touch-startup-image" href="~/apple-touch-startup-ipad-portrait.png" media="screen and (min-device-width: 481px) and (max-device-width: 1024px) and (orientation:portrait)">
    <link rel="apple-touch-startup-image" href="~/apple-touch-startup-image.png" media="screen and (max-device-width: 320px)">

Setting the Visual Studio Tools Version

2016-10-12T13:45:57.4470000

If you upgrade Visual Studio, you will need to make sure the Accelerator is aware of the current tools version to use. The Tools version is used by the Accelerator in the following ways:

1) During Generation, the Accelerator puts the tools version in any project file that is generated by the Acelerator.

2) The Build Script uses the tools version to determine the correct MS build programs to use.

The Tools version used by the Accelerator is in you standard configuration file. You can access this by runing the Accelerator Luanch Pad and navigating to the Configuration Tab. Click the "Edit" button to open the configuration editor. Change the Visual Studio Tools version to the version you have installed. If you have multiple configuration files, you will need to make this change in each one.

After changeing this setting, you will need to regenerate your build scripts. Go to this post to learn how to regenerate the build scripts:

http://support.surroundtech.com/thread/build-scripts/

Set initial focused control in a detailer

2016-09-07T20:12:05.6170000

The detailer has a property ap_ControlToSetFocusToInitially which will set the focus to that control on loading of the detailer when the detailer is not in display mode.

The recommended place to set this property is in the am_SetParentProperties override method.

Using AB_PageScriptInfoModel and A4DN.Core.MVC.CMS.Models.GoogleJsonLD to render JSON-LD markup

2016-08-22T21:14:19.0070000

UPDATE: See "Use AB_SocialMetaModel in CMS website to generate all social media meta/link/script markup" for simplifying wrapper class.

CMS Websites may want to take advantage of Google's support for JSON-LD semantic markup. To do so, it is necessary to output JSON data structure markup into script tags in the head element of your page. Accelerator 6.4.1 provides a number of helper classes to make this easier.

The AB_PageScriptInfoModel object represents a list of AB_PageScriptEntity objects, each of which will be rendered as a script tag. You can use these for any type of script tag; all standard attributes are supported. For example, to render a link to a javascript file, all you need to provide is a Src property containing the url to load, optionally with Async or Defer properties set. Inline javascript can be included by using Content instead of Src; the value of the Content property is rendered as-is (without HTML escaping) as the content of the script tag.

For Json-LD, you must specify Type = "application/ld+json" and provide the Content by instantiating an object from the GoogleJsonLD namespace, populating its properties, and then calling ToString() on it to serialize it to Json markup.

Json-LD is a complex family of schemas, of which Google supports a subset, and Accelerator supports a subset of Google's subset which is focused on the common types of websites created with the Accelerator CMS system. The supported semantic types are:

AB_SiteName: https://developers.google.com/search/docs/data-types/sitename
AB_SiteLogo: https://developers.google.com/search/docs/data-types/logo
AB_SocialProfileLinks: https://developers.google.com/search/docs/data-types/social-profile-links
AB_CorporateContacts: https://developers.google.com/search/docs/data-types/corporate-contacts
AB_BreadcrumbList: https://developers.google.com/search/docs/data-types/breadcrumbs
AB_ItemList: https://developers.google.com/search/docs/guides/mark-up-listings (Note: Google's documentation is incomplete, has some errors, and it is unclear what the correct markup / usage of lists are. This type is experimental.)

@using A4DN.Core.MVC.CMS.Models
@using A4DN.Core.MVC.CMS.Models.GoogleJsonLD
@{
    var scriptModel = new AB_PageScriptInfoModel();

    scriptModel.Add(new AB_PageScriptEntity
    {
        Type = "application/ld+json",
        Content = new AB_SiteName
        {
            Name = "Surround Technologies",
            Url = "http://www.surroundtech.com"
        }.ToString()
    });

    scriptModel.Add(new AB_PageScriptEntity
    {
        Type = "application/ld+json",
        Content = new AB_SiteLogo
        {
            Url = "http://www.surroundtech.com",
            Logo = Request.Url.GetLeftPart(UriPartial.Authority) + Url.am_MediaFile("surroundlogo-withtag.png")
        }.ToString()
    });

    scriptModel.Add(new AB_PageScriptEntity
    {
        Type = "application/ld+json",
        Content = new AB_SocialProfileLinks
        {
            Name = "Surround Technologies",
            Url = "http://www.surroundtech.com",
            SameAs = new List<string>
            {
                "http://twitter.com/#!/surroundtech",
                "http://www.facebook.com/SurroundTech",
                "http://www.linkedin.com/company/surround-technologies",
                "http://www.youtube.com/surroundtechnologies"
            }
        }.ToString()
    });

    scriptModel.Add(new AB_PageScriptEntity
    {
        Type = "application/ld+json",
        Content = new AB_CorporateContacts
        {
            Url = "http://www.surroundtech.com",
            Logo = Request.Url.GetLeftPart(UriPartial.Authority) + Url.am_MediaFile("surroundlogo-withtag.png"),
            Contacts = new List<AB_ContactPoint>
            {
                new AB_ContactPoint
                {
                    ContactType = "sales",
                    Telephone = "+1-239-405-8427"
                }
            }
        }.ToString()
    });

}
@Html.DisplayFor(m => scriptModel)

Using AB_PageLinkInfoModel to generate markup for link elements

2016-08-22T20:52:11.0070000

UPDATE: See "Use AB_SocialMetaModel in CMS website to generate all social media meta/link/script markup" for simplifying wrapper class.

Most MVC websites need to output some link tags on each page, usually in ~/Views/Shared/_Layout.cshtml or a partial template. Accelerator 6.4.1 introduces some helper classes to create strongly-typed model objects that represent these tags, and to render them consistently.

AB_PageLinkEntity supports all of the standard HTML5 attributes for link elements. Only Href is required; if it is empty the link element will not be rendered.

@using A4DN.Core.MVC.CMS.Models
@{
    var linkModel = new AB_PageLinkInfoModel();

    linkModel.AddRange(new List<AB_PageLinkEntity>
    {
        new AB_PageLinkEntity { Rel = "canonical", Href = Request.Url.AbsoluteUri },
        new AB_PageLinkEntity { Rel = "icon", Sizes = "32x32", Type = "image/png", Href = Url.Content("~/favicon.png") },
        new AB_PageLinkEntity { Rel = "shortcut icon", Type = "image/x-icon", Href = Url.Content("~/favicon.ico") },
        // new AB_PageLinkEntity { Rel = "apple-touch-startup-image", Href = Url.am_MediaFile("apple-touch-startup.png") },
        new AB_PageLinkEntity { Rel = "apple-touch-icon", Href = Url.Content("~/apple-touch-icon-iphone.png") },
        new AB_PageLinkEntity { Rel = "apple-touch-icon", Sizes = "76x76", Href = Url.Content("~/apple-touch-icon-ipad.png") },
        new AB_PageLinkEntity { Rel = "apple-touch-icon", Sizes = "120x120", Href = Url.Content("~/apple-touch-icon-iphone-retina.png") },
        new AB_PageLinkEntity { Rel = "apple-touch-icon", Sizes = "152x152", Href = Url.Content("~/apple-touch-icon-ipad-retina.png") },
    });
}
@Html.DisplayFor(m => linkModel)

To render the model, ~/Views/Shared/DisplayTemplates/AB_PageLinkInfoModel.cshtml is required:

@model A4DN.Core.MVC.CMS.Models.AB_PageLinkInfoModel
@foreach (var entity in Model.Where(m => !String.IsNullOrWhiteSpace(m.Href)))
{
<link rel="@entity.Rel" href="@entity.Href" crossorigin="@entity.CrossOrigin" hreflang="@entity.HrefLang" media="@entity.Media" sizes="@entity.Sizes" title="@entity.Title" type="@entity.Type">
}

Using AB_PageMetaInfoModel to generate markup for meta elements

2016-08-22T20:43:44.5070000

UPDATE: See "Use AB_SocialMetaModel in CMS website to generate all social media meta/link/script markup" for simplifying wrapper class.

Most MVC websites need to output some meta tags on each page, usually in ~/Views/Shared/_Layout.cshtml or a partial template. Accelerator 6.4.1 introduces some helper classes to create strongly-typed model objects that represent these tags, and to render them consistently.

In the following example, the HttpContext.Current.Items collection is used to pass data up from the page-specific view template to ~/Views/Shared/_META_Elements.cshtml, which _Layout.cshtml renders. This information is used to populate an AB_PageMetaInfoModel object, which is a list of AB_PageMetaEntity objects.

When rendered, only the AB_PageMetaEntity objects that have non-null, non-whitespace Content values will be output. There's no need to condition adding objects to the collection based on whether or not they have a content value.

Each AB_PageMetaEntity must specifiy either Name or Property. Property is only used for Facebook OpenGraph metadata, and for the HTML5 markup to be valid the head element requires a prefix attribute: prefix="og: http://ogp.me/ns# fb: http://ogp.me/ns/fb#"

Server-side HTML parsing and jQuery-like searching

2016-08-18T17:34:21.8370000

It is occasionally useful for server-side code, either inside View templates, Ajax request handlers, or Model classes, to search html markup, extract information from it, or even modify it. On the client this can be done using jQuery, and now on the server it's possible to perform these operations using AngleSharp and some utility methods in A4DN.Core.MVC.CMS.Infrastructure.Helpers.

// In controller or model:
var document = HtmlHelpers.am_GetParsedDocument(content);

// In view:
var document = Html.am_GetParsedDocument(content);

These methods return an AngleSharp IHtmlDocument, which has many methods for querying and/or modifying the content. By default the parsed document will be cached for 10 seconds so that repeated calls using the same content string will not re-parse the content. An optional second argument can be passed to alter the cache idle timeout. The first method uses HttpContext.Current.Cache as the cache, while the second uses Html.ViewContext.HttpContext.Cache. In most scenarios these are equivalent.

The rest of the methods will be shown using the Html.am_* syntax that's used inside views, but they can all be called using the HtmlHelpers.am_* syntax from controllers and models as well.

var elements = Html.am_GetElements(content, selector);

This is similar to jQuery's $("...") function, and takes the same kind of selector (except for jQuery's additions to the standard CSS-like selector syntax.) The return value is an IHtmlCollection<IElement>, which supports foreach and LINQ methods.

var value = Html.am_GetDataAttributeValue(content, elementSelector, dataAttributeName);

This method finds the first element in the content that matches elementSelector, and returns the value of that element's data-{dataAttributeName} attribute. Looking up data attributes is a common use case for server-side parsing.

var content = Html.am_RenderDocument(document);

If you use AngleSharp to make modifications to the DOM inside of document, am_RenderDocument() can be used to get an updated content string.

Using data-replacewith attributes to relocate DOM elements after page load

2016-08-18T17:03:23.9630000

Using jQuery, it is possible to move elements around in the DOM after the page has been loaded. But that requires writing Javascript code, and sometimes it can be useful to declare what to move and where to move it, rather than writing procedural code to execute the move. For example, static content in a CMS webpage module can include a declarative placeholder element which indicates where to insert dynamically-generated content.

The a4dn.replacewith.js plugin can be found in Accelerator MVC's DistributableContent project. In generated MVC projects, you'll find the plugin in the Scripts/ folder of your project. When this plugin is loaded, it extends jQuery with a function named $.a4dn_process_replacewith().

This function is used to process elements that have data-replacewith attributes. It takes the value of the attribute as a jQuery selector or an element id, finds the matching element within the page, and moves it to the location of the element that has the data-replacewith attribute.

This is typically used for CMS static web content pages that have dynamically-inserted content, to indicate where the dynamic content should be located within the static content.

The flag data-replacewith-mode="inner" can be used when you only want to move the children of the specified element, instead of the entire element. This is for situations where the markup structure won't allow an extra wrapper element to be inserted.

Either way, after the function is run the div with data-replacewith will be gone from the DOM, and if inner mode is used the container element will also be gone from the DOM.

Usage - Markup:

<div data-replacewith="#dynamic">Placeholder content; this entire div will be replaced with #dynamic.</div>

<div data-replacewith="#dynamic" data-replacewith-mode="inner">This div will be replaced with #dynamic's children.</div>

Usage - Process all attributes at page ready:

$(function() {
    $.a4dn_process_replacewith();
});

With no argument, a4dn_process_replacewith() searches the entire page.

Usage - Process specific container after page load (eg: when inserting content from an ajax request):

onSuccess: function (data) {
    $("#container").html($(data.markup));
    $.a4dn_process_replacewith("#container");
}

The #container argument restricts the search to just the newly added elements.

Use ThemePunch's Revolution Slider control on CMS web pages

2016-08-16T21:59:31.5700000

ThemePunch's Revolution Slider is included in many Bootstrap themes, and is also available as a standalone plugin. Accelerator CMS static web pages can include slider markup directly, but we also offer support for managing the list of slides as modules in the CMS Webpages tree.

Accelerator does not include a license for ThemePunch Revolution. It must be purchased through a theme or directly from ThemePunch, and the javascript and css files provided by ThemePunch must be deployed with your website.

Markup on the CMS page that includes the slider:

<div class="container-fluid">
    <div class="row">
        <div class="col-xs-12">
            <a4dn-revolutionslider id="slider1"
                data-treeroot="Navigation/Sliders/HomePage" 
                data-container-class="rev_slider_wrapper" 
                data-slider-class="rev_slider"
                data-slide-content-field="Banner Carousel">
            </a4dn-revolutionslider>
        </div>
    </div>
</div>

The Bootstrap container, row, and col are used to provide the slider with size constraints; any container that provides a block would do.

The a4dn-revolutionslider element will be replaced with appropriate markup for a Revolution Slider control, along with a javascript initizliation call that passes the data attributes to the plugin. Most of the data attribute names correspond closely to options for Revolution v5 sliders.

id: must be a unique identifier on the page. Used to uniquely identify the initialization with the specific slider element.
data-treeroot: identifies the Webpages tree element that is the parent of the list of modules to use as slides. "Navigator" is typically the application name used in the CMS Website's System, and is also specified when creating the Webpages module for the website. "/Sliders/HomePage" is the tree branch that you create within the Webpages module to hold the slides. You can use any naming convention that suits your site; this example assumes that all sliders will be defined under /Sliders, and that different sliders might be used on different pages.
data-container-class: Must be "rev_slider_wrapper" in order to set options and to auto-generate the initialization call. Bootstrap Themes will typically define a different container class for presets the theme provides.
data-slider-class: For auto-generation of the initialization, any class can be used here, to hook into custom CSS you provide. Bootstrap Themes will typically define several slider classes to use for the different presets they offer.
data-slide-content-field: Specifies which field the slide content should be pulled from; generally "Banner Carousel" or "Slider Carousel". (Dev note: can also be a property name on module entity or module extension attributes object.)

Markup for individual slides

In the Website Content Managment application for your website, all modules that you add to the Webpages tree have "Banner Carousel" and "Slider Carousel" tabs you can edit in the module's Detail window. When you add a module to the slide list (eg: under /Sliders/HomePage), you have to edit the content in one of these tabs to provide the HTML markup for the slide. The data-slide-content-field specifies which field to use.

NOTE: You can add new modules just for use within the slider, using the "Custom Explorer" module type, or you can add an existing module to make it available in the slider as well as wherever it already exists in the webpages tree. Each module has a single pair of markup tabs, so if you want to use a module in multiple sliders you need to use the same markup for each or use both tabs, except all modules for a slider need to use the same tab. If that's not desired, you must create a new module.

See https://www.themepunch.com/revsliderjquery-doc/slides/ for documentation on the slide markup. You must include the entire <li>...</li> element.

Within the markup, you can use special syntax for urls:

src="~/..." or href="~/..."
- The ~/ will be replaced with the deployment root url for the website. This can be used for links to named CMS pages, the home page "~/", the media url "~/media/...", etc
src="a4dn:..." or href="a4dn:..."
- The ... is typically a filename in the Media Library for the website. The attribute value will be replaced with the full url for the media file, based on the deployment and configuration settings.

Use AB_ConfiguredCacheCollection to create one or more AB_Caches that are config-driven

2016-08-10T16:15:54.7100000

In Use AB_Cache to store state information objects for a short time the low-level interface for creating and using AB_Cache is documented. To use the low-level interface, caching properties must be hardcoded or otherwise provided.

AB_ConfiguredCacheCollection allows a set of caching properties to be defined in a configuration file, and then one or more AB_Caches can be instantiated using those properties.

Usage - Set up Cache:

// Set up static service-side cache for holding custom field definitions
protected static AB_ConfiguredCacheCollection ap_WorkflowCaches = new AB_ConfiguredCacheCollection { };

// Get the custom fields cache; if the cache is disabled this will return null
protected static AB_Cache ap_CustomFieldsCache { get { return ap_WorkflowCaches["CustomFieldsCache"]; } }

The string used as an index on ap_WorkflowCaches is used to find the configuration entries. For this pool we're setting a 10 minute sliding expiration policy.

Configuration:

<add key="Feature.CustomFieldsCache.IsDisabled" value="False"/>
<add key="Feature.CustomFieldsCache.CacheMemoryLimitMegabytes" value="0"/>
<add key="Feature.CustomFieldsCache.PhysicalMemoryLimitPercentage" value="0"/>
<add key="Feature.CustomFieldsCache.PollingInterval" value="00:02:00"/>
<add key="Feature.CustomFieldsCache.SlidingExpiration" value="00:10:00"/>

How to specify IS NULL and IS NOT NULL where clauses in am_Select

2016-08-09T17:22:56.4430000

Typically Accelerator uses Search-by-Example, where an entity is created with properties populated with the values to search for. Any unpopulated values (set to null) are not searched. Using this approach, it is not possible to explicitly search for records where fields are NULL or not NULL.

To perform an explicit NULL search, create an InputArgs object as usual, initialize its ap_Query property, and then add a WHERE clause:

var inArgs = new AB_SelectInputArgs<ItemMasterEntity>(
    new ItemMasterEntity 
    { 
        ItemGrade = grade 
    }
);

inArgs.ap_Query = inArgs.ap_InputEntity.am_BuildDefaultQuery();

inArgs.ap_Query.am_AddWhereClause(
    ItemMasterEntity.ClassGenericShapeProperty.ap_PropertyName, 
    "IS NOT", 
    null, 
    true
);

am_BuildDefaultQuery() is called to create the initial set of WHERE clauses based on the search entity passed to the AB_SelectInputArgs constructor.

am_AddWhereClause() takes four arguments for the overload we need:

The string name of the property for the field we want to test
"IS" or "IS NOT" for the kind of test we want to do
null, for the property value to compare against
true, to validate the WHERE clause. (this argument is only set to false when you want to avoid data type conversions)

Passing logged in credentials when calling ViewModel methods

2016-08-09T13:11:17.5370000

The Data Access Layer needs to supply a User Name and Password in the connection string in order to connect to the data store. This User Name/Password can be hardcoded in the connectionParms.config, but normally a developer turns this off by removing the hard coded values and requires each service call to supply the logged in credentials. The Accelerator core automatically passes these credentials in many cases, but there are situations with custom components where you will be responsible for passing these parameters. The logged in credentials are available in the AB_DataPropertyController class and can be accessed like this:

var result = SBInterfaceVm.am_Select(new AB_SelectInputArgs<AB_StandardBaseInterfaceEntity>(sbQuery, AB_DataPropertyController.ap_UserIdentityStore.ap_UserName, AB_DataPropertyController.ap_UserIdentityStore.ap_Password, AB_DataPropertyController.ap_Token));
if (result.ap_IsSuccess)
{ 
}

Note: It is recommended to pass the UserName, Password and Token. The token is a variable that will be used in a future enhancement where the Accelerator Database Authentication will support tokenized security.

Delay load of Explorer Bar until Dropdown auto complete has finished

2016-08-08T18:47:35.3070000

You can add the following code to your Search Explorer Bar code behind to make it wait until the dropdown has finished auto completing to load records.

NOTE: This requires Accelerator 6.4 or greater.

Certificate Expiration in ClickOnce Deployment

2016-08-07T13:48:34.3570000

Here is information from MSDN on WPF ClickOnce Certificate Expiration...

Certificate Expiration in ClickOnce Deployment

Additional Certificate Information

Renewcert

Accelerator BP Service Host Performance Improvements in v6.4.0.0

2016-07-27T21:35:39.3130000

In v6.4.0.0, Accelerator BP Service Host has been updated to vastly improve the rate it is able to look up per-module Framework Data, which makes both WPF and MVC applications start up more quickly. This improvement was made by consolidating database queries and briefly caching query results across framework service calls. In earlier versions, it could take up to 12 seconds (on a slow network) to retrieve all of the Framework data for a single module, with many database queries per second during the entire period. That's been reduced to less than 100 milliseconds and just a few database queries after the first couple of modules.

For WPF, the per-module Framework data is retrieved when the application is started after downloading a new version or when using the Clear Cache option.
For MVC, the per-module Framework data is retrieved when the website (Line of Business, CMS, or custom) is restarted on IIS, and intermittently after that.

The Accelerator BP Service Host's WebAppSettings.config adds eight new configuration settings that control the cross-request caching. If the caching is suspected to be causing a problem (eg: metadata not being updated, or user-specific metadata leaking across users) the IsDisabled settings can be used to turn the caching off. Some performance improvements will still be present; each module will take about 1 second to update.

The memory limit settings can be used to control the cache's size in memory, and PollingInterval controls how often the memory size is checked. If the cache grows too large, older values will be dropped out.

The SlidingExpiration settings control how quickly a cached value will be dropped after its last access. These can be quite short during framework data updating because the service calls are fired very rapidly. Making these periods longer can improve performance during application usage, but could cause delays in recognizing security/authorization changes or user-initiated changes to view columns.

These settings only need to be added to your Accelerator BP Service Host deployment if you wish to change them; the settings shown below use the default values the code will use if the settings are missing.

  <add key="Feature.FrameworkAuthCache.IsDisabled" value="False"/>
  <add key="Feature.FrameworkAuthCache.CacheMemoryLimitMegabytes" value="0"/>
  <add key="Feature.FrameworkAuthCache.PhysicalMemoryLimitPercentage" value="0"/>
  <add key="Feature.FrameworkAuthCache.PollingInterval" value="00:02:00"/>
  <add key="Feature.FrameworkAuthCache.SlidingExpiration" value="00:01:00"/>
  <add key="Feature.ViewColumnCache.IsDisabled" value="False"/>
  <add key="Feature.ViewColumnCache.CacheMemoryLimitMegabytes" value="0"/>
  <add key="Feature.ViewColumnCache.PhysicalMemoryLimitPercentage" value="0"/>
  <add key="Feature.ViewColumnCache.PollingInterval" value="00:02:00"/>
  <add key="Feature.ViewColumnCache.SlidingExpiration" value="00:00:20"/>

Use AB_Cache to store state information objects for a short time

2016-07-27T20:47:04.0430000

As a general rule, BP Service calls should depend only upon their input args, static information set during startup, and configuration settings. This helps them to function correctly when handling many concurrent requests from different users, because state values from one user's request won't leak into another user's state.

However, sometimes this rule leads to performance issues because the BP Service has to repeat the same operation, with the same results, on every request. For example, if every request has to query the database to look up some information about the current user, and that information rarely changes, then it's unnecessary load on the database server.

The AB_Cache class can be used to hold a value in memory for a short time, even across BP Service calls, and it will drop the value if it is not used within a configurable time period. The class is a wrapper around System.Runtime.Caching.MemoryCache, with added support for Regions.

private static ObjectCache _MyCache = new AB_Cache();
protected ObjectCache MyCache { get { return _MyCache; } }


MyCache.Set("mykey", "a value", new CacheItemPolicy { SlidingExpiration = new TimeSpan(0, 2, 0) }, "Region_A");
var val = MyCache.Get("mykey", "Region_A") as string;

This example sets up a cache with default options for memory limits and expiration time. The AB_Cache() constructor accepts MemoryCache's arguments for CacheMemoryLimitMegabytes, PhysicalMemoryLimitPercentage, and PollingInterval.

In the Set() call, a CacheItemPolicy is passed which sets a two minute expiration, and the Region argument provides a namespace for the key arguments. A typical use in a BP Service would be to use InputArgs.ap_UserID as the region, so that each user has their own namespace within the cache.

A service application may contain multiple cache objects, which should all be static fields so that they're retained for the life of the service process. Each cache object has its own memory use limits, and provides a separate storage for its own regions and keys.

Adding Arbitrary Data to Connection Strings

2016-07-27T16:36:55.5370000

The Accelerator uses the information in the ConnectionParams files to generate a connection string used to contact your database. If required, you have the ability to add your own custom text to the end of the generated connection string.

Below is an example using a demo system’s connection parameters file that shows how to add arbitrary text to the end of your connection string. Note: You will need to add any required semi-colons yourself.

Original Connection Parms
<server id="Development">
    <add key="ServerType" value="Mainframe" />
    <add key="DataSource" value="10.10.1.2" />
    <add key="Database" value="TestDB" />
    <add key="UserID" value="Username" />
    <add key="Password" value="xxxxxx" />
    <add key="Collection" value="DATA" />
</server>

Original Connection String
"Server=10.10.1.2;Database=TestDB;UserId=Username;Password=xxxxxx;CurrentSchema=DATA;"

With CustomConfiguration
<server id="Development">
    <add key="ServerType" value="Mainframe" />
    <add key="DataSource" value="10.10.1.2" />
    <add key="Database" value="TestDB" />
    <add key="UserID" value="Username" />
    <add key="Password" value="xxxxxx" />
    <add key="Collection" value="DATA" />
    <add key="CustomConfiguration" value="APPID=TestApp;" />
</server>

New Connection String
"Server=10.10.1.2;Database=TestDB;UserId=Username;Password=xxxxxx;CurrentSchema=DATA;APPID=TestApp;"

How to use Framework Authentication with Active Directory

2016-07-18T13:08:29.1500000

Features

Allows Framework authentication to operate against ActiveDirectory server instead of comparing against an encrypted password stored in the Accelerator database.

Requires one config setting to activate, and three settings to configure.
Can use explicit values for the config settings, or can use the account running the DAL framework.
Framework authorization data is still in Accelerator Database.

Configuration

The following settings are added to the Accelerator web.config file.

<appSettings>
    <add key="UseActiveDirectoryAuthenticationForFramework" value="True" />
    <add key="ActiveDirectoryQueryUsername" value="" />
    <add key="ActiveDirectoryQueryPassword" value="" />
    <add key="ActiveDirectoryConnectionPath" value="LDAP://xxx.xxx.xx.xx" />
</appSettings>

The first one turns AD authentication on if the value is True (not case sensitive) and off otherwise. The next two settings specify an Active Directory account which has permission to talk to the Active Directory server. Any AD account can generally work here. The final setting specifies the URL for the Active Directory server.

If the last three settings are not set but authorization is turned on, then the account running the process will be used.

Note:

Even though the Authentication is performed via Active Directory, the User must exist in the Accelerator User File with a valid User Group that will give them access to the system. All security access to the system, applications, modules, commands etc. is driven by the User Groups assigned to the User.

Caching data between requests in ASP.NET MVC

2016-07-12T15:07:09.7700000

MVC's HttpContext object contains three collections that can hold onto data from one request to the next: Temp[], Session[], and Cache[]. They all use strings for their keys, and can store arbitrary objects (sometimes with limitations.)

Temp[] is used to hold a value for one-time use. Once the value is retrieved it is removed from the collection. A typical use would be to store a model object in a POST handler, redirect to a GET handler, and retrieve the model object from Temp[] to render it. (AB_BaseController provides am_StoreModelStateErrors and am_RestoreModelStateErrors to assist in this scenario by passing the ModelState object through Temp[] too, so that the GET handler can render validation errors that were discovered in the POST handler.)

Session[] is used to hold values for the duration of the user's session, or until they are explicitly removed. Storing a lot of data in Session[] can cause excess memory consumption on the server, limiting the number of concurrent sessions it can handle. To address this problem the session mode can be configured to store data in a standalone SessionServer system service or in MSSQL. If either of these modes are used, only [Serializable] objects can be stored in Session[]. (Typically Accelerator-based MVC applications that use user login will store the UserEntity and other user-related objects in Session[], but not all of that data is serializable, so only the In Process mode can be used.)

Cache[] is like Session[], except data can be set to expire and be removed automatically. Its Add() method lets you specify either an absolute expiration time or a sliding expiration timer (eg: time since last access.) It is also possible to specify a method which will be called when the item is removed from the cache.

private const string UNREAD_CACHE_KEY = "__MSG_Unread_Messages__";

public List<MSG_MessageEntity> UnreadMessages
{
    get
    {
        var msgs = HttpContext.Current.Cache[UNREAD_CACHE_KEY] as List<MSG_MessageEntity>;
        if (msgs == null)
        {
            // Real World: perform expensive database lookup here
            msgs = new List<MSG_MessageEntity>();

            TimeSpan expirationTime;
            if (!TimeSpan.TryParse(ConfigurationManager.AppSettings["Features.Messages.LookupFrequency"], out expirationTime))
            {
                expirationTime = new TimeSpan(0, 1, 0);
            }
            HttpContext.Current.Cache.Add(UNREAD_CACHE_KEY, msgs, null, DateTime.Now.Add(expirationTime), Cache.NoSlidingExpiration, CacheItemPriority.Default, null);
        }

        return msgs;
    }
}

How to Remove the remarks tab from a module

2016-07-07T23:10:47.8530000

Remarks is an Accelerator Module that can be added to any module. Remarks are added and removed via the Accelerator Maintenance.

In the Accelerator Maintenance, click on the SB Interface Module. Remarks can be added to either the Detail or the Explorer Content. You can choose to remove it from 1 or both. All you need to do is delete the SB Interface record.

In this example, I can delete remarks from the Customer Module Detail and Explorer Content by deleting these 2 records.

After you restart the system, you will no longer see the Remarks tabs.

Accelerator Commands and Command Bars

2016-07-05T13:33:42.8070000

The Accelerator allows you to define command bars, which contain commands, at several different locations:

System
Module
Sub-Module
Detail
System_Search_Select
Module_Search_Select

There are also 3 different command bar types:

Menubar
Toolbar
Popup

Not all locations support a particular command bar type. Here are the command bar locations with the supported command bar types:

System
- Menubar
- Toolbar
Module
- Toolbar
- Popup
Sub-Module
- Toolbar
- Popup
Detail
- Menubar
- Toolbar
System_Search_Select
- Menubar
- Toolbar
Module_Search_Select
- Toolbar
- Popup

Here is a look at all the command bar locations and types:

Command Bars can be defined at the System, Application and Module level. By default, the Accelerator generates all command bars at the system level. You can use the Accelerator Maintenance to change the system level command bars and commands, or add application and module command bars that replace the the higher level command bars. For example, the module level command bars will replace the application and system level command bars. You will notice that the command bars tab shows as a sub module on the system, application and module modules within the Accelerator Maintenance.

System Level Command Bars:

Application Level Command Bars:

Module Level Command Bars:

Data type conversion in Datamaps

2016-06-29T14:12:25.8770000

It is a best practice to use the appropriate data type in your .net entities and not be restrained to the type defined in the database schema. For example, in many legacy systems, the date field was defined with decimal or numeric 8 and stored in the format CCYYMMDD. In .net, all dates should use the DateTime data type.

The Accelerator allows you to convert you data between the data type defined in the entities and the data type defined in your schema. By default, the datamaps assume that the database type is the same as the entity type. If they are not, you need to specify the database type. The accelerator has some builtin data type conversions which should cover most of your database conversion needs. We also have the ability fo you to develop your own custom conversion programs.

In this example, our database has a datatype of DATE and NUMERIC(8) which both store dates.

In the .net Entity, all 3 fields are defined using the DateTime? data type. (ex:)

In order to map these 3 fields to and from the entity, I need to specify on the map the "dataBaseFieldType".

You can specify it like this:

In you have custom conversion needs, you can specify your own convert to and convert from methods.

Configuring Services to access different Accelerator databases (ex: Dev, Test, Prod)

2016-06-29T13:22:51.4870000

The Accelerator product comes with services to access the Accelerator Database. These services are installed in a folder within the Accelerator install directory. If the default install location is used, these services can be found here:

C:\Program Files\Accelerator for .NET\v#_#\A4DNServices.

These services need to be hosted in IIS in order to access them. You will need to copy the A4DNServices folder to your IIS Web server and convert the folder to an application in IIS. After you copy the services to your web server website folder, you will need to configure 2 configurations:

A4DNServices\WebAppSettings_Template.config

A4DNServices\bin\ConnectionParms_Template.config

You will need to copy these configs and remove the "_Template" from the name. The "_Template" is added so that you can copy the Accelerator Services folder after each Accelerator upgrade without clobbering your settings.

The WebAppSettings.config contains all the appSettings for your web.config. You will notice that your web.config references the WebAppSettings.config. The WebAppSettings.config is yours to change as needed and will not be clobbered by future accelerator upgrades.

The ConnectionParms.config contains the information on how to access the Accelerator Database. This config is also yours to change as needed and will not be clobbered by future accelerator upgrades.

The ConnectionParms.config allows you to define multiple connections. This is where you define where the Accelerator database exists and how to access it. This needs to be configured before the services will work.

The "serverSelect" element defines the default connection that will be used. You need to specify one of the server ids defined in the config. The default template has 2 server IDs defined: DB2_CONNECTION and MSSQL_CONNECTION. The template is configured to use the MSSQL_CONNECTION. You can define additional Sever IDs as needed. For example, you can define the server information (ServerType, DataSource, UserID, Password and Collection(or Library Name)) to connect to your Accelerator DEV, TST, and PRD databases by defining the Server ID Connection information for each and then Setting the ServerSelect idref to use the appropriate server ID for the service. If you do define connection information for multiple acceleartor databases, then it is important that you always pay attention to the "serverSelect idref" as that is the connection that the service will use.

Refer to this post for setting up multiple connections.

is-it-possible-to-setup-multiple-database-connections

The last step before the services will work is to convert the folder to an application.

In IISManager, Right click on the folder and click "Convert to Application".

You have the option to select an application pool.

Make sure the Application Pool you choose has these settings:

To test that the service is running, you can right click on the same folder and click Manage Applictaion --> Browse. You can then add the service AB_FrameworkBP.svc to the end of the URL:

ex: http://localhost/EasyBuyCyclesDEM/A4DNServices/AB_FrameworkBP.svc

You should get this html if the service is configured correctly in IIS:

Use AB_GeneralForm to implement forms on CMS website pages

2016-06-28T20:26:28.0600000

Accelerator 6.4.0 introduces a new CMS feature: AB_GeneralForm. This feature allows simple forms to be added to CMS website pages with a div tag and data attributes, similar to the way Bootstrap Javascript plugins work. Some form types are available in Accelerator and others can be added by the website project; the form type defines a set of available fields and their validation rules using standard DataAnnotations property attributes. The CMS page markup decares which fields to use, their order, and whether or not they are required. It also declares actions to take when the form is submitted: send an email to the user, send an internal email, create a workflow instance, redirect to a different CMS page, unhide an element on the page and insert a message into it.

In the CMS page:

<div data-a4dn-general-form="contact-info"
    data-a4dn-fields="*FirstName,*LastName,*Email,Company,Title,Phone,Address,*Message"
    data-a4dn-display-template="bs-form-icons"
    data-a4dn-requestor-mandrill-template="..."
    data-a4dn-internal-mandrill-template="..."
    data-a4dn-workflow-namespace="..."
    data-a4dn-confirmation-modulenumber="..."
    data-a4dn-show-on-success="..."
    data-a4dn-show-on-error="..."
    data-a4dn-submit-label="..."
></div>

This element's content will be populated with the "contact-info" form, rendered using ~/Views/AB_GeneralForm/bs-form-icons.cshtml, and only showing the fields listed in data-a4dn-fields. Any field names prefixed with * will be required. If submit-label is provided, it will override the label on the Submit button.

NOTE: Currently, a CMS page can only contain one element like this at a time. Support for multiple forms on a page is planned for a later release.

a4dn-general-form: The value "contact-info" gets mapped to the C# model class that has properties for all of the available fields for this form type. Website projects can define their own types and add them to the mapping list.
a4dn-fields: A comma-separated list of the fields to show, prefixed by * if they are requried. The field names match the C# property names, Mandrill merge tag names, and Workflow custom field namespaces.
a4dn-display-template: The name of the Razor template used to render the model. This allows different form styles to be used with the same model / form type. Website projects can provide their own templates.
a4dn-requestor-mandrill-template: Optional. If provided the form data will be emailed to the user using the specified Mandrill template. The model class must specify which form field to use for the user's email address and name; therefore not all form types support emailing the user.
a4dn-internal-mandrill-template: Optional. If provided the form data will be emailed to a configured email address using the specified Mandrill template. The website project's web.config file must contain an AB_GeneralForm.InternalEmail setting.
a4dn-workflow-namespace: Optional. If specified a new Workflow Instance will be created for the given workflow. The model class can populate the instance name with any of the form fields.
a4dn-confirmation-modulenumber: Optional. If specified a successful form submission will cause the browser to load the CMS page for the given module number.
a4dn-show-on-success: Optional. If specified the value should be a selector expression for a hidden element to show after successfully submitting the form. If the element contains an element with class a4dn-js-message, it's content will be set to the success message returned by the server.
a4dn-show-on-error: Optional. If specified this works like show-on-success, except for non-validation error messages when the form submission fails. (Eg: failure to send an email.)
a4dn-submit-label: Optional. The label for the submit button; defaults to Submit (or whatever the display template chooses to use.)
a4dn-{fieldname}: Optional. To override the label and placeholder text for a field, add a data attribute named a4dn- and the fieldname in lowercase. (Don't include the * for required fields.) The value of the attribute should be the label, a | character, and the placeholder text.
a4dn-{fieldname}-options: Optional. Specifies allowed values for the field, which will be rendered as a dropdown select control. The attribute value can be either a comma-separated list or the id or name of a Property Code table.

confirmation-modulenumber cannot be used with show-on-success; use one or the other.

If show-on-error is not specified, or if it is specified but the element selector does not locate an element, then errors will be displayed in a Javascript Alert popup dialog.

If confirmation-modulenumber is not specified, and show-on-success is either not specified or the selector doesn't locate an element, then the success message returned by the server will be shown in a Javascript Alert popup dialog.

Fix "This collection already contains an address with scheme http" error in BP Service deployments

2016-06-28T16:58:24.8100000

If a BP Service is deployed in an IIS Application that's bound to multiple domain names or ports, The service may respond with an error. When custom errors are turned off the full error mesage is shown:

This collection already contains an address with scheme http. There can be at most one address per scheme in this collection. If your service is being hosted in IIS you can fix the problem by setting 'system.serviceModel/serviceHostingEnvironment/multipleSiteBindingsEnabled' to true or specifying 'system.serviceModel/serviceHostingEnvironment/baseAddressPrefixFilters'.

This occurs because WCF can't tell which of the bindings it should respond to. To fix the problem, find the <serviceHostingEnvironment> element in the service's web.config file, and add the bindings WCF should use.

<serviceHostingEnvironment aspNetCompatibilityEnabled="true">
    <baseAddressPrefixFilters>
         <add prefix="http://hostname.com/BPServices"/>
    </baseAddressPrefixFilters>
</serviceHostingEnvironment>

At least one prefix must be specified, but you can list more than one if needed.

Authentication fallback options for Accelerator

2016-06-21T18:16:59.1700000

Accelerator's authentication method, AB_FrameworkViewModel.am_ValidateUserAndGetSysEntity(), uses WebAppSettings.config settings in the Accelerator BP Service to determine which authentication service to use: Accelerator's FWUS user table, IBMi user authentication, or Active Directory. This has been a problem when different user interfaces, for example an internal WPF application and an external website, want to use different authentication services. In the past we've needed to deploy the Accelerator BP Service Host twice, with different config settings, talking to the same A4DN database.

Starting in Accelerator 6.3.1.0 the am_ValidateUserAndGetSysEntity() method takes a new optional argument TryAuthTypes. This is a set of Flags that indicate which authentication services to use.

In this code example, an MVC application authenticates using either Active Directory or Accelerator:

var fh = HttpContext.Current.ApplicationInstance.ap_FrameworkHelper();
var retArgs = fh.ap_ViewModel.am_ValidateUserAndGetSysEntity(new AB_ValidateUserInputArgs(
    Int32.Parse(ConfigurationManager.AppSettings["SystemNumber"]), username, password)
{
    TryAuthTypes = AB_ValidateUserInputArgs.AuthTypes.ActiveDirectory | AB_ValidateUserInputArgs.AuthTypes.Accelerator
});

The values for TryAuthTypes are Configured, Accelerator, IBMi, and ActiveDirectory. The default is Configured, which implements the pre-6.3.1.0 behavior. Any other value(s) override the behavior so that each authentication service is tried in turn. The order is fixed: Active Directory, IBMi, then Accelerator. The first one that passes will cause the authentication to succeed.

When using multiple types, the configuration settings which tell the BP service which authentication to use are ignored, but the other settings which enable authentication (eg: Active Directory server url and credentials) are still used.

These changes only impact authentication: determining if the username is an active account and that the password is correct. The rest of the user security system has not been changed in any way.

Finding circular references in Views

2016-06-09T20:47:31.6430000

You can run the following query to find any direct circular references in the views tables (FWVW).

SELECT *
FROM FWVW a
INNER JOIN FWVW b ON a.FWVWIVNM = b.FWVWNM 
WHERE a.FWVWNM = b.FWVWIVNM

Displaying a Custom Popup Toolbar with Commands

2016-06-09T14:15:02.4100000

The Accelerator allows you to override the default “POPUP” toolbar within a DataGrid by specifying your own custom CommandBar to appear in its place.

The command bars (I.E. Commands groupings that show up: When expanding the menus for File/Tools/Navigator/etc; When you right-click a record; In the header of a DataGrid, etc) are each defined in the “Command Bars” module in our maintenance:

All command bars are assigned a type:

TOOLBAR – Meant to be displayed as a list, visible at all times. An example of this is the Commands in the header of a DataGrid.
MENUBAR – Meant to be displayed as a dropdown, visible when the menu button is clicked. An example of this is the “File” menu at the top of the system window.
POPUP – Meant to be displayed as a list, visible when right-clicking on a single record. An example of this is the context menu displayed when right-clicking inside of a DataGrid.

Since Command Bars are just a group of commands, you’ll first need to create a new Command Bar specifically for the right-click menu in the grid. Name the Command Bar whatever you want, but ensure that the “Type” is “POPUP”. We will link this to the module shortly, though this must be done from the Modules window.

Next, add the Commands to the Command Bar. Each Command Bar record has a “Command Elements” tab that contains the list of commands in the command bar. A full list of Commands is available in the “Commands” module (also visible in maintenance). Note that you can always add a new command to the system if you need to define a new user operation.

Now that we’ve created the command grouping and populated it with commands, we need to tell the system where and when to display it. To accomplish this, we need to navigate to the “Modules” window and link the command back to the right-click menu. In the “Modules” window, find the relevant module and go to the “Command Bars” tab.

Here, you can use the QuickAdd to add your new Command Bar to the module. Use a command bar location of “Module” (this is a module-level command that applies to all grids for this module), then choose your command bar from the “Command Bar” field. Lastly, select “Replace Higher Level Toolbars”, as we want your new command bar to be the only one providing commands to this menu.

Once everything has been entered, hit “Add” to link the Command Bar to the module. Because you specified “POPUP” during command bar creation, the command will automatically be added as a POPUP command bar. When right-clicking, only your new list of commands should appear.

How to Call a DB2 Stored Procedure

2016-06-03T19:25:35.2100000

The current recommended method for calling DB2 stored procedures is to create a helper class to be reused in all instances where stored procedures are necessary. The recommended location for this class is in your BOS.Shared assembly.

Create a Shared Helper Class

Since you will be calling the DB2 database directly, you need to add the following reference to your helper class's project:

using IBM.Data.DB2.iSeries;

Create a class 'StoredProcedureHelper.cs' in the BOS.Shared project, which should already exist in your 'System' solution folder. This new StoredProcedureHelper class is defined below.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using A4DN.Core.BOS.DALBaseForSQL;
using IBM.Data.DB2.iSeries;

namespace BOS.NewProductManagerShared
{
    public static class StoredProcedureHelper
    {
        public static object[] CallStoredProcedure(string SPName, StoredProcParam[] spParams, IAB_Interpreter ap_SQLHandler)
        {
            if (SPName == null)
                throw new ArgumentException(BOS.NewProductManagerShared.Properties.MessageResource.StoredProcNameError);
            
            object[] rtnvals = null;
            try
            {
                using (iDB2Command cmd = new iDB2Command())
                {
                    cmd.CommandText = ap_SQLHandler.ap_ConnectionParms.Collection + "." + SPName.ToUpper();
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.Connection = ap_SQLHandler.ap_Connection as iDB2Connection;

                    if (ap_SQLHandler.ap_Connection.State != ConnectionState.Open) {
                        ap_SQLHandler.ap_Connection.Open();
                    }

                    IList<iDB2Parameter> _outs = new List<iDB2Parameter>();
                    foreach (StoredProcParam param in spParams)
                    {
                        var _db2param = new iDB2Parameter(param.Name, param.Type, param.Size)
                        {
                            Direction = param.Dir
                        };

                        if (param.Type == iDB2DbType.iDB2Decimal)
                            _db2param.Precision = (byte)param.Precision;
                        if (_db2param.Direction == ParameterDirection.Input)
                            _db2param.Value = param.Value;
                        else
                            _outs.Add(_db2param);

                        cmd.Parameters.Add(_db2param);
                    }

                    cmd.ExecuteReader();

                    rtnvals = new object[_outs.Count];
                    for (int i = 0; i &lt; _outs.Count; i++)
                        rtnvals[i] = _outs[i].Value;
                }
            }
            catch
            {
                throw;
            }

            return rtnvals;
        }
    }

    public class StoredProcParam
    {
        public string Name;
        public ParameterDirection Dir;
        public object Value;
        public iDB2DbType Type;
        public int Size;
        public int Precision;

        public StoredProcParam()
        {
        }

        public StoredProcParam(string _Name, ParameterDirection _Dir, object _Value, iDB2DbType _Type, int _Size, int _Precision)
        {
            this.Name = _Name;
            this.Dir = _Dir;
            this.Value = _Value;
            this.Type = _Type;
            this.Size = _Size;
            this.Precision = _Precision;
        }
    }
}

Add a Webpage Module

2016-06-01T23:38:00.1700000

The AB_WebPageExplorer explorer component allows the addition of a module that requires zero coding and displays a web page using the WebBrowser Control. Launch the Accelerator Maintenance and Click on the "System" Module.

Step 1: Select the System that you want this new web page module to be added.

Step 2: Click the "Modules" tab in the Preview Area.

Step 3: Click the "Quick Add" button to show the quick add.

Step 4: Either select an existing Application or you have the option to create a new application by clicking on the "New" button next to the drop down.

Step 5: Create a new Module by clicking the "New" Button. If you already created the module, then select the module you want to add.

Step 6: On the New Module Detail, specify the Module Name, Description and Image. The Image must be an image that either exists in the Accelerator Core images folder or in your own image folder located in your WPF System Core Project.

Step 7: Change the Module Type to "Web Explorer".

Step 8: Specify the Web Page URL.

Step 9: Save and Close the Module Detail.

Step 10: Back at the Quick Add; Click the Add Button to add the new module to your application.

Step 11: Run you system and click on the new Module. The website you sepcified should be loaded.

Step 12: You will notice that the system command bars are being used. You can add module level command bars to your new module that replace the higher level command bars so that you only have the commands you want available.

Tracking down Binding Issues

2016-05-31T18:19:15.4030000

Here is a great article detailing multiple ways to track down any binding issues you might be having. Binding Issues Article

Create a new Workflow Instance

2016-05-25T16:51:36.3670000

You can create new Workflow Instances from MVC or WPF apps, or from a BP service host. Start by adding to your project a reference to the Workflow Client Integration assembly, which is in the A4DN Maintenance path:

<Reference Include="A4DN.WF.BOS.ClientIntegration">
  <SpecificVersion>False</SpecificVersion>
  <HintPath>$(A4DNMaintenanceHintPath)A4DN.WF.BOS.ClientIntegration.dll</HintPath>
</Reference>

This assembly provides two attributes, an interface, and a utility method that will be used to create a new Workflow Instance.

[WF_WorkflowInstance("MyWorkflow")] is added to a class that contains properties which correspond to the workflow's custom fields. "MyWorkflow" is the namespace of the Workflow.
[WF_WorkflowField] is added to each property. The property name should match the custom field name, but if it doesn't the field name can be specified in the attribute.
WF_IWorkflowInstanceData is an interface that the class must implement. There are no properties or methods to add; this is used as a hook for extension methods.
this.am_AddToWorkQueue() is an extension method that you call to create the new Workflow Instance.

Here's a simple example of a utility class that's only used for workflow:

[WF_WorkflowInstance("TrialConfirmation")]
public class DemoConfirmation : WF_IWorkflowInstanceData
{
    [WF_WorkflowField]
    public string Token { get; set; }

    [WF_WorkflowField]
    public string Email { get; set; }

    [WF_WorkflowField]
    public string IPAddress { get; set; }

    [WF_WorkflowField]
    public string UserAgent { get; set; }

    [WF_WorkflowField]
    public string Referer { get; set; }
}

Another class can use this to create a new instance for the TrialConfirmation workflow:

new DemoConfirmation
{
    Token = token,
    Email = email,
    IPAddress = HttpContext.Current.Request.UserHostAddress,
    UserAgent = HttpContext.Current.Request.UserAgent,
    Referer = HttpContext.Current.Request.UrlReferrer == null ? "" : HttpContext.Current.Request.UrlReferrer.OriginalString
}.am_AddToWorkQueue(instanceName: "Trial Registration Confirmation for " + email);

The DemoConfirmation object is being created, its am_AddToWorkQueue() method is called, and then the object is destroyed. When used this way, there's no need to hold onto the object that's being passed to Workflow. The instanceName argument is used to set the text that will be displayed in the Workflow Instance search results grid; it can be set per-instance, or it can be set as a default in the [WF_WorkflowInstance] attribute.

Another typical approach is to add the workflow attributes and interface to an existing data model class, such as a data entity. That will give the model an am_AddToWorkQueue() method which can be called to add itself to a workflow. The attributes are designed so that they can be added to any class without interfering with the class or forcing any particular naming convention on the properties.

Throttle requests to MVC Website

2016-05-25T15:40:26.1270000

When you have forms on your website (login forms, search forms, registration forms, etc) or any request that needs to do a lot of work, it's usually a good idea to throttle those requests to prevent automated scripts from using the form and overloading your server.

Add this statement to your Controller class:

using A4DN.Core.MVC.Base.Infrastructure.Attributes.Action;

Then add the [AB_RequestThrottle] to the request handlers you want to throttle:

[HttpPost]
[AB_RequestThrottle]
public ActionResult SubmitRegistration(DemoRegistrationModel model)
{
    ...
}

Each time this method is used, an entry is created/updated in HttpContext.Cache using the key "AB_RequestThrottle.SubmitRegistration.{IP Address}.Count. The initial value of the entry is 0 and it gets incremented for each use. The attribute will then delay processing the request by 200ms per access. So, the first time an IP address uses the method, the delay is 0ms, then 200ms, then 400ms, etc. If there are no requests for 5 minutes, the cache entry will be deleted and the counter is reset.

The timing can be adjusted by using optional arguments:

[AB_RequestThrottle(CooldownMinutes = 5, PerRequestSleepMS = 200)]

Styling full-width banner images in CMS web pages

2016-05-19T19:04:13.3470000

Many modern website designs make use of a graphic banner at the top of the page which spans the full page width, scales automatically with changes in the browser window width, and which has content (like titles) overlaid on top of it. A CSS background image can be used to achieve these effects.

The HTML markup is simple: an overall "banner" container, within that is a "banner-image" element whose background will be the image, and inside that is a "banner-content" element that holds the overlaid content.

<div class="banner">
    <div class="banner-image">
        <div class="banner-content">
        </div>
    </div>
</div>

The CSS for styling the image set the banner height, the image url, the positioning of the image relative to the banner-image element, and rules for scaling.

background-size: cover will scale the image so that it covers the full width and height of the element without distorting the image. If the element's dimensions aren't the same ratio as the images, the image will be cropped on either the top and bottom or left and right sides.

background-position controls how the image gets cropped. In this example, a point that is 50% of the images width from the left edge, and 30% from the image's top, will be fixed to a point that is 50% from the left and 30% from the top of the banner-image element.

These two styles are the ones you'll need to adjust based on the image you're working with.

For background-container, the example creates a box that is 1170px wide, positioned 20px down from the top of the background image, and centered horizontally. (auto margins for left and right will center the element.)

<style>
.banner-image {
    background-image: url("/media/architecture.jpg");
    background-position: left 50% top 30%;
    background-repeat: no-repeat;
    background-size: cover;
    height: 300px;
}

.banner-content {
    width: 1170px;
    margin: 20px auto;
}

@media (max-width: 767px) {
    .banner-image {
        background-position: center; 
    }
    .banner-content {
        width: 100%;
    }
}
</style>

The @media rule at the end adjust the styles for small devices, using 767px or narrower as the breakpoint for changing the style. The image's position is changed to be centered, and the content is changed to be full width instead of fixed at 1170px. Typically, several media rules would be used for different breakpoints to adjust the size and position of the banner content.

Utilizing the Resource Monitor

2016-05-19T17:38:25.5800000

You can use Window's built-in Resource Monitor to help debug your live Applications.

Whereas the Processes tab of the Task Manager will give you a simplified list of the processes running on your machine, the resource monitor will provide a detailed account of the resources your processes are consuming. This includes a memory footprint and list of referenced DLLs/files, which can be useful if you are trying to resolve dependency issues in a live environment.

When used alongside other development tools, the Resource Monitor can be a useful tool for diagnosing issues with a process.

The Resource Monitor contains CPU, Memory, Disk and Network tabs that will display all used resources that fall into those categories. Processes that have not performed I/O recently will not appear in the Disk or Network tabs.

You can drill down to a particular process (or processes) by selecting one via the checkbox to the left of the Process, in the "Processes" section. Alternatively, selecting the checkbox in the section's header will select all Processes in the list.

The monitor will remember the last 60 seconds of activity since the window was opened. If you are trying to get more detailed information about a small moment in time, you can pause the monitor. Pausing the Resource Monitor will prevent new information from being collected and old information from being discarded.

To access the Resource Monitor (resmon.exe), open up the Run window and enter resmon.

Alternatively, there is a "Resource Monitor' button in the "Performance" tab of the Task Manager.

The Resource Monitor is available on all machines running Windows 7 or greater.

In an MVC application, get the website's absolute url

2016-05-12T18:32:48.0670000

In an MVC project, the URL for any given handler depends upon where the web application is deployed. While running out of Visual Studio, a handler like MyController.Index() will have a url like http://localhost:5555/MyController/Index. If the web application is deployed to its own IIS website the url will be http://hostname.com/MyController/Index, but if it is deployed as a virtual application in a shared IIS website the url would be http://hostname.com/virtappname/MyController/Index. Finally, UrlHelper methods like Url.Action("Index", "MyController") will return a url path that's relative to the deployment path: /MyController/Index.

To get the absolute URL for the root of the web application, use this:

var homeUrl = VirtualPathUtility.ToAbsolute(Url.Content("~/"));

Url.Content() will parse the ~/ at the start of a url string and expand it based on the application's deployment root; either / or /virtappname/ in the examples above. Url is the current UrlHelper object, which is available inside controllers and views. In other classes you can create a helper:

var urlHelper = new UrlHelper(HttpContext.Current.Request.RequestContext);
var homeUrl = VirtualPathUtility.ToAbsolute(urlHelper.Content("~/"));

You can use any of the UrlHelper methods here, such as Url.Action().

var homeUrl = VirtualPathUtility.ToAbsolute(Url.
Action("Index", "MyController"));

However, when using Action() there is a shortcut: the fourth parameter, which is optional, can be used to specify the HTTP scheme to use (http or https). When that is specifed, Action() will return an absolute url instead of a url path that's relative to the deployment root.

var homeUrl = Url.
Action("Index", "MyController", null, Request.Url.Scheme);

Request is also made available in controllers and views. In other classes use HttpContext.Current.Request.Url.Scheme.

Add DataAnnotations validation attributes to entity classes you can't modify

2016-05-12T15:01:43.3300000

When using a data entity / model class that is defined by a Web Service Reference, you cannot add DataAnnotations attributes to it directly. (The code is in a generated References.cs file that gets overwritten when you update the service reference.) The generated web service entity class uses partial, which allows you to specify a separate class for the attributes.

In this example, ContactsEntity is a generated class from the ContactsService service reference. We add [MetadataType] to specify where the attributes can be found. Nothing else needs to be modified (though, if you need to, you can add additional properties here for use in your views and controllers.)

Note that this class must be in the same namespace as the generated class.

namespace MVC.SurroundTechWebsite.ContactsService
{
    [MetadataType(typeof(ContactsEntityMetadata))]
    public partial class ContactsEntity
    {
    }
}

To add attributes, implement the metadata class with fields whose names and types match the entity class' properties, and then add attributes to those fields. This class can be in the same namespace, but that's not required.

public class ContactsEntityMetadata
{
    [Required(AllowEmptyStrings = false, ErrorMessage = "Required")]
    public string FirstName;
        
    [Required(AllowEmptyStrings = false, ErrorMessage = "Required")]
    public string LastName;
        
    [Required(AllowEmptyStrings = false, ErrorMessage = "Required")]
    public string CompanyName;
        
    [Required(AllowEmptyStrings = false, ErrorMessage = "Required")]
    [DataType(DataType.PhoneNumber)]
    public string PhoneNumber;
        
    [Required(AllowEmptyStrings = false, ErrorMessage = "Required")]
    [DataType(DataType.EmailAddress)]
    public string Email;
        
    [DataType(DataType.Url)]
    public string Website;

    [DataType(DataType.MultilineText)]
    public string AdditionalComments;
}

How to parse entity key fields out of a unique key string

2016-05-11T16:18:48.4470000

Sometimes all you know about a data entity record is its unique key string. This can be from a reference to a parent record, passed as miscellaneous input to a BOS method, or in MVC applications it can be passed through a url query parameter or post body.

The unique key string is a concatenation of the entity's [AB_Key] properties. To access those individual properties, use the am_ParseUniqueKeyIntoProperties() method:

var customerPartEntity = new OECustomerPartEntity { ap_UniqueKey = InputArgs.ap_MiscellaneousInput };
customerPartEntity.am_ParseUniqueKeyIntoProperties();
ode.CUSTOMERPARTNUMBER = customerPartEntity.PartNumber;

In this example the key was passed in ap_MiscellaneousInput. It could have originally come from either the ap_UniqueKey or the ap_CompactUniqueKey property on the entity. A new entity is created an ap_UniqueKey is set to the key string, and then am_ParseUniqueKeyIntoProperties() is called. This will set all of the [AB_Key] properties, which can then be accessed individually.

To get other fields, the entity can be used as input to either am_Fetch or am_Select once its [AB_Key] fields are set. Though, in this case the call to am_ParseUniqueKeyIntoProperies() isn't necessary if am_Fetch() is used, because am_Fetch() will call it automatically.

Datamaps - Join to the same table twice - Part 2

2016-04-18T14:06:13.0230000

This is a continuation from the following discussion:

Datamaps - Join to the same table twice - Part 1

Add Join Relationships

Now we need to add 2 join relationships in the am_LoadRelationshipMaps method. Both of these joins will be similar but they will use different joinTableAlias. Also, the fields that you are joining on should be different.

/// <summary>
/// Loads maps to join two database files.
/// </summary>
public override Dictionary<string, AB_RelationshipMap> am_LoadRelationshipMaps()
{
    var relationshipMap = new AB_RelationshipMapsDictionary(ap_PrimaryTable);
 
 
    relationshipMap.am_AddRelationshipMap(JoinTableName, useDistinctJoins: false, joinTableAlias: JoinTableAlias1)
        .am_JoinWhere(primaryTableField: "PrimaryFieldJoinKey1", joinTableField: "JoinKey");
 
    relationshipMap.am_AddRelationshipMap(JoinTableName, useDistinctJoins: false, joinTableAlias: JoinTableAlias2)
        .am_JoinWhere(primaryTableField: "PrimaryFieldJoinKey2", joinTableField: "JoinKey");
    return relationshipMap;
}

Add datamaps for Join Fields

Once the relationship maps are added we can now setup the datamaps for the join fields. They are the same as normal join field datamaps with the exception that for the targetTable: instead of specifing the Join Table Name we need to use the Join Table Alias.

//Join Alias 1 fields
maps.am_AddDataMap("JoinField1", ExampleEntity.JoinTableAlias1JoinField1Property, targetTable: JoinTableAlias1);
maps.am_AddDataMap("JoinField2", ExampleEntity.JoinTableAlias1JoinField2Property, targetTable: JoinTableAlias1);
 
//Join Alias 2 fields
maps.am_AddDataMap("JoinField1", ExampleEntity.JoinTableAlias2JoinField1Property, targetTable: JoinTableAlias2);
maps.am_AddDataMap("JoinField2", ExampleEntity.JoinTableAlias2JoinField2Property, targetTable: JoinTableAlias2);

Notice that the two sets of join fields are the same field names from the database tables but use different properties on the Entity.

Datamaps - Join to the same table twice - Part 1

2016-04-18T13:34:56.3670000

In order to join to the same table twice we need to alais the tables. This is supported in the Accelerator Datamaps and is an option to Alias the tables by default when generating a module.

Define constants for tables

private const string PrimaryTableName = "[dbo].[PrimaryTable]";
private const string PrimaryTableAlias = "primaryTableAlias";
private const string JoinTableName = "[dbo].[JoinTable]";
private const string JoinTableAlias1 = "joinTableAlias1";
private const string JoinTableAlias2 = "joinTableAlias2";

Setup alias for Primary Table

Now in the am_LoadFieldMaps method we setup the primary table to use the alias name. If your code is using the AB_DataMapsDictionary for creating the datamaps all you need to do is set the ap_PrimaryTable to the alias name and the ap_AliasedTable to the actual primary table name.

/// <summary>
/// Defines the maps for the Data Source Field Names and Entity Properties for module.
/// </summary>
public override Dictionary<string, AB_DataSourcePropertyReference> am_LoadFieldMaps(string qualifier)
{
    // Set the Primary File Name, Foreign fields will have to be mapped on a case-by-case basis
    ap_PrimaryTable = PrimaryTableAlias;
    ap_AliasedTable = PrimaryTableName;
    //Create a dictionary to hold the maps
    var maps = new AB_DataMapsDictionary(ap_PrimaryTable, qualifier);

Continued in the following discussion:

Datamaps - Join to the same table twice - Part 2

Bypass WPF logon to support Single Sign On (SSO)

2016-04-12T15:12:06.1670000

Please refer to this discussion setting up WCF to use SSL. This is required for SSO. You also must be at Accelerator Version 6.2.1 or greater.

Make sure that you set the ClientCredentialType to "Windows"

In you system WPF startup project, open the App.xaml.cs.

Override the am_Initialize() method and add the code in bold below. The ap_UserName and ap_Password will be passed to the service and will be used to look up the user in the Accelerator User Table FWUS. The ap_UserName is being set to the Windows Identity current user. Refer to this documentation regarding the WindowsIdentity Class.

The ap_UserName must be a valid Accelerator User with a User Group that has authority to the system. You have the option to set the password or leave it blank. Whatever you choose, make sure it matches the password in the FWUS table for the Accelerator User. If you do use the password, then it will need to be the same for all users.

The call to the base.am_Dologin() will run the login code, You need to also override the method am_ShowLogon and comment out the base call. This will stop the login from showing.

protected override void am_Initialize()
{
    base.am_Initialize();

    AB_DataPropertyController.ap_UserIdentityStore.ap_UserName = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
    AB_DataPropertyController.ap_UserIdentityStore.ap_Password = "";

    base.am_DoLogin();
}

protected override void am_ShowLogon(AB_LogonBase logonWindow, AB_LogonStartUpTabOption startOption)
{
    //  base.am_ShowLogon(logonWindow, startOption);
}

Setting up WCF services to use SSL

2016-04-12T14:51:27.3830000

By default, an Accelerator generated system has SSL turned off. With a few steps, it is easy to turn this capability on.

Here are the steps:

1) In the Web.config for the Accelerator services and your System services, you need to add a security and transport element to the bindings element.

<bindings>
  <!-- A4DN_Tag: Binding Quota Size -->
  <basicHttpBinding>
    <binding name="BasicHttpWithBigQuota" maxReceivedMessageSize="2147483647">
      <readerQuotas maxDepth="64" maxStringContentLength="2147483647" maxArrayLength="2147483647" maxBytesPerRead="4096" maxNameTableCharCount="16384" />
      <!-- For SSL Deployment, uncomment the <security> element below -->
      <security mode="Transport">
        <transport clientCredentialType="Windows"/>
      </security>
    </binding>
  </basicHttpBinding>
</bindings>

2) Set the clientCredentialType. The enum HttpClientCredenttialType has the valid values. For example, if you set it to "Windows", the client windows credentials will be passed to the WCF service. In you use this, you need to make sure that the windows authentication is enabled in IIS for the service.

3) Verify that all endpoints have the bindingConfiguration equal to BasicHttpWithBigQuota.

<service name="BOS.CustomerBusinessProcess.CustomerBP" behaviorConfiguration="BOS.EasyBuyCyclesBPServiceHost.Service1Behavior">
  <endpoint address="" binding="basicHttpBinding" contract="BOS.CustomerBusinessProcess.ICustomerBPServiceContract" bindingConfiguration="BasicHttpWithBigQuota" />
  <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
</service>

4) In the Services.Config, set the BindingSecurityMode to "Transport" and set the BindingTransportClientCredentialType to the same value you set clientCredentialType in the Web.config. You will need to set these setting on both the system and accelerator web services. You also need to change the address from "http" to https". Note: The BindingTransportClientCredentialType key is only supported with Accelerator Version 6.2.1 or greater.

<system.bp>
    <add key="Address" value="https://localhost/EasyBuyCycles/" />
    <add key="ConnectionType" value="WebServices" />
    <add key="Binding" value="BasicHttpBinding" />
    <add key="BindingSecurityMode" value="Transport" />
    <add key="BindingTransportClientCredentialType" value="Windows" />
</system.bp>

5) Publish your Accelerator and System Services to IIS.

Fix "Argument Null Exception" when creating a module's BP object in another module's BP class

2016-03-31T14:40:11.4200000

When your BP class in one module needs to talk to the BP for another module, you might write code like this:

AB_FrameworkBusinessObjectProcessBase<TermsCodeEntity> _termsBP;
AB_FrameworkBusinessObjectProcessBase<TermsCodeEntity> _TermsBP
{
    get
    {
        if (_termsBP == null)
        {
            Type bpType = Type.GetType("BOS.TermsCodeBusinessProcess.TermsCodeBP, BOS.TermsCodeBusinessProcess, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
            _termsBP = Activator.CreateInstance(bpType) as AB_FrameworkBusinessObjectProcessBase<TermsCodeEntity>;
        }
        return _termsBP;
    }
}

One reason to use code like this is when your BP modules need to talk to each other through methods inherited from AB_FrameworkBusinessObjectProcessBase. If the BPs referenced each other directly you'd have a cirular reference problem, and neither BP could be compiled cleanly. But if one BP uses reflection it can instantiate the other BP at runtime, and since the methods it is calling are in the base class there's no compile-time dependency on the referenced module's non-base methods.

For this code to work, the BP project needs to include a reference to BOS.TermsCodeBusinessProcess. Otherwise bpType will be null, and CreateInstance will throw an Argument Null Exception.

Since reflection is being used and the type is specified with a string, this is not a compile-time error. It won't become a problem until run-time. Even then, it won't always be a problem; if this module is referenced in a program that also references BOS.TermsCodeBusinessProcess, GetType will be able to find the dll and won't return null. The exception will only occur when this module is used separately from BOS.TermsCodeBusinessProcess.

In this particular case, there's no need for reflection. If you already know the Type of object you need to create, add the reference and instantiate the object normally:

AB_FrameworkBusinessObjectProcessBase<TermsCodeEntity> _termsBP;
AB_FrameworkBusinessObjectProcessBase<TermsCodeEntity> _TermsBP
{
    get
    {
        if (_termsBP == null)
        {
            _termsBP = new TermsCodeBusinessProcess.TermsCodeBP();
        }
        return _termsBP;
    }
}

Reflection should only be used when you don't know the Type until run-time, and all you have is a string containing the type's full name. And in that case, you need to make sure that you've got references to all of the possible types you might have to instantiate in every application where your code is used.

NuGetPackages folder and Version Control

2016-03-23T13:46:13.3270000

When using the NuGet Package Manager in Visual Studio, you will get files installed to a packages folder in your source tree. In Accelerator-generated systems we include a nuget.config file at the top of the source tree which contains this configuration:

<configuration>
  <config>
    <add key="repositoryPath" value=".\NuGetPackages" />
  </config>
</configuration>

This tells NuGet to install the packages for all projects into the top-level NuGetPackages folder.

The packages will almost always include dll files, and will often include exe files too. Version Control systems, like Git and TFS, will usually ignore these file types by default. Whenever you add a new NuGet package, you have to make sure you manually add all of the package's files to source control.

Git (TortoiseGit):

Right-click on the NuGetPackages folder and find the TortoiseGit menu option "Add...". In the dialog that appears, check the "Include ignored files" checkbox at the bottom to see the dlls, exes, and other ignored file types. Select them all and commit.

TFS:

Open the Source Control Explorer, and expand to see the NuGetPackages folder. Right-click and choose "Add items to folder". In the dialog select all of the package folders and click the Next button. The next dialog has two tabs: Items to Add and Excluded Items. Open the Excluded Items tab, select everything, and click on the Include Items text in the lower right of the tab. This will add all of the files to your Pending Changes list so you can check them in.

Debugging Modules Window

2016-03-18T18:49:16.4570000

Visual Studio has a window that allows you to see all the DLL's that are loaded when running your system. Along with the DLLs that are loaded it also provides information such as DLL version, last modified date, and whether the debug symbols are loaded. This is very handy to make sure the correct DLL has loaded. Many times I have made changes to code and thought my code didn't work just to realize that my code changes were not picked up and loaded and that an older version of the DLL was being used instead. This window will help you ensure that the DLL you expected is what was actually loaded at runtime.

To acess this window during debug, click the menu item Debug --> Windows --> Modules (Ctrl+Alt+U)

Here is what it looks like in action:

Here is some additional information from MSDN:

https://msdn.microsoft.com/en-us/library/4c8f14c9.aspx

Accelerator Views

2016-03-18T13:36:33.1470000

In the Accelerator Maintenance, you have the ability to add multiple views to a module based on how the module is used. How the module is used is based on the Standard Base Interface Record. The SB Interface Record allows you to change what view or views are used based on the parent component name (The class object name where the module will be loaded). If the SB Interface record is blank, that indicates that the module is being loaded from the navigator as a main module.

You can specifiy a default view, the number of records to load, and whether or not to show the explorer bar and/or auto load the content window based on the default view. Note: You must have a default view per module location.

A view can be reused by multiple modules. You will notice that the above detail is a View Reference. The word "Reference" means that you are referening a view and then setting information on how the view will be used per module location.

An Accelerator View allows you to specify what view columns you want the Users to be able to see. You then have the ability to hide/show the columns, set the display position, column width, sort and sort position, and whether you want the column to show in the extended view(Not supported in WPF).

Note: This is setting the default for the view. Each user can overide this based on their individual preferences.

You can specify multiple columns to sort on with the sort position. The Accelerator framework will add an Order By to the query based on this information.

This is what the above Accelerator View looks like at runtime. Notice what columns are shown, the display sequence, column width and sort.

The user can override the view by click on the (1) view settings button located at the bottom of each datagrid. The user can make changes and then click OK. This will save the settings to their profile. The User can reset to the default view settings by (2) clicking the default button.

When creating an Accelerator View, you can inherit the view columns from another view and then just specify what you want to be different. This can include adding addition columns that are not on the inherited view. This inheritence will make it much easier for you to create multiple variances of a view.

Here is an example of (1) "View by Legal Name" inheriting "View by Name". (2) The "View by Legal Name" contains 2 columns that are different. (3) The display position and visible state are being overriden.

Adding Google Maps and Bing Maps to your WPF Detail and Content Preview

2016-03-17T22:26:51.1500000

You can add a google maps tab or a bing maps tab to your WPF detailer and/or content window preview.

Here are the steps:

Open your WPF Detail XAML.
Add the following Namespace:

xmlns:datapresentation="clr-namespace:A4DN.Core.WPF.Base.DataPresentation;assembly=A4DN.Core.WPF.Base"

If you are using the AB_DockingTabControl, then use the following XAML to add the google and bing maps tab item to your TabControl.

 <datapresentation:AB_GoogleMapDockingTab x:Name="GoogleMapsTab" ap_FullAddress="{Binding Path=MapAddress}" Visibility="{Binding Source={StaticResource CustomerVM}, Path=IsMapTabVisible, Converter={StaticResource boolToVisibilityConverter}}"/>
            <datapresentation:AB_BingMapDockingTab x:Name="BingMapsTab" ap_Address="{Binding Path=MapAddress}" Visibility="{Binding Source={StaticResource CustomerVM}, Path=IsMapTabVisible, Converter={StaticResource boolToVisibilityConverter}}"/>

If you are using the AB_TabControl, then use the following XAML to add the google and bing maps tab item to your TabControl.

 <datapresentation:AB_GoogleMapTab x:Name="GoogleMapsTab" ap_FullAddress="{Binding Path=MapAddress}" Visibility="{Binding Source={StaticResource CustomerVM}, Path=IsMapTabVisible, Converter={StaticResource boolToVisibilityConverter}}"/>
            <datapresentation:AB_BingMapTab x:Name="BingMapsTab" ap_Address="{Binding Path=MapAddress}" Visibility="{Binding Source={StaticResource CustomerVM}, Path=IsMapTabVisible, Converter={StaticResource boolToVisibilityConverter}}"/>

In both cases, you will need to supply a property in your entity that has the full address and bind ap_FullAddress to that property. You can also create a dependency property in your viewmodel code to control when the tab is visible. For example, you may want to set the tab to collapsed on a new record.

Here is how the MapAddress property is defined in our EasyBuy system.

[AB_VirtualMember]
public string MapAddress
{
    get
    {
        return string.Format("{0} {1} {2} {3} {4}", BillingAddress1, BillingAddress2, BillingAddress3, BillingPostalCode, BillingCountry);
    }
}

In the Detail Code Behind, you will need to set the datacontext on the tabs and you have the option to show the tabs in the content window preview. (Note: use AB_DockingTabItem if you are using the AB_DockingTabControl and AB_TabItem if you are using AB_TabControl.)

// Add Google and Bing Maps to Content Window Preview
am_AddTabToPreview(new AB_DockingTabItem[] { GoogleMapsTab, BingMapsTab });
// Set DataContext on tabs so that the can bind to properties in the entity
ap_AdditionalTabItemsToSetDataContextOn.Add(GoogleMapsTab);
ap_AdditionalTabItemsToSetDataContextOn.Add(BingMapsTab);

Tabs will now show and look like this:

Drop down with Re:new using AB_NewlookDropdownController

2016-03-17T21:24:50.2130000

The AB_NewlookDropdownController is a class used to simplify the process of loading a combobox on a Newlook screen using data from the Accelerator for .NET. This class can be used in any WPF detailer that inherits AB_NewlookDetails Detailer. In the following example the steps to implement a newlook dropdown will be followed using the EasyBuy Auto Parts System as an example.

Setting up the Newlook Screen

In order for the AB_Newlook dropdown to work properly it must be setup based on the following naming convention:

A combobox control with the following properties set. This is not added in the designer, but by setting your field in the 'Identify' editor to the type 'Combo Entry Field'
- Name: Set to a name appropriate to the combo box. In this example the name is 'ParentName' Substitute this value anywhere you see in this document, as all other newlook controls are based off of this.
- Sorted: False
- Variable: var
A 'Search' CommandButton (Optional)
- Name: Search
- TakeFocusOnClick: True, this allows the event to be trapped in the .net portion of the solution
- Picture: @\Images\Find.png, the find image will need to be in the \Images directory of your newlook solution. Image
- PictureSize: PicSizeStretch
An 'Open' CommandButton (Optional)
- Name: Open
- TakeFocusOnClick: True, this allows the event to be trapped in the .net portion of the solution
- Picture: @\Images\Vb_open2.png, the find image will need to be in the \Images directory of your newlook solution. Image
- PictureSize: PicSizeStretch
An 'New' CommandButton (Optional)
- Name: New
- TakeFocusOnClick: True, this allows the event to be trapped in the .net portion of the solution
- Picture: @\Images\Vb_new.png, the find image will need to be in the \Images directory of your newlook solution. Image
- PictureSize: PicSizeStretch
A hidden Entry field for the 'key'. This is used to set the actual value based on the combobox value. This is only necessary if you have a key as well as a value and you do not wish to show the key.
- Variable: varID

Setting up the .Net Detailer

Step 1: Create an instance of AB_NewlookDropdownController and set appropriate properties in the am_OnInitialized() Method
- ap_SbInterfaceReferenceID: This must be setup in the SB Interface Modue, each module should ahve a generated dropdown entry
- ap_NewlookControlName: Name of the combo entry field setup in the newlook screen
- ap_DetailType: Type of Detail Opened when clicking the Open or New command buttons
- ap_ViewModelType: View Model type used to select data to populate the combo box
- ap_EntityType: Type of entity returned by the View Model Selection
- ap_DisplayMemberFieldName: Name of the 'Value' field in the entity
- ap_KeyFieldName: Name of the 'key' field in the entity
- ap_CurrentView: View used to sort/filter combo box items
- ap_ScreenName: Screen the combo box should be populated on
Step 2: Enroll AB_NewlookDropdownController in ap_NewlookDropdownControllers collection

Multiple Usergroups in Accelerator Security

2016-03-15T19:53:00.6200000

Accelerator Security has been improved in version 6.2.0.0 to now support two different methods of handling multiple user groups for a single user. The two different methods are inclusive and exclusive security. By default the security mode is set to inclusive when working with multiple user groups. This configuration can be changed in the web.config appSettings in the Accelerator Services by setting the following key to false.

<!--Multiple User Group Security Option -->
<add key="Framework.IsMultipleUserGroupSecurityInclusive" value="false" />

Inclusive (true): If the security mode is set to be inclusive this will mean that the user will have access if any of the enrolled usergroups have access to that object.

Exclusive (false): If the security mode is set to be exclusive this will mean that the user will have access to an object only if all of the enrolled usergroups have access to the object.

Previous to Accelerator 6.2.0.0

Previous to the Accelerator version 6.2.0.0 the multiple usergroup security did not work correctly. It would give you access to objects that were enrolled in the first added usergroup and then to all modules in any applications that were added to any additional enrolled usergroups.

Data grid view columns are not showing correctly as defined by the Accelerator View

2016-03-08T17:13:54.1430000

If you change the View Columns for your View using the Accelerator Maintenance and don't see the correct columns in your content window datagrid, then try the following troubleshooting steps:

1) Make sure you have a Datamap defined for the column and make sure the string name matches your view column name. In this case, the view column name is YD1CIID.

maps.am_AddDataMap("YD1CIID", CustomerEntity.CustomerInternalIDProperty);

2) Make sure you don't have any user Column overrides that are being applied. To clear this, run your system and navigate to the module that has the changed view settings. Click the "Edit View Settings" button.

Then click (1) the default button and then click (2) OK.

The User Override will be deleted and you will be using the defaut view which should contain your view column changes.

3) Try clearing the Accelerator Cache.

Debugging the Accelerator Core Code

2016-03-08T15:51:17.3170000

When you install the Accelerator, the core dlls are included in release and debug versions as well as all the source code is included.

The release DLLs are what your projects reference from default generation.

Here are the folder paths based on installing at C:\Program Files\Accelerator for .NET\v6_2\.

Core Release DLLS
- C:\Program Files\Accelerator for .NET\v6_2\Core\DotNet
Core Debug DLLS
- C:\Program Files\Accelerator for .NET\v6_2\Core\DotNetDebug
Source Code files
- C:\Program Files\Accelerator for .NET\v6_2\Source

If you want to debug the Accelerator Code from your system, all you need to do is point your <A4DNCoreHintPath> element that is located in your A4DNReference.msbuild file to the Core\DotNetDebug folder.

You will need to restart your Visual Studio environment for the change to take effect. You can then open the source files located in your source folder and have fun debugging.

Note: It is also recommended to run your build script. This will ensure the Accelerator DLLs with debug symbols are properly loaded into your bin folder.

Remember to set the Core\DotNetDebug folder back to Core\DotNet when you are finished.

<?xml version="1.0" encoding="utf-8"?>
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <A4DNVersion>6.2.0.0</A4DNVersion>
    <A4DNCoreHintPath>C:\Program Files\Accelerator for .NET\v6_2\Core\DotNetDebug\</A4DNCoreHintPath>
    <A4DNSilverlightHintPath>C:\Program Files\Accelerator for .NET\v6_2\Core\Silverlight\</A4DNSilverlightHintPath>
    <A4DNMaintenanceHintPath>C:\Program Files\Accelerator for .NET\v6_2\Maintenance\</A4DNMaintenanceHintPath>
    <A4DNCodeFactoryHintPath>C:\Program Files\Accelerator for .NET\v6_2\CodeFactory\Wizards\</A4DNCodeFactoryHintPath>
    <A4DNJobMonitorHintPath>C:\Program Files\Accelerator for .NET\v6_2\JobMonitor\</A4DNJobMonitorHintPath>
  </PropertyGroup>
</Project>

How to Properly add Accelerator DLL references to your Project using A4DNReference.msbuild

2016-03-08T15:33:16.8770000

When you need to add Accelerator DLL references to your project, you want to make sure that the version and hint path are pulled from your A4DNReference.msbuild file. This A4DNReference.msbuild file contains the Accelerator version and hintpath for your System. When you upgrade your system using the Upgrade Utility, this is the main file that we are changing.

Here is what the A4DNReference.msbuild file looks like.

<?xml version="1.0" encoding="utf-8"?>
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <A4DNVersion>6.2.0.0</A4DNVersion>
    <A4DNCoreHintPath>C:\Program Files\Accelerator for .NET\v6_2\Core\DotNet\</A4DNCoreHintPath>
    <A4DNSilverlightHintPath>C:\Program Files\Accelerator for .NET\v6_2\Core\Silverlight\</A4DNSilverlightHintPath>
    <A4DNMaintenanceHintPath>C:\Program Files\Accelerator for .NET\v6_2\Maintenance\</A4DNMaintenanceHintPath>
    <A4DNCodeFactoryHintPath>C:\Program Files\Accelerator for .NET\v6_2\CodeFactory\Wizards\</A4DNCodeFactoryHintPath>
    <A4DNJobMonitorHintPath>C:\Program Files\Accelerator for .NET\v6_2\JobMonitor\</A4DNJobMonitorHintPath>
  </PropertyGroup>
</Project>

You will notice that the file has the A4DNVersion as well as hint paths such as A4DNCoreHintPath to find the location of a specific Accelerator folder.

By using this file and linking to these variables in your project instead of hard coding this information, you can easily upgrade the Accelerator and all you projects will point to the correct folder and dll version.

To use this A4DNReference.msbuild file, we first need to add an import statement to your project file. The Accelerator generates all your project files with this import statement already included. If you created your own project in Visual Studio, then you need to manually add this import.

To add the import statement, open your project file (.csproj) in a text editor. Add this Import element to the project file after the Project element. Make sure that the relative path to the A4DNReference.msbuild file is correct.

<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="../../../A4DNReference.msbuild" />

Once you import the A4DNReference.msbuild file, you can now access the XML elements by using variables like this: $(A4DNVersion), $(A4DNCoreHintPath), $(A4DNMaintenanceHintPath) and so forth...

If you reference an Accelerator DLL via Visual Studio, it will add a reference to your project that looks like this. Notice the hard coded version number and hint path.

<Reference Include="A4DN.Core.BOS.Base, Version=6.2.0.0, Culture=neutral, PublicKeyToken=a051f91c03e970af, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\..\..\Program Files\Accelerator for .NET\v6_2\Core\DotNet\A4DN.Core.BOS.Base.dll</HintPath>
</Reference>

Hiding the Detail and/or Audit tab from the Content Window Preview Pane

2016-03-04T17:18:26.6470000

There are 2 properties in the Content WIndow that can be set to hide/show the Detail and/or Audit tab from the Content WIndow Preview Pane. By Default, the boolean flags are set to true (Show). You can easily set them to false (Hide) in the am_SetParentProperties method in your Content Window code behind.

protected override void am_SetParentProperties()
{
    RG_SetParentProperties();

    ap_CreateDetailPreviewTab = false;
    ap_CreateAuditPreviewTab = false;
}

Adding Accelerator Modules that reuse the same WPF and BOS code - Scenario 2

2016-03-04T16:43:53.5670000

If you have multiple Accelerator modules referencing the same code, you may need to condition in the code based on Module Number. An example would be that you want to load different preview pane sub modules based on the module number.

If you need to condition based on module number, I suggest that you centralize where you hard code the module numbers. This not only gives you insight into what modules you are conditioning on throughout your system, but also allows you to quickly change them if needed.

In this example, I want to load different preview sub modules in the content window and the detail based on whether the module is the Command Groups module or the User Groups module.

The best way to centralize the module numbers is to create an enum. So that it is accessible from anywhere, I would suggest you put the enum class in your system level BOS Shared project.

namespace BOS.AcceleratorShared
{
    /// <summary>
    /// Class SharedEnums.
    /// </summary>
    public static class SharedEnums
    {

        /// <summary>
        /// Enum Modules
        /// </summary>
       public enum Modules
        {
            /// <summary>
            /// The command groups
            /// </summary>
           CommandGroups = 90000365,
           /// <summary>
           /// The user groups
           /// </summary>
           UserGroups = 90000074,

           
        }

    }
}

Now that you have the enum, we can condition the preview sub modules in the content window and the detail by changing the ap_SubBrowserLoadID property.

In the content window, you can add the condition below to the RG_SetParentProperties() method. By default, the Accelerator will set the ap_SubBrowserLoadID property to the Content Window Class Name, so you only need to code if you want to change this default value. In the example below, we are changing it only if the module is Command Groups.

private void RG_SetParentProperties()
{
    // Call Initialize Component im order to access XAML objects in Code Behind
    InitializeComponent();

    ap_MainDetailType = typeof(UserGroupsDetail);

    // Visual State Manager
    _ViewModel = FindResource("UserGroupsViewModel") as UserGroupsViewModel;
    ap_ViewModel = _ViewModel;
    ap_DataMaps = new UserGroupsMaps().ap_FieldMaps;


    if (ap_ModuleEntity.IsModule(SharedEnums.Modules.CommandGroups))
    {

        // Change SubBowser ID 
        ap_SubBrowserLoadID = "RFWUGY01_COMMANDS";
    }
}

In the Detail, you will need to override the method am_CreateSubBrowsers and set the ap_SubBrowserLoadID property. By default, the Accelerator will set the ap_SubBrowserLoadID property to the Detail Window Class Name, so you only need to code if you want to change this default value. In the example below, we are changing it only if the module is Command Groups.

protected override void am_CreateSubBrowsers()
{
    if (ap_ModuleEntity.IsModule(SharedEnums.Modules.CommandGroups))
    {
        // Change SubBowser ID 
        ap_SubBrowserLoadID = "FFWUGD01_COMMANDS";
    }

    base.am_CreateSubBrowsers();
}

It has been a standard for us to use a different ap_SubBrowserLoadID for the Content Window vs. the Detail Window. This allows you to control what Tabs show in each tab control. There is no reason why you can't use the same ap_SubBrowserLoadID for both locations.

You just need to define each ap_SubBrowserLoadID by creating a Standard Base Interface Record for each Sub Module to show and View References to the Child Module so that it knows what View or Views to load.

Adding Accelerator Modules that reuse the same WPF and BOS code - Scenario 1

2016-03-04T15:45:22.2230000

With the Accelerator, it is possible to define multiple modules in the Accelerator Maintenance that point to the same WPF and BOS code. This ensures a high level of reuse for easy maintenance. An example of why you would do this can be demonstrated with 2 Accelerator Modules. In the Accelerator, we have a file FWUG that has a type field to designate whether the Group is a User Group (Type = "SYSTEM") or a Command Group (Type = "COMMAND"). I want to create 2 separate modules, with 2 separate module names and iconography as well as only show the FWUG records for the Type selected. The best way to do this is to have both modules share the same code base and then condition where appropriate. You can condition on Module number since User Group and Command Group will have different module numbers, but I would recommend that you condition (In this case) based on the Accelerator View in the Business Process layer.

Let me take you through the steps:

Step 1 - Make sure the module is generated. This will give you a module definition for 1 of the types. Change the module information according to match the type.

Step 2 - Create a Search Explorer Bar that will be used by the new module. In the Accelerator, views are tied to the explorer bar and not the module number. We need to create another Explorer Bar that will be used to define the new view(s). Open the module code in Visual Studio. You can create the explorer bar 2 ways. (1) If you want to have different search fields per module, then you need to copy the existing Explorer Bar xaml and code behind and then rename. (2) If you will have the same search fields and just want different views, then you can just create a C# class that inherits the initial explorer bar code behind.

The new C# class will look like this: (In this example, UserGroupsExpBarSearch_RFWUGEBS1 (Type = "SYSTEM") is the original and UserGroupsExpBarSearch_RFWUGEBS2 (Type = "COMMAND") is the new class that inherits from the original.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WPF.UserGroups
{
    /// <summary>
    /// Class UserGroupsExpBarSearch_RFWUGEBS2. This class used by the Command Groups Module. The Group Type will be "Command".
    /// </summary>
    public class UserGroupsExpBarSearch_RFWUGEBS2 : UserGroupsExpBarSearch_RFWUGEBS1
    {
    }
}

Step 3 - Create New Module and View Reference and View in Accelerator. In order to make sure the assembly names are correct. It is important to first copy the existing module and save it. Then you can change the Module Name, Description, Image, and most importantly the Explorer Bar Item Name which must match your newly created Search Explorer Bar. Save your module again. Then click on the View References and create a new View Reference and View. In this example, I created a new View named "FWUGV01_COMMAND".

Step 4 - Code your query conditions based on view name in the Module Business Process am_Select method.

public override AB_SelectReturnArgs am_Select(AB_SelectInputArgs inputArgs)
{
    switch (inputArgs.ap_View)
    {
        case "FWUGV01_COMMAND":

            if (inputArgs.ap_Query == null)
            {
                inputArgs.ap_Query = new AB_Query();
            }

            // Remove Group Type "SYSTEM" and add Group Type "COMMAND"
            inputArgs.ap_Query.am_RemoveWhereClause(UserGroupsEntity.GroupTypeProperty.ap_PropertyName);
            inputArgs.ap_Query.am_AddWhereClause(UserGroupsEntity.GroupTypeProperty.ap_PropertyName, "=", "COMMAND");

            break;

        default:

            if (inputArgs.ap_Query == null)
            {
                inputArgs.ap_Query = new AB_Query();
            }

            // Make sure Group Type "SYSTEM" Exists
            inputArgs.ap_Query.am_RemoveWhereClause(UserGroupsEntity.GroupTypeProperty.ap_PropertyName);
            inputArgs.ap_Query.am_AddWhereClause(UserGroupsEntity.GroupTypeProperty.ap_PropertyName, "=", "SYSTEM");


            break;

    }


    return base.am_Select(inputArgs);
}

Copying Command Bars in the Accelerator Maintenance

2016-03-04T04:16:22.0100000

The Accelerator comes with alot of predefined command bars and commands. There are 4 Accelerator systems that can serve as a template to copy command bars.

Accelerator Template 1 - Command Bars to support soft delete. This uses a DELETE command ID instead of the PERMDELETE command ID. All command bars are place in the system toolbar tray.
Accelerator Template 2 - Command Bars to support permanent delete. This uses a PERMDELETE command ID instead of the DELETE command ID. All command bars are place in the system toolbar tray.
Accelerator Template 3 - Command Bars to support soft delete. This uses a DELETE command ID instead of the PERMDELETE command ID. System command bars go in the system toolbar tray and the module record level command bars go in the module toolbar tray.
Accelerator Template 4 - Command Bars to support permanent delete. This uses a PERMDELETE command ID instead of the DELETE command ID. System command bars go in the system toolbar tray and the module record level command bars go in the module toolbar tray.

You DON'T want to make any changes to command bars with a command ID greater than 9000000. These command bars are templates and may be updated with an Accelerator release. If you need to add/remove command elements, then you should copy the command bar, make your changes, and then reference the newly created command bar. This can be done through the Command Bar Module.

You can also copy and reference all command bars from other Systems, Applications, and Modules. This can be done by going to the System Module in the Accelerator Maintenance. (1) Select the System you want to copy command bars to. (2) Select the "Command Bars" tab in the preview. Review the command bars. If you have command bars greater than 9000000, then review the system templates and try to identify which template the command bars came from. It may be worth taking a screen print of the command bars to make sure you don't miss any. It is also wise to back up your Accelerator data as well. Once satisfied, remove all the command bars. (2) Click the "Copy Command Bars" button. (3) Select to copy command bars from another System, Application or Module. Most systems that were generated from the Accelerator Wizards copied the Command Bar references from a template and didn't actually copy the command bars first. That is why you may be referenecing command bars greater that 9000000. If you want to create new command bars by copying the command bars first based on the copy from and then reference the newly created command bars, then make sure to check the "Create and Reference New Command Bars...". (4) Review the Copy To section and then click "Ok". Once you create the new command bars, you can go ahead and make changes without getting clobbered by an Accelerator upgrade.

(1) You will now notice the command bars are no longer greater than 9000000.

Using the AB_ModuleExplorerStandalonePresenter Content Control Steps 3 and 4

2016-03-03T21:30:00.3400000

This is a continuation from the following discussion:

http://support.surroundtech.com/thread/using-the-ab_moduleexplorerstandalonepresenter-content-control-step-1-and-2/

Step 3: Add the XAML for the AB_ModuleExplorerStandalonePresenter.

Add the following namespace to your XAML

 xmlns:base="clr-namespace:A4DN.Core.WPF.Base;assembly=A4DN.Core.WPF.Base"

Add the AB_ModuleExplorerStandalonePresenter control where you want it to show. Make sure you name it using x:Name and set the Module number of the module you are showing and the Standard Base Interface Reference ID from above. You also have properties to set whether to show/hide the Module Explorer Info Area and the Preview Pane. You can optionally add an ae_SubbrowserReady handler.

<base:AB_ModuleExplorerStandalonePresenter x:Name="CustomerRemarksModuleExplorer" ap_ModuleNumber="90000103" ap_SBInterfaceReferenceID="CustomerRemarksDialog" ap_ModuleExplorerHeaderIsVisible="True"  ap_ModuleExplorerPreviewIsVisible="True"/>

Step 4: In the code behind, you can control when the data gets loaded by calling am_LoadRecords() and passing the parent entity. In my example, I am loading the data in the contstructor of the window and passing in the selected customer entity. Remarks will load just for the selected customer.

public CustomerRemarksDialog(CustomerEntity selectedCustomerEntity)
{

    InitializeComponent();

    Title = string.Format("Remarks for Customer: {0}", selectedCustomerEntity.LegalName);

    // Load Remark records for Customer
    CustomerRemarksModuleExplorer.am_LoadRecords(selectedCustomerEntity);


}

If you want to issue commands to the Sub Module, you can do this in the SubBrowserReady handler.

private void CustomerRemarksModuleExplorer_ae_SubbrowserReady(object sender, EventArgs e)
{
    CustomerRemarksModuleExplorer.ap_SubBrowser.ap_ModuleExplorer.am_ProcessCommand(new AB_Command("YourCommandID"), null);

}

To put this all together, I will show you how I created an instance of this window and passed in the selected customer entity. I added a command and trapped the command in the content window code behind of the customer.

switch (command.ap_CommandID)
{

    case "SHOW_REMARKS":

        var dlg = new CustomerRemarksDialog(selectedEntity);
        dlg.ShowDialog();

        e.Handled = true;
            break;

		default:
			break;
}

This is what the window looks like:

Using the AB_ModuleExplorerStandalonePresenter Content Control Steps 1 and 2

2016-03-03T21:26:51.6670000

You can show a Module Explorer anywhere you want in WPF by using the AB_ModuleExplorerStandalonePresenter. This is an example of showing Remarks in a custom window.

Step 1: Create a Standard Base Interface record within the Accelerator Maintenance

(1) The reference ID will be used in code to determine which module to load dynamically at runtime. In this example, I am going to name it "CustomerRemarksDialog".

(2) The child module information is the module you want to show. In this example, I am going to show the Accelerator Remarks Module.

Step 2: Create a View Reference record within the Accelerator Maintenance

Create a view reference record in the module you want to show. In this example, I am going to (1) open the Remarks Module and (2) click the View References Tab. (3) Click thw "New" button to create a new View Reference.

On the View Reference Detail, (1) specify the view you want to use. If this is the only view, then you need to mark it as the default view and then whether you want to show the search explorer bar or auto load the data.

Then, (2) specify the parent component. This is the Standard Base Interface Reference ID from above.

This discussion continues here:

http://support.surroundtech.com/thread/using-the-ab_moduleexplorerstandalonepresenter-content-control-step-3-and-4/

How to Show a dialog window of In Use newlook sessions

2016-03-03T17:04:22.6000000

You can show a dialog of all the newlook sessions and how they are being used from anywhere within your WPF system. To access this window, add the following line of code to a button click.

AB_SystemController.ap_NewLookModel.am_ShowNewlookInUseSessionsDialog();

This code will show the following Dialog.

Build Scripts

2016-03-02T21:21:53.5730000

Accelerator version 6.2 offers a new and improved project dependency analysis and build script generator.

To take advantage of the new tool, you will need to generate your build script with Accelerator version 6.2. To do this, open the Accelerator LaunchPad and click on the Tools button on the left side. Then click on the Code Generator button. In the Code Generator, (1) Select your System Generation Configuration File and then (2) Click the Generate Build Script button.

Another window will popup. You can leave all the defaults and click the Run Tool button. You will get a message popup once the tool has completed.

This will generate the build script (.bat) and MSbuild file which has the build layers as determined by the project dependency Analysis (.msbuild) to the Output Directory. Note: the "Max Circular Reference Depth" is the number of levels to hunt for circular references. 4 should be plenty to find a circular reference. You may increase this if you suspect a circular reference is deeper. The circular dependency tool will take longer as this number increases.

Here are the files that may be generated based on the inputs and analysis:

<systemName>_msbuild.bat
- Always generated - This is the bat file that you can double-click to excute the msbuild file. This will delete all dlls in your solution bin and obj folders. It will then run the dependency tool and exceute the build.
<systemName>_gen.msbuild
- Always generated - this is the msbuild file that the bat file executes. This file has the project build layers from the project dependency analysis.
<systemName>_WARNINGS.txt
- Generated from dependency analysis tool to warn you of any bad DLL references. If you see this file, look at the warnings and fix the references in your solution.
<systemName>_CircularReferenceGraph.txt
- Generated from dependency analysis tool if circular references were found. If you see this file, see instructions below on how to view the graph.
<systemName>_BuildLayerGraph.txt
- Generated from dependency analysis tool if "Generate Diagram Files?" is checked prior to running the tool above. See instructions below on how to view the graph.
<systemName>_DependencyGraph.txt
- Generated from dependency analysis tool if "Generate Diagram Files?" is checked prior to running the tool above. See instructions below on how to view the graph.

If a file is generated that ends with Graph.txt, you can download a graph viewer from Graphviz - Graph Visualization Software

After you install the software, you can run the tool (gvedit.exe) and open any of the files that end with Graph.txt.

Here is an example of 2 circular references found by opening the <systemName>_CircularReferenceGraph.txt in GVEdit. You will need to resolve any circular references in order to get a clean build.

Accelerator Remote Error Logging

2016-03-02T15:51:46.9530000

Remote Error logging allows for client systems and system services to relay errors to the Accelerator Services. These errors can then be viewed through Accelerator Maintenance in the 'Event Log' Module that is part of the 'User Access' application.

Remote error logging can be used to track down errors on client systems without checking each systems log individually. These feature 'phones home' any errors above a specified threshold to the systems Accelerator Service Host. The systems IT department can later review and diagnose these errors.

The system can also be configured to send emails to administrators to resolve critical errors, avoiding potential extended system downtime.

The data is stored in the 2 files located in the Accelerator Database:

FWMD - Added Module Table Entry for Event Log
FWJE - Added new file to store logging data

The following error levels can be set as configuration values. It is recommended to keep remote logging to a minimum in production systems as each message logged requires a service call. When running a large number of clients this can generate numerous service calls. Error is the recommended setting to avoid a large log file and unnecessary network traffic.

Debug - This is the most verbose level and should not be used in production systems with the exception of limited debugging for short periods of time. It's primary purpose is tracking down issues when using the debugger is not an option.
Info - Used to report statuses that do not impact performance or require action.
Warn - Warnings of issues that could pose a problem, but do not require immediate action
Error - System errors, typically used when trapping exceptions.
Fatal - An error that causes the entire system to crash. Fatal errors are automatically reported when the entire application crashes due to an unhanded exception.

Configuration Settings in App config files for client systems

<!-- Remote Logging Settings (Client Settings) -->
<add key="Logging.RemoteLoggingEnabled" value="True" />
<add key="Logging.RemoteLoggerLevel" value="Error" />

Configuration Settings in Web config files for system services

<!-- Remote Logging Settings -->
  <add key="Logging.RemoteLoggingEnabled" value="true" />
  <add key="Logging.RemoteLoggerLevel" value="Error" />
<!-- Remote Logging Email Settings, Requires Remote Logging Enabled, Required SMTP Server  (Service Only) -->
  <add key="Logging.SendEmailNotifications" value="false" />
  <add key="Logging.EmailAddressSender" value="notifications@surroundtech.com" />
  <add key="Logging.EmailNotificationLevel" value="Error" />
  <add key="Logging.EmailAddressReceiver" value="admin@surroundtech.com"/>
<!-- Remote Logging Email SMTP Server Settings (Service Only) -->
  <add key="SMTP.Host" value="mailout.surroundtech.com"/>
  <add key="SMTP.Port" value="25"/>
  <add key="SMTP.SenderUserName" value="notifications@surroundtech.com"/>
  <add key="SMTP.SenderPassword" value="******"/>

Accelerator Launch Pad and Maintenance Logging

2016-03-02T15:35:51.1870000

The Accelerator Maintenace also uses the same runtime logging as your system. Review this discussion on Accelerator Logging.

The Error Logs generated from any Accelerator Tool launched from the LaunchPad are located in the C:\Users\<YourUserName>\AppData\Roaming\Accelerator for .NET\Logging folder.

The Accelerator Maintenance BP Service Host settings are located in the WebAppSettings.config located in the folder where you publish the Accelerator Services.

The Accelerator Services WebAppSettings.config is defaulted to the following. You can change any setting in the WebAppSettings.config and your changes will not get clobbered when doing an Accelerator upgrade.

<!--Logging Settings -->
  <add key="Logging.Enabled" value="true" />
  <add key="Logging.AssemblyName" value="A4DN.Core.BOS.Logging.dll" />
  <add key="Logging.ClassName" value="A4DN.Core.BOS.Logging.AB_NLogLogger" />
  <!--Valid values are "Debug," "Info," "Warn," "Error," "Fatal" (Debug is the most verbose, Fatal is the least.)-->
  <add key="Logging.LoggerLevel" value="Error" />
  <add key="Logging.Async" value="true" />
  <add key="Logging.LogPath" value="C:\temp\Accelerator for .NET\Logging\AcceleratorServices" />
<!-- Remote Logging Settings (Client Settings) -->
  <add key="Logging.RemoteLoggingEnabled" value="false" />
  <add key="Logging.RemoteLoggerLevel" value="Error" />

Accelerator Logging

2016-03-02T15:26:51.3770000

The Accelerator has logging built into the runtime engine.

For WPF, you have the ability to log both the client and server side code. The log settings for the client are located in the app.config within your System WPF project. The server side log settings are located in your web.config withing your BP Service Host Project.

For MVC, you can log just the server side. The server side log settings are located in your web.config within your MVC project.

By default, the Accelerator generates with the following log settings:

<!--Logging Settings -->
    <add key="Logging.Enabled" value="True" />
    <add key="Logging.AssemblyName" value="A4DN.Core.BOS.Logging.dll" />
    <add key="Logging.ClassName" value="A4DN.Core.BOS.Logging.AB_NLogLogger" />
<!--Valid values are "Debug," "Info," "Warn," "Error," "Fatal" (Debug is the most verbose, Fatal is the least.)-->
    <add key="Logging.LoggerLevel" value="Error" />
    <add key="Logging.Async" value="True" />
    <add key="Logging.LogPath" value="%APPDATA%\Accelerator for .NET\Logging\<YourSystemName>" />
<!-- Remote Logging Settings -->
    <add key="Logging.RemoteLoggingEnabled" value="True" />
    <add key="Logging.RemoteLoggerLevel" value="Error" />

You can change any of these settings in your WPF app.config and/or BP service Host Web.config for WPF client and server side logging; and in your MVC project Web.config for MVC server side logging.

Here is information regarding the app.setting logging keys and values:

Key: Logging.AssemblyName
- The name of the assembly that holds the logger implementation that will be used to perform logging. By default, the accelerator uses A4DN.Core.BOS.Logging.dll. You are welcome to develop your own and plug in your DLL Assembly Name.
Key: Logging.ClassName
- The full namespace of the class that implements the logger interface. By default, the accelerator uses A4DN.Core.BOS.Logging.AB_NLogLogger. You are welcome to develop your own and plug in your Class Name.
Key: Logging.LoggerLevel
- The minimum message level to log.
- Valid values are Debug, Info, Warn, Error, Fatal
  - Debug is the most verbose, Fatal is the least.
Key: Logging.Enabled
- The flag to enable logging.
- Valid values are True, False
Key: Logging.Async
- The flag to set logging to be synchronous or asynchronous
- Valid values are True, False
Key: Logging.LogPath (Only use if storing logs to a file)
- Set the path the log files will be written to.
- Valid values are a valid windows folder path
Key: Logging.EventLogName (Only use if storing logs to event viewer)
- Set the name of the EventLog section to write the logs to.
- Valid values are any permitted Event Viewer section name
Key: Logging.SourceName (Only use if storing logs to event viewer)
- Set the source value in the event viewer log
- Valid values are any string value
Key: Logging.RemoteLoggingEnabled
- Set the client to make service calls to the error logging service for the event log module
- Valid values are True, False
Key: Logging.RemoteLoggerLevel
- Sets the value to be logged using the remote logging service to create logging entries on the server
- Values include Debug, Info, Warn, Error, Fatal
- Warning DO not use Info or Debug in production setting as it will make excessive network calls.

You have the option to log to a windows folder or windows event viewer and/or to the Accelerator remote Event Log module.

Retailed Topics:

http://support.surroundtech.com/thread/accelerator-launch-pad-and-maintenance-logging/

http://support.surroundtech.com/thread/accelerator-remote-error-logging/

Creating a SQL join using fields from another join in the Datamaps

2016-03-01T13:49:16.7930000

Tables

A. Document Master

B. PO Master

C. Invoice Master

Document Master (A) Keys

PO #
Invoice #

PO Master (B) Keys

PO #
Vendor #

Invoice Master (C) Keys

Invoice #
Vendor #

Join for A->B

relationship_A_to_B = relationshipMap.am_AddRelationshipMap(joinTable: TableName_B);

relationship_A_to_B.am_JoinWhere("PO #", "PO #");

Join for B->C

relationship_B_to_C = relationshipMap.am_AddRelationshipMap(joinTable: TableName_C, primaryTable: TableName_B);

relationship_B_to_C.am_JoinWhere("Vendor #", "Vendor #");

relationship_B_to_C.am_JoinWhere(new AB_JoinCondition(new AB_QueryField(TableName_A, "Invoice #"), "=", new AB_QueryField(TableName_C, "Invoice #"));

Maps for B

maps.am_AddDataMap(string.Format("{0}.[NAME OF FIELD]", TableName_B), [METADATA FOR FIELD], targetTable: TableName_B);

Maps for C

maps.am_AddDataMap(string.Format("{0}.[NAME OF FIELD]", TableName_C), [METADATA FOR FIELD], targetTable: TableName_C);

Why do I sometimes get an exception when starting an MVC project?

2016-02-26T22:57:55.7630000

Sometimes when starting up an Accelerator-based MVC project from Visual Studio, the page that comes up says Error rendering module #xxxx: AttachmentController missing? and this is followed by a large Exception dump. One possible reason for this error is that you've enabled a module for web access, but there is no corresponding Controller class in the MVC application. The controller class's name must be the module's Namespace followed by Controller.

However, there is a more common cause. If you have a Razor template file open and focused when you start the website, by default Visual Studio will try to navigate directly to the template you've got open. This is a hold-over from the ASPX days, when every template file lived at the website root and the url was just the aspx filename. For MVC projects you generally need to start on a home page or login page. For Accelerator-based MVC projects, all module-based pages are reached via the url /Main/Index?modulenum=####. When Visual Studio tries to navigate directly to a template, it can wind up routed to /Main/Index, without the module number. The core AB_MainController class will try to navigate to the first module in the navigator list for the website application, and for CMS websites that's often the Media Library module. We don't support viewing the Media Library module directly like that, which leads to an exception getting thrown.

The fix for this is generally a Best Practice whenever working with ASP.Net MVC projects:

Right-click on the MVC project in Solution Explorer, and open the Properties page
Under Web, change the Start Action from Current Page to Specific Page, but leave the url box empty. This will ensure that Visual Studio starts the website on the default entry page, usually the website root.

How to set a global variable in each newlook session from .NET after logon

2016-02-23T23:27:48.0800000

When working with multiple newlook sessions from .NET, you may want to pass information from the WPF .NET client to each session that is created. This is epecially handy if you want to gather information once and then pass it to each session instead of having each individual session take the performance hit.

You can easily attach to the after sigon event which will be fired after each newlook session signs on. The best place to attach to this event is in your Browser code behind in your System WPF project.

In the browser code behind, attach to the ae_AfterNewlookSignOn event in the Browser constructor. In the event handler, you can get access to the newlook reference and then call the am_SetValue method.

public Browser()
{
    // Set the Splash Window Type
    ap_SplashWindowType = typeof(Splash);

    InitializeComponent();

    // Attach to event
    AB_SystemController.ap_NewLookModel.ae_AfterNewlookSignOn += Ap_NewLookModel_ae_AfterNewlookSignOn;

}

private void Ap_NewLookModel_ae_AfterNewlookSignOn(object sender, System.EventArgs e)
{
    var newlookReference = sender as AB_NewlookOCXControl;
    if (newlookReference != null)
    {
        newlookReference.am_SetValue("GlobalVariable", "Value");
    }

}

How to run the newlook scripts prior to the detail window showing

2016-02-22T23:42:42.8470000

The newlook scripts are run in the detail code behind in the method am_Newlook_ProcessCommandScript. This method is called after the data is loaded which also occurs after the detail window is shown. The user will see a Navigating message while the script is running.

You can run the newlook scripts prior to the detail window showing. For example, you may want to write code to close the window if the script does not navigate to the correct screen and prompt the user with a message box instead. This can easily be achieved with the following code below.

In the am_BeforeProcessCommand method in the detail code behind, you can trap individual commands or trap all commands. When this method is called, the detail window is currently not shown. This allows you to call the am_Newlook_ProcessCommandScript method prior to the detail window showing.

This example calls am_Newlook_ProcessCommandScript prior to the detail window showing for the "NEW" and "OPEN" commands. The screen messages are checked and if it contains a certain message, the user is prompted with a message box and the detail is closed without ever showing. Otherwise, the detail window will show as usual.

protected override void am_BeforeProcessCommand(AB_Command command, System.Windows.RoutedEventArgs e)
{
			
	switch (command.ap_CommandID)
	{
                case "NEW":
                case "OPEN":

                    am_Newlook_ProcessCommandScript(command.ap_CommandID, ap_CurrentCommand, ap_EntityToPerformCommandOn);
                    if (ap_NewlookReference.ap_ScreenMessages.Contains("You are not authorized"))
                    {
                        MessageBox.Show(ap_NewlookReference.ap_ScreenMessages, "Error", MessageBoxButton.OK);
                        e.Handled = true;
                        Close();
                    }
                    

                    break;
	}
			
}

In the method am_Newlook_ProcessCommandScript in the detail code behind, you need to make sure of 2 things:

1) That you call the base method in am_Newlook_ProcessCommandScript. This has logic to ensure that the framework does not call the method am_Newlook_ProcessCommandScript in the data loaded event if you have already called this method in the am_BeforeProcessCommand method. Remember that the default behavior is to call am_Newlook_ProcessCommandScript when the data is loaded. We don't want to call this method twice. Add this as the first line of code in the method am_Newlook_ProcessCommandScript.

 base.am_Newlook_ProcessCommandScript(scriptCommand, command, EntityToPerformCommandOn);

2) The default when playing a transaction is to call the transaction in the completed event of a background worker. The parameter is called _RunWorkerAsync and by default is true. If this is true, the ap_NewlookReference variable will not be updated with the screen name, title, messages etc. immediately following the am_PlayTransaction. If you want to wait for the script to complete, then you need to set _RunWorkerAsync to false. The last parameter in this code snippet is false which will wait for the script to complete. This will allow you to access the screens and messages immediately following the am_PlayTransaction.

ap_NewlookReference.am_PlayTransaction("<TransactionName>", true, scriptKeyInput, false);

Find any currently logged on Users

2016-02-22T22:47:29.4870000

You can query the A4DN database to determine if there are any currently logged on users. Here is a query which will tell you the users that are currently logged on and which systems they are logged onto.

SELECT s.FWSYNM as 'System',

u.FWUSUS as 'User Id',

u.FWUSDS as 'User',

l.FWJLONDT as 'Logon Date',

l.FWJLONTM as 'Logon Time',

l.FWJLPCNM as 'Computer'

FROM FWJL l

LEFT JOIN FWUS u ON l.FWJLUSID = u.FWUSID

LEFT JOIN FWSY s on s.FWSYNO = l.FWJLSYNO

WHERE l.FWJLOFDT IS NULL

Adding additional Tab Items to your module WPF Detailer

2016-02-17T20:36:56.8930000

The Accelerator support 2 different types of tab item controls in WPF: AB_TabItem and AB_DockingTabItem. AB_TabItem is a wrapper around the standard WPF TabItem control and AB_DockingTabItem is a wrapper around a 3rd party control called Dragablz.

You can choose which tab style to generate in the standards configuration.

The Accelerator generates by default a DetailFieldsTab and an AuditFieldsTab. You will see these 2 tabs in the Detail XAML. These tabs are already setup by the framework to have the correct data context as well as to show in the preview Tab Control on the Content Window.

If you need to add additional Tab Items to your WPF Detailer, then you can add additional Tab Items in the XAML. Make sure to use the same Tab Item that the DetailFieldsTab and AuditFieldsTab use.

If you want your new tab item to use the same Data Context as the other tabs and have the Accelerator runtime manage setting it, then you need to add the following line of code to your am_SetParentProperties method in the detail code behind.

ap_AdditionalTabItemsToSetDataContextOn.Add(GoogleMapsTab);

If you want to have this new tab show in the preview Tab Control on the Content Window, then you need to to add the following line of code to your am_SetParentProperties method in the detail code behind.

am_AddTabToPreview(new AB_DockingTabItem[] { GoogleMapsTab});

This is an example of what it may look like:

protected override void am_SetParentProperties()
{
     RG_SetParentProperties();	  
     base.am_SetParentProperties();
     // Add Google and Bing Maps to Preview
     am_AddTabToPreview(new AB_DockingTabItem[] { GoogleMapsTab, BingMapsTab });
 
     ap_AdditionalTabItemsToSetDataContextOn.Add(GoogleMapsTab);
 
     ap_AdditionalTabItemsToSetDataContextOn.Add(BingMapsTab);
}

Parent Keys

2016-02-16T21:20:26.8600000

Parent Keys are key-value pairs that get passed from a module to its subbrowsers. There are two types of parent keys OnSearch and OnPreload.

The OnSearch parent keys are used for loading records in a subbrowser content window and the OnPreload are used for new records created in the subbrowser. To specify a field in the parent you want broadcasted to the subbrowsers you add the AB_BroadcastMember attribute to the field in the entity. This attribute allows you to specify if you want it to be for OnSearch, OnPreload, or Always(both).

[AB_BroadcastMember(AB_DataShouldBePassed.OnSearch)]

[AB_BroadcastMember(AB_DataShouldBePassed.OnPreload)]

[AB_BroadcastMember(AB_DataShouldBePassed.Always)]

There are now two collections of parent keys on the AB_ContentWindowBase class. These two collections are ap_ParentKeys and ap_SearchParentKeys. Both of these collections will only be populated if the content window is in a subbrowser. The ap_ParentKeys are the OnPreload keys and will be used for new records. The ap_SearchParentKeys are used to create the initial search entity for the explorer bar and are able to be accessed in the content window for custom use. In most cases these two collections will have the same keys in them but it is recommended that you use the ap_ParentKeys unless you are dealing with functionality releted

Services sometimes taking a long time

2016-02-16T14:23:00.5330000

If your service calls are sometimes taking a very long time it may be a configuration issues with IIS. If the settings are not correct your IIS app pool could be recycling too oftern. You can view when IIS app pools get recycled by looking at the Window's Event Log. The recycle events will be recorded in the Windows Logs\System and they will tell you why the recycle was requested.

Here is an example of one of those log entries:

A worker process with process id of '10788' serving application pool 'Complex' has requested a recycle because it reached its virtual memory limit.

Deploying WPF Systems to IIS

2016-02-15T23:51:56.9930000

Before you can deploy a WPF system to IIS, please refer to the topic Configuring Deployment Scripts to create a deployment package.

Once you have a deployment package, you can copy the package to your IIS server. Since the Accelerator can create a package for multiple Environments, we recommend the following folder tree and naming standard:

Create a Folder in C:\inetpub\wwwroot
- The folder should be named as follows: {System}{EnvironmentID}
- In the {System}{EnvironmentID}, create 2 folders: A4DNServices and BPServices
  - The A4DNServices will contain the Accelerator Services and the BPServices will contain your services as well as the WPF installer folder.
This is what is should look like for each Environment:
- {System}{EnvironmentID}
  - A4DNServices
  - BPServices
    - Installer
In IIS management, you will need to convert to application both the A4DNServices and BPServices folder.

Once the Package is on the server, all you need to do is unzip it and copy the contents of BPServices to the BPServices in the correct {System}{EnvironmentID} folder. The BP services folder has both the BOS code and the WPF click once installer.

You can now click on your desktop icon to receive the update if previously installed or use the installer URL for first time installation.

Refer to WPF Click Once Deployment - Setting Minimum Required Version Automatically if you want to force your users to upgrade when a new version is available.

Configuring Deployment Scripts

2016-02-15T22:56:46.8970000

Before you can configure the deployment scripts, please refer to the following topic:

Instructions for creating Deployment Scripts in systems generated prior to version 6.1.4.0

Configuring the Click Once Settings for use with Deployment Scripts

Here are the steps to Configure Deployment Scripts:

1) Configuring the Deployment Script manifest xml files

In windows explorer, navigate to the new DeploymentScripts folder that was added to your system folder.
You will notice that a Manifest xml file was created for each of your Environment IDs.

Open each xml file and verify that the publisher, suiteName and product are correct. The Publisher is usually your company name and is the text that is listed in the windows start menu. The Suite Name is optional and if specified will show up under the Publisher Name as a sub folder. The Product is the name that will be used for the application shortcut.

2) Configuring the variables in the deployment script .bat file

Open and edit your {system}_Deployment.bat file located in the DeploymentScripts Folder.
The script is setup so that you only need to configure the variables, most of which should already be correct. You just need to specify a couple settings that may be specific to your environment.
- Make sure the BPServiceHostPublishProfile exists and has the correct name. Refer to step 4 in Configuring the Click Once Settings for use with Deployment Scripts for details on setting this up (1).
- Make sure the mage.exe and 7z.exe exist and the path is correct. You may need to install 7-zip. Depending on your Visual Studio version, the mage.exe may be in a different folder (2)(3).
- If you are using a password for your click once certificates, you need to set the variable SigningManifestPassword (4).
- Set the ClickOnceIconName to the Icon Name that you specified on in step 1 of Configuring the Click Once Settings for use with Deployment Scripts (5).
- Specify the Environment ID, Environment Icon, Environment Installation Folder URL for each Environment (6).

To run the Deployment Script:

Set the ApplicationVersion Variable at the top of the script to the version you want to generate a click once for.
Run your {System}_Deployment.bat file by double clicking it in Windows Explorer. If everything is configured correctly, Your Deployment folder will contain a zipped file for each environment. Here is wait the script is doing:
- Updates the Application Version in the WPF project and the "Version" Key in the app.config.
- Runs your build script based on the BuildScriptLocation variable.
- Clears the Deployment folder based on the DeploymentFolder variable.
- Publishes your BPservices using the BPServiceHostPublishProfile variable.
- Publishes your WPF Click Once.
- Creates the Click Once html install page.
- Creates a zipped package for each environment and outputs them to your Deployment Folder.

Refer to Deploying WPF Systems for details on what to do with the zipped folders for each environment.

Configuring the Click Once Settings for use with Deployment Scripts

2016-02-15T22:04:20.1970000

Accelerator version 6.1.4.0 makes deploying WPF applications to multiple environments much easier and now generates scripts to automate and standardize the deployment process. Once configured, a developer can deploy to multiple environments by running a .bat file. This can be further automated by using 3rd party products such as TeamCity

This documents contains the instructions to configure the deployment scripts.

Refer to Instructions for creating deployment scripts in systems generated prior to version 6.1.4.0 if your system was generated prior to Accelerator Version 6.1.4.0.

Refer to WPF Click Once Deployment - Setting Minimum Required Version Automatically if you want to force your users to upgrade when a new version is available.

Steps:

1) Verfiy the WPF Click Once Properties

Under WPF Properties, Click Application on the left and set the main icon.

Click on Publish on the left hand side and set the Publishing Folder Location (1). This location will need to match the DeploymentFolder variable in the Deployment Script.
Set the Installation Folder URL for your Development Environment. This is URL of the installer folder within IIS. This must match the EnvID1InstallationFolderURL variable in the Deployment Script.

Click on the "Updates..." button. Verify that the settings look like this:

Hit "Ok" to close the Dialog Window.
Click on the "Options..." button.
Make sure the "Create desktop shortcut" is clicked

2) Add Additional Icons for all Environments.

You may want a different icon per environment. If you do, you need to add all Icons under your WPF.{Solution} Project

3) Create a Certificate for each Environment

Under WPF Properties, Click Signing on the left hand side.
Create a test certificate for each environment you have. You will need to rename each certfifcate to this naming standard: WPF.{SystemName}.{EnvironmentID}.pfx
You have the option to specify a password. If you do, use the same password for all certificates.
After you create and rename the certificates for each environment, click the "Select from File..." button and select your development certificate.

4) Create a Publish setting for your BPServiceHost

Right click on your BPServiceHost Project and click "Publish"
Create a new custom Profile. Call it "FileSystemRelease".

Select the Publish Method "FileSystem" (1)
Select the Target Location. Set this to the Publish folder location you specifed earlier in the Default Standards Configuration Editor (2).

Set the Configuration to "Release" (1)
Click the "Delete all existing files prior to publish" (2)
Click the "Publish" button (3)

Refer to Configuring Deployment Scripts to complete the Deployment Script Setup.

Services.config and the EnvironmentID Attribute

2016-02-15T21:00:45.1000000

As of Accelerator version 6.1.4.0, you can now add a new attribute to the services element called EnvironmentID in your services.config. This attribute is picked up by the WPF runtime engine and displayed on the logon, splash and browser status bar. This helps identify what services are being called.

In the WPF UX, the environment ID along with the "Version" key from the app.config shows on the logon, splash and browser window.

Instructions for creating Deployment Scripts in systems generated prior to version 6.1.4.0

2016-02-15T20:24:18.8970000

This documents the process of adding the necessary files to your system to support the deployment scripts. Systems generated with version 6.1.4.0 and greater already have these files generated and can refer to instructions to configure the deployment scripts.

Steps:

1) Generate the Build and Deployment Scripts

Launch the Accelerator Launchpad
Click Tools (1) and then click the Code Generator (2)

Select the System Configuration
Click on Edit Button (1)
Expand Generation Options (2)
Specify your Envionment IDs separated by a comma (3).
Specify the Deployment Output Folder (4). It is recommended to keep this folder outside of source control. This is where the packages will be created. There will be 1 zipped folder per environment ID.
Click Save and Close (5)
Click Generate Build Script (6)
Click Generated Deployment Script (7)

2) Add ConnectionParms.config and Service.Config for each Environment ID.

Open one of your Visual Studio Solutions. We will only be working with the System projects, so you can just open the .sln located in your system folder.

Updates to your DALServiceHost Project:

In your DALServiceHost Project, Create a ConnectionParm.config for each of your Envionment IDs. The name of each config should follow this standard: ConnectionParms.<EnvironmentID>.config (1).
Set the Build Action to Content and the Copy to Output Directory to Copy if newer.

Setup each ConnectionParms.<EnvironmentID>.config with the correct settings for the environment. It may be helpful to set the "idref" to something meaningful like "DEVDB", "TSTDB" etc. Just make sure to set the idref and the server id.

Updates to your BPServiceHost Project:

In your BPServiceHost Project, Create a Services.config for each of your Envionment IDs. The name of each config should follow this standard: Services.<EnvironmentID>.config (2).
Set the Build Action to Content and the Copy to Output Directory to Copy if newer.
Setup each Services.<EnvironmentID>.config with the correct settings for the environment. You can also add a new attribute to the services element called EnvironmentID. This attribute is picked up by the WPF runtime engine and displayed on the logon, splash and browser status bar. This helps identify what services are being called.

In your BPServiceHost project, you can also add the existing items (all your newly created ConnectionParms.<EnvironmentID>.config) from your DalServiceHost (3). When you add them make sure to specify "Add As Link"

Set the Build Action to Content and the Copy to Output Directory to Copy if newer.

Here is an exmaple of what your dal and bp service hosts should look like:

Updates to your WPF System Project:

In the WPF System Project, add all your newly created ConnectionParms.<EnvironmentID>.config from your DalServiceHost and all your newly created Services.<EnvironmentID>.config from your BPServiceHost as linked Items. When you add them make sure to specify "Add As Link"
For all the Services.configs, Set the Build Action to Content and the Copy to Output Directory to Copy if newer.
For all the ConnectionParms.config, Set the Build Action to None and the Copy to Output Directory to Copy if newer. (Setting the Build Action to None will ensure that the connectionParms.config is not deployed to the WPF client)

Refer to Configuring the Click Once Settings for use with Deployment Scripts for more details on setting up the Deployments

AB_DropDown Dependency Properties

2016-02-12T20:22:24.3800000

There are three different types of dependencies properties that can be added to a dropdown. Below are the three types are:

ap_KeyDependencyProperties - This should be the set of properties that uniquely identifies a record.
ap_FilterDependecyProperties - These are properties that filter the list of the return records. Can also be fields in the ap_KeyDependencyProperties.
ap_NonKeyDependencyProperties - These are additional properties that are obtained from the selected record.

Note: A Dependency Property can belong to more than 1 of these collections, but properties in the ap_NonKeyDependencyProperties should not be in any of the other collections.

Each dependency property can also implement an on changed event. The two main change event handlers are am_OnIdChanged and am_OnFilterIdChanged. The ap_NonKeyDependencyProperties should not implement either of these change handlers.

When am_OnIdChanged gets invoked it will do the following:

If field is in the ap_FilterDependencyProperties it will call am_OnFilterIdChanged
Creates a new entity and populates all of the ap_KeyDependencyProperties that are not non null ap_FilterDependencyProperties
If any of the ap_KeyDependencyProperties are not null then it attempts to fetch the record with a query object with only the ap_KeyDependencyProperties set.

When am_OnFilterIdChanged gets invoked it will do the following

Clear all records in the dropdown
Clear all of the ap_NonKeyDependencyProperties and any ap_KeyDependencyProperty that is not in the ap_FilterDependencyProperties
Set the currently selected dropdown item to null
Fire the change events

All ap_KeyDependencyProperties should use the am_OnIdChanged as the change hanlder even if they are also in the ap_FilterDependencyProperties. Properties that are only in the ap_FilterDependencyProperties should use am_OnFilterIdChanged. Properties that are in the ap_NonKeyDependencyProperties should not have any changed event hanlder unless it is some custom logic.

Properties that are in the ap_KeyDependencyProperties should also be in the ap_FilterDependencyProperty when they are keys to the record but not the field that gets entered into the dropdown.

WPF Click Once Deployment - Setting Minimum Required Version Automatically

2016-01-29T16:55:15.6030000

When you publish a WPF Click-Once installation, you have the option to set the Minimum Required Version on the Application Updates Dialog.

Setting the minimum version to the current version will force the update on the user instead of giving the user the option to download the new install. Generally, our customers want to force the new version on the users and not give them an option. In order to do this, you need to always remember to set the minimum version. This is a way to have the minimum version to allows be the current version. You simplly need to add this to your Project file. Open your wpf .csproj file into a text editor and add Target to the Project.

  <Target Name="AutoSetMinimumRequiredVersion" BeforeTargets="GenerateDeploymentManifest">
    <FormatVersion Version="$(ApplicationVersion)" Revision="$(ApplicationRevision)">
      <Output PropertyName="MinimumRequiredVersion" TaskParameter="OutputVersion" />
    </FormatVersion>
    <FormatVersion Version="$(ApplicationVersion)" Revision="$(ApplicationRevision)">
      <Output PropertyName="_DeploymentBuiltMinimumRequiredVersion" TaskParameter="OutputVersion" />
    </FormatVersion>
  </Target>

This target is now included in the Accelerator Templates and will be added whe generating systems in the future.

Use AB_LogicalOperatorScope to analyze performance using System.Diagnostics.Trace

2016-01-29T16:21:38.4930000

If your code is performing slowly and you're not sure why, a useful analysis technique is to add some diagnostic logging around blocks of code you suspect might be slow and to report how much time is spent in those code blocks. System.Diagnostics provides a number of tools which can be used, including the Stopwatch class for high-resolution timing and the Trace class for sending output to various TraceListeners. When an application is running in debug mode, Visual Studio attaches a ConsoleTraceListener to the Output window for you, so any trace output, such as from calling System.Diagnostics.Trace.WriteLine(), will be visible there. It's also possible, using settings in App.Config or Web.Config, to send trace output to other places, such as text files or the Windows Event log.

The AB_LogicalOperationScope class makes it easy to wrap a block of code with tracing, with a start time, end time, duration, and nested logging. To use it, wrap the code to diagnose in a using block. These blocks can be nested, which will cause the log entries to be indented to show the nesting:

protected override void am_AsyncSearchCompleted(System.Collections.IList EntityRecords, AB_SelectReturnArgs SelectReturnArgs)
{
    using (new AB_LogicalOperationScope("am_AsyncSearchCompleted"))
    {
        using (new AB_LogicalOperationScope("Call base.am_AsyncSearchCompleted"))
        {
            base.am_AsyncSearchCompleted(EntityRecords, SelectReturnArgs);
        }

        using (new AB_LogicalOperationScope("Call _LoadTree after async search"))
        {
            // Load Tree
            _LoadTree();
        }

        if (_SelectedModule == null)
            return;

        using (new AB_LogicalOperationScope("Set ap_SelectedItem properties after async search"))
        {
            foreach (AB_BusinessObjectEntityBase item in ap_DataPresenter.ap_Items.Cast<ab_businessobjectentitybase>().Where(item =&gt; item.ap_CompleteUniqueKey == _SelectedModule.ap_CompleteUniqueKey))
            {
                ap_DataPresenter.ap_SelectedItem = item;
                break;
            }
        }
    } 
}</ab_businessobjectentitybase>

This method's log trace will look like this:

&#xD;
[171318832883] START am_AsyncSearchCompleted&#xD;
    [171318888188] START Call base.am_AsyncSearchCompleted&#xD;
    [171319062011] FINISH (66.916909ms) Call base.am_AsyncSearchCompleted&#xD;
    [171319074116] START Call _LoadTree after async search&#xD;
        [171319095415] START _LoadTree - 142ab766-fc33-43be-8032-8331bba53513&#xD;
            [171319104210] START Set expanded flag and event handler - 142ab766-fc33-43be-8032-8331bba53513&#xD;
            [171319114309] FINISH (3.891454ms) Set expanded flag and event handler - 142ab766-fc33-43be-8032-8331bba53513&#xD;
            [171319131723] START Add modules to recordSet - 142ab766-fc33-43be-8032-8331bba53513&#xD;
            [171319143700] FINISH (4.614388ms) Add modules to recordSet - 142ab766-fc33-43be-8032-8331bba53513&#xD;
            [171319171338] START Call ap_DataTransform for 3 records - 142ab766-fc33-43be-8032-8331bba53513&#xD;
            [171319216930] FINISH (17.554848ms) Call ap_DataTransform for 3 records - 142ab766-fc33-43be-8032-8331bba53513&#xD;
        [171319230210] FINISH (51.892719ms) _LoadTree - 142ab766-fc33-43be-8032-8331bba53513&#xD;
    [171319236621] FINISH (62.559667ms) Call _LoadTree after async search&#xD;
[171319240466] FINISH (156.903067ms) am_AsyncSearchCompleted&#xD;

Accelerator Tab Controls

2016-01-19T22:13:26.5500000

In order to support this new feature, the Module Detail XAML code needed to be updated to support a new TabControl and TabItem Class. The TabControl will be replaced with either AB_DockingTabControl or AB_TabControl and TabItem will be replaced with AB_Tab. The decision to replace TabControl with either AB_DockingTabControl or AB_TabControl depends on whether you want to use this new float/docking enhancement. The decision of what control to use is stored in your Standards Configuration. The Upgrade Utility and the Generation Wizards will pull from this standards configuration to decide which control to use. Before you use the Upgrade Utility, make sure to set the System Configuration to your desired setting. The default is to use the Docking control which will scrub your detail XAML and replace TabControl with AB_DockingTabControl.

The new tab control types are AB_TabControl and AB_DockingTabControl. The AB_TabControl inherits from the WPF TabControl and the AB_DockingTabControl inherits from the Dragablz tab control.

Scrub Program Code Changes:

The scrub program will upgrade a module's existing generated code to use one of the new Tab Control types. The scrub program does the following steps to update any existing code.

Adds an app.config setting for Module.TabControl.AssemblyName and Module.TabControl.ClassName
If docking tabs are selected it will add a reference to the Dragablz.dll to every WPF module project
WPF Detail.xaml changes
- Docking Tab changes
  - AB_Tab, AB_TabItem, TabItem all get converted to AB_DockingTabItem
  - Style attribute is removed from AB_DockingTabItem
- Standard Tab changes
  - AB_Tab, AB_DockingTabItem, TabItem all get converted to AB_TabItem
  - Style attribute is removed from AB_TabItem
WPF Detail.xaml.cs changes
- ap_MainTabControl.ap_Tabs has been changed to ap_MainTabControl.ap_TabItems
WPF ContentWindow.xaml.cs changes
- ap_SubBrowserTabControl.ap_Tabs has been changed to ap_SubBrowserTabControl.ap_TabItems
- am_SubBrowsersCreated(ObservableCollection<AB_Tab> has been changed to am_SubBrowsersCreated(ObservableCollection<AB_TabItem>

Issues when upgrading to AB_DockingTabControl:

The AB_DockingTabItem does not get displayed in the visual tree. Because it is not a part of the visual tree this breaks most bindings using the ElementName. If the binding is referencing another control that is not a parent of the control you can switch and ElementName binding to use a source of x:Reference. The x:Reference binding results in the same behavior in most cases as the ElementName but it finds the controls differently.

The AB_DockingTabItems does not inherit the DataContext of the AB_DockingTabControl by default. For any additional tabs added to a detail at the Main tab control level it is suggested that these tabs be added to the ap_AdditionalTabItemsToSetDataContextOn collection in the am_SetParentProperties method of the code behind for the detailer. For any child tab controls if the desired DataContext is the ap_CurrentEntity of the detailer than the same method will work, otherwise a binding will need to be set for each TabItem to the desired DataContext for that tab.

Adding Placeholder Text to Fields and Dropdowns

2016-01-11T17:16:12.1000000

The Accelerator supports adding placeholder text to Textboxes and Dropdowns for the purpose of showing instructions to a user before they've entered a value. To add Placeholder text to your inputs, see the instructions below.

To add Placeholder text to AB_FieldWithLabel controls

Set ap_PlaceholderText to the text you want to show.
Set ap_IsPlaceholderTextVisible to 'True'.

Example

XAML

<base:AB_FieldWithLabel ap_PlaceholderText="Enter Product number" ap_IsPlaceholderTextVisible="True" ... />

To add Placeholder text to AB_DropDownBase controls

Add an event handler to the dropdowns 'Loaded' event.
In the event handler, set ap_ComboDropDownPlaceHolderText on the MainComboBox control inside of the Dropdown to the text you want to show.

Example

XAML

<base:AB_DropDownBase x:Name="Field_ProductDropdown" Loaded="Field_ProductDropdown_Loaded" ... />

private void Field_ProductDropdown_Loaded(object sender, RoutedEventArgs e)
{
    AB_DropDownBase dropdown = sender as AB_DropDownBase;
    if (dropdown == null || dropdown.ap_MainComboBox == null)
        return;

    dropdown.ap_MainComboBox.ap_ComboDropDownPlaceHolderText = "Select a Product";
}

Fiddler (software) - Captures HTTP and HTTPS traffic and logs it for the user to review

2016-01-04T15:39:08.4570000

Fiddler is a great tool to monitor network traffic which can give you insight into the service calls from your application to understand frequency and duration. I like to use this tool as part of undertanding and improving performance. You may need to use other profiling tools as well, but this is a great tool to undertand what service calls are taking the longest to execute.

You can download Fiddler4 from here.

Here is more information from wikipedia.

Improve MVC performance by managing Session and Output Cache

2016-01-03T16:56:32.4100000

There are two attributes that can be placed on an MVC Controller class improve the performance of all the methods in the class:

SessionState - By setting to readonly, methods in the controller can be called and executed in parallel by concurrent AJAX requests. However, they won't be able to make any changes to the Session[] object.

OutputCache - The responses to the class' methods will be cached for up to the specified duration. The VaryByParam value ensures that both the url and query parameters will be used to uniquely identify a request/response in the cache. The VaryByCustom value uses a method in MvcApplication to ensure that the cache is cleared when the session id changes after the user logs out and back in.

See Also:

&#xD;
[SessionState(System.Web.SessionState.SessionStateBehavior.ReadOnly)]&#xD;
[OutputCache(NoStore=false, Duration=180, VaryByParam="*", VaryByCustom="SessionID", Location=OutputCacheLocation.Server)]&#xD;
public class FeaturedSpecialsController : Controller&#xD;
{&#xD;
...&#xD;
}&#xD;

Here is the implementation of the VaryByCustom method in the AB_MvcApplication class. It supports "SessionID" as the VaryByCustom value, or a special case value of "_ExpBarSearchPopulated" that's used in the Accelerator Line-of-Business application. Any other values are passed to the base HttpApplication class.

&#xD;
/// <summary>&#xD;
/// Used for OutputCacheAttribute on controller classes or action methods&#xD;
/// </summary>&#xD;
///<param name="context">An <see cref="T:System.Web.HttpContext"></see> object that contains information about the current Web request.&#xD;
///<param name="custom">The custom string that specifies which cached response is used to respond to the current request.&#xD;
/// <returns>If the value of the <paramref name="custom"></paramref> parameter is "browser", the browser's <see cref="P:System.Web.Configuration.HttpCapabilitiesBase.Type"></see>; otherwise, null.</returns>&#xD;
/// <remarks><example>&#xD;
/// <code>&#xD;
/// [OutputCache(NoStore=false, Duration=180, VaryByParam="*", VaryByCustom="SessionID", Location=OutputCacheLocation.Server)]&#xD;
/// </code>&#xD;
/// </example>&#xD;
/// When this attribute is applied to a controller class or an &#xD;
/// individual action method, the response to the method(s) will be &#xD;
/// cached for up to the specified duration. The VaryByParam value &#xD;
/// ensures that both the url and query parameters will be used &#xD;
/// to uniquely identify a request/response in the cache.&#xD;
/// The VaryByCustom value "SessionID" is applied by this method&#xD;
/// to ensure that the cache is cleared when the session id changes &#xD;
/// after the user logs out and back in.&#xD;
/// See Also:&#xD;
/// http://www.asp.net/mvc/tutorials/older-versions/controllers-and-routing/improving-performance-with-output-caching-cs&#xD;
/// http://stackoverflow.com/questions/2289941/outputcache-controller-attribute-vary-by-user-role-is-this-possible-in-net-mvc</remarks>&#xD;
public override string GetVaryByCustomString(HttpContext context, string custom)&#xD;
{&#xD;
    if (custom.ToLower().Equals("sessionid"))&#xD;
    {&#xD;
        return GetVaryBySessionString(context);&#xD;
    }&#xD;
    else if (custom.ToLower().Equals("_expbarsearchpopulated"))&#xD;
    {&#xD;
        // For the ExpBarSearch form in the navigator, vary by sessionid to make sure&#xD;
        // each user gets their own cache, and also by module number and any form fields&#xD;
        // that are currently cached for the module.&#xD;
&#xD;
        var modulenum = context.Request["modulenum"];  // From MainController.Index()&#xD;
        var cacheString = AB_BaseController.am_GetExpBarCustomCacheString(modulenum, context.Session);&#xD;
        return GetVaryBySessionString(context) + ";" + modulenum + ";" + cacheString;&#xD;
     }&#xD;
&#xD;
    return base.GetVaryByCustomString(context, custom);&#xD;
}&#xD;
&#xD;
/// <summary>&#xD;
/// Gets the vary by session string.&#xD;
/// </summary>&#xD;
///<param name="context">The context.&#xD;
/// <returns>System.String.</returns>&#xD;
protected string GetVaryBySessionString(HttpContext context)&#xD;
{&#xD;
    // The combination of the ASP.NET session id and the A4DN&#xD;
    // session token should be unique per-user and per-login.&#xD;
    var aspSessionID = context.Request.Cookies["ASP.NET_SessionId"];&#xD;
    var aspxAuth = context.Request.Cookies[".ASPXAUTH"];&#xD;
    var a4dnSession = context.Request.Cookies["session"];&#xD;
&#xD;
    if (aspSessionID != null || aspxAuth != null || a4dnSession != null)&#xD;
    {&#xD;
        return (aspSessionID == null ? "" : aspSessionID.Value)&#xD;
             + (aspxAuth == null ? "" : aspxAuth.Value)&#xD;
             + (a4dnSession == null ? "" : a4dnSession.Value);&#xD;
    }&#xD;
    else&#xD;
    {&#xD;
        return "";&#xD;
    }&#xD;
}&#xD;

IIS Application Deployment Security Setup

2016-01-03T16:26:33.8770000

Steps for setting up a new MVC/WCF Deployment on IIS7+

Create a new Application Pool for the deployment.
1. Right-click on Appplication Pools and choose “Add Application Pool”
2. Use the name of your MVC/WCF app as the name of your application pool, so it’s easy to tell that they go together later.
3. Make sure .NET 4.*, Integrated pipeline, and Start Immediately are selected, and click OK.
4. In the Application Pool list, right-click on the new pool and choose Advanced Settings
5. Under Process Model, set Identity to “ApplicationPoolIdentity”. This creates a new account on the machine which will be used to run the pool.
Create your new Application
1. Right-click on the Site you want to use to host your new application, and choose “Add Application”
2. The Alias is usually your application name; this becomes the root portion of the url for your application.
3. Click the Select button to choose an application pool, and select the app pool you created in step #1
4. Select the physical path where the application will be deployed.
5. Click Connect As, and make sure “Application user” is selected. This tells IIS to use the application pool user created in step #1b.
6. Don’t bother with Test Settings; it will fail at this point.
Set up file system security
1. Select your Application in the connections panel, and click on Edit Permissions in the right-hand Actions panel.
2. Open the Security tab, and click Edit, then click Add on the dialog that comes up.
3. In “Enter the object names to select”, type in IIS AppPool\{name of the application pool from step #1b}
  - Eg: If you named your application pool MyApp, you would type in IIS AppPool\MyApp
4. Click on Check Names, and it should accept the name, which will appear as just your app name underlined.
5. Click OK once to get back to the security settings, and choose the permissions you need. Typically "Read & Execute", "List Folder Contents", and "Read" are sufficient for web sites/services that don't need to modify any files. For CMS websites, the Views folder requires Full Control so that the website can write out cached razor template versions of the HTML Body content that comes from the CMS Webpages module. See step #4.
6. Click OK two more times to go back to IIS.
For CMS-based websites, Navigate to the Views folder in Windows Explorer, right-click on it and open the Properties dialog, go to the Security tab and click on the Edit button. Choose the user for your application pool, give it Full Control, and click Apply to save the change.

Intercept and Customize MVC model binding

2015-12-29T23:16:54.3570000

I have an MVC project that uses data entity objects which have a virtual DeliveryDate property whose getter creates a DateTime from DeliveryYear, DeliveryMonth, and DeliveryDay int properties. There is no setter for converting the other way; it had been intentionally removed at some point. This caused a problem for me: I’m displaying DeliveryDate in a form using @Html.EditorFor(m => m.DeliveryDate), but the model that my request handler gets back from POST requests always has DateTime.Now in DeliveryDate, because the year, month, and day properties aren’t being set and the virtual returns DateTime.Now by default.

My solution is to intercept MVC's model binding and set DeliveryYear, DeliveryMonth, and DeliveryDay based on the DeliveryDate value being submitted. This is actually pretty easy to do, but it was hard to find out how to do it.

My data entity class is named WebOrderEntity. The first step is to create a class named WebOrderEntityBinder. I’ll get to the details of that class in a moment.

Next, in Global.asax’s Application_Start() method I register my custom binder class for the WebOrderEntity type:

&#xD;
// Register custom model binder classes&#xD;
ModelBinders.Binders[typeof(RR.Entities.WebOrderEntity)] = new WebOrderEntityBinder();&#xD;

Easy enough.

Now, the binder class:

&#xD;
public class WebOrderEntityBinder : DefaultModelBinder&#xD;
{&#xD;
    protected override void OnModelUpdated(ControllerContext controllerContext, ModelBindingContext bindingContext)&#xD;
    {&#xD;
        var model = bindingContext.Model as WebOrderEntity;&#xD;
&#xD;
        // The WebOrderEntity.DeliveryDate property is virtual and doesn't have a setter,&#xD;
        // so to bind to it we have to parse the submitted value into a DateTime object&#xD;
        // and then set the Year, Month, and Day properties individually.&#xD;
        var deliveryDateVPR = bindingContext.ValueProvider.GetValue(bindingContext.ModelName + ".DeliveryDate");&#xD;
        if (deliveryDateVPR != null)&#xD;
        {&#xD;
            try&#xD;
            {&#xD;
                var deliveryDate = DateTime.Parse(deliveryDateVPR.AttemptedValue);&#xD;
                model.DeliveryYear = deliveryDate.Year;&#xD;
                model.DeliveryMonth = deliveryDate.Month;&#xD;
                model.DeliveryDay = deliveryDate.Day;&#xD;
            }&#xD;
            catch (Exception e)&#xD;
            {&#xD;
                bindingContext.ModelState.AddModelError("DeliveryDate", "Could not parse " + deliveryDateVPR.AttemptedValue);&#xD;
            }&#xD;
        }&#xD;
&#xD;
        base.OnModelUpdated(controllerContext, bindingContext);&#xD;
    }&#xD;
}&#xD;

The tricky bits are:

Cast bindingContent.Model to the object type to get the model you’re binding to.
If the form contains a collection of the objects, and you’ve used EditorFor on the whole collection or a model that contains it (like you should), the form parameters will have names like ItemCollection[4]_ItemClass.PropName. If you use EditorFor directly on the object, the form parameter names will just be the property names. bindingContext.ModelName contains the prefix for the first case, and I’ve appended .DeliveryDate to get the right form parameter name for the particular WebOrderEntity I’m binding to. I’m not sure if this will work for the second case; the key might just be DeliveryDate without the prefix or period.
Once you figure out the key, bindingContext.ValueProvider.GetValue() returns an object that describes the value that was passed in. AttemptedValue is the string that was passed in. There’s a RawValue property too, but it was also a string. I’m not sure when you’d use it; I was expecting it to be a DateTime object.
If there are any errors, call bindingContext.ModelState.AddModelError() to add an error to the ModelState object that your request handler will use to determine if the model was bound and passed validation correctly.
Finally, call the base OnModelUpdated() method to let it do whatever it needs to do.

Latest Forum Discussions

Linking in Property Codes Drop Down

How to Add the Remarks tab to a module

Surround Training Courses

Visual C# Programming (4 - 5 Day Course)

Windows Presentation Foundation (WPF) (2 - 3 Day Course)

Changing the WPF Tab Background Color

Overriding Columns in XAML

Modifying the RowHeaders in the Datagrid

Switching between tab controls

Multilingual Support

Selecting Data using SQL Functions

How to Regenerate Service References

"Files corrupt in deployment" message while installing or updating a ClickOnce application

Use AB_SocialMetaModel in CMS website to generate all social media meta/link/script markup

Excel Export- Adding additional columns to excel export from entity

Memory Management Best Practices in WPF

Ports for IBM i Access

Add iOS home page icons and startup images to MVC app for Safari and Mobile Safari

Setting the Visual Studio Tools Version

Set initial focused control in a detailer

Using AB_PageScriptInfoModel and A4DN.Core.MVC.CMS.Models.GoogleJsonLD to render JSON-LD markup

Using AB_PageLinkInfoModel to generate markup for link elements

Using AB_PageMetaInfoModel to generate markup for meta elements

Server-side HTML parsing and jQuery-like searching

Using data-replacewith attributes to relocate DOM elements after page load

Use ThemePunch's Revolution Slider control on CMS web pages

Use AB_ConfiguredCacheCollection to create one or more AB_Caches that are config-driven

Usage - Set up Cache:

Configuration:

How to specify IS NULL and IS NOT NULL where clauses in am_Select

Passing logged in credentials when calling ViewModel methods

Delay load of Explorer Bar until Dropdown auto complete has finished

Certificate Expiration in ClickOnce Deployment

Accelerator BP Service Host Performance Improvements in v6.4.0.0

Use AB_Cache to store state information objects for a short time

Adding Arbitrary Data to Connection Strings

How to use Framework Authentication with Active Directory

Caching data between requests in ASP.NET MVC

How to Remove the remarks tab from a module

Accelerator Commands and Command Bars

Data type conversion in Datamaps

Configuring Services to access different Accelerator databases (ex: Dev, Test, Prod)

Use AB_GeneralForm to implement forms on CMS website pages

Fix "This collection already contains an address with scheme http" error in BP Service deployments

Authentication fallback options for Accelerator

Finding circular references in Views

Displaying a Custom Popup Toolbar with Commands

How to Call a DB2 Stored Procedure

Add a Webpage Module

Tracking down Binding Issues

Create a new Workflow Instance

Throttle requests to MVC Website

Styling full-width banner images in CMS web pages

Utilizing the Resource Monitor

In an MVC application, get the website's absolute url

Add DataAnnotations validation attributes to entity classes you can't modify

How to parse entity key fields out of a unique key string

Datamaps - Join to the same table twice - Part 2

Datamaps - Join to the same table twice - Part 1

Bypass WPF logon to support Single Sign On (SSO)

Setting up WCF services to use SSL

Fix "Argument Null Exception" when creating a module's BP object in another module's BP class

NuGetPackages folder and Version Control

Debugging Modules Window

Accelerator Views

Adding Google Maps and Bing Maps to your WPF Detail and Content Preview

Drop down with Re:new using AB_NewlookDropdownController

Multiple Usergroups in Accelerator Security

Data grid view columns are not showing correctly as defined by the Accelerator View

Debugging the Accelerator Core Code

How to Properly add Accelerator DLL references to your Project using A4DNReference.msbuild

Hiding the Detail and/or Audit tab from the Content Window Preview Pane

Adding Accelerator Modules that reuse the same WPF and BOS code - Scenario 2

Adding Accelerator Modules that reuse the same WPF and BOS code - Scenario 1

Copying Command Bars in the Accelerator Maintenance

Using the AB_ModuleExplorerStandalonePresenter Content Control Steps 3 and 4

Using the AB_ModuleExplorerStandalonePresenter Content Control Steps 1 and 2

How to Show a dialog window of In Use newlook sessions

Build Scripts