1. Team S07

2. Agenda Scope of project Global use case diagram Analysis use cases High Level design (Software Architecture) Prototype challenges faced and remaining Technical risks mitigated Transition strategy Management Issues / Change Requests Management Progress and Tracking Plans for implementation phase

3. Scope of project

4. Global use case diagram

5. Analysis Use Case # 1

6. Architectural changes and motivations behind the changes SNoChangeMotivation 1Traditional user interface approach left and adopted Rich User Interface Customer requirement of having enhanced UI with less number of steps to perform an operations. Intuitive UI. Non-Blocking UI experience. 2EJB centric approach has dropped, and Web centric approach adopted. Support to Rich UI framework, which does most of the processing by using client resources such as browser cache and client machine processor which doesn’t need the container to manage heavy EJB Instead an efficient and light weight container required to service Rich UI components

7. Software Architecture

8. High Level design - Software Architecture

9. Software Components Third party Software Component and libraries VendorLicense JDK/ JREOracle Sun License (most of it also under GPL) Spring Framework 3.0Spring Source Spring libraries are licensed under the terms of the Apache License, Version 2.0.Apache License, Version 2.0 Ext JS 4.0Sencha ExtJs 4.0 is available in dual licensing scheme; however, we have used it under the licensing terms of GNU GPL license v3.GNU GPL license v3 Hibernate CoreJBOSS Community The GNU Lesser General Public License version 2.1 (LGPLv2.1) Tomcat 7.0ApacheApache Tomcat is developed under the Apache License version 2Apache License version 2

10. Dual layer MVC architecture

11. UI Layer Data Package

12. JSON Parsing

13. Following are key features of Spring framework, which ECMS application enjoys: Annotation Driven Architecture. IOC or Dependency Injection by its Component Scanning mechanism, which saves the time for instantiation of user objects. Decoupling between Dispatcher and Mapping and View resolving mechanism. Aspect Oriented Programming model Spring in-built role based security.

14. Spring MVC Architectural View

15. Data Base Layer

16. Prototype Stage Challenges

17. Prototype challenges (1) SnoChallengesAction Performed /Solutions 1To reduce the number of steps taken to complete a user operation Requirement of having many CRUD operation with less number of steps, this is challenging to achieve if we proceed with a traditional approach of UI using HTML forms and pages Used Rich UI components from third party open source libraries with AJAX to provide enhanced user interface, which capable of operations without leaving a page 2To reduce the latency time for a User action For non-blocking user experience of ECMS UI, it requires to reduce the latency time, which is time taken between data packets leaves and receive, from and by the client browser for given user command Ajax communication between UI and Service layer to meet this challenge

18. Prototype challenges (2) SnoChallengesAction Performed /Solutions 3Technological evolution (UI layer framework) Ext JS framework was revised in April 2011 from 3.x to 4.x which includes the MVC architecture. This change has required us to move to ExtJS 4.x and refactor the design at Client Tier to exhibit MVC architecture introduced in ExtJS 4.x. ExtJS 4.x documentation followed and revised the UI layer structure, integrated ExtJS 4.x together with ExtJS 3.x, to not to disturb existing modules. New features development with carry on using ExtJS 4.x and Ext3.x features shall be interchange with ExtJS4.x 4Novelty of Technology Ext JS 4.x and Spring framework 3.x are new technologies which have recently released in 2011. An important use case prototyped.

19. Technical Risks and Mitigation

20. Technical Risks Mitigated (1) SnoRiskRisk Mitigation 1Integration of two new frameworks at different layers (ExtJS (UI) and Spring framework (Service)), where team has no prior experience. Integrating two frame works performed in steps, as two unknown frameworks required good time of study and analysis. 1.UI layer integrated to the system with ExtJS framework, which communicates to the server using Servlet technology. 2.Spring Controller accessed by JSP at front end. 3.JSP interchanged with Java Script and Servlet interchanged with Spring MVC Controller to finally integrate both layer MVCs 2Exchanging Objects between layers Prototyped by sending JSON from UI Layer to Server and transform to JAVA object at Service Layer and vice versa.

21. Technical Risks Mitigated (2) SnoRiskRisk Mitigation 3Managing large number of records at UI Layer on general user queries (Risk realized proactively) Pagination Feature prototyped to mitigate the risk. Pagination send Ajax request to get the limited number of records on Java Script load. HibernateCallback implemented to get the limited number of records. 4Analysis boundary objects realization using Java Script Components Main Job use case implemented using ExtJS and Spring MVC.

22. Transition Strategy User Interface Layer

23. Static Structure (1)

24. Static Structure (2)

25. Dynamic Structure

26. Asynchronous calls to server

27. Communication Between UI and Service Layer

28. Transition Strategy Service Layer

29. Static Structure

30. Dynamic Structure

31. Transition Strategy Persistence Layer

32. Static Structure

33. Dynamic Structure

34. Deployment Structure

35. Management Issues

36. Change Requests

37. Management Progress and Tracking

38. Plans for implementation phase

39. Expected implementation issues