eXpress App Framework Team

September 2011 - Posts

  • Creating a State Machine module for eXpand Framework–Part 2

    Let me describe for a moment how we at DevExpress work. We build and sell software which means that we only sell and provide support for products that have been built and tested by us! However I am here as a framework evangelist and huge XAF fan. This makes it my duty to spread the word as much as I can and make XAF even bigger. To this end through collaboration within the XAF community, we have been building and supporting eXpand. This framework follows XAF to the letter and takes things even further. eXpand gets its inspiration from real life situations and bases itself on examples from DevExpress Support Center. eXpand is the first open source project based on the DevExpress eXpressApp Framework (XAF). More info is available at www.expandframework.com and our very existence relies on your efforts! Anyone is welcome to contribute and enjoy the rewards. It is not necessary to be a XAF guru, we can all manage to create a behavior taken from DevExpress code central. Let’s work together to enhance our beloved XAF!

    Prerequisites
    Part 1

    In this post we are going to enhance the State Machine module UI. Remember that along with all the usual XAF goodies we can now use Xpand code base which gives us a lot more options. Our StateMachineTransitionPermission has 2 lookups, StateMachineName and StateMachine. Our goal is to populate both of these cascading lookups without creating a platform specific module.

    StateMachineNames

    Creating lookups is a common scenario for which Xpand provides a set of property editors and controllers. By contrast with other business frameworks XAF allows maximum flexibility. Therefore in most cases we are able to code in such a generic way that everything could live in separate frameworks such as eXpand. Now, in order to populate the StateMachine name I am going to derive a new controller from a specialized abstract controller which is Xpand.ExpressApp.SystemModule.PopulateController<T>. This controller uses the PredefinedValues attribute of the XAF model. When filling the attribute with a set of values separated by semicolons XAF will create a lookup with these values targeting each supported platform.

    image

    However, if at runtime we set the value of the PredefinedValues attribute this will be written at model’s lastlayer and it will make it dirty. We want to avoid this because we want to leave the lastlayer intact.. To cater for this need the populate controller uses a hack. First it stores the lastlayer in a variable then removes it from the model’s layers collection. As a result it is possible to modify the new lastlayer as shown in the Populate method and then return the clean old one to its place. Now the model has all the necessary information with a clean userdiffs layer and while XAF is creating a new view can get the PredefinedValues string from it and create the lookups.

    public abstract class PopulateController<T> : ViewController<ObjectView> {

       

        …

     

        protected virtual void Populate(Func<IModelMember, string> collect) {

            var name = PropertyName;

            if (name != null) {

                var model = ((ModelApplicationBase)Application.Model);

                var lastLayer = model.LastLayer;

                model.RemoveLayer(lastLayer);

                PopulateCore(collect, name);

                model.AddLayer(lastLayer);

           }

       }

     

        private void PopulateCore(Func<IModelMember, string> collect, string propertyName) {

            IModelMember modelMember = View.Model.ModelClass.AllMembers.FirstOrDefault(member => member.Name == propertyName);

            if (modelMember != null) {

                modelMember.PredefinedValues = collect.Invoke(modelMember);

            }

        }

        …

        …

       }

     

    Although this seems like a complicated explanation users need not be intimidated! The implementation of our controller that will populate all StateMachineNames is as simple as this,

    public class StateMachinePopulateController : PopulateController<StateMachineTransitionPermission> {

        protected override string GetPredefinedValues(IModelMember wrapper) {

            IList<XpoStateMachine> xpoStateMachines = ObjectSpace.GetObjects<XpoStateMachine>(null);

            return xpoStateMachines.Select(machine => machine.Name).AggregateWith(";");

        }

     

        protected override Expression<Func<StateMachineTransitionPermission, object>> GetPropertyName() {

            return permission => permission.StateMachineName;

        }

    }

     

    The first thing we did was to provide the propertyName in the GetPropertyName method. Then using the GetPredifinedalues method we return the semincolon delimited string with the machine names. This very simple controller is capable of populating the statemachine lookup for win and web platforms!.
     
    StateCaptions
    This is a cascading lookup and as a result when the current StateMachineName changes it needs to provide a list of all its StateCaptions. To this end we are going to use a specialized property editor, Xpand’s StringLookupEditor. This supports the DataSourceProperty XAF attribute which will be used to provide the StateCaption collection. Moreover when using Xpand it is possible to mark editors with an interface and host it in a transparent module. We can then use the Xpand PropertyEditor attribute with the type of the interface as parameter to tell XAF which propertyeditor will be created at runtime. Finally we need to apply all these along with an ImmediatePostData to the StateMachineName property. The permission will look like this,
     

    [ImmediatePostData]

    public string StateMachineName { get; set; }

     

    //IStringLookupPropertyEditor lives in Xpand.ExpressApp assembly

    //Xpand.ExpressApp.Web.PropertyEditors.StringLookupPropertyEditor, Xpand.ExpressApp.Win.PropertyEditors.StringLookupPropertyEditor inherit from IStringLookupPropertyEditor

    [PropertyEditor(typeof(IStringLookupPropertyEditor))]

    [DataSourceProperty("StateCaptions")]

    public string StateCaption { get; set; }

     

    IList<string> _stateCaptions = new List<string>();

    [Browsable(false)]

    public IList<string> StateCaptions {get {return _stateCaptions;}}

     

    If you look carefully at this code however you may notice that __stateCaptions count is always zero. Let me remind you here that the StateMachineTransitionPermission is a non persistent sessionless object. This means that the object is not handled by an ObjectSpace therefore a call like ObjectSpace.FindObjectSpaceByObject(this) will always return null. In addition the permission does not implement INotifyPropertyChanged so we need to synchronize the class just before the StateCaptions are requested. Below you can see a modified version of the StateMachinePopulateController,

     

    public class StateMachinePopulateController : PopulateController<StateMachineTransitionPermission> {

        protected override void OnViewControlsCreated() {

            base.OnViewControlsCreated();

            var stringLookupPropertyEditor = GetPropertyEditor(permission => permission.StateCaption) as IStringLookupPropertyEditor;

            if (stringLookupPropertyEditor != null)

                stringLookupPropertyEditor.ItemsCalculating += StringLookupPropertyEditorOnItemsCalculating;

        }

        void StringLookupPropertyEditorOnItemsCalculating(object sender, HandledEventArgs handledEventArgs) {

            var propertyEditor = GetPropertyEditor(permission => permission.StateMachineName);

            if (propertyEditor != null && View.IsControlCreated) {

                var stateMachineTransitionPermission = ((StateMachineTransitionPermission)View.CurrentObject);

                var readOnlyCollection = GetStateCaptions(propertyEditor);

                stateMachineTransitionPermission.SyncStateCaptions(readOnlyCollection, propertyEditor.ControlValue as string);

            }

        }

     

        ReadOnlyCollection<string> GetStateCaptions(PropertyEditor propertyEditor) {

            var stateMachineName = propertyEditor.ControlValue as string;

            return ObjectSpace.GetObjects<XpoState>(state => state.StateMachine.Name == stateMachineName).Select(

                    state => state.Caption).ToList().AsReadOnly();

        }

     

    Finally we add the new SyncStateCaptions method and the full version of the permission will be,

     

    [NonPersistent]

    public class StateMachineTransitionPermission : PermissionBase {

        …

        …

     

        [ImmediatePostData]

        public string StateMachineName { get; set; }

     

        [PropertyEditor(typeof(IStringLookupPropertyEditor))]

        [DataSourceProperty("StateCaptions")]

        public string StateCaption { get; set; }

     

        IList<string> _stateCaptions = new List<string>();

        [Browsable(false)]

        public IList<string> StateCaptions {get {return _stateCaptions;}}

     

        public void SyncStateCaptions(IList<string> stateCaptions, string machineName) {

            StateMachineName = machineName;

           _stateCaptions = stateCaptions;

        }

    }

    To support platform independent cascading lookups we wrote only about 10 lines of code! This is proof of how much XAF architecture cuts down on development costs. The module can be downloaded from the Xpand download page   and we are happy to hear your feedback. Remember that your questions are the best candidates for future posts!

  • eXpand Framework calculated members creation—Pros and Cons

    Let me describe for a moment how we at DevExpress work. We build and sell software which means that we only sell and provide support for products that have been built and tested by us! However I am here as a framework evangelist and huge XAF fan. This makes it my duty to spread the word as much as I can and make XAF even bigger. To this end through collaboration within the XAF community, we have been building and supporting eXpand. This framework follows XAF to the letter and takes things even further. eXpand gets its inspiration from real life situations and bases itself on examples from DevExpress Support Center. eXpand is the first open source project based on the DevExpress eXpressApp Framework (XAF). More info is available at www.expandframework.com and our very existence relies on your efforts! Anyone is welcome to contribute and enjoy the rewards. It is not necessary to be a XAF guru, we can all manage to create a behavior taken from DevExpress code central. Let’s work together to enhance our beloved XAF!

    As promised in the previous post I will now attempt to provide a concise yet comprehensive look at the 5 possibilities that Xpand gives us when we want to create a calculated member. I will also provide discussion of the relative advantages and disadvantages of each approach. We can see all of them in action in Xpand FeatureCenter application. Remember it is only thanks to the fact that XAF/XPO have such a strong and flexible architecture that this is possible! We must also acknowledge that these approaches have evolved as a direct result of contributions from the XAF team and community.

    image

    1. The XPO way –>Using Code

    Take a look at the CreateCalculabeMember extension method in the code below,

    public class CreateRuntimeCalculatedFieldController : ViewController {

        public override void CustomizeTypesInfo(DevExpress.ExpressApp.DC.ITypesInfo typesInfo) {

            base.CustomizeTypesInfo(typesInfo);

            XPClassInfo classInfo = XafTypesInfo.XpoTypeInfoSource.XPDictionary.GetClassInfo(typeof(Customer));

            if (classInfo.FindMember("SumOfOrderTotals")==null) {

                var attributes = new Attribute[] {new PersistentAliasAttribute("Orders.Sum(Total)")};

                XPCustomMemberInfo calculabeMember = classInfo.CreateCalculabeMember("SumOfOrderTotals", typeof(float), attributes);

                typesInfo.RefreshInfo(typeof(Customer));

            }

        }

    }

     

    XPO has a dictionary of domain metadata. The metadata of each persistent object is stored in XPClassInfo classes and the metadata of their properties is stored in XPMemberInfo classes. One of the main advantages of this approach is that it  adds a new member to the XPO dictionary and therefore follows XAF to the letter. This is because in order to form the model XAF first queries the XPO dictionary and finally in order to configure the views it queries the model. Since we have worked in the data layer our calculated values will be sent to any data bound enabled control for rendering. The other benefit is that if we code there are no restrictions on what we can do, for example we can create members calling a WCF service. The sky’s the limit!

    On the other hand each time we write new code we need to spend time testing and distributing it. Furthermore in certain scenarios problems can occur due to the fact that we add a new member to the object. For each new member we add to an object we are forced to deal with long properties lists in our model which can be somewhat unwieldy – imagine an  object with 200 properties.

    Note; XAF is smart enough to manage all of this without even breaking a sweat. This means that its performance does not suffer in any way. It is simply that this approach can leave the user with a bit of a headache!

    2. Using the model

    We have extended our model in order to describe all types of calculated and runtime properties.

     

    image_thumb[14]

     

    Having done this makes it pretty easy to utilize the powerful XPO and add members in its dictionary as with the previous approach. This means this method shares some of the benefits we mentioned above. However as we are not writing code we can’t enjoy the same level of flexibility unless we utilize ModelUpdaters. Also as the columns can only be created using model editor they are only useful in situations when we have permission to modify the model. Finally we could end up with a huge number of properties here too for the same reason we identified previously.

     

    All this is not to say that this approach doesn’t have its own unique advantages. For example the model difference can be stored in a database or xml file making it easy to distribute. To this end we can use the build in API or a specialized module like IO. Moreover it is possible to develop on site (client). Of course working at the model level allows us to use a model manager module like ModelDifference which is a great aid. It can be used to distribute the unbound columns to users, roles and even to other applications. In addition since ModelDifference supports both platforms it is possible to create calculated members without restarting the application or IIS.

    3.WorldCreator extended members

    This module maps the structure of the XPMemberInfo class to a persistent object. This approach is again similar to model approach (and once again has similar benefits) however there is a crucial difference. Instead of using the model to gather data to form the calculated members we use the input taken from the UI.

    image_thumb[17]image_thumb[20]

    Using the UI is simplicity itself! It requires no technical knowledge whatsoever as the user is only required to choose from a set of basic options. We can still code if we wish, this time by creating persistent objects and then leaving eXpand to take care of the rest. That being said the real beauty of this approach is that the product can be developed on site without the user having to write a single line of code or using a sophisticated tool like Model Editor. Moreover we can enjoy ease of distribution due to the fact that our objects are stored in the database. As the metadata is now in the form of persistent objects locating it and working with it is as easy as ever.

    By now it should be clear that as we are still relying on XPO we are faced with the same old problem regarding multiple views.

    4. Using a WordCreator Dynamic Assembly

    Our fourth approach uses the same module to create dynamic persistent assemblies using code generation templates. XAF is the best framework to describe domains which is evidenced by the way that  WorldCreator maps the Assembly structure to persistent objects and auto generates a flexible UI.

    image_thumb[23]

    Using the templates will create a dynamic assembly with exactly the same code and structure as if we had taken the time to design it ourselves inside VS. Distribution is still easy since is everything is in the database. The fact that we script at runtime means that our options are almost unlimited when taking this approach.

    5. The Unbound Column

    Extending the model with an Unbound column node as shown makes it possible to create Unbound grid columns and set their unbound expressions.

    image

     

    image

    This is the only approach that allows us to work directly on views without utilizing XPO. This means that we gain the maximum level of flexibility since it is possible to have different columns for the same object views. Therefore we can work on this column independently. At the same time the end user can change the UnboundExpression at runtime using expression editor (windows only). When it comes to distribution we find the same advantages as we do whenever we deal with the model.

    As with the second approach we lose some flexibility because we are not writing code but again we can get round this using ModelUpdaters. In addition our columns still cannot be used when we do not have permission to modify the model. Another disadvantage concerns the fact that XAF is designed to make all calculations in the data layer and send the values to controls by applying an MVC pattern. A few years after XAF was released, Microsoft built Silverlight featuring very similar architecture. Taking into account the various factors this has been recognized as the optimal approach. Although using Unbound columns allows us to work in a different way we need to write extra code to support each control (Tree, Pivot etc) because the calculations are performed in the UI.


    We are happy to read your feedback about this!. Remember that your questions are the best candidates for future posts.

  • eXpandFrameWork Supporting Unbound Columns

    Let me describe for a moment how we at DevExpress work. We build and sell software which means that we only sell and provide support for products that have been built and tested by us! However I am here as a framework evangelist and huge XAF fan. This makes it my duty to spread the word as much as I can and make XAF even bigger. To this end through collaboration within the XAF community, we have been building and supporting eXpand. This framework follows XAF to the letter and takes things even further. eXpand gets its inspiration from real life situations and bases itself on examples from DevExpress Support Center. eXpand is the first open source project based on the DevExpress eXpressApp Framework (XAF). More info is available at www.expandframework.com and our very existence relies on your efforts! Anyone is welcome to contribute and enjoy the rewards. It is not necessary to be a XAF guru, we can all manage to create a behavior taken from DevExpress code central. Let’s work together to enhance our beloved XAF!

    Recently in Xpand forums Dionisis Soldatos raised a question about how unbound columns can be implemented with XAF. Unbound columns along with their UnboundExpression can be used for creating calculated fields even at runtime. Since we are talking about unbound grid columns it should be obvious that we will operate at the UI level by modifying the grid control columns. However lets do a deep dive inside XAF model to extend it as needed!

    The Model

    By now we are all used to XAF providing us with excellent out of the box solutions which negate the need for us to write hundredths of lines of code. This of course means money saved during developing and ultimately your product hits the market faster. Why spend time reinventing the wheel when the XAF team have already done the hard work for you?

    XAF creates the model by reading the metadata of our classes, this model has 3 types of view. One of these is the ListView which can be displayed with data source enabled controls like Grid controls. ListView has columns which correspond to existing object properties metadata and when XAF creates a Grid at runtime it queries model’s ListView columns. It then creates and configures Grid columns from their attributes. These stages are well tested and it is preferable to use them in our solution and override the unnecessary stages. For example we could create a normal model column node using XAF default Add/Column menu. After the Grid column is created it we simply need a few lines of code to make it unbound and set its Unbound Expression.

     

    image

     

    In order to store this expression we still need to extend model’s ListView with an attribute. The model can be extended either by registering an interface at ModuleBase.ExtendModelInterfaces or by deriving it from an already registered interface. I am going to take the latter options by deriving from IModelColumn interface which I will explain as we go.

    public interface IModelColumnUnbound : IModelColumn {

     

        [Category("eXpand")]

        bool ShowUnboundExpressionMenu { get; set; }

     

        [Category("eXpand")]

        [Required]

        string UnboundExpression { get; set; }

    }

    XAF model editor is a highly sophisticated tool which has the capability to recognize that we extended the model. It then takes care of the vital step of adding an entry to the Add menu for creating Unbound columns.

    image

    Now it is possible to create a new type of column with 2 extra attributes as shown,

    image

    Moving on we need to set the mandatory PropertyName attribute shown above to an always existing object property name. Remember XAF requires this in order to behave as designed. To this end we are going to set as PropertyName the object’s key property name using this simple DomainLogic class,

    [DomainLogic(typeof(IModelColumnUnbound))]

    public class IModelColumnUnboundLogic {

        public static string Get_PropertyName(IModelColumnUnbound columnUnbound) {

            return ((IModelListView)columnUnbound.Parent.Parent).ModelClass.KeyProperty;

        }

    As a result (PropertyName, PropertyEditorType and Caption) attributes will be populated the next time we create a ColumnUnbound Node. However these will be fixed values and it is preferable to hide them from the end user. At the same time we need to mark Caption attribute as required and remove its default value. To do all of this we just need to extend our IModelColumnUnbound interface like this,

    image

    Note; Although PropertyName and Caption belong to IModelColumn using the new operator it is possible to override them!

    We have now finished with the model modifications and for our ColumnUnbound nodes XAF by design will create a new column pointing back to object’s key property metadata.

    The UI

    A key benefit of XAF’s commitment to design patterns, specifically to the Single responsibility principle, is that it provides us with the model’s synchronizer classes. These can be used to synchronize our model with the control and vice versa. It is only necessary to derive from the abstract ModelSyncroniser<T,V> and implement ApplyModeCore method to synchronize the control and from SynchronizeModel to do the same with the model.

    public class c: ModelSynchronizer<GridListEditor, IModelListView> {

        public UnboundColumnSynchronizer(GridListEditor control, IModelListView model)

            : base(control, model) {

        }

     

        protected override void ApplyModelCore() {

            var xafGridColumns = GetXafGridColumns();

            foreach (var column in xafGridColumns) {

                var modelColumnUnbound = (IModelColumnUnbound)column.Model;

                column.FieldName = modelColumnUnbound.Id;

                column.UnboundType = UnboundColumnType.Object;

                column.OptionsColumn.AllowEdit = false;

                column.ShowUnboundExpressionMenu = modelColumnUnbound.ShowUnboundExpressionMenu;

                column.UnboundExpression = modelColumnUnbound.UnboundExpression;

            }

        }

     

        IEnumerable<XafGridColumn> GetXafGridColumns() {

            IEnumerable<XafGridColumn> xafGridColumns =

                Model.Columns.OfType<IModelColumnUnbound>().Select(

                    unbound => Control.GridView.Columns[unbound.PropertyName] as XafGridColumn).Where(column => column != null);

            return xafGridColumns;

        }

     

        public override void SynchronizeModel() {

            var xafGridColumns = GetXafGridColumns();

            foreach (var xafGridColumn in xafGridColumns) {

                ((IModelColumnUnbound) xafGridColumn.Model).UnboundExpression = xafGridColumn.UnboundExpression;

            }

        }

    }

     

     

    The above code uses the GetXafGridColumns method to return the grid columns that correspond to IModelColumnUnbound nodes. The web implementation is very similar and can be found here.

    All that is left is to register our UnboundColumnSynchronizer like this,

    public class UnboundColumnController : ViewController<ListView> {

        protected override void OnActivated() {

            base.OnActivated();

            var gridListEditor = View.Editor as GridListEditor;

            if (gridListEditor != null)

                gridListEditor.CreateCustomModelSynchronizer += GridListEditorOnCreateCustomModelSynchronizer;

        }

     

        void GridListEditorOnCreateCustomModelSynchronizer(object sender, CreateCustomModelSynchronizerEventArgs createCustomModelSynchronizerEventArgs) {

            createCustomModelSynchronizerEventArgs.ModelSynchronizer = new UnboundColumnSynchronizer((GridListEditor)sender, View.Model);

        }

    }

     

    Note; Setting ShowUnboundExpressionMenu to true is only supported by Windows platform. There, an end user can modify the UnBoundExpression by invoking Grid’s expression editor

    image image

    Together with the unbound column Xpand allows for up to 5 different approaches to creating calculated fields. In the next post we will discuss the pros and cons of each approach so stay tuned!

    We are happy to read your feedback about this!. Remember that your questions are the best candidates for future posts

  • Checking whether the currently logged user belongs to a certain role in a filter becomes easier in 11.1.7

    Prerequisites

    I am confident that every user who utilized XAF’s Security module with the Complex Security strategy should have met this requirement at least once using XAF, for example, when you had to filter out a ListView to display records only for people from the Administrators role and hide them from the rest. Or, you wanted to make your favorite Appearance or Validation rule work only for people from the Users role? Sound familiar?

    A good way to address such requirements is to implement a custom function criteria operator. Tolis recently demonstrated how it can be done in his recent blog post about applying security to the State Machine module. The first time I saw the blog, I thought that it would be nice to have such a function in XAF out-of-the-box. So, shortly thereafter, after seeing a discussion on the forum, I logged a corresponding feature request.

    New built-in criteria function

    This feature request was implemented in version 11.1.7, and that means that you can already make use of the new IsCurrentUserInRole function in your criteria. The function’s use is very simple. All that you need to do is to pass the name of the role as a parameter:

    IsCurrentUserInRole(‘Administrators’)

    I expect that this built-in criteria function will be no less popular than the CurrentUserId()  function and will also save you a lot of time, because the described requirements are quite common in business applications.

    Future plans

    While we are talking about custom criteria functions, a note about our future plans. Although XAF already provides a similar feature called Read-Only Parameters, we are gradually stepping away from it and moving towards custom criteria functions everywhere. This is because they provide more capabilities (e.g. they are supported by all DevExpress products and not only in XAF; functions can accept arguments whereas Read Only Parameters are constants, etc.). It is intended not only to optimize our support costs, but also to allow a faster evolution of our products.

    Do you like this small improvement? Please let us know your opinion! Happy XAFing!Winking smile

  • Scheduling workflows in eXpandFrameWork

    Let me describe for a moment how we at DevExpress work. We build and sell software which means that we only sell and provide support for products that have been built and tested by us! However I am here as a framework evangelist and huge XAF fan. This makes it my duty to spread the word as much as I can and make XAF even bigger. To this end through collaboration within the XAF community, we have been building and supporting eXpand. This framework follows XAF to the letter and takes things even further. eXpand gets its inspiration from real life situations and bases itself on examples from DevExpress Support Center. eXpand is the first open source project based on the DevExpress eXpressApp Framework (XAF). More info is available at www.expandframework.com and our very existence relies on your efforts! Anyone is welcome to contribute and enjoy the rewards. It is not necessary to be a XAF guru, we can all manage to create a behavior taken from DevExpress code central. Let’s work together to enhance our beloved XAF!

    In this post we are going to extend the functionality of the workflow module. to create a UI that will help us to schedule workflows. Some of you may recall that we looked at using a Delay inside a While activity in Working with CRUD activities – Short Transactions. Recently, DX-Squad member Martin Praxmarer raised an interesting question relating to this topic:

    I have the requirement to do a workflow which starts each day on 6 clock - searches for orderdocuments where a specific date is less then X days. I know I will do an do while loop, but workflow definition has 2 options, start when new object, start when criteria, so when do i start this Workflow?

    In order to achieve this we will use the WorkFlow demo that ships with our framework. The first thing is to design our custom ScheduledWorkflow persistent object by implementing IWorkflowDefinition. We didn’t derive it from the existing WorkFlowDefinition object because it has properties like TargetObjectType and start up conditions.

    public enum StartMode {

        OneTime,

        Daily,

        Weekly

    }

     

    [DefaultClassOptions]

    [Appearance("WeekDays", "StartMode <> 'Weekly'",

        TargetItems = "RecurEveryWeeks;Moday;Tuesday;Wednesday;Thursday;Friday;Saturday;Sunday",

        Visibility = ViewItemVisibility.Hide)]

    public class ScheduledWorkflow : BaseObject, IWorkflowDefinition {

        public ScheduledWorkflow(Session session)

            : base(session) {

        }

     

        public bool IsActive {

            get { return GetPropertyValue<bool>("IsActive"); }

            set { SetPropertyValue("IsActive", value); }

        }

     

        public bool RuntASAPIfScheduledStartIsMissed {

            get { return GetPropertyValue<bool>("RuntASAPIfScheduledStartIsMissed"); }

            set { SetPropertyValue("RuntASAPIfScheduledStartIsMissed", value); }

        }

     

        [Association]

        public XPCollection<ScheduledWorkflowLaunchHistory> LaunchHistoryItems {

            get { return GetCollection<ScheduledWorkflowLaunchHistory>("LaunchHistoryItems"); }

        }

     

        [ImmediatePostData]

        public StartMode StartMode {

            get { return GetPropertyValue<StartMode>("StartMode"); }

            set { SetPropertyValue("StartMode", value); }

        }

     

        public TimeSpan StartTime {

            get { return GetPropertyValue<TimeSpan>("StartTime"); }

            set { SetPropertyValue("StartTime", value); }

        }

     

        [Appearance("RecurEveryDays", "StartMode <> 'Daily'", Visibility = ViewItemVisibility.Hide)]

        public int RecurEveryDays {

            get { return GetPropertyValue<int>("RecurEveryDays"); }

            set { SetPropertyValue("RecurEveryDays", value); }

        }

     

        public int RecurEveryWeeks {

            get { return GetPropertyValue<int>("RecurEveryWeeks"); }

            set { SetPropertyValue("RecurEveryWeeks", value); }

        }

     

        public bool Monday {

            get { return GetPropertyValue<bool>("Monday"); }

            set { SetPropertyValue("Monday", value); }

        }

     

        public bool Tuesday {

            get { return GetPropertyValue<bool>("Tuesday"); }

            set { SetPropertyValue("Tuesday", value); }

        }

     

        public bool Wednesday {

            get { return GetPropertyValue<bool>("Wednesday"); }

            set { SetPropertyValue("Wednesday", value); }

        }

     

        public bool Thursday {

            get { return GetPropertyValue<bool>("Thursday"); }

            set { SetPropertyValue("Thursday", value); }

        }

     

        public bool Friday {

            get { return GetPropertyValue<bool>("Friday"); }

            set { SetPropertyValue("Friday", value); }

        }

     

        public bool Saturday {

            get { return GetPropertyValue<bool>("Saturday"); }

            set { SetPropertyValue("Saturday", value); }

        }

     

        public bool Sunday {

            get { return GetPropertyValue<bool>("Sunday"); }

            set { SetPropertyValue("Sunday", value); }

        }

        #region IWorkflowDefinition Members

        public string GetActivityTypeName() {

            return GetUniqueId();

        }

     

        public IList<IStartWorkflowCondition> GetConditions() {

            return new IStartWorkflowCondition[0];

        }

     

        public string GetUniqueId() {

            if (Session.IsNewObject(this)) {

                throw new InvalidOperationException();

            }

            return "ScheduledWorkflow" + Oid.ToString().ToUpper().Replace("-", "_");

        }

     

        [Browsable(false)]

        public bool CanCompile {

            get { return false; }

        }

     

        [Browsable(false)]

        public bool CanOpenHost {

            get { return IsActive && !string.IsNullOrEmpty(Name); }

        }

     

        public string Name {

            get { return GetPropertyValue<string>("Name"); }

            set { SetPropertyValue("Name", value); }

        }

     

        [Size(SizeAttribute.Unlimited)]

        public string Xaml {

            get { return GetPropertyValue<string>("Xaml"); }

            set { SetPropertyValue("Xaml", value); }

        }

        #endregion

        public override void AfterConstruction() {

            base.AfterConstruction();

            Xaml = DCWorkflowDefinitionLogic.InitialXaml;

        }

    }

     

    In the above class we have added some scheduled specific properties such as StartMode, StartTime, RecurEveryDays etc. The class has been decorated with the Appearance attribute to control the visibility of the Day properties. This means when StartMode <> 'Weekly these properties will be hidden.

    Moreover there is a collection LaunchHistoryItems of ScheduledWorkflowLaunchHistory objects, which will be used later to check if the workflow has been launched.

    public class ScheduledWorkflowLaunchHistory : BaseObject {

        public ScheduledWorkflowLaunchHistory(Session session) : base(session) {}

        public DateTime LaunchedOn {

            get { return GetPropertyValue<DateTime>("LaunchedOn"); }

            set { SetPropertyValue<DateTime>("LaunchedOn", value); }

        }

        [Association]

        public ScheduledWorkflow Workflow {

            get { return GetPropertyValue<ScheduledWorkflow>("Workflow"); }

            set { SetPropertyValue<ScheduledWorkflow>("Workflow", value); }

        }

    }

     

    After designing these classes, we now have all the required input in order to schedule our workflows.

    The next step is to load our custom workflows by extending the workflow provider service as shown,

    public class ScheduledWorkflowDefinitionProvider : WorkflowDefinitionProvider {

        public ScheduledWorkflowDefinitionProvider(Type workflowDefinitionType) : base(workflowDefinitionType) { }

        public ScheduledWorkflowDefinitionProvider(Type workflowDefinitionType, IObjectSpaceProvider objectSpaceProvider) : base(workflowDefinitionType, objectSpaceProvider) { }

        public override IList<IWorkflowDefinition> GetDefinitions() {

            IList<IWorkflowDefinition> result = base.GetDefinitions();

            IObjectSpace objectSpace = ObjectSpaceProvider.CreateObjectSpace(); //don't dispose immediately

            foreach(ScheduledWorkflow workflow in objectSpace.GetObjects<ScheduledWorkflow>()) {

                result.Add(workflow);

            }

            return result;

        }

    }

     

    After this we are ready to implement our final service that will schedule our workflows,

    public class ScheduledWorkflowStartService : BaseTimerService {

        private bool NeedToStartWorkflow(IObjectSpace objectSpace, ScheduledWorkflow workflow) {

            if (workflow.StartMode == StartMode.OneTime) {

                if (workflow.LaunchHistoryItems.Count == 0) {

                    return true;

                }

            } else if (workflow.StartMode == StartMode.Daily) {

                var historyItem = objectSpace.FindObject<ScheduledWorkflowLaunchHistory>(CriteriaOperator.Parse("GetDate(LaunchedOn) = ?", DateTime.Today));

                if (historyItem == null && DateTime.Now.TimeOfDay > workflow.StartTime) {

                    return true;

                }

            } else if (workflow.StartMode == StartMode.Weekly) {

                throw new NotImplementedException();

            }

            return false;

        }

        public ScheduledWorkflowStartService()

            : base(TimeSpan.FromMinutes(1)) {

        }

        public ScheduledWorkflowStartService(TimeSpan requestsDetectionPeriod) : base(requestsDetectionPeriod) { }

        public override void OnTimer() {

            using (IObjectSpace objectSpace = ObjectSpaceProvider.CreateObjectSpace()) {

                foreach (ScheduledWorkflow workflow in objectSpace.GetObjects<ScheduledWorkflow>(new BinaryOperator("IsActive", true))) {

                    WorkflowHost host;

                    if (HostManager.Hosts.TryGetValue(workflow.GetUniqueId(), out host)) {

                        if (NeedToStartWorkflow(objectSpace, workflow)) {

                            host.StartWorkflow(new Dictionary<string, object>());

                            var historyItem = objectSpace.CreateObject<ScheduledWorkflowLaunchHistory>();

                            historyItem.Workflow = workflow;

                            historyItem.LaunchedOn = DateTime.Now;

                            objectSpace.CommitChanges();

                        }

                    }

                }

            }

        }

    }

     

    Note; the service is not fully implemented, however its very easy to continue from this point. This code will live in the new Xpand.ExpressApp.Workflow module. Now, for the rest of the implementation I would like to ask the help of our community. Anyone that wants to finish it contribute it is most welcome!

    Finally we modify the WorkflowServerStarter class and add this service,

    private void Start_(string connectionString, string applicationName) {

        ServerApplication serverApplication = new ServerApplication();

        serverApplication.ApplicationName = applicationName;

        serverApplication.Modules.Add(new WorkflowDemoModule());

        serverApplication.ConnectionString = connectionString;

        serverApplication.Security = new SecurityComplex<User, Role>(

            new WorkflowServerAuthentication(new BinaryOperator("UserName", "WorkflowService")));

        serverApplication.Setup();

        serverApplication.Logon();

     

        IObjectSpaceProvider objectSpaceProvider = serverApplication.ObjectSpaceProvider;

     

        server = new WorkflowServer("http://localhost:46232", objectSpaceProvider, objectSpaceProvider);

     

        server.WorkflowDefinitionProvider = new ScheduledWorkflowDefinitionProvider(typeof(XpoWorkflowDefinition));

     

        //Add the service           

        server.ServiceProvider.AddService(new ScheduledWorkflowStartService());

    We are now ready to go!

    4-9-2011 12-50-05 μμ

    Note; You can watch this approach live in this webinar

    Updated: Big thanks to Martin Praxmarer for contributing the missing parts of this implementation. It can be found in eXpand v11.2.11.9 

    Related Links
    Blog posts
    Online documentation
    Videos

LIVE CHAT

Chat is one of the many ways you can contact members of the DevExpress Team.
We are available Monday-Friday between 7:30am and 4:30pm Pacific Time.

If you need additional product information, write to us at info@devexpress.com or call us at +1 (818) 844-3383

FOLLOW US

DevExpress engineers feature-complete Presentation Controls, IDE Productivity Tools, Business Application Frameworks, and Reporting Systems for Visual Studio, along with high-performance HTML JS Mobile Frameworks for developers targeting iOS, Android and Windows Phone. Whether using WPF, ASP.NET, WinForms, HTML5 or Windows 10, DevExpress tools help you build and deliver your best in the shortest time possible.

Copyright © 1998-2017 Developer Express Inc.
All trademarks or registered trademarks are property of their respective owners