I use Nuxeo for content management purposes on a project.
I know I'll also need to support "workflow" scenarios, which I currently know very little about.
For example: I'll need to support a workflow scenario for approving a release of a software component.
Such an approval may be composed of several different stages, and in every stage I may need to trigger some kind of an automatic interaction with certain users of the system.
What may be considered some good/valid considerations for not "settling for" the workflow engine provided by Nuxeo, and using a dedicated engine such as Activiti or jBPM instead?
I know the question is very (perhaps too) broad, but still:
What could be some points to consider before I choose one over the other?
Are there other tools I should consider?
Yes, your question IS too broad. every workflow tool has its own cons and pros. why don't you list down all of your needs then compare each of the tools. mainly: Alfresco Activiti, Camunda, jBPM or Nuxeo
I need to work on a customer on boarding application. The workflow between various users can be implemented using JSF framework itself, with the help of faces confiq.xml I can specify the flow between various users. But here BPM is used with the help of webmethods tool. Does BPM is required always for implementation of workflow? What is its importance over normal implementation using other technologies?
Sassi,
in JSF you control only the pageflow between different UIs which can be part of a single activity which is performed by one user or or part of many activities.
A business process typically involves multiple people (participants / roles) and systems. The WfMS / BPMS for instance:
manages the task lists of the process participants
orchestrates the control flow between the different manual and system tasks
manages the process context information throughout the process (data. documents, persistence, versioning - ideally all ootb without coding)
provides rollback, error compensation features
creates an audit trail which is important for compliance / processes that need to be auditable (QA, regulators)
provides dashboards for operational monitoring
and reports for analysis and reporting of KPIs like averages process execution times or volumes grouped by different business data
allows you to model your business process in a graphical way, preferably in a standard notation (BPMN), which is much more user-friendly and a good basis for the communication between business and IT. The business will find it much harder to read the faces-config.xml.
supports the evaluation of simple or complex business rules to determine process flow and work assignment with user-friendly means
allows the
allows versioning of the process definitions (as if you had multiple faces-config versions in the classpath)
...
Find more BPMPS features and examples e.g. here http://www.eclipse.org/stardust/.
Eclipse Stardust is a mature and comprehensive open source BPMS which covers the aspects listed above and more.
There are lots of workflow solutions that are not a BPM system. However, a BPM system should always include a workflow solution. Presumably implemented by using a BPM notation standard and including kpi monitoring, business rules, simulation, user management, organization modeling and reporting. Although you could implement all those parts yourself in Java EE (with JSF) it would presumably take much more time.
Is it possible to integrate Sitecore with external workflow engine (K2, Skelta), and if so, how to connect external workflow with Sitecore content item, and do i need to implement new interface in Sitecore (like workbox).
The reason why i need this, because current Sitecore workflow does not have all features that other workflow engines have, like escalating workflow items or parallel approval steps.
There are at least two ways. The most common way is to use Sitecore workflow actions to hand items off to the external workflow system. Another way is to implement the IWorkflowProvider and possibly related interfaces to abstract the external workflow engine completely. I personally have never tried either approach, so I can't provide any detail.
According to the sitecore website they list open architecture as a benefit. They even go so far as to say.
"Integrate with third-party systems: Sitecore CMS provides a full data integration and
abstraction layer that allows you to connect to any database, web service or other external systems"
So theoretically it is possible. (Full disclosure, I do work for K2) I will ask around to see if anyone internally has done this before.
Anyone else out there done anything similar?
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 3 years ago.
Improve this question
We have written a software package for a particular niche industry. This package has been pretty successful, to the extent that we have signed up several different clients in the industry, who use us as a hosted solution provider, and many others are knocking on our doors. If we achieve the kind of success that we're aiming for, we will have literally hundreds of clients, each with their own web site hosted on our servers.
Trouble is, each client comes in with their own little customizations and tweaks that they need for their own local circumstances and conditions, often (but not always) based on local state or even county legislation or bureaucracy. So while probably 90-95% of the system is the same across all clients, we're going to have to build and support these little customizations.
Moreover, the system is still very much a work in progress. There are enhancements and bug fixes happening continually on the core system that need to be applied across all clients.
We are writing code in .NET (ASP, C#), MS-SQL 2005 is our DB server, and we're using SourceGear Vault as our source control system. I have worked with branching in Vault before, and it's great if you only need to keep 2 or 3 branches synchronized - but we're looking at maintaining hundreds of branches, which is just unthinkable.
My question is: How do you recommend we manage all this?
I expect answers will be addressing things like object architecture, web server architecture, source control management, developer teams etc. I have a few ideas of my own, but I have no real experience in managing something like this, and I'd really appreciate hearing from people who have done this sort of thing before.
Thanks!
I would recommend against maintaining separate code branches per customer. This is a nightmare to maintain working code against your Core.
I do recommend you do implement the Strategy Pattern and cover your "customer customizations" with automated tests (e.g. Unit & Functional) whenever you are changing your Core.
UPDATE:
I recommend that before you get too many customers, you need to establish a system of creating and updating each of their websites. How involved you get is going to be balanced by your current revenue stream of course, but you should have an end in mind.
For example, when you just signed up Customer X (hopefully all via the web), their website will be created in XX minutes and send the customer an email stating it's ready.
You definitely want to setup a Continuous Integration (CI) environment. TeamCity is a great tool, and free.
With this in place, you'll be able to check your updates in a staging environment and can then apply those patches across your production instances.
Bottom Line: Once you get over a handful of customers, you need to start thinking about automating your operations and your deployment as yet another application to itself.
UPDATE: This post highlights the negative effects of branching per customer.
Our software has very similar requirements and I've picked up a few things over the years.
First of all, such customizations will cost you both in the short and long-term. If you have control over it, place some checks and balances such that sales & marketing do not over-zealously sell customizations.
I agree with the other posters that say NOT to use source control to manage this. It should be built into the project architecture wherever possible. When I first began working for my current employer, source control was being used for this and it quickly became a nightmare.
We use a separate database for each client, mainly because for many of our clients, the law or the client themselves require it due to privacy concerns, etc...
I would say that the business logic differences have probably been the least difficult part of the experience for us (your mileage may vary depending on the nature of the customizations required). For us, most variations in business logic can be broken down into a set of configuration values which we store in an xml file that is modified upon deployment (if machine specific) or stored in a client-specific folder and kept in source control (explained below). The business logic obtains these values at runtime and adjusts its execution appropriately. You can use this in concert with various strategy and factory patterns as well -- config fields can contain names of strategies etc... . Also, unit testing can be used to verify that you haven't broken things for other clients when you make changes. Currently, adding most new clients to the system involves simply mixing/matching the appropriate config values (as far as business logic is concerned).
More of a problem for us is managing the content of the site itself including the pages/style sheets/text strings/images, all of which our clients often want customized. The current approach that I've taken for this is to create a folder tree for each client that mirrors the main site - this tree is rooted at a folder named "custom" that is located in the main site folder and deployed with the site. Content placed in the client-specific set of folders either overrides or merges with the default content (depending on file type). At runtime the correct file is chosen based on the current context (user, language, etc...). The site can be made to serve multiple clients this way. Efficiency may also be a concern - you can use caching, etc... to make it faster (I use a custom VirtualPathProvider). The largest problem we run into is the burden of visually testing all of these pages when we need to make changes. Basically, to be 100% sure you haven't broken something in a client's custom setup when you have changed a shared stylesheet, image, etc... you would have to visually inspect every single page after any significant design change. I've developed some "feel" over time as to what changes can be comfortably made without breaking things, but it's still not a foolproof system by any means.
In my case I also have no control other than offering my opinion over which visual/code customizations are sold so MANY more of them than I would like have been sold and implemented.
This is not something that you want to solve with source control management, but within the architecture of your application.
I would come up with some sort of plugin like architecture. Which plugins to use for which website would then become a configuration issue and not a source control issue.
This allows you to use branches, etc. for the stuff that they are intended for: parallel development of code between (or maybe even over) releases. Each plugin becomes a seperate project (or subproject) within your source code system. This also allows you to combine all plugins and your main application into one visual studio solution to help with dependency analisys etc.
Loosely coupling the various components in your application is the best way to go.
As mention before, source control does not sound like a good solution for your problem. To me it sounds that is better yo have a single code base using a multi-tenant architecture. This way you get a lot of benefits in terms of managing your application, load on the service, scalability, etc.
Our product using this approach and what we have is some (a lot) of core functionality that is the same for all clients, custom modules that are used by one or more clients and at the core a the "customization" is a simple workflow engine that uses different workflows for different clients, so each clients gets the core functionality, its own workflow(s) and some extended set of modules that are either client specific or generalized for more that one client.
Here's something to get you started on multi-tenancy architecture:
Multi-Tenant Data Architecture
SaaS database tenancy patterns
Without more info, such as types of client specific customization, one can only guess how deep or superficial the changes are. Some simple/standard approaches to consider:
If you can keep a central config specifying the uniqueness from client to client
If you can centralize the business rules to one class or group of classes
If you can store the business rules in the database and pull out based on client
If the business rules can all be DB/SQL based (each client having their own DB
Overall hard coding differences based on client name/id is very problematic, keeping different code bases per client is costly (think of the complete testing/retesting time required for the 90% that doesn't change)...I think more info is required to properly answer (give some specifics)
Layer the application. One of those layers contains customizations and should be able to be pulled out at any time without affect on the rest of the system. Application- and DB-level "triggers" (quoted because they may or many not employ actual DB triggers) that call customer-specific code or are parametrized with customer keys) are very helpful.
Core should never be customized, but you must layer it in somewhere, even if it is simplistic web filtering.
What we have is a a core datbase that has the functionality that all clients get. Then each client has a separate database that contains the customizations for that client. This is expensive in terms of maintenance. The other problem is that when two clients ask for a simliar functionality, it is often done differnetly by the two separate teams. There is currently little done to share custiomizations between clients and make common ones become part of the core application. Each client has their own application portal, so we don't have the worry about a change to one client affecting some other client.
Right now we are looking at changing to a process using a rules engine, but there is some concern that the perfomance won't be there for the number of records we need to be able to process. However, in your circumstances, this might be a viable alternative.
I've used some applications that offered the following customizations:
Web pages were configurable - we could drag fields out of view, position them where we wanted with our own name for the field label.
Add our own views or stored procedures and use them in: data grids (along with an update proc) and reports. Each client would need their own database.
Custom mapping of Excel files to import data into system.
Add our own calculated fields.
Ability to run custom scripts on forms during various events.
Identify our own custom fields.
If you clients are larger companies, you're almost going to need your own SDK, API's, etc.
There is a pretty strong need for us to design some workflows around various processes. The problem is none of us actually know any workflow technology yet, and finding good data to compare the available options has been tedious and not entirely fruitful.
So I figured I'd ask you guys.
The main technologies we are looking at are Windows Workflow Foundation and eDocs Workflow. What other options are there? Sharepoint 2007 has workflow functionality too, right? Is that just based on WF?
What are the pros and cons of the various technologies? How do they compare?
EDIT: Also, one feature the administrative types like with eDocs Workflow is that it provides a method for them to edit it themselves. I believe Sharepoint '07 does as well. Is there some other way to allow that with a straight WWF implementation?
Sharepoint and WF more like complementary technologies, designed as two different workflow authoring tools in the same ecosystem. There's a Sharepoint workflow designer, and a WF (Windows Workflow Foundation) workflow designer.
The Sharepoint designer is meant to be an Office-like workflow editing experience, easier to get started with, geared for non-technical types, and generates all the web forms automatically.
The 'WF' workflow designer on the other hand is actually a component of Visual Studio (by default - as Bernie says you can rehost it), and designed to allow programmers to be able to fully customize workflow, and integrate it with any other code/systems desired. Building and deploying sharepoint sites this way is still possible, through the use of 'Sharepoint Activities', but more complex.
If you take the former route, you can hopefully let the administrative types do their own basic customizations (up to the limits of that environment) without causing total chaos.
It is possible to 'rehost' the WF designer (the one from Visual Studio) in your own application, so that users can author workflows. There are a number of code examples on the web, the most important one from MS itself: http://msdn.microsoft.com/en-us/library/aa480213.aspx).
At some point, when evaluating WF, I implemented a demo application that did this and added some features and found that although it works, not everybody can understand and use the more difficult activities (like the policy activity) that require understanding of how the rules engine works.