[attachment=1882]

INTRODUCTION
PROJECT OVERVIEW
The revolutionary trends of computerization have reached the peaks achieving global goals in all fields and sectors. The IRecruit systems getting computerized are leading to a new and innovative way to approach to above said. With the major organizations hosting services of HRMS our project specifically aims to the total computerization of the IRecruit.

With the total automation of IRecruit, the manual dependency is minimized to a large extent. It inherits all the properties of computerizing a system which includes quick response, less processing time, non-diligence, fast recovery, robustness, flexibility, reliability, scalability.
Todayâ„¢s trend demands high rate of automation for the IRecruit as the organizations are growing in exponential form and maintaining employment records in a consistent format. To satisfy the needs of clients, todayâ„¢s organization need more and more of workforce. The IRecruit system takes care of this by taking in resumes from new aspirants and allowing the HR to view them in and do selections there upon.
PROJECT SCOPE
The project mainly focuses on recording information related to managing information related to JobPostings, People, Companies, Resumes and Candidates. Retrieving information like Job details, Resumes details, candidate details etc,.generating reports like Use Reports, Job Reports, Transaction Reports, Usage Reports, and Skill Reports. For Candidate there is a creation of new login, searching for a new job, etc. The system also enables the HR personnel to view the resumes of new aspirants and select them based on the selection criteria.
SCREEN DESIGN / GRAPHICAL USER INTERFACE
The system uses a very user-friendly interface developed using Hyper Text Markup Language (HTML), which most users are acquainted with and is broadly used on the world wide web(WWW). The controls are placed on the forms in an easily accessible manner so that user strain is minimized to the maximum extent.
Whenever a user enters any form the system also states the action to be performed in an easily understandable and pleasant speech. The navigation of the user form one area of the system to another is very easy using easy to access and properly placed hyperlinks which user can access on the click of a button.
The system also poses a unique format for each type of users; this ensures that user is presented with options he has access to. This ensures a great deal of security to the system and to the organization as an employee is not given an option to carryout unauthorized activity.
General Description
The system has Four major modules:
¢ Candidate module
¢ Employee module
¢ Recruiter module
¢ Administrator module
The welcome form of the Candidate module displays the options to a person. It has options for him to post his/her resume, searching the job, and manage Candidate. Or he/she can sing-up new account. The sign-in form is the entry point of an candidate to the site through he/she has to login everyday. When we select Candidate page link in form it displays the information about the candidate. From this page candidate can manage candidate information and can post resumes.
From the search job option candidate can search the jobs posted using several criteriaâ„¢s like search words, function, location, time span.
The Employee Welcome page have the following links home, Job Postings, Resumes, People, Companies, other. Through this employee of the company nothing but the recruiter or Hr manager can see the resumes of the different candidates, can create new job etc.
The Administrator page have the following links like home, Job Postings, Resumes, People, Companies, other. With this he can manage all the details about the companies, people, JobPostings etc.
Description about the sub modules in this system
¢ Job Postings
1. Job Maintenance
a. PDF Report: Exports the report of the jobs to the pdf format about the job which is selected
b. Edit Job: Editing the job details which is selected
c. Candidate: Edit the candidate details
d. Refresh post date: Change post date to todayâ„¢s date
e. Activate: Activate the job to view the candidates
f. Required skills: Select the skills for the job
g. Job history: View the transactions that are made to the job
2. Job Search: Search and manage the job details by using some search criteria like search words, functions, location, Time span, active status, companies.
3. Create Job : Create new job
¢ People
1. Manage All: Manage all the people nothing but candidates, employee, applicant details. It contains following sub options
a. Edit User: Edit the user information like username and password
b. Edit Person: Edit person details like name, address, qualification etc.
c. Evaluations: Can create new evaluations or modify existing evaluations
d. Resumes: Can upload resumes, enter text resumes or remove resumes
e. Candidate info: View the candidate info with the jobs that are applied
f. Interviews: Can view and manage the interview schedule
2. Manage Candidates: Can manage the above options a-f for the specified candidates.
3. Manage Employees: Can manage the above options a-f for the specified Employee.
4. Manage Applicants: Can manage the above options a-f for the specified applicant.
5. Search for Person : Can search a person and manage the person by using the above a-f options
6. Create Person : Create a new Person and assign the roles to the persons like admin, recruiter, employee, candidate etc.
¢ Companies
1. Manage Companies
Can manage companies by selecting given below options
a. Edit Company
Edit company details like name, address, reference id, etc.
b. Add Division
Adds new Division to the company
c. Company Jobs
View Jobs and edit job details
d. Add job
Adds new Job to the company
e. Remove
Remove company
f. Associates
Edit associates for the company
2. Create Company
Creates new company
¢ Resumes
1. Scan Resumes
Scans resumes with the criteria
2. Manage Resumes
Manages resumes received from the candidates
3. Emailed Resumes
Manages emailed resumes
¢ Other
1. Reports
It contains the following reports types
a) User Reports
1) User List Report
A complete list of users including all employees and all candidates.
2) Candidate List Report
A report listing all candidates registered.
3) Employee List Report
A report listing all employees
b) Job Reports
1) Active Jobs
A list of active jobs and their current status.
2) All jobs (Active + Inactive)
A list of all jobs and their current status.
3) Active Jobs (Company Grouping)
A list of all active jobs grouped by companies/divisions.
4) All Jobs Company Grouping
A list of all jobs grouped by companies/divisions.
c) Transaction Reports
1) Transactions for past 3 days
Report all transaction past 3 days
2) Transactions for past 30 days
Report all transaction over the past 30 days.
d) Usage Reports
1) Usage over past 3 days
Report all usage requests in past 3 days.
2) Usage over past 30 days
Report all usage requests in past 30 days.
e) Skill Reports
1. Skills setup
A report showing the current skills assessment configuration.
2. Manage Locations
Manage Locations like remove etc
3. Run Job Agents
Lists the information like Active jobs, Scheduled interviews, Job Applicants, Resume Scans, etc.
Candidate Module
This is a very useful candidate through this he can search the jobs that are posted by the companies. And then he can post their resume to the selected companies.
This module mainly contains three functionalities.
¢ Home
¢ Candidate
¢ Job Search
Home : By selecting Home he can access the home page of the candidate Home page. It contains the links like home, candidate, job search, login details or sign-up link.
Candidate : By selecting candidate page link in home page . He can view the details. He/she can manage their details like updating information like personal details, upload resume, enter text resume, update profile, search agents, remove profile etc.
Job Search : By selecting JobSearch page link in home page. He/She can search the jobs posted by giving information like search word, function, location, time span.
Employee Module
This module focuses on the basic employee of the company. The employee is given a login form wherein he enters the login details user id and password. The employee has to maintain details about job postings, people, companies, resumes, other reports.
The options given to a basic employee are
¢ Job Postings
1. Job Maintenance
2. Job Search
3. Create Job
¢ People
1. Manage Candidates
2. Manage Applicants
3. Search for Person
4. Create Person
¢ Companies
1. Manage Companies
2. Create Company
¢ Resumes
1. Scan Resumes
2. Manage Resumes
3. Emailed Resumes
¢ Other
1. Reports
2. Manage Locations
3. Run Job Agents
Employee is nothing but the user of the application in the company that is maintained this project. He has the ability to manage all the above tasks.
Employee Module
This module focuses on the recruiter of the company. The recruiter given a login form wherein he enters the login details user id and password. The recruiter has to maintain details about job postings, companies, resumes, other reports.
The options given to a basic employee are
¢ Job Postings
1. Job Maintenance
2. Job Search
3. Create Job
¢ People
1. Manage Candidates
2. Manage Applicants
3. Search for Person
4. Create Person
¢ Resumes
1. Scan Resumes
2. Manage Resumes
3. Emailed Resumes
¢ Other
1. Reports
2. Manage Locations
3. Run Job Agents
Employee is nothing but the user of the application in the company that is maintained this project. He has the ability to manage all the above tasks.
Administrator Module

This module focuses on the basic employee who acts as administrator of the system. Each employee is given a user id and password, which identifies him uniquely. The employee is given a login form wherein he enters the login details user id and password. The administrator has the ability to maintain everything in the system. He can create users and given permission to the user like System Administration, recruiter, employee, candidate etc.
As he is a basic employee the system shows his form with his/her select options
.The options given to a basic employee are
¢ Job Postings
1. Job Maintenance
2. Job Search
3. Create Job
¢ People
1. Manage All
2. Manage Candidates
3. Manage Employees
4. Manage Applicants
5. Search for Person
6. Create Person
¢ Companies
1. Manage Companies
2. Create Company
¢ Resumes
1. Scan Resumes
2. Manage Resumes
3. Emailed Resumes
¢ Other
1. Reports
2. Manage Locations
3. Run Job Agents

The administrator has the abilities to do all the above tasks.
SYSTEM ANALYSIS
Need of the system
Present day organizations, especially large companies house employees in large numbers they need number of employees. In order to recruit employees they consult consultants or recruiters, so that the recruiters get the applications and scan resumes and send relevant applications to the final hr that need employees. The burden on recruiters department is immense. The lack of consistency in record maintenance leads to both loss of property as well as employee confidence.
With the total automation of IRECUIT, the manual dependency is minimized to a large extent. It should inherit all the properties of computerizing a system, which includes quick response, less processing time, non-diligence, fast recovery, robustness, flexibility, reliability, scalability¦
In addition to these characteristics the system should maintain data in consistent format all the while.
Proposed System
The proposed system should have the above features. The features of the system are, it maintains the employee details, candidate details, resume details, company details and Job Posting of companies. The system should also be easy to access, accurate and consistent results can be obtained.
The employee details include all the personal information, login information. The system should be able to maintain the details about the applicants and company details. After that, they scan resumes and forward relevant profiles to the required recruit managers. The system should also provide a new aspirant to be able to submit his/her resume and it should also take care of intimating HR about it.
FEASIBILITY STUDY REPORT
After analyzing the existing system, the organization is in need of automation of existing manual system. The organization has the capacity to stand the cost of developing new system and is willing to do that. The product will be of utmost use and the level of ease has been increased to a great extent.
SOFTWARE REQUIREMENT SPECIFICATION
Introduction
Purpose
The purpose of this project is to handle Recruitment Process of organizations.
Document Conventions
1. All the main headings are in BOLD and underlined.
2. Error message will be denoted using a (*) prefix.
3. The steps in the document follow Software Development Lifecycle methodology.
Product Scope
The scope of the project is limited to a multiple organizations.
Reference
Java Server Programming J2EE edition “ wrox.
J2EE Complete reference -McGraw Hill.
Oracle 8i-Oracle Press
Java Servlet Programming “Oreilly .
Overall Description
Product Perspective
This project has been developed in replacement of existing manual system. This project mainly focuses on automation and customizing the existing IRECUIT module.
Product Function
The different functionalities provided by this module are as follows:
1. Maintains employee details.
2. Provides the functionality of submitting resume.
3. Maintains company details.
4. Maintains candidate details.
5. Maintains job postings.
6. Scans Resumes.
User Classes and Characteristics
The project may consist of user classes:
Employee class
Maintains details of the employee like address, user profile, company details
Company class
The class contains the company details like name and address, job postings. Each company has its own unique department id.
Candidate class
This class contains information like name, qualification, skill set, resume etc.
Resume class
The main aim of using this class is to able the user to enter the resume details and when he submits the form it stores the details in the database for later viewing.
Login class
The class displays the login screen and after validates the login id with the password in the database. And more classes
Operating Environment
¢ Operating System
Windows 2000 professional or higher
¢ Hardware platform
Pentium III processor or higher
256 MB RAM
¢ Software specifications
Jboss 3.3, J2SDK 1.4
Oracle 8i
Internet Explorer5.0 or Mozilla
Design and Implementation Constraints
Coding standards for variables
- Do not start or end variable names with underscores.
- Do not initialize variables in definition.
- Global variables should be initialized separately in a initialization
routine.
- Initialize only one variable per statement and explicitly.
Coding Standards for function
- Use prototyping for all the function.
- Argument should be listed one per a line.
- Return from only one place and function as for as possible.
- Watch out for functions that do not null terminate strings.
Design and Implementation Constraints
- Only authorized users should be able to access the system.
- Administrator can only create users
- The entire user interfaces need to be in HTML format.
User Documentation
A complete documentation depicting the functionality of the system should be provided with the system.
Assumptions and Dependencies
The project assumes that all the employees need to login and logout.
External Interface Requirements
User Interfaces
- The interfaces between the user and system should be done using
the HTML forms.
- The HTML fields are of the same font.
- The HTML forms have to be titled with the functionality of the form.
- The colors used should be uniform throughout the application.
Hardware Interfaces
¢ The system is being developed on Windows platform on a network and intended to work in a many organizations.
Software Interfaces
¢ The application connects to the database using the jdbc type 4 drivers for oracle.
¢ The project gets its inputs from the HTML forms which are processed by the servlets, Beans and JSPs.
Communication Interfaces
¢ The HTML forms communicate to the servlets using the HTTP 1.1 protocol.
¢ The data is being passed along in encrypted format.
System Features
¢ It maintains employee records
¢ Maintains resume details.
¢ Maintains employee details.
¢ Provides the functionality of submitting resume.
¢ Maintains company details.
¢ Maintains candidate details.
¢ Maintains job postings.
¢ Scans Resumes.
Other Non-Functional Requirements
Performance Requirements
¢ The system needs to be reliable.
¢ When the system is unable to process a particular request an appropriate error message should be generated.
Safety Requirements
¢ The details need to be maintained properly.
¢ When and employee leaves the organization his details need to be removed both in masters and dependent tables and the same employee id should not be assigned to any new employee.
Security Requirements
¢ The information passes between the html forms and the servlets should be in encrypted format.
¢ The system should be accessible to authorized personnel only.
SYSTEM DEVELOPMENT ENVIRONMENT
Java coding standards
Why Coding Standards are Important
Coding standards for Java are important because they lead to greater consistency within your code and the code of your teammates. Greater consistency leads to code that is easier to understand, which in turn means it is easier to develop and to maintain. This reduces the overall cost of the applications that you create. You have to remember that your Java code will exist for a long time, long after you have moved on to other projects. An important goal during development is to ensure that you can transition your work to another developer, or to another team of developers, so that they can continue to maintain and enhance your work without having to invest an unreasonable effort to understand your code. Code that is difficult to understand runs the risk of being scrapped and rewritten “ I wouldn™t be proud of the fact that my code needed to be rewritten, would you If everyone is doing their own thing then it makes it very difficult to share code between developers, raising the cost of development and maintenance. Inexperienced developers, and cowboys who do not know any better, will often fight having to follow standards. They claim they can code faster if they do it their own way. Pure hogwash. They might be able to get code out the door faster, but I doubt it. Cowboy programmers get hung up during testing when several difficult-to-find bugs crop up, and when their code needs to be enhanced it often leads to a major rewrite by them because they™re the only ones who understand their code. Is this the way that you want to operate I certainly do not.
The Prime Directive
No standard is perfect and no standard is applicable to all situations: sometimes you find yourself in a situation where one or more standards do not apply. This leads me to introduce what I consider to be the prime directive of standards:
When you go against a standard, document it : All standards, except for this one, can be broken. If you do so, you must document why you broke the standard, the potential implications of breaking the standard, and any conditions that may/must occur before the standard can be applied to this situation. The bottom line is that you need to understand each standard, understand when to apply them, and just as importantly when not to apply them.
Important Instructions to maintain standards
Use full English descriptors that accurately describe the variable/field/class/¦ For example, use names like first Name, grandTotal, or CorporateCustomer. Although names like x1, y1, or fn are easy to type because they™re short, they do not provide any indication of what they represent and result in code that is difficult to understand, maintain, and enhance (Nagler, 1995; Ambler, 1998a).
Use terminology applicable to the domain. If your users refer to their clients as customers, then use the term Customer for the class, not Client. Many developers will make the mistake of creating generic terms for concepts when perfectly good terms already exist in the industry/domain.
Use mixed case to make names readable. You should use lower case letters in general, but capitalize the first letter of class names and interface names, as well as the first letter of any non-initial word (Kanerva, 1997).
Use abbreviations sparingly, but if you do so then use them intelligently: This means you should maintain a list of standard short forms (abbreviations), you should choose them wisely, and you should use them consistently. For example, if you want to use a short form for the word number, then choose one of nbr, no, or num, document which one you chose (it doesnâ„¢t really matter which one), and use only that one.
Avoid long names (< 15 characters is a good idea): Although the class name
PhysicalOrVirtualProductOrService : might seem to be a good class name at the time this name is simply too long and you should consider renaming it to something shorter, perhaps something like Offering (NPS, 1996).
Avoid names that are similar or differ only in case : For example, the variable names persistent Object and persistent Objects should not be used together, nor should anSqlDatabase and anSQLDatabase (NPS, 1996).
Avoid leading or trailing underscores : Names with leading or trailing underscores are usually reserved for system purposes, and may not be used for any user-created names except for pre-processor defines (NPS, 1996). More importantly, underscores are annoying and difficult to type so I try to avoid their use whenever possible.
Good Documentation
We will also be discussing documentation conventions, so letâ„¢s discuss some of the basics first:
Comments should add to the clarity of your code : The reason why you document your code is to make it more understandable to you, your coworkers, and to any other developer who comes after you (Nagler, 1995).
If your program isnâ„¢t worth documenting, it probably isnâ„¢t worth running (Nagler, 1995) : What can I say, Nagler hit the nail on the head with this one.
Avoid decoration, i.e. do not use banner-like comments : In the 1960s and 1970s COBOL programmers got into the habit of drawing boxes, typically with asterisks, around their internal comments (NPS, 1996). Sure, it gave them an outlet for their artistic urges, but frankly it was a major waste of time that added little value to the end product. You want to write clean code, not pretty code. Furthermore, because many of the fonts used to display and print your code are proportional, and many arenâ„¢t, you canâ„¢t line up your boxes properly anyway.
Keep comments simple. Some of the best comments I have ever seen are simple, point-form notes. You do not have to write a book, you just have to provide enough information so that others can understand your code.
Write the documentation before you write the code. The best way to document code is to write the comments before you write the code. This gives you an opportunity to think about how the code will work before you write it and will ensure that the documentation gets written. Alternatively, you should at least document your code as you write it. Because documentation makes your code easier to understand you are able to take advantage of this fact while you are developing it. The way I look at it, if you are going to invest the time writing documentation you should at least get something out of it (Ambler, 1998a).
Document why something is being done, not just what. Fundamentally, I can always look at a piece of code and figure out what it does. For example, I can look at the code in Example 1 below and figure out that a 5% discount is being given on orders of $1,000 dollars or more. Why is this being done Is there a business rule that says that large orders get a discount Is there a limited-time special on large orders or is it a permanent program Was the original programmer just being generous I do not know unless it is documented somewhere, either in the source code itself or in an external document (Ambler, 1998a).
An Overview of J2EE
The following topics describe the J2EE Platform requirements for each kind of J2EE platform element.
J2EE Application Components
The J2EE runtime environment defines four application component types that a J2EE product must support:
Application clients are Java programming language programs that are typically GUI programs that execute on a desktop computer. Application clients offer a user experience similar to that of native applications, and have access to all of the facilities of the J2EE middle tier.
Applets are GUI components that typically execute in a web browser, but can execute in a variety of other applications or devices that support the applet-programming model. Applets can be used to provide a powerful user interface for J2EE applications. Servlets, JSP pages, filters, and web event listeners typically execute in a web container and may respond to HTTP requests from web clients. Servlets, JSP pages, and filters may be used to generate HTML pages that are an application™s user interface. They may also be used to generate XML or other format data that is consumed by other application components. A special kind of servlet provides support for web services using the SOAP/HTTP protocol. Servlets, pages created with the JavaServer Pages„¢ technology, web filters, and web event listeners are referred to collectively in this specification as web components. Web applications are composed of web components and other data such as HTML pages. Web components execute in a web container. A web server includes a web container and other protocol support, security support, and so on, as required by J2EE specifications. Enterprise JavaBeans„¢ (EJB) components execute in a managed environment that supports transactions. Enterprise beans typically contain the business logic for a J2EE application. Enterprise beans may directly provide web services using the SOAP/HTTP protocol.
J2EE Server Support for Application Components:
The J2EE servers provide deployment, management, and execution support for conforming application components. Application components can be divided into three categories according to their dependence on a J2EE server:
Components that are deployed, managed, and executed on a J2EE server. These components include web components and Enterprise JavaBeans components. See the separate specifications for these components.
Components that are deployed and managed on a J2EE server, but are loaded to and executed on a client machine. These components include web resources such as HTML pages and applets embedded in HTML pages.
Components deployment and management is not completely defined by this specification. Application Clients fall into this category. Future versions of this specification may more fully define deployment and management of Application Clients.
J2EE Containers
Containers provide the runtime support for J2EE application components. Containers provide a federated view of the underlying J2EE APIs to the application components. J2EE application components never interact directly with other J2EE application components.
J2EE Servers
Underlying a J2EE container is the server of which it is a part. A J2EE Product Provider typically implements the J2EE server-side functionality using an existing transaction processing infrastructure in combination with Java 2 Platform, Standard Edition (J2SE) technology. The J2EE client functionality is typically built on J2SE technology.
Resource Adapters
A resource adapter is a system-level software component that implements network connectivity to an external resource manager. A resource adapter can extend the functionality of the J2EE platform either by implementing one of the J2EE standard service APIs (such as a JDBC„¢ driver), or by defining and implementing a resource adapter for a connector to an external application system.
Java„¢ Transaction API (JTA)
The Java Transaction API consists of two parts:
An application-level demarcation interface is used by the container and application components to demarcate transaction boundaries. An interface between the transaction manager and a resource manager used at the J2EE SPI level (in a future release).
RMI-IIOP
The RMI-IIOP subsystem is composed of APIs that allow for the use of RMI-style programming that is independent of the underlying protocol, as well as an implementation of those APIs that supports both the J2SE native RMI protocol (JRMP) and the CORBA IIOP protocol. J2EE applications can use RMI-IIOP, with IIOP protocol support, to access CORBA services that are compatible with the RMI programming restrictions (see the RMI-IIOP spec for details).
JDBC„¢ API
The JDBC API is the API for connectivity with relational database systems. The JDBC API has two parts: an application-level interface used by the application components to access a database, and a service provider interface to attach a JDBC driver to the J2EE platform. Support for the service provider interface is not required in J2EE products.
Java Connector Architecture
The Connector architecture is a J2EE SPI that allows resource adapters that support access to Enterprise Information Systems to be plugged in to any J2EE product. The Connector architecture defines a standard set of system-level contracts between a J2EE server and a resource adapter.
Security Service
The Java„¢ Authentication and Authorization Service (JAAS) enables services to authenticate and enforce access controls upon users. It implements a Java technology version of the standard Pluggable Authentication Module (PAM) framework, and extends the access control architecture of the Java 2 Platform in a compatible fashion to support user-based authorization. The Java„¢ Authorization Service Provider Contract for Containers (JACC) defines a contract between a J2EE application server and an authorization service provider, allowing custom authorization service providers to be plugged into any J2EE product.
Deployment
The Java 2 Platform, Enterprise Edition Deployment Specification defines a contract between deployment tools and J2EE products. The J2EE products provide plug-in components that run in the deployment tool and allow the deployment tool to deploy applications into the J2EE product. The deployment tool provides services used by these plug-in components.
J2EE Architecture
Web Applications and Exploded Directory Format (EDF)
Overview of Web Applications
A Web application contains an applicationâ„¢s resources, such as servlets, JavaServer Pages (JSPs), JSP tag libraries, static resources such as HTML pages and image files. A Web Application can also define links to outside resources such as Enterprise Java Beans (EJBs). Web applications deployed on WebLogic Server use a standard J2EE deployment descriptor file and Web Logic-specific deployment descriptor file to define their resources and operating attributes. JSP and HTTP servlets can access all services and APIs available in Web Logic Server. These services include EJB, database connections via Java Database Connectivity (JDBC), Java Messaging Service (JMS), XML, and more. A Web archive (WAR file) contains the files that make up a Web application (WAR file). A WAR file is deployed as a unit on one or more Web Logic Server instances. A Web archive on Web Logic Server always includes the following files: One servlet or Java Server Page (JSP), along with any helper classes. A web.xml deployment descriptor, which is a J2EE standard XML document that describes the contents of a WAR file.A weblogic.xml deployment descriptor, which is an XML document containing Web Logic Server-specific elements for Web applications. A Web archive may also include HTML or XML pages and supporting files such as image and multimedia files. The WAR file can be deployed alone or packaged in an enterprise application archive (EAR file) with other application components. If deployed alone, the archive must end with a .war extension. If deployed in an EAR file, the archive must end with an .ear extension. BEA recommends that you package and deploy your stand-alone Web applications as part of an enterprise application. This is a BEA best practice, which allows for easier application migration, additions, and changes. Also, packaging your applications as part of an enterprise application allows you to take advantage of the split development directory structure, which provides a number of benefits over the traditional single directory structure.
Note: If you are deploying a directory in exploded format (not archived), do not name the directory .ear, .jar, and so on.
Web Application Directory Structure
Web applications use a standard directory structure defined in the J2EE specification. You can deploy a Web application as a collection of files that use this directory structure, known as exploded directory format, or as an archived file called a WAR file. BEA recommends that you package and deploy your WAR file as part of an enterprise application. This is a BEA best practice, which allows for easier application migration, additions, and changes. Also, packaging your Web application as part of an enterprise application allows you to take advantage of the split development directory structure, which provides a number of benefits over the traditional single directory structure. Web application components are assembled in a directory in order to stage the WAR file for the jar command. HTML pages, JSP pages, and the non-Java class files they reference are accessed beginning in the top level of the staging directory. The WEB-INF directory contains the deployment descriptors for the Web application (web.xml) and weblogic.xml) and two subdirectories for storing compiled Java classes and library JAR files. These subdirectories are respectively named classes and lib. JSP taglibs are stored in the Web Applications Basics WEB-INF directory at the top level of the staging directory. The Java classes include servlets, helper classes and, if desired, precompiled JSP. The entire directory, once staged, is bundled into a WAR file using the jar command. The WAR file can be deployed alone or as part of an enterprise application (recommended) with other application components, including other Web applications, EJB components, and Web Logic Server components. JSP pages and HTTP servlets can access all services and APIs available in Web Logic Server. These services include EJBs, database connections through Java Database Connectivity (JDBC), Java Message Service (JMS), XML, and more.
Main Steps to Create a Web Application
The following is an example of a Web application directory structure, in which myWebApp/ is the staging directory:
Web Application Directory Structure
An Overview of JSP
The Java Server Pages„¢ Technology
Java Server Pages„¢ technology is the Java„¢ technology in the J2EE platform for building applications containing dynamic Web content such as HTML, DHTML, XHTML and XML. The Java Server Pages technology enables the authoring of Web pages that create dynamic content easily but with maximum power and flexibility.
The Java Server Pages technology provides a textual description for the creation of a response from a request. The technology builds on the following concepts:
Template Data
Substantial portions of dynamic content is actually fixed. The JSP technology allow for the natural manipulation of this data.
Addition of Dynamic Data
The JSP technology allows the addition of dynamic data to the template data in a way that is simple yet powerful.
Encapsulation of Functionality
The JSP technology provides two related mechanisms for the encapsulation of functionality: the standard Java Beans component architecture and the tag library
mechanism.
Good Tool Support
The JSP technology has features that enable the creation of good authoring tools. The result is a flexible and powerful server-side technology.
Benefits of the Java Server Pages Technology
The Java Server Pages technology offers a number of benefits:
Write Once, Run Anywhere„¢ properties
The Java Server Pages technology is platform independent, both in its dynamic Web pages, Web servers, and its underlying server components. You can author JSP pages on any platform, run them on any Web server or Web enabled application server, and access them from any Web browser.
High quality tool support
The Write Once, Run Anywhere properties of JSP allows the user to choose best-of-breed tools. Additionally, an explicit goal of the Java Server Pages design is to enable the creation of high quality portable tools.
Separation of Roles
JSP supports the separation of roles: developers write components that interact with server-side objects.
Reuse of components and tag libraries
The Java Server Pages technology emphasizes the use of reusable components such as Java Beans„¢ components, Enterprise Java Beans„¢ components and tag libraries.
Separation of dynamic and static content
The Java Server Pages technology enables the separation of static content from dynamic content that is inserted into the static template.
Support for scripting and actions
The Java Server Pages technology supports scripting elements as well as actions. Actions permit the encapsulation of useful functionality in a convenient form that can also be manipulated by tools; scripts provide a mechanism to glue together this functionality in a per-page manner.
Web access layer for N-tier enterprise application architecture(s)
The Java Server Pages technology is an integral part of the Java 2 Platform Enterprise
Edition (J2EE), which brings Java technology to enterprise computing.
An Overview of Servlets
What is a Servlet
A servlet is a web component, managed by a container that generates dynamic content. Servlets are small, platform independent Java classes compiled to an architecture neutral byte code that can be loaded dynamically into and run by a web server. Servlets interact with web clients via a request response paradigm implemented by the servlet container. This request-response model is based on the behavior of the Hypertext Transfer Protocol (HTTP).
What is a Servlet Container
The servlet container, in conjunction with a web server or application server, provides the network services over which requests and responses are set, decodes MIME based requests, and formats MIME based responses. A servlet container also contains and manages servlets through their lifecycle. A servlet container can either be built into a host web server or installed as an add-on component to a Web Server via that serverâ„¢s native extension API. Servlet Containers can also be built into or possibly installed into web-enabled Application Servers. All servlet containers must support HTTP as a protocol for requests and responses, but may also support other request / response based protocols such as HTTPS (HTTP over SSL). The minimum required version of the HTTP specification that a container must implement is HTTP/1.0. It is strongly suggested that containers implement the HTTP/1.1 specification as well.
A Servlet Container may place security restrictions on the environment that a servlet can executed In a Java 2 Platform Standard Edition 1.2 (J2SE) or Java 2 Platform Enterprise Edition 1.3 (J2EE) environment, these restrictions should be placed using the permission architecture defined by Java 2 Platform. For example, high end application servers may limit certain action, such as the creation of a Thread object, to insure that other components of the container are not negatively impacted.
SYSTEM DESIGN
Data Dictionary
Table Name: action code
Field Name Type Constraint
Code varchar(25) primary key
Description varchar(100),
Table Name: activity
Field Name Type Constraint
Uid bigint auto_increment primary Key
Actv_obj_type varchar(60),
Actv_obj_id varchar(60),
person_id bigint not null,
Actv_dtm datetime not null,
Actv_type_cd varchar(25) not null,
Actv_desc varchar(200),
Table Name: actv_type
Field Name Type Constraint
Actv_type_cd varchar(25) primary key
Actv_type_dscr varchar(100) not null,
Void_ind bit not null,
Table Name: address
Field Name Type Constraint
Id bigint auto_increment, , primary key
address_1 varchar(50)
address_2 varchar(50)
City varchar(50)
State varchar(50)
Country varchar(10)
postal_code varchar(15)
Description varchar(80)
creat_prsn_id bigint
crt_dtm datetime
last_mod_id bigint
last_mod_dtm datetime
void_ind bit not null
TableName: audit_log
Field Name Type Constraint
aud_log_id bigint auto_increment primary key
aud_log_msg varchar(150) not null
aud_ent_id bigint not null
aud_ent_class varchar(250) not null
aud_prsn_id bigint not null
aud_log_date datetime not null
TableName: btch_info
Field Name Type Constraint
btch_id bigint not null
btch_typ_cd varchar(20) not null
btch_dsc varchar(80) not null
btch_sts varchar(255) not null
btch_cls_nm varchar(255) not null
btch_strt_dtm datetime not null
btch_end_dtm datetime not null
TableName: btch_log
Field Name Type Constraint
btch_log_id bigint auto_increment, primary key
btch_id bigint not null
btch_log_msg varchar(200) not null
btch_log_dtm datetime not null
btch_err bit not null
TableName: business_type
Field Name Type Constraint
bus_type_code varchar(30) primary key
bus_type_desc varchar(60) not null
void_ind Bit not null
TableName: cand_rjct_rsn
Field Name Type Constraint
code varchar(15) primary key
cand_rjct_desc varchar(60) not null
cand_rjct_void_ind Bit not null
TableName: candidate
Field Name Type Constraint
cand_id bigint auto_increment , primary key
person_id bigint not null unique
cand_look_full_ind bit not null
cand_look_part_ind bit not null
cand_look_ctrct_ind bit not null
cand_look_perm_ind bit bit not null
cand_cntct_ok_ind bit not null
cand_has_job_ind bit not null
bad_cntct_info_ind bit not null
cand_actv_ind bit not null
cand_trvl_pct Integer not null
cand_slry_min_amt numeric(12,2)
cand_slry_typ_code varchar(20)
last_actv_dtm datetime not null
void_ind bit not null
TableName: candidate_loc
Field Name Type Constraint
cand_loc_id bigint auto_increment primary key
cand_id bigint not null
location_id bigint not null
void_ind Bit not null
TableName: cmn_first_name
Field Name Type Constraint
name varchar(40) primary key
TableName: cmn_last_name
Field Name Type Constraint
name varchar(40) primary key
TableName: cmpy_addr
Field Name Type Constraint
cmpy_addr_id bigint auto_increment primary key
company_id Bigint
address_id Bigint
cmpy_addr_type_code varchar(30),
TableName: cmpy_addr_type
Field Name Type Constraint
cmpy_addr_type_code varchar(30) primary key
cmpy_addr_type_desc varchar(80) not null
cmpy_addr_excl_ind Bit not null
void_ind Bit not null
TableName: company
Field Name Type Constraint
company_id bigint auto_increment
cmpy_parent_id Bigint
cmpy_addr_id Bigint not null
cmpy_name varchar(60)
cmpy_code varchar(15)
cmpy_phone varchar(15)
cmpy_phone_2 varchar(15)
cmpy_lst_chg_dt Datetime
void_ind Bit
TableName: company_person
Field Name Type Constraint
uid bigint auto_increment primary key
company_id bigint not null
person_id bigint not null
strt_dt Datetime not null
end_dt Datetime
strt_schd_dt Datetime
end_schd_dt Datetime
job_slry_min_amt numeric(12,2)
slry_typ_code varchar(20)
void_ind Bit not null
TableName: company_person_role
Field Name Type Constraint
uid bigint auto_increment, primary key
role_type varchar(30) not null
cmp_person_id Bigint not null
date_start Bigint not null
date_end Datetime not null
date_end Datetime
date_strt_expct Datetime
date_end_expct Datetime
title varchar(60) not null
slry_amt numeric(12,2)
bill_rate_amt numeric(12,2)
slry_typ_code varchar(20)
void_ind Bit not null
TableName: company_role_type
Field Name Type Constraint
code varchar(30) primary key
role_desc varchar(60) not null
pers_ovrlp Bit not null
cmp_ovrlp Bit not null
void_ind Bit not null
TableName: contact_info
Field Name Type Constraint
cntct_info_id bigint auto_increment, primary key
person_id bigint not null unique,
cntct_info_email varchar(35),
cntct_info_html_email bit,
cntct_info_email_2 varchar(35),
cntct_info_html_email_2 bit,
cntct_info_cell_phn varchar(255),
cntct_info_wrk_phn varchar(255),
cntct_info_hom_phn varchar(255),
cntct_info_alt_phn varchar(255),
cntct_info_hom_addr bigint,
cntct_info_wrk_addr bigint,
TableName: country
Field Name Type Constraint
cntry_cd varchar(2) primary key
cntry_nm varchar(80) not null
cntry_ext_cd varchar(15)
cntry_num Bigint not null
void_ind Bit not null
TableName: email_resume
Field Name Type Constraint
Uid bigint auto_increment, primary key
from_email_addr varchar(160) not null
from_email_name varchar(90)
email_subj varchar(200) not null
sent_dtm Datetime not null
sts_cd varchar(20)
first_name varchar(40)
last_name varchar(40)
phone_number varchar(225)
TableName: email_resume_attch
Field Name Type Constraint
id bigint auto_increment, primary key
email_rsm_info_id b Igint not null
orig_file_nm varchar(255) not null
save_file_nm varchar(255) not null
attch_cat_cd varchar(20)
save_dtm Datetime not null
TableName: emplyr_rjct_rsn
Field Name Type Constraint
code varchar(15) primary key
emplyr_rjct_desc varchar(60) not null
emplyr_rjct_void_ind bit not null
TableName: event
Field Name Type Constraint
Id bigint auto_increment primary key
event_type_cd varchar(30) not null
event_dtm Datetime not null
proc_dtm Datetime
event_retry_cnt Bigint not null
event_dsc varchar(120) not null
event_sts varchar(30) not null
event_err varchar(120)
creat_prsn_id Bigint
crt_dtm Datetime
last_mod_id Bigint
last_mod_dtm Datetime
TableName: event_attch
Field Name Type Constraint
id bigint auto_increment primary key
event_attch_dsc varchar(60) not null
attch_obj_id varchar(60) not null
attch_obj_type_cd varchar(60) not null
event_id bigint not null
attch_seq_id Intege
TableName: event_ntf_usr_grp
Field Name Type Constraint
id bigint primary key
event_type_cd Varchar(30) not null
user_role_type_cd Varchar(30) not null
TableName: event_typ
Field Name Type Constraint
Code varchar(30) primary key
event_dsc varchar(60) not null
event_hdlr_clss varchar(200) not null
void_ind Bit not null
TableName: industry
Field Name Type Constraint
Code varchar(20) primary key
Description varchar(150) not null
TableName: interview
Field Name Type Constraint
Uid bigint auto_increment, primary key
job_id Bigint
intv_cand_id Bigint not null
intv_intvwr_id Bigint
intv_sts_typ varchar(20) not null
intv_rslt_txt varchar(100)
intv_ref_id varchar(15)
date_start Datetime
date_end Datetime
intv_desc varchar(200)
intv_note Text
intv_fllw_up varchar(200)
Voided Bit not null
TableName: intv_sts_type
Field Name Type Constraint
intv_sts_typ_cd varchar(20) primary key
intv_sts_typ_nm varchar(40)
intv_sts_typ_strt_dt Datetime not null
intv_sts_typ_end_dt Datetime
TableName: job_agent
Field Name Type Constraint
job_agt_id bigint auto_increment primary key
job_agt_cand_id bigint not null
job_agt_nm varchar(60 not null
job_agt_trvl_pct integer
job_agt_snd_fail_cnt integer not null
job_agt_days_back integer not null
job_agt_srch_phrs varchar(150) not null
ob_agt_srch_phr_cndtn nteger not null
job_agt_trg_dtm datetime not null
job_agt_crt_dt datetime not null
job_agt_actv bit not null
void_ind bit not null
TableName: job_agent_function
Field Name Type Constraint
job_agt_id Bigint primary key
function_code Bigint primary key
TableName: job_agent_location
Field Name Type Constraint
job_agt_id Bigint primary key
job_agnt_loctn_id Bigint primary key
TableName: job_agnt_func
Field Name Type Constraint
job_agt_id Bigint primary key
job_agnt_loctn_id Bigint primary key
TableName: job_agt_loctn
Field Name Type Constraint
job_agnt_loctn_id bigint auto_increment primary key
loc_id Bigint Not null
job_agnt_id Bigint Not null
TableName: job_appl
Field Name Type Constraint
job_app_id bigint auto_increment primary key
strt_dt datetime not null
end_dt datetime
job_appl_cvr_ltr text
job_app_rsm_id bigint not null
person_id bigint not null
job_id bigint not null
TableName: job_cand_cmpy_role
Field Name Type Constraint
Uid bigint auto_increment primary key
job_cand_id bigint not null
cmpy_prsn_role_id bigint not null
create_dtm Datetime not null
update_dtm Datetime not null
void_ind Bit not null
TableName: job_cand_offer
Field Name Type Constraint
job_cand_offr_id bigint auto_increment primary key
job_cand_id Bigint not null
offer_end_dtm Datetime not null
start_dtm Datetime not null
end_dtm Datetime
void_ind Bit not null
TableName: job_cand_rslt
Field Name Type Constraint
Uid Bigint auto_increment primary key
Person_id Bigint not null
job_id Bigint not null
calc_dtm Datetime not null
score Bigint not null
TableName: job_cand_sts
Field Name Type Constraint
job_cand_sts_id bigint auto_increment primary key
job_cand_id bigint not null
job_cand_sts_typ_cd varchar(20) not null
job_cand_sts_prsn_id bigint not null
job_cand_sts_strt_dt datetime not null
job_cand_sts_end_dt datetime
job_cand_sts_void_ind bit not null
TableName: job_cand_sts_type
Field Name Type Constraint
job_cand_sts_typ_cd varchar(20) Primary key
job_cand_sts_typ_dsc varchar(40)
job_cand_sts_typ_strt_dt Datetime not null
job_cand_sts_typ_end_dt Datetime
TableName: job_candidate
Field Name Type Constraint
job_cand_id bigint auto_increment Primary key
job_id bigint not null
cand_info_id bigint not null
src_prsn_id bigint
resume_id bigint
cover_ltr varchar(20)
job_cand_str bigint
skill_scr bigint
inact_rsn_cd varchar(20)
add_dtm Datetime
auto_add_dt Datetime
elgb_dtm Datetime
rjct_dtm Datetime
dcln_dtm Datetime
hire_dtm Datetime
void_ind bit not null
TableName: job_close_rsn
Field Name Type Constraint
Code varchar(15) primary key
job_close_rsn_desc varchar(60) not null
void_ind Bit not null
TableName: job_function
Field Name Type Constraint
Code varchar(20) primary key
Description varchar(230) not null
TableName: job_pay_type
Field Name Type Constraint
job_pay_typ_cd varchar(20) primary key
job_pay_typ_nm varchar(50) not null
void_ind bit not null
TableName: job_post
Field Name Type Constraint
Uid bigint auto_increment primary key
job_prnt_id Bigint
job_pay_typ_code varchar(20) not null
job_title varchar(120) not null
job_smry Text
job_ref_id varchar(30)
job_term_cd varchar(20) not null
job_shft_cd varchar(20) not null
job_cnt bigint not null
job_dur_amt Integer
job_wrk_schd_cd varchar(30)
job_srch_wrds varchar(200)
job_slry_min_amt numeric(12,2) not null
job_slry_typ_code varchar(20)
job_slry_max_amt numeric(12,2) not null
job_post_dtm datetime
job_lst_chng_dtm datetime
job_filled_dtm datetime
job_lst_skll_dtm datetime not null
job_trvl_pct bigint, not null
company_id bigint, not null
job_hrg_mgr_id bigint,
job_prim_recr_id bigint,
job_scnd_recr_id bigint,
job_src_id bigint,
job_src_cmpy_id bigint,
job_fncn_code varchar(20)
job_dsc Text
job_edu Text
job_rqd_sklls Text
job_cmpy_info varchar(200)
job_ftrd_ind bit not null
job_telcmt_ind bit not null
location_code Bigint
creat_prsn_id Bigint
crt_dtm Datetime
last_mod_id Bigint
last_mod_dtm Datetime
void_ind bit not null
TableName: job_role
Field Name Type Constraint
Uid bigint auto_increment primary key
job_id Bigint not null
Person_id Bigint not null
role varchar(30) not null
note Text
TableName: job_skill
Field Name Type Constraint
Uid bigint auto_increment, Primary key
skill_code varchar(50)
job_id Bigint not null
Parent_id Bigint
level Integer
Description varchar(240) not null
add_decay Bigint not null
chld_cjct_typ Integer
view_children Bit
TableName: job_status
Field Name Type Constraint
job_sts_id bigint auto_increment primary key
job_id Bigint not null
job_sts_typ_cd varchar(20) not null
job_sts_rsn_typ_cd varchar(20) not null
job_sts_prsn_id Bigint not null
job_sts_strt_dt Datetime not null
job_sts_end_dt Datetime
job_sts_pnd_pst_dt Datetime
job_sts_dsc varchar(180)
void_ind bit not null
TableName: job_sts_rsn_type
Field Name Type Constraint
job_sts_rsn_typ_cd varchar(20) Primary key
job_sts_rsn_typ_nm varchar(60) not null
void_ind bit not null
TableName: job_sts_rsn_type_xref
Field Name Type Constraint
sts_rsn_xref_id Bigint primary key
sts_typ_frm_cd varchar(20)
sts_typ_to_cd varchar(20) not null
sts_rsn_typ_to_cd varchar(20) not null
dflt_ind Bit not null
void_ind Bit not null
TableName: job_sts_type
Field Name Type Constraint
job_sts_typ_cd varchar(20) Primary key
job_sts_typ_dsc varchar(60) not null
job_sts_typ_strt_dt Datetime not null
job_sts_typ_end_dt Datetime
job_sts_typ_actv Bit not null
void_ind Bit not null
TableName: job_task
Field Name Type Constraint
job_task_id bigint auto_increment primary key
job_id Bigint not null
task_id Bigint not null
TableName: locale
Field Name Type Constraint
lcl_cd varchar(5) Primary key
lcl_desc varchar(120) not null
void_ind Bit not null
TableName: location
Field Name Type Constraint
loc_id Bigint primary key
loc_prnt_id Bigint
name varchar(120) not null
Description varchar(120)
void_ind Bit not null
TableName: object_history
Field Name Type Constraint
uid bigint auto_increment Primary key
obj_type varchar(255)
obj_id Bigint
person_id Bigint not null
date Datetime
action_code varchar(50)
Description varchar(200)
TableName: page_priv
Field Name Type Constraint
Uid Bigint primary key
pg_name varchar(200) not null
pg_desc varchar(200) not null
TableName: page_priv_role
Field Name Type Constraint
Uid Bigint Primary key
pg_priv_id Bigint not null
pg_usr_role varchar(30) not null
TableName: person
Field Name Type Constraint
person_id bigint auto_increment primary key
first_name varchar(30)
middle_name varchar(30)
last_name varchar(30)
title varchar(90)
known_as varchar(30)
dob Datetime
prefix varchar(10)
gender varchar(10)
marital_status varchar(10)
locale_cd varchar(5) not null
creat_prsn_id Bigint
crt_dtm Datetime
last_mod_id Bigint
last_mod_dtm Datetime
void_ind bit not null
TableName: post_code_loc
Field Name Type Constraint
post_cd varchar(20) primary key
post_cntry_id varchar(2) not null
post_loc_cd bigint not null
TableName: protect_res
Field Name Type Constraint
prot_res_cd varchar(30) primary key
prot_res_desc varchar(30) not null
TableName: protect_res_role
Field Name Type Constraint
uid bigint auto_increment, primary key
prot_res_cd varchar(30) not null
usr_role_typ_cd varchar(30) not null
TableName: prsn_addr
Field Name Type Constraint
prsn_addr_id bigint auto_increment primary key
person_id bigint
addr_id bigint
addr_type_code varchar(30)
TableName: prsn_addr_type
Field Name Type Constraint
prsn_addr_type_code varchar(30) primary key
prsn_addr_type_desc varchar(80) not null
prsn_addr_excl_ind Bit not null
void_ind Bit not null
TableName: prsn_skll_scr
Field Name Type Constraint
uid bigint auto_increment, primary key
skill_code varchar(50) not null
person_id bigint not null
score bigint not null
TableName: pwd_hint_quest
Field Name Type Constraint
pwd_hint_quest_cd varchar(20) primary key
pwd_hint_quest_txt varchar(80) not null
void_ind Bit not null
TableName: recr_cmpy_info
Field Name Type Constraint
recr_cmpy_id bigint auto_increment, primary key
recr_cmpy_job_info varchar(255)
recr_cmpy_cmpy_id bigint not null
recr_cmpy_lst_chg_dtm datetime not null
void_ind Bit not null
TableName: rsm_scn_btch
Field Name Type Constraint
rsm_scn_btch_id bigint auto_increment primary key
person_id Bigint not null
job_id Bigint
rsm_scn_btch_dt Datetime not null
rsm_scn_btch_dt Datetime
sm_scn_btch_shrd_ind Bit not null
rsm_scn_btch_exp_dt Datetime
rsm_scn_btch_sts Integer not null
rsm_scn_btch_dsc varchar(255) not null
Rsm_scn_btch_max_age Integer not null
rsm_scn_btch_incl_inact Bit
rsm_scn_btch_min_pct Bigint
rsm_scn_btch_min_cntt Bigint
rsm_scn_btch_max_cntt Bigint
TableName: rsm_scn_crit
Field Name Type Constraint
rsm_scn_crit_id bigint auto_increment primary key
rsm_scn_btch_id Bigint not null
rsm_scn_crit_phr varchar(255) not null
rsm_scn_crit_typ_cd varchar(255) not null
rsm_scn_crit_case Bit not null
rsm_scn_crit_wgt Integer not null
TableName: rsm_scn_rslt
Field Name Type Constraint
rsm_scn_rslt_id bigint auto_increment primary key
person_id bigint not null
rsm_scn_btch_id bigint not null
resume_id bigint not null
run_dt datetime not null
rsm_scn_rslt_scr integer not null
TableName: search_word
Field Name Type Constraint
id bigint auto_increment primary key
job_id bigint not null
phrase varchar(255) not null
weight Integer not null
in_title bit not null
TableName: sect_cont
Field Name Type Constraint
uid bigint auto_increment , primary key
title varchar(200) not null
content text not null
TableName: sect_info
Field Name Type Constraint
Uid bigint auto_increment , primary key
Title varchar(200) not null
TableName: service_request
Field Name Type Constraint
uid bigint auto_increment, primary key
person_id bit,
svc_req varchar(150) not null
svc_dtm Datetime not null
svc_sesn_id varchar(50) not null
svc_clnt_ip varchar(30)
svc_clnt_cntry_cd varchar(20)
svc_clnt_lang_cd varchar(20)
svc_clnt_param varchar(150)
TableName: skill
Field Name Type Constraint
Code varchar(50) not null
parent_code varchar(50)
score_method varchar(15) not null
Description varchar(200) not null
Section Bit not null
needs_rating Bit not null
add_decay Bigint not null
Weight Bigint
conj_type integer not null
Voided bit not null
TableName: skll_scr_mth_lvl
Field Name Type Constraint
id bigint auto_increment primary key
skill_id varchar(50) not null
skill_scr_meth_id varchar(15) not null
lvl_caption varchar(60) not null
lvl_val varchar(40) not null
score integer not null
void_ind Bit not null
TableName: skll_scr_mthd
Field Name Type Constraint
Code varchar(15) Primary key
skll_scr_mthd_desc varchar(60) not null
void_ind Bit not null
TableName slry_type
Field Name Type Constraint
slry_typ_cd varchar(20) primary key
slry_typ_nm varchar(50) not null
void_ind Bit not null
TableName srgt_key
Field Name Type Constraint
srgt_ky_cd varchar(30) primary key
srgt_ky_desc varchar(80) not null
srgt_ky_id bigint not null
srgt_ky_strt_id bigint not null
TableName: sys_const
Field Name Type Constraint
sys_cnst_cd varchar(50) primary key
sys_cnst_val varchar(200) not null
sys_cnst_typ varchar(20) not null
sys_cnst_dsc varchar(200) not null
TableName: task
Field Name Type Constraint
Id bigint auto_increment primary key
task_parent_id Bigint
task_typ_cd varchar(20) not null
task_dsc varchar(180) not null
task_est_secs Bigint not null
task_compl_prcnt Bigint not null
task_ref_code varchar(20)
creat_prsn_id Bigint
crt_dtm Datetime
last_mod_id Bigint
last_mod_dtm Datetime
task_due_dtm Datetime
task_start_dtm Datetime
task_end_dtm Datetime
task_act_strt_dtm Datetime
task_act_end_dtm Datetime
task_cat_cd varchar(255) not null
task_cmpny bigint not null
usr_task_ind bit not null
void_ind bit not null
TableName: task_attch
Field Name Type Constraint
Id bigint auto_increment Primary key
event_attch_dsc varchar(60) not null
attch_obj_id varchar(60) not null
attch_obj_type_cd varchar(60) not null
task_id Bigint not null
attch_seq_id Integer
TableName task_cat
Field Name Type Constraint
Code varchar(255) Primary key
task_dsc varchar(100) not null
void_ind bit not null
TableName: task_pre_req
Field Name Type Constraint
id bigint auto_increment primary key
task_id Bigint not null
pre_task_id Bigint not null
creat_prsn_id Bigint not null
crt_dtm Datetime not null
last_mod_prsn_id Bigint not null
last_mod_dtm Datetime not null
TableName: task_res
Field Name Type Constraint
Id bigint auto_increment Primary key
task_id Bigint not null
person_id Bigint not null
res_dsc varchar(120) not null
res_start_dtm Datetime
res_end_dtm Datetime
TableName: task_sts
Field Name Type Constraint
id Bigint auto_increment primary key
task_id Bigint not null
task_sts_chg_prsn_id Bigint not null
task_sts_type_cd varchar(25) not null
task_strt_dtm datetime not null
task_end_dtm datetime
TableName: task_sts_type
Field Name Type Constraint
Code varchar(25) Primary key
task_phrs_cd varchar(200) not null
void_ind Bit not null
TableName: user
Field Name Type Constraint
user_id bigint auto_increment Primary key
person_id Bigint not null unique
active Bit not null
user_name varchar(35) unique
user_pass varchar(15)
creat_prsn_id Bigint
crt_dtm Datetime
last_mod_id Bigint
last_mod_dtm Datetime
user_pass_hint_qwst_cd varchar(20)
user_pass_hint_ansr varchar(40)
TableName: user_eval
Field Name Type Constraint
Uid bigint auto_increment primary key
person_id Bigint not null
evaluator_id Bigint not null
Description Text
notes varchar(255)
date_created Datetime
date_performed Datetime
TableName: user_resume
Field Name Type Constraint
resume_id bigint auto_increment Primary key
cand_info_id Bigint not null
rsm_name varchar(50)
rsm_file_nm varchar(250)
rsm_file_attch_ind Bit
last_chg_dtm Datetime
last_indx_dtm Datetime not null
rsm_indx_err_ind bit not null
rsm_txt Text
active bit bit not null
TableName: user_role_type
Field Name Type Constraint
user_role_type_cd varchar(30) primary key
user_role_type_nm varchar(80) not null
user_role_priv_ind bit not null
user_role_grp_ind bit not null
user_role_type_strt_dtm Datetime not null
user_role_type_end_dtm Datetime
TableName: user_role_user_role_xref
Field Name Type Constraint
uid bigint auto_increment primary key
auth_usr_role_typ_cd varchar(30) not null
trgt_usr_role_typ_cd varchar(30) not null
prot_res_cd varchar(30) not null
TableName: user_roles
Field Name Type Constraint
Uid bigint auto_increment Primary key
role_name varchar(30) not null
role_group varchar(35)
role_usr_prvlg_ind Bit not null
role_membr_ind Bit not null
person_id Bigint not null
TableName: user_skill
Field Name Type Constraint
Uid bigint auto_increment primary key
skill_code varchar(50) not null
eval_id Bigint not null
person_id Bigint not null
score_meth_cd varchar(15) not null
level varchar(20) not null
view_children Bit
ER Diagram
ER Diagram
An E-R diagram can express the overall logical structure of a database graphically. The relative simplicity and pictorial clarity of this diagramming technique may well account in the large part for the wide spread use of the E-R model. Such a diagram consists of the following major components:
¢ Rectangles : Which represent entity sets.
¢ Ellipse : Which represents attributes.
¢ Diamond :Which represent relationship sets.
¢ Lines : Which page link attributes to entity sets to relationships sets.
ENTITY RELATION DIAGRAM
7
UNIFIED MODELLING LANGUAGE
An Overview of UML
The UML is a language for
¢ Visualizing
¢ Specifying
¢ Constructing
¢ Documenting
These are the artifacts of a software-intensive system.
A conceptual model of UML
The three major elements of UML are
¢ The UML™s basic building blocks
¢ The rules that dictate how those building blocks may be put together.