Engroup document management system overview

• Technology: engroup document system is developed base on excellent java frameworks and libaries as Spring, Spring Modules, Jackrabbit, Lucene at back-end and Flex at front-end.
• Development Time: first line of codes are written when we write the blog post http://blog.esofthead.com/jackbrabbit-ocm-and-spring. By time, the source code have many changes when we have more knowledge of using Jackrabbit, Luncene and product requirements, java libraries are more stable.
• Status: engroup document management (EDM) are maintained and bug-fixes phase. engroup 1.5.1 released on 10/7/2009 has 3 bug-fixes for EDM and we continue to fix any discovered defects of EDM reports from our customer and our QC team. With the workflow process applied to all engroup modules since 1.7.0 version (our roadmap), EDM will support workflow as well (what are the rules people must follow while access document?) also we improve searching criteria and back-up records system and user collaboration.

Benefits of using Engroup Document System

Increased Productivity / Efficiencies

• All documents are stored in central system. People does not need to search document in many sources: mail, network drive, local files etc
• Access heavy use documents instantly by bookmark menu.
• Work with document everywhere and anytime. You only need a web browser to do that.
• Get all documents in the same category fastly.
• Keep all previous documents in versionable form. You can get previous work easily as you work with current document.

Improved, faster and more flexible search

Engroup document system can retrieve files by any word or phrase in the document - known as full text search or browse documents using taxonomies - things are not presented in network sharing.

Secure your data

Most of user are familar with operating file system permission, engroup developers make our system familar with what you are using. Engroup provides permission rules are similar with file permissions. By default, each engroup user has his personal folder with full access right, and he can not access other folders (except administrator can access all folders). Engroup administrator will provide the rights for users, group of users (roles) access some folders/files with appropriate permissions. Engroup search only display results of documents can be accessible by user.

Data Integration with other engroup modules

Engroup modules saved documents in the same central place, it means you can access employee CVs, Sales documents or project attachments in one storage only. When you perform search content document, the system will list all matched document in all places: project management, CRM, HR etc which you have authorization to access.

Here are the new user features of engroup 1.5.1, the detail changes can be read at http://esofthead.com/node/51.

1. Project Management module:

• Helps enterprise manage their works easily with hierarchy tasks, deadlines.
• Collaborates project members, store project information with messages and their comments, attachments.
• Manages project resources and statuses such as project members, risks and problems.
• Provides automotive scheduling base on various variables start date, end date, predecessor tasks.
• Integrations with Microsoft Project: import/export data to/from MS Project format.

2. Connection module: is extracted from previous Dashboard module

• Private messages.
• Members List.

3 User Profile module: is extracted from previous Dashboard module

• Uploads user picture to profile section.
• Crop picture to profile picture.
• Displays profile picture.

We will write the usage of engroup modules such as document management, project management in future posts. Stay tuned.

1. Do you feel angry because you think he did bad job without care quality or he is a junior developer who do not have experience to do the right thing at the first time?

2. You are agree with your developer but you are afraid that customer think your team produce a bad result and take time for correction that make project cost is increased?

With many years experience of project management in various team sizes, and senior project manager manage a big account over 100 members with my direct subordinates are project managers, I must admit that such situation occurs sometimesand it makes developers are afraid to tell their manager that they need time to make their code better.

Note that my 'bad code' definition is not source code has low quality such as having a lot defects or do not following coding standards but a 'bad code' means you can write a better code to solve project problems, optimize your code, gain better performance or increase re-usability. I have worked with many talent developers who handle such tasks as extra tasks not belong in project schedule and do it in their own time (though it is not a good for his personal time), but most of time all project members are afraid to modifying existing code base while project manager do not approve. Here are the result I see: the bad code is not optimized, it is modified base on new requirements from customer and it becomes terrible code with low quality, many defects. The cycle is repeated, developer are afraid to make it better, it become worse and so on. Project will have many technical debts and when the project size is grown bigger, team productivity will decrease continuously. Project quality is complained by customer or even they cancel project, otherwise project members must work overtime to fix defects with low source code quality. Most of cases, customer are not satisfied project performance and/or project members are exhausted, company lost profit.

It is normal in project management if we leave 2-3 free days after each iteration for team spending time to look what they did in the past, a knowledge management system is a tool for members to share their knowledge and works and project technical lead review solutions right away or weekly basic to improve code quality better if you do not want to spend much effort fixing later. Managing and developing software projects have many pressure: quality, deadline, customer feedbacks etc, there are not all software solutions are reviewed by all team members to give feedbacks about their advantages and disadvantages, there are some common API is developed by one developer and others try to use without giving any comments or they think they have no time to tune that API better. If you let such situation happens, your project has a red alarm!

'Engroup is a information, knowledge center and communication tool for groups and companies. Engroup promotes both informal and formal communication by combining various communication methods like private message (one-to-one, simple protocol), chat or email. In addition, Engroup provides many enterprise features like Human Resource Management, Customer Relationship, Document Management and Project Management modules. By utilizing the strength of Java language at server side and Flex on Flash runtime at client side, Engroup provides the fast and stability platform with user friendly interface'.

Engroup is the right tool for you if you want a software for one or many following needs:

• Manage your tasks.
• Read new channels.
• Communicate with others: private message, chat, mail, forum.
• Manage your company knowledge and information: wiki, document management.
• Manage company employee information.
• Manage customer information.
• Manage project: problems, risks, resources and documents.

Engroup milestone 3 is the scrum iteration release (1 month after the second milestone), it includes bug fixes, major improvements in Customer Relationship Management module and a new Project Management module is added. For the detail, you should check out our RELEASE NOTES at http://esofthead.com/node/49

- If any engroup modules need to tag some resource, which resource can be a document or a CRM Lead etc, it does not call tag service (if it do so, tag service must be available and it depends on tag service) but send a message with necessary information to a specific channel name 'add.tag'. If a tag service is available, it will receive message from that channel and save tag as requested.

- When a new user register to engroup system, engroup must do: 1. Create new user document workspace 2. Synchronize user information with its forum and wiki and several tasks later we will add, for example create a account with the same name in chat server, email server. Instead of adding code in register user part and modifying code when there is new added action when register user, we simply send a message to 'add.user' channel, any interested parties would listen this channel and do their tasks.

Engroup runs in Spring Osgi platform that we can control the dependencies among engroup modules and engroup external libraries. With the goal to make engroup modules are loose coupling, Engroup uses publish-subscribe pattern to make two modules have no dependencies in code can talk together with the help from ActiveMQ (messaging server) and Spring Integration framework.

Here are an example that we use all of these tools in engroup: we have two modules engroup document management module and engroup tag resource. Each document could have many tags, when a document is saved into engroup data-store, it will post message to appropriate channel to notify engroup tag module to save its tag. The similar process is applied for any module support tag source in engroup.

• Set up embedded ActiveMQ server:

For deployment simplicity, engroup uses embedded ActiveMQ instance in its community edition.

        <!--  lets create an embedded ActiveMQ Broker -->
        <amq:broker useJmx="false" persistent="false">
                <amq:transportConnectors>
                        <amq:transportConnector uri="tcp://localhost:0" />
                </amq:transportConnectors>
        </amq:broker>

        <!--  ActiveMQ destinations to use  -->

        <!-- JMS ConnectionFactory to use, configuring the embedded broker using XML -->
        <amq:connectionFactory id="jmsFactory" brokerURL="vm://localhost" />

        <bean id="connectionFactory"
                class="org.springframework.jms.connection.SingleConnectionFactory">
                <property name="targetConnectionFactory">
                        <ref local="jmsFactory" />
                </property>
        </bean>

• Using Spring JMS to send message:

          <!--Convert java object to Json message format-->
          <bean id="messageConverter"
                  class="com.engroup.integration.jms.converter.JsonMessageConverter" />
  
          <bean id="jmsTemplate"
                  class="org.springframework.jms.core.JmsTemplate">
                  <property name="connectionFactory" ref="connectionFactory" />
                  <property name="messageConverter" ref="messageConverter"></property>
          </bean>
  
          <bean id="messageDispatcher"
                  class="com.engroup.integration.dispatcher.jms.JmsMessageDispatcher">
                  <property name="jmsTemplate" ref="jmsTemplate" />
          </bean>

• Define message destinations:

In engroup tag module, we define two message destinations: tagRemove and tagAdd

        <!--Import spring service connection factory from engroup esb module-->
        <osgi:reference id="connectionFactory"
                interface="javax.jms.ConnectionFactory" />

        <bean id="tagRemoveDest"
                class="org.apache.activemq.command.ActiveMQQueue">
                <constructor-arg value="tag.remove" />
        </bean>

        <bean id="tagAddDest"
                class="org.apache.activemq.command.ActiveMQQueue">
                <constructor-arg value="tag.add" />
        </bean>

• Define service activator for channels:

Now, we define service activator to handle tag add request

        <bean id="tagServiceActivator"
                class="com.engroup.module.tag.integration.TagServiceActivator">
                <property name="tagService" ref="tagService" />
        </bean>

        <!-- Establish add tag channel and related things -->

        <jms:inbound-gateway id="jmsTagAdd" request-destination="tagAddDest"
                request-channel="tag.addChannel" reply-timeout="5000"
                request-timeout="5000" />

        <integration:channel id="tag.addChannel" />

        <integration:channel id="tag.addChannelAfterTransformer" />

        <integration:channel id="tag.result" />

        <engroup-esb:json-to-map-transformer input-channel="tag.addChannel"
                output-channel="tag.addChannelAfterTransformer" />

        <!--Method addTag is used to receive message from channel &#39;tag.addChannelAfterTransformer&#39;,
process and return message to channel &#39;tag.result&#39;-->

        <integration:service-activator ref="tagServiceActivator"
                method="addTag" input-channel="tag.addChannelAfterTransformer"
                output-channel="tag.result">
        </integration:service-activator>

Here is a part of code of TagServiceActivator:

public void addTag(Map tagInfo) {
        String contentId = (String) tagInfo.get("contentId");
        String[] tags = (String[]) tagInfo.get("tags");

        tagService.deleteTagRelationshipOfContent(contentId);

        for (String tag : tags) {
            tagService.saveTagRelationship(contentId, tag.trim());
        }
    }

Remember to add dependency Spring integration packages into MANIFEST.MF file, otherwise you will get ClassNotFoundException while
running Osgi.

• Send message to tag module channels

We go to the code of any modules are interesting in tag resource, in our example it is document module. First, we import messageDispatcher to document service bean:

         <osgi:reference id="connectionFactory"
                interface="javax.jms.ConnectionFactory" />

        <osgi:reference id="messageDispatcher"
                interface="com.engroup.integration.dispatcher.MessageDispatcher" />

        <bean id="internalAccessValidatorFileService"
                class="com.engroup.module.ecm.service.impl.AccessValidatorFileSystemServiceImpl">
                <property name="jcrTemplate" ref="jcrMappingTemplate" />
                <property name="transactionService"
                        ref="contentTransactionService">
                </property>
                <property name="messageDispatcher" ref="messageDispatcher"></property>
        </bean>

When we want to send a message to add tag channel of engroup tag module, we just simply construct a message and messageDispatcher will do the rest:

    private void sendSaveTagRequest(String contentId, String[] tags) {
        Dictionary
 props = new Hashtable();
        props.put("contentId", contentId);
        props.put("tags", tags);
        messageDispatcher.dispatchObject(AvailableDestinationNames.TAG_ADD,
                props);
    }

Osgi can help you control strictly dependencies of a module with external packages if we control well, we can limit dependencies of one engroup module with other module. Spring Integration framework provides solution to integrate data among modules without modifying existing code base. At the beginning, we feel it is complex solution while combining Spring Integration with Osgi platform. However, after number of modules is grown continuously also data exchange among modules are increased, such complex solution become a simple one on both development and deployment. Could you have other solutions?

The following screen-shots are result of displaying tag in document module.

Engroup 1.5.07082009 has the following new features and improvements according with the previous one:

• eSoftHead replaces Engroup AIR client application by Flex client browser. In the past, several clients complained the security warning while they install Engroup client and additional steps they must do to install client application. With engroup web client, such obstacles are disappeared. eSoftHead will only distribute Engroup AIR client application in its commercial delivery since Engroup 1.6. It will interact with native application, processes and file system that a web application cannot do.
• Document Management Module:
• • Bookmark content: user can bookmark their favorite content and manage bookmarks and its folders easily.
  • Access control: it is the key feature of this release. Now, Engroup Document Management manage contents like Operating System manages its file systems.
  • Improve performance of listing/reading contents.
• Improving caching model and create web session-like variable to manage user sessions.
• Various bug fixes of other modules

All your suggestions/comments will be highly appreciated. Please do not hesitate to drop some lines to us at info@esofthead.com.

The most feasible solution that many companies choose is to developboth web and desktop presentations and reuse the back-end layer since, in general,the main difference between desktop and web applications is presentation layer. However, the middleware and persistent layer in web and desktop applications could be different depending on application architecture as well as communication protocol between presentation and back-end layers. Moreover, for enterprise applications, the cost for developing two separate presentation layers is so high. Let's imagine that your application has hundreds of views and many business processes at client side.

eSoftHead found a better solution - AIR/Flex. Being inspired by the article Building web and Adobe AIR applications from a shared Flex code base, we applied that Adobe solution on our product - Engroup ( http://esofthead.com/node/25) to build the both desktop and web applications using the same code base (this does not mean
that all source codes are portable between desktop and web environments but most of them). Our goal is to deliver Engroup to our customers in the same form. Engroup 1.5 Milestone 2 will be released in both versions: Web (for community use) and Desktop (for commercial use). You can see its two screenshots respectively below:

To make the dream of developing web and desktop applications in the same codebase become true, the following design is applied:

• Build projects based on component responsibility: if a component requires specific classes of AIR libraries, we split the project into 2 sub projects; one for web (if needed) and one for AIR. One example is dynamic loading Engroup modules. We created Platform_AIR including classes responsible for loading the modules of Engroup desktop and Platform_Web including classes responsible for loading the modules of Engroup web.
• Use Abstract Factory pattern instead of Factory method pattern: Abstract Factory pattern creates a family of different implementation services between web and desktop. It helps you manage the set of differences easier.
• Try to keep shared code between desktop and web as much as possible: While implementing, we always kept in mind of reducing the size of project specific for AIR and web as small as possible. For example, if we have 5 services that need to be implemented, we try to write 5 implementation classes. The result we got is 6-7 classes.
• Standardize communication protocol between client and server (regardless of whether client is desktop or web application): we chose Flash/Flex as platform of our Engroup rich internet application due to its capacity of developing both web and desktop application. To avoid using web frameworks for developing web client and Java/Qt etc for developing desktop client, Flash is a good choice with more than 95% code is shared in both web and desktop applications (including hundreds of page and components) in our project. Using Flex makes our application run on Flash platform easier. If we used standard web technology (AJAX and other web frameworks), we would have to use another communication to connect between client and server.

That's our story. If you need to develop an application running on both Web and Desktop, what will you do?

In our last project, we faced 2 challenges of how to build the SaaS platform including various modules; some are developed by ourselves and some are third parties (Forum, Wiki, Mail, etc.). With third-parties, we limit modifying their code base and database schema due to client's requirements. Here are our challenges:

Challenge 1: When a new user is registered, some our modules need to acknowledge and have re-actions. For example:

• Document Management module creates a personal document workspace for that user.
• Calendar module creates a personal calendar for that user.
• Forum and Wiki register that user to their user database because Engroup supports Single Sign On (SSO) mechanism. That means any user registered to Engroup user database can access Forum and Wiki resources without registering their user database.

Since our application follows SaaS model, the modules acknowledging and having re-actions to that registered user are dynamically discovered at runtime. This prohibits us from invoking module API in static manner.

Challenge 2: We want to implement audit trail process. Each module installed into our platform must follow the rules of tracking our user activities. Our goal is to build a common API sending user activities to reporting server but all our modules must loose coupling with the reporting API. This design helps us to configure reporting server in different machines easily.

We found out the solution for 2 application integration problems above - service bus. After evaluating 3 open source enterprise service bus (ESB) frameworks: Spring Integration, Mule, and Service Mix, Spring Integration finally is our choice, based on the criterion we set as follows: