Electronic Claim Submission

We know that "Medical Billing is a Process of Submission of Bills/Claims to the Insurance Company in a specified format for the service rendered (for the treatment given) by the doctor for the patient."  And also we know that the most widely used form is Health Care Finance Admin-1500 designed by the Health Care Financing Administration (CMS 1500 or HCFA 1500).

But instead of Sending in Paper form, We can also use Electronic transmission of claims. Here are the advantages sending the claim electronically instead of paper claims.

1. Electronic Submission of Claims (Electronic Data Interchange or EDI) can help reduce paperwork, eliminate printing and mailing expenses, and improve claim   payment accuracy.
   
   
2. No concerns of claims being lost in transit, no concerns regarding data entry errors being made by insurance staff while processing claims, less rejections,   less turnaround time between the process of data and process of claim by the insurance company.
   
   
3. When you file an electronic claim, you also save valuable time. When a paper claim is filed, the U.S. mail may take a few days to deliver the claim. The  insurance company must digitize the information, then it must process the claim and, finally, the company has to mail the statement and reimbursement    back to you. With electronic claims, you send the claim through Internet connection. This takes as much time as picking up the telephone and calling the  company. The insurance carrier instantly receives the claim, the claim is already digitized and the company can process the claim immediately.
   

Now you may ask a  question, since Electronic claim transmission is acceptable and useful, then why do we need still to use CMS 1500 to send the claims.The answer is : we cannot completely wipe off the Paper format, because there are some scenario, you need to send only by paper claims. We will see later about that scenario

        

Read More

ZK MVVM Form Binding CRUD with Spring and Hibernate - Part 2

Create domain object and create DAO/Service layer.

        

In the Previous Part 1, we created our project using Maven. Now we will see how to add our middle tier layers.
Step 1:
First the Delete Package named “ZKBeanValidation ” which is created by default. Now Select “Java” folder and right click, Select New –> Other-> Package and enter the Package name as “zkexample.domain” as shown.

Now select the domain package and right click, Select New –> Other->Class and Enter the class name as UserProfile as shown here.

UserProfile.java Code.

package zkexample.domain;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@Table(name="userprofile")
public class UserProfile implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private long id;
	
	private String firstName;
	private String lastName;
	private String middleName;
	private String userAccountNumber;
	private String SSN;
	private String address1;
	private String address2;
	private String city;
	private String State;
	private String zipCode;
	private String email;
	private String userLoginID;
	private String password;
	
	@Temporal(TemporalType.DATE)
	private Date DOB;
	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public String getMiddleName() {
		return middleName;
	}

	public void setMiddleName(String middleName) {
		this.middleName = middleName;
	}

	public String getUserAccountNumber() {
		return userAccountNumber;
	}

	public void setUserAccountNumber(String userAccountNumber) {
		this.userAccountNumber = userAccountNumber;
	}

	 
	public Date getDOB() {
		return DOB;
	}

	public void setDOB(Date dOB) {
		DOB = dOB;
	}

	public String getSSN() {
		return SSN;
	}

	public void setSSN(String sSN) {
		SSN = sSN;
	}

	public String getAddress1() {
		return address1;
	}

	public void setAddress1(String address1) {
		this.address1 = address1;
	}

	public String getAddress2() {
		return address2;
	}

	public void setAddress2(String address2) {
		this.address2 = address2;
	}

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}

	public String getState() {
		return State;
	}

	public void setState(String state) {
		State = state;
	}

	public String getZipCode() {
		return zipCode;
	}

	public void setZipCode(String zipCode) {
		this.zipCode = zipCode;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getUserLoginID() {
		return userLoginID;
	}

	public void setUserLoginID(String userLoginID) {
		this.userLoginID = userLoginID;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

}

Step 2:
Next we will create our DAO Layer. Select the java folder and right click, Select New –> Other->Package and enter the package name as zkxample.dao. After package is created, select the package dao and right click, select New-> Other->Interface and enter the interface name as “CRUDDao”

package zkexample.dao;

import java.util.List;

public interface CRUDDao {
	<T> List<T> getAll(Class<T> klass);

	<T> void Save(T klass);

	<T> void delete(T klass);
}

Now let us create the DAO Class which implement the above interface. Select the package dao and right click, select New-> Other->class  and enter the class name as "CRUDDaoImpl” as shown

package zkexample.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class CRUDDaoImpl implements CRUDDao {

	@Autowired
	SessionFactory sessionFactory;

	@SuppressWarnings("unchecked")
	public <T> List<T> getAll(Class<T> klass) {
		return getCurrentSession().createQuery("from " + klass.getName())
				.list();
	}

	protected final Session getCurrentSession() {
		return sessionFactory.getCurrentSession();
	}

	public <T> void Save(T klass) {
		getCurrentSession().save(klass);
	}

	public <T> void delete(T klass) {
		getCurrentSession().delete(klass);

	}

}

Hibernate 3 provides a feature called "contextual Sessions", where Hibernate itself manages one current Session per transaction. This is roughly equivalent to Spring's synchronization of one Hibernate Session per transaction.The main advantage of this DAO style is that it depends on Hibernate API only; no import of any Spring class is required.

For more information, Please refer the following links
1. The Persistence Layer with Spring 3.1 and Hibernate
2. Spring Integration with Hibernate
3. Implementing DAOs based on plain Hibernate 3 API

Step 3:
Now let us create our service layer.
Select the zkxample package, and right click, select New-> Other->Interface and enter the interface name as “CRUDService”

package zkexample.service;

import java.util.List;

public interface CRUDService {
	<T> List<T> getAll(Class<T> klass);

	<T> void Save(T klass);

	<T> void delete(T klass);
}

Now let us create the Service Class which implement the above interface. Select the package service and right click, select New-> Other->class and enter the class name as "CRUDServiceImpl” as shown

package zkexample.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import zkexample.dao.CRUDDao;

@Service
public class CRUDServiceImpl implements CRUDService {

	@Autowired
	private CRUDDao CRUDDao;

	@Transactional(readOnly = true)
	public <T> List<T> getAll(Class<T> klass) {
		return CRUDDao.getAll(klass);
	}

	@Transactional
	public <T> void Save(T klass) {
		CRUDDao.Save(klass);
	}

	@Transactional
	public <T> void delete(T klass) {
		CRUDDao.delete(klass);
	}

}

In the next part 3, we will see how we can integrate Spring with Hibernate.

        

Read More

ZK MVVM Form Binding CRUD with Spring and Hibernate - Part 1

Create Maven Project

        

In this post, let us see how to create ZK Maven Project

Step 1:
In the eclipse IDE, Select File –> New-> Other->Maven Project as shown

Click Next

Uncheck the option “Create a simple Project(skip archetype selection) and Click Next

Select “ZK” for catalog and Select “org.zkoss zk-archetype-webapp 6.0” from the list as shown above.

Enter “ZKBeanValidation” for Group ID, Artifact ID and Package as shown above. Finally click finish to create the Project.
Now Maven will create the project structure as shown here.

Step 2:
Next we will update POM.XML. By default, Maven ZK will create 6.0.1 version. Let us change to latest version “6.5.2” . And also, let us remove the ZK Commercial version Repository in the POM.XML File. We will add the dependency for Spring, Hibernate and Mysql. Here is the complete final POM.XML File.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>ZKBeanValidation</groupId>
	<artifactId>ZKBeanValidation</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<properties>
		<zk.version>6.5.2</zk.version>
		<commons-io>1.3.1</commons-io>
		<maven.build.timestamp.format>yyyy-MM-dd</maven.build.timestamp.format>
		<packname>-${project.version}-FL-${maven.build.timestamp}</packname>
		<spring.version>3.2.0.RELEASE</spring.version>
	</properties>
	<packaging>war</packaging>
	<name>The ZKBeanValidation Project</name>
	<description>The ZKBeanValidation Project</description>
	<licenses>
		<license>
			<name>GNU LESSER GENERAL PUBLIC LICENSE, Version 3</name>
			<url>http://www.gnu.org/licenses/lgpl.html</url>
			<distribution>repo</distribution>
		</license>
	</licenses>
	<repositories>
		<repository>
			<id>ZK CE</id>
			<name>ZK CE Repository</name>
			<url>http://mavensync.zkoss.org/maven2</url>
		</repository>
		 
	</repositories>
	<pluginRepositories>
		<pluginRepository>
			<id>zkmaven</id>
			<name>ZK Maven Plugin Repository</name>
			<url>http://mavensync.zkoss.org/maven2/</url>
		</pluginRepository>
	</pluginRepositories>
	<dependencies>
		<dependency>
			<groupId>org.zkoss.zk</groupId>
			<artifactId>zkbind</artifactId>
			<version>${zk.version}</version>
		</dependency>
		<dependency>
			<groupId>org.zkoss.zk</groupId>
			<artifactId>zul</artifactId>
			<version>${zk.version}</version>
		</dependency>
		<dependency>
			<groupId>org.zkoss.zk</groupId>
			<artifactId>zkplus</artifactId>
			<version>${zk.version}</version>
		</dependency>
		<dependency>
			<groupId>org.zkoss.zk</groupId>
			<artifactId>zhtml</artifactId>
			<version>${zk.version}</version>
		</dependency>
		
		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>${commons-io}</version>
		</dependency>

<!-- Spring framework -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency> <!-- Used for Hibernate4 LocalSessionFactoryBean -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- AOP dependency -->
		<dependency>
			<groupId>cglib</groupId>
			<artifactId>cglib</artifactId>
			<version>2.2.2</version>
		</dependency>

		<!-- Persistence Management -->
		<dependency> <!-- Apache BasicDataSource -->
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.2.2</version>
		</dependency>

		<dependency> <!-- MySQL database driver -->
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.20</version>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>4.1.10.Final</version>
		</dependency>		
		<!-- ZK 5 breeze theme
		<dependency>
			<groupId>org.zkoss.theme</groupId>
			<artifactId>breeze</artifactId>
			<version>${zk.version}</version>
			<optional>true</optional>
		</dependency>
		 -->
	</dependencies>
	<build>
		<finalName>${project.artifactId}</finalName>
		<plugins>
			<!-- Run with Jetty -->
			<plugin>
				<groupId>org.mortbay.jetty</groupId>
				<artifactId>maven-jetty-plugin</artifactId>
				<version>6.1.10</version>
				<configuration>
					<scanIntervalSeconds>5</scanIntervalSeconds>
					<stopKey>foo</stopKey>
					<stopPort>9999</stopPort>
				</configuration>
				<executions>
					<execution>
						<id>start-jetty</id>
						<phase>pre-integration-test</phase>
						<goals>
							<goal>run</goal>
						</goals>
						<configuration>
							<scanIntervalSeconds>0</scanIntervalSeconds>
							<daemon>true</daemon>
						</configuration>
					</execution>
					<execution>
						<id>stop-jetty</id>
						<phase>post-integration-test</phase>
						<goals>
							<goal>stop</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<!-- Compile java -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.3.2</version>
				<configuration>
					<source>1.5</source>
					<target>1.5</target>
				</configuration>
			</plugin>
			<!-- Build war -->
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<groupId>org.apache.maven.plugins</groupId>
				<version>2.1.1</version>
			</plugin>
			<!-- Pack zips -->
			<plugin>
				<artifactId>maven-assembly-plugin</artifactId>
				<version>2.2</version>
				<executions>
					<execution>
						<id>webapp</id>
						<phase>package</phase>
						<goals>
							<goal>single</goal>
						</goals>
						<configuration>
							<finalName>ZKBeanValidation${packname}</finalName>
							<appendAssemblyId>false</appendAssemblyId>
							<descriptors>
								<descriptor>assembly/webapp.xml</descriptor>
							</descriptors>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
</project>

In the next part 2, we will create domain,DAO and service layers.

        

 

Read More

Medical Billing–Patient Insurance

Patient Insurance

We know that, patient has to give his insurance information to the Doctor before the treatment. Collecting the patient insurance information is very important data entry part to avoid delayed or denials.

Either at the time of appointment or at the time of patient visit the practice(Check in), patient insurance information has to be collected. If it is existing patient, then we need to verify the existing patient insurance information which is already in the file(or computer system).

Very Important. For New Patient, we need to collect signed copy of HIPAA consent form. For more details, please check here.

The following information has to collect from the patient

1. Insurance Company Name

2. Policy No (Unique number to identify the patient within the insurance system)

3. Policy Group No (Identifies in which plan the patient enrolled with the insurance company)

4. Effective Date (From which date, benefits or covered services are allowed)

5. Relationship to the Patient(Patient may have the insurance on his name, or he/she may be covered by one of the family member)

6. Insured details such as first name, last name, etc if the patient is not the same as insurer.

7. Copay and deductible amount

And also, we need to scan the patient insurance card back and front part into the system. Sample Insurance card here.

        

Read More

ZK + Spring Security Login form– Additional Login Parameters - Part 4

Extra Spring Login Parameters.

In the last article, we have seen the complete implementation of Spring security Login without Database connection.  In this post, we will see how we can pass additional parameters from the login screen to validate. For example, in the bigger application, apart from user name and password, you may also need to get domain or company name or Client ID, etc..

So our Login screen will look like this

Thanks to the following post from which I frame this example
Two-Factor Authentication and Spring Security 3

Technologies used in this example:

1. ZK 6.5.1 CE Version.
2. Spring-security-core 3.0.5

Step 1:
Download this document and setup the development environment.

Step 2:
Let us create ZK Maven Project. Follow the below instruction.
In the Eclipse IDE, Select File –> New-> Other-> Maven Project as shown here.

Click Next.

Uncheck the option “Create a simple Project(skip archetype selection) and Click next.

Select “ZK” in the catalog and select “ZK-archetype-webapp 6.0” as shown here."

Click Next after selecting the ZK Archetype.

Enter “zkloginexample4” for Group ID, Artifact id and Package. And important, please select “ZK-Version-since” from the bottom list and then select finish.
Now, the following folder structure will be created.


Step 3:
Next we will include the spring dependency in the POM File.
Double click the POM.XML file in the project navigator.

Click on the POM.XML tab. The following modification has been done.
1. Change the ZK Version to latest CE Version.
2. Remove the Maven ZK EE Version Repository.
3. Add the spring security dependency.
Here is the modified POM.XML file.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>zkloginexample4</groupId>
	<artifactId>zkloginexample4</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<properties>
		<zk.version>6.5.1</zk.version>
		<commons-io>1.3.1</commons-io>
		<maven.build.timestamp.format>yyyy-MM-dd</maven.build.timestamp.format>
		<packname>-${project.version}-FL-${maven.build.timestamp}</packname>
	</properties>
	<packaging>war</packaging>
	<name>The zkloginexample4 Project</name>
	<description>The zkloginexample4 Project</description>
	<licenses>
		<license>
			<name>GNU LESSER GENERAL PUBLIC LICENSE, Version 3</name>
			<url>http://www.gnu.org/licenses/lgpl.html</url>
			<distribution>repo</distribution>
		</license>
	</licenses>
	<repositories>
		<repository>
			<id>ZK CE</id>
			<name>ZK CE Repository</name>
			<url>http://mavensync.zkoss.org/maven2</url>
		</repository>
		<repository>
			<id>ZK EVAL</id>
			<name>ZK Evaluation Repository</name>
			<url>http://mavensync.zkoss.org/eval</url>
		</repository>
	</repositories>
	<pluginRepositories>
		<pluginRepository>
			<id>zkmaven</id>
			<name>ZK Maven Plugin Repository</name>
			<url>http://mavensync.zkoss.org/maven2/</url>
		</pluginRepository>
	</pluginRepositories>
	<dependencies>
		<dependency>
			<groupId>org.zkoss.zk</groupId>
			<artifactId>zkbind</artifactId>
			<version>${zk.version}</version>
		</dependency>
		<dependency>
			<groupId>org.zkoss.zk</groupId>
			<artifactId>zul</artifactId>
			<version>${zk.version}</version>
		</dependency>
		<dependency>
			<groupId>org.zkoss.zk</groupId>
			<artifactId>zkplus</artifactId>
			<version>${zk.version}</version>
		</dependency>
		<dependency>
			<groupId>org.zkoss.zk</groupId>
			<artifactId>zhtml</artifactId>
			<version>${zk.version}</version>
		</dependency>

		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>${commons-io}</version>
		</dependency>
		<!-- Spring Security -->
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-core</artifactId>
			<version>3.0.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-web</artifactId>
			<version>3.0.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-config</artifactId>
			<version>3.0.5.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
		</dependency>

		<!-- ZK 5 breeze theme <dependency> <groupId>org.zkoss.theme</groupId> 
			<artifactId>breeze</artifactId> <version>${zk.version}</version> <optional>true</optional> 
			</dependency> -->
	</dependencies>
	<build>
		<finalName>${project.artifactId}</finalName>
		<plugins>
			<!-- Run with Jetty -->
			<plugin>
				<groupId>org.mortbay.jetty</groupId>
				<artifactId>maven-jetty-plugin</artifactId>
				<version>6.1.10</version>
				<configuration>
					<scanIntervalSeconds>5</scanIntervalSeconds>
					<stopKey>foo</stopKey>
					<stopPort>9999</stopPort>
				</configuration>
				<executions>
					<execution>
						<id>start-jetty</id>
						<phase>pre-integration-test</phase>
						<goals>
							<goal>run</goal>
						</goals>
						<configuration>
							<scanIntervalSeconds>0</scanIntervalSeconds>
							<daemon>true</daemon>
						</configuration>
					</execution>
					<execution>
						<id>stop-jetty</id>
						<phase>post-integration-test</phase>
						<goals>
							<goal>stop</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<!-- Compile java -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.3.2</version>
				<configuration>
					<source>1.5</source>
					<target>1.5</target>
				</configuration>
			</plugin>
			<!-- Build war -->
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<groupId>org.apache.maven.plugins</groupId>
				<version>2.1.1</version>
			</plugin>
			<!-- Pack zips -->
			<plugin>
				<artifactId>maven-assembly-plugin</artifactId>
				<version>2.2</version>
				<executions>
					<execution>
						<id>webapp</id>
						<phase>package</phase>
						<goals>
							<goal>single</goal>
						</goals>
						<configuration>
							<finalName>zkloginexample4${packname}</finalName>
							<appendAssemblyId>false</appendAssemblyId>
							<descriptors>
								<descriptor>assembly/webapp.xml</descriptor>
							</descriptors>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
</project>

Step 4:
Next step we will update web.xml to take care spring filter.
Here is the updated web.xml file.

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

	<description><![CDATA[My ZK Application]]></description>
	<display-name>zkloginexample4</display-name>

	<!-- ====================================================== -->
	<!-- CONFIGURATION FILES -->
	<!-- ====================================================== -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			/WEB-INF/spring-security.xml
 		</param-value>
	</context-param>

	<!-- ====================================================== -->
	<!-- SPRING CONTEXT LOADER -->
	<!-- ====================================================== -->

	<!-- The org.springframework.web.context.ContextLoaderListener class uses 
		a context parameter called contextConfigLocation to determine the location 
		of the Spring configuration file. The context parameter is configured using 
		the context-parameter element. The context-param element has two children 
		that specify parameters and their values. The param-name element specifies 
		the parameter's name. The param-value element specifies the parameter's value -->

	<listener>
		<display-name>Spring Context Loader</display-name>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- Spring Security -->
	<!-- A servlet filter capturing every user requests and sending them to 
		the configured security filters to make sure access is authorized. -->
	<filter>
		<filter-name>springSecurityFilterChain</filter-name>
		<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
	</filter>

	<filter-mapping>
		<filter-name>springSecurityFilterChain</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>


	<!-- //// -->
	<!-- ZK -->
	<listener>
		<description>ZK listener for session cleanup</description>
		<listener-class>org.zkoss.zk.ui.http.HttpSessionListener</listener-class>
	</listener>
	<servlet>
		<description>ZK loader for ZUML pages</description>
		<servlet-name>zkLoader</servlet-name>
		<servlet-class>org.zkoss.zk.ui.http.DHtmlLayoutServlet</servlet-class>

		<!-- Must. Specifies URI of the update engine (DHtmlUpdateServlet). It 
			must be the same as <url-pattern> for the update engine. -->
		<init-param>
			<param-name>update-uri</param-name>
			<param-value>/zkau</param-value>
		</init-param>
		<!-- Optional. Specifies whether to compress the output of the ZK loader. 
			It speeds up the transmission over slow Internet. However, if you configure 
			a filter to post-processing the output, you might have to disable it. Default: 
			true <init-param> <param-name>compress</param-name> <param-value>true</param-value> 
			</init-param> -->
		<!-- [Optional] Specifies the default log level: OFF, ERROR, WARNING, INFO, 
			DEBUG and FINER. If not specified, the system default is used. <init-param> 
			<param-name>log-level</param-name> <param-value>OFF</param-value> </init-param> -->
		<load-on-startup>1</load-on-startup><!-- Must -->
	</servlet>
	<servlet-mapping>
		<servlet-name>zkLoader</servlet-name>
		<url-pattern>*.zul</url-pattern>
	</servlet-mapping>
	<servlet-mapping>
		<servlet-name>zkLoader</servlet-name>
		<url-pattern>*.zhtml</url-pattern>
	</servlet-mapping>
	<!-- [Optional] Uncomment it if you want to use richlets. <servlet-mapping> 
		<servlet-name>zkLoader</servlet-name> <url-pattern>/zk/*</url-pattern> </servlet-mapping> -->
	<servlet>
		<description>The asynchronous update engine for ZK</description>
		<servlet-name>auEngine</servlet-name>
		<servlet-class>org.zkoss.zk.au.http.DHtmlUpdateServlet</servlet-class>

		<!-- [Optional] Specifies whether to compress the output of the ZK loader. 
			It speeds up the transmission over slow Internet. However, if your server 
			will do the compression, you might have to disable it. Default: true <init-param> 
			<param-name>compress</param-name> <param-value>true</param-value> </init-param> -->
		<!-- [Optional] Specifies the AU extension for particular prefix. <init-param> 
			<param-name>extension0</param-name> <param-value>/upload=com.my.MyUploader</param-value> 
			</init-param> -->
	</servlet>
	<servlet-mapping>
		<servlet-name>auEngine</servlet-name>
		<url-pattern>/zkau/*</url-pattern>
	</servlet-mapping>

	<!-- [Optional] Uncomment if you want to use the ZK filter to post process 
		the HTML output generated by other technology, such as JSP and velocity. 
		<filter> <filter-name>zkFilter</filter-name> <filter-class>org.zkoss.zk.ui.http.DHtmlLayoutFilter</filter-class> 
		<init-param> <param-name>extension</param-name> <param-value>html</param-value> 
		</init-param> <init-param> <param-name>compress</param-name> <param-value>true</param-value> 
		</init-param> </filter> <filter-mapping> <filter-name>zkFilter</filter-name> 
		<url-pattern>your URI pattern</url-pattern> </filter-mapping> -->
	<!-- //// -->

	<!-- ///////////// -->
	<!-- DSP (optional) Uncomment it if you want to use DSP However, it is turned 
		on since zksandbox uses DSP to generate CSS. <servlet> <servlet-name>dspLoader</servlet-name> 
		<servlet-class>org.zkoss.web.servlet.dsp.InterpreterServlet</servlet-class> 
		<init-param> <param-name>class-resource</param-name> <param-value>true</param-value> 
		</init-param> </servlet> <servlet-mapping> <servlet-name>dspLoader</servlet-name> 
		<url-pattern>*.dsp</url-pattern> </servlet-mapping> -->

	<!-- /////////// -->
	<!-- [Optional] Session timeout -->
	<session-config>
		<session-timeout>60</session-timeout>
	</session-config>

	<!-- [Optional] MIME mapping -->
	<mime-mapping>
		<extension>doc</extension>
		<mime-type>application/vnd.ms-word</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>gif</extension>
		<mime-type>image/gif</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>htm</extension>
		<mime-type>text/html</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>html</extension>
		<mime-type>text/html</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>jpeg</extension>
		<mime-type>image/jpeg</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>jpg</extension>
		<mime-type>image/jpeg</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>js</extension>
		<mime-type>text/javascript</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>pdf</extension>
		<mime-type>application/pdf</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>png</extension>
		<mime-type>image/png</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>txt</extension>
		<mime-type>text/plain</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>xls</extension>
		<mime-type>application/vnd.ms-excel</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>xml</extension>
		<mime-type>text/xml</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>zhtml</extension>
		<mime-type>text/html</mime-type>
	</mime-mapping>
	<mime-mapping>
		<extension>zul</extension>
		<mime-type>text/html</mime-type>
	</mime-mapping>

	<welcome-file-list>
		<welcome-file>index.zul</welcome-file>
		<welcome-file>index.zhtml</welcome-file>
		<welcome-file>index.html</welcome-file>
		<welcome-file>index.htm</welcome-file>
	</welcome-file-list>
</web-app>

Step 5:
As you can see in the web.xml file, we are loading new xml file configuration named as “spring-security.xml”.
Select the Folder “WEB-INF”, right click, Select New->Other-XML File and give the file name as “spring-security.xml”

Paste the following content

<!-- Spring namespace-based configuration -->

<beans:beans xmlns="http://www.springframework.org/schema/security"
	xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	       http://www.springframework.org/schema/aop   
		   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd                        
           http://www.springframework.org/schema/security
           http://www.springframework.org/schema/security/spring-security-3.0.xsd">

	<!-- ====================================================== -->
	<!-- For catching the @Secured annotation methods -->
	<!-- Tells the Spring Security engine that we will use Spring Security's -->
	<!-- pre and post invocation Java annotations (@PreFilter, @PreAuthorize, -->
	<!-- @PostFilter, -->
	<!-- @PostAuthorize) to secure service layer methods.. -->
	<!-- Look in GFCBaseCtrl.java onEvent() method. -->
	<!-- ====================================================== -->

	<!-- Enable the @Secured annotation to secure service layer methods -->
	<global-method-security secured-annotations="enabled" />


	<beans:bean id="languageFilter"
		class="zkloginexample4.ExUsernamePasswordAuthenticationFilter">
		<beans:property name="authenticationManager" ref="authenticationManager" />
		<beans:property name="authenticationFailureHandler"
			ref="failureHandler" />
	</beans:bean>


	<http entry-point-ref="loginUrlAuthenticationEntryPoint">
		<intercept-url pattern="/login.zul" access="IS_AUTHENTICATED_ANONYMOUSLY" />
		<intercept-url pattern="/*.zul" access="IS_AUTHENTICATED_REMEMBERED" />
		<intercept-url pattern="/zk/*" access="IS_AUTHENTICATED_REMEMBERED" />
		<custom-filter position="FORM_LOGIN_FILTER" ref="languageFilter" />
		<logout />
	</http>


	<beans:bean id="loginUrlAuthenticationEntryPoint"
		class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint">
		<beans:property name="loginFormUrl" value="/login.zul" />
	</beans:bean>


	<beans:bean id="failureHandler"
		class="org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler">
		<beans:property name="defaultFailureUrl" value="/login.zul?login_error=1" />
	</beans:bean>

	<authentication-manager alias="authenticationManager">
		<authentication-provider user-service-ref="myUserDetailsService">
			<password-encoder hash="md5" />
		</authentication-provider>
	</authentication-manager>

	<beans:bean id="myUserDetailsService" class="zkloginexample4.MyUserDetailsService" />


</beans:beans>

You can see here, we have setup our own Entry point
The first thing we need to do is extend the UsernamePasswordAuthenticationFilter class so that it can handle a second input field.
So we will create a class under the default package zkloginexample4. Here is the class definition

package zkloginexample4;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

public class ExUsernamePasswordAuthenticationFilter extends
		UsernamePasswordAuthenticationFilter {

	private String extraParameter = "Company";
    private String delimiter = ":";

	@Override
	public Authentication attemptAuthentication(HttpServletRequest request,
			HttpServletResponse response) throws AuthenticationException {
		String dbValue = request.getParameter("Company");

		System.out.println("Value is " + dbValue);
		request.getSession().setAttribute("dbValue", dbValue);
		return super.attemptAuthentication(request, response);
	}

	@Override
	protected String obtainUsername(HttpServletRequest request) {
		String username = request.getParameter(getUsernameParameter());
		String extraInput = request.getParameter(getExtraParameter());

		String combinedUsername = username + getDelimiter() + extraInput;

		System.out.println("Combined username = " + combinedUsername);
		return combinedUsername;
	}

	/**
	 * @return The parameter name which will be used to obtain the extra input
	 *         from the login request
	 */
	public String getExtraParameter() {
		return this.extraParameter;
	}

	/**
	 * @param extraParameter
	 *            The parameter name which will be used to obtain the extra
	 *            input from the login request
	 */
	public void setExtraParameter(String extraParameter) {
		this.extraParameter = extraParameter;
	}

	/**
	 * @return The delimiter string used to separate the username and extra
	 *         input values in the string returned by
	 *         <code>obtainUsername()</code>
	 */
	public String getDelimiter() {
		return this.delimiter;
	}

	/**
	 * @param delimiter
	 *            The delimiter string used to separate the username and extra
	 *            input values in the string returned by
	 *            <code>obtainUsername()</code>
	 */
	public void setDelimiter(String delimiter) {
		this.delimiter = delimiter;
	}
}

As you can see, we have created additional two java classes such as DbUser.java and UserDAO.java. So let us create this two classes in the package zkloginexample4 as shown.


Here is the code for DBUser.Java

package zkloginexample4;

public class DbUser {

	/**
	 * The username
	 */
	private String username;

	/**
	 * The password as an MD5 value
	 */
	private String password;

	/**
	 * Access level of the user. 1 = Admin user 2 = Regular user
	 */
	private Integer access;

	/**
	 * The company Name
	 */
	private String companyName;
	
	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public Integer getAccess() {
		return access;
	}

	public void setAccess(Integer access) {
		this.access = access;
	}

	public String getCompanyName() {
		return companyName;
	}

	public void setCompanyName(String companyName) {
		this.companyName = companyName;
	}
	
}

Here is the code for UserDAO.java

package zkloginexample4;

import java.util.ArrayList;
import java.util.List;

public class UserDAO {

	/**
	 * Simulates retrieval of data from a database.
	 * http://krams915.blogspot.in/2010/12/spring-security-mvc-integration_18.html
	 */
	public DbUser searchDatabase(String username, String companyName) {
		// Retrieve all users from the database
		List<DbUser> users = internalDatabase();

		// Search user based on the parameters
		for (DbUser dbUser : users) {
			if (dbUser.getUsername().equals(username) == true &&  dbUser.getCompanyName().equals(companyName) == true) {
				// return matching user
				return dbUser;
			}
		}
		System.out.println("Not Exists");
		throw new RuntimeException("User does not exist!");
	}

	/**
	 * Our fake database. Here we populate an ArrayList with a dummy list of
	 * users.
	 */
	private List<DbUser> internalDatabase() {
		// Dummy database

		// Create a dummy array list
		List<DbUser> users = new ArrayList<DbUser>();
		DbUser user = null;

		// Create a new dummy user
		user = new DbUser();
		user.setUsername("rod");
		// Actual password: admin
		user.setPassword("a564de63c2d0da68cf47586ee05984d7");
		// Admin user
		user.setAccess(1);
		user.setCompanyName("abc");

		// Add to array list
		users.add(user);

		// Create a new dummy user
		user = new DbUser();
		user.setUsername("dianne");
		// Actual password: user
		user.setPassword("65d15fe9156f9c4bbffd98085992a44e");
		// Regular user
		user.setAccess(2);
		user.setCompanyName("abc");

		// Add to array list
		users.add(user);

		// Create a new dummy user
		user = new DbUser();
		user.setUsername("scott");
		// Actual password: user
		user.setPassword("2b58af6dddbd072ed27ffc86725d7d3a");
		// Regular user
		user.setAccess(2);
		user.setCompanyName("abc");

		// Add to array list
		users.add(user);

		// Create a new dummy user
		user = new DbUser();
		user.setUsername("scott");
		// Actual password: user
		user.setPassword("22b5c9accc6e1ba628cedc63a72d57f8");
		// Regular user
		user.setAccess(2);
		user.setCompanyName("xyz");

		// Add to array list
		users.add(user);

		return users;
	}
}

Step 6:
Next step is to add the login.zul. Select the folder “webapp”. Right click, Select New->Other->Zul file. Enter the file name as login.zul
Here is the file content.

<?page id="loginPage" title="Digital medical sheet - Login page" onLoad="win.doOverlapped();"?>
<window id="win" title="LOGIN" border="normal" width="300px"
	position="center">

	<!-- this form-login-page form is also used as the
		form-error-page to ask for a login again. -->
	<html style="color:red" if="${not empty param.login_error}">

		
		<![CDATA[ Your login attempt was not successful, try
		again.<br/><br/> Reason:
		${SPRING_SECURITY_LAST_EXCEPTION.message} ]]>
		
		
    </html>

	<groupbox>
		<caption>Login</caption>
		<h:form id="f" name="f" action="j_spring_security_check"
			method="POST" xmlns:h="http://www.w3.org/1999/xhtml">
			<grid>
				<columns sizable="false">
					<column width="50%" />
					<column width="50%" />
				</columns>
				<rows>
					<row>
						<label value="User:" />
						<textbox id="u" name="j_username" />
					</row>
					<row>
						<label value="Password:" />
						<textbox id="p" type="password"
							name="j_password" />
					</row>

					<row>
						<label value="Company Name" />
						<textbox id="pa" name="Company" />
					</row>



					<row spans="2">
						<div align="center">
							<h:input type="submit" value="login" />
							<h:input type="reset" value="Reset" />
						</div>
					</row>
				</rows>
			</grid>
		</h:form>
	</groupbox>
</window>

Step 7:
Now the let us change the index.zul file content which is created by default.

<zk>
	<window >
		Welcome to ZK Secured Page
		<button label="Logout" href="/j_spring_security_logout"/>
	</window>
</zk>

Step 8:
Now you can select the Project “zkloginexample4”, right click-> Run as –> Run on Server

Select the tomcat server and Click finish button

Now you can enter any valid username/passwords as follows

rod/koala/abc
dianne/emu/abc
scott/wombat/abc
scott/wombat/xyz

You can download the source here

Reference
1. Introduction to Spring Security Concepts.
2. Getting Started Spring Security
3. Understanding Spring Security
4. Configuring spring security
5. Spring Security 3 - MVC Integration Tutorial (Part 2)

Read More

Different format of Medical Forms

 

In the last section, we said submission of claims to the insurance company in a specified format. Let us see some important format as follows

1.  HCFA(Health Care Financing Administration)  1500 form or CMS(Centers for Medicare and Medicaid Services) form.
It is a standard form that non-institutional providers use such as your family doctor or specialist used send claims. Mostly individual
Physician charges are billed on the CMS 1500 form

2.  UB-04( uniform institutional billing claim form) Form (formerly UB-92 OR CMS-1450)
This form is used to submit claims for institutional providers such as hospitals. Some insurance accepts CMS 1500 form to submit  hospital billing. You should always check the insurance company which form they prefer to bill hospital charges.

You can see sample CMS 1500 and UB04 Form here

        

Read More

Sample CMS 1500 and UB04 Form

CMS 1500 Blank Form

CMS 1500 Sample Filled Form

Sample UB04 Form

Read More