Added task module to restructure.

pom.xml

@@ -151,16 +151,16 @@
 			<artifactId>spring-webflow</artifactId>
 			<version>2.5.1.RELEASE</version>
 		</dependency>
-		        <dependency>
-            <groupId>javax.faces</groupId>
-            <artifactId>jsf-api</artifactId>
-            <version>1.2_13</version>
-        </dependency>
-        <dependency>
-            <groupId>javax.faces</groupId>
-            <artifactId>jsf-impl</artifactId>
-            <version>1.2_13</version>
-        </dependency>
+		<dependency>
+			<groupId>javax.faces</groupId>
+			<artifactId>jsf-api</artifactId>
+			<version>1.2_13</version>
+		</dependency>
+		<dependency>
+			<groupId>javax.faces</groupId>
+			<artifactId>jsf-impl</artifactId>
+			<version>1.2_13</version>
+		</dependency>
 
 		<!-- https://mvnrepository.com/artifact/com.sun.facelets/jsf-facelets -->
 		<dependency>
@@ -182,6 +182,13 @@
 			<scope>provided</scope>
 		</dependency>
 
+		<!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
+		<dependency>
+			<groupId>commons-codec</groupId>
+			<artifactId>commons-codec</artifactId>
+			<version>1.12</version>
+		</dependency>
+
 
 	</dependencies>
 

src/main/java/org/openhds/config/TaskApplicationContext.java

@@ -0,0 +1,22 @@
+package org.openhds.config;
+
+import java.util.concurrent.Executor;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+
+@Configuration
+@EnableAsync()
+@ComponentScan(basePackages= {"org.openhds.task"})
+public class TaskApplicationContext {
+	@Bean
+	public Executor taskExecutor() {
+		ThreadPoolTaskExecutor task = new ThreadPoolTaskExecutor();
+		task.setMaxPoolSize(5);
+		task.setQueueCapacity(25);
+		return new ThreadPoolTaskExecutor();
+	}
+}

src/main/java/org/openhds/service/AsyncTaskService.java

@@ -0,0 +1,27 @@
+package org.openhds.service;
+
+import java.util.List;
+
+import org.openhds.domain.AsyncTask;
+
+public interface AsyncTaskService {
+
+    public static final String INDIVIDUAL_TASK_NAME = "Individual Task";
+    public static final String LOCATION_TASK_NAME = "Location Task";
+    public static final String RELATIONSHIP_TASK_NAME = "Relationship Task";
+    public static final String SOCIALGROUP_TASK_NAME = "Social Group Task";
+    public static final String VISIT_TASK_NAME = "Visit Task";
+    public static final String FORM_TASK_NAME = "Form Task";
+
+    boolean taskShouldRun(String taskName);
+
+    void startTask(String taskName);
+
+    void clearSession();
+
+    void updateTaskProgress(String taskName, long itemsWritten);
+
+    void finishTask(String taskName, long itemsWritten, String md5);
+
+    List<AsyncTask> findAllAsyncTask();
+}

src/main/java/org/openhds/service/impl/AsyncTaskServiceImpl.java

@@ -0,0 +1,80 @@
+package org.openhds.service.impl;
+
+import java.util.Calendar;
+import java.util.List;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.openhds.dao.Dao;
+import org.openhds.domain.AsyncTask;
+import org.openhds.service.AsyncTaskService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component
+public class AsyncTaskServiceImpl implements AsyncTaskService {
+
+    private SessionFactory sessionFactory;
+    private Dao<AsyncTask, String> dao;
+
+    @Autowired
+    public AsyncTaskServiceImpl(SessionFactory sessionFactory, @Qualifier("taskDao") Dao<AsyncTask, String> dao) {
+        this.sessionFactory = sessionFactory;
+        this.dao = dao;
+    }
+
+    @Override
+    public boolean taskShouldRun(String taskName) {
+        return taskShouldRun(dao.findByProperty("taskName", taskName));
+    }
+
+    private boolean taskShouldRun(AsyncTask task) {
+        return task == null || task.getTaskEndDate() != null;
+    }
+
+    @Override
+    @Transactional(propagation=Propagation.REQUIRES_NEW)
+    public void startTask(String taskName) {
+        AsyncTask task = dao.findByProperty("taskName", taskName);
+        if (task == null) {
+            task = new AsyncTask();
+            task.setTaskName(taskName);
+        }
+        task.setTaskEndDate(null);
+        task.setTotalItems(0);
+        task.setTaskStartDate(Calendar.getInstance());
+        dao.saveOrUpdate(task);
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    public void updateTaskProgress(String taskName, long itemsWritten) {
+        AsyncTask task = dao.findByProperty("taskName", taskName);
+        task.setTotalItems(itemsWritten);
+    }
+
+    @Override
+    @Transactional
+    public void finishTask(String taskName, long itemsWritten, String md5) {
+        AsyncTask task = dao.findByProperty("taskName", taskName);
+        task.setTotalItems(itemsWritten);
+        task.setTaskEndDate(Calendar.getInstance());
+        task.setMd5Hash(md5);
+    }
+
+    @Override
+    public void clearSession() {
+    	Session session = sessionFactory.getCurrentSession();
+    	session.flush();
+    	session.clear();
+    }
+
+    @Override
+    public List<AsyncTask> findAllAsyncTask() {
+        return dao.findAll(false);
+    }
+
+}

src/main/java/org/openhds/task/FormsXmlWriterTask.java

@@ -0,0 +1,52 @@
+package org.openhds.task;
+
+import java.util.List;
+
+import org.openhds.service.FormService;
+import org.openhds.domain.Form;
+import org.openhds.util.ShallowCopier;
+import org.openhds.service.AsyncTaskService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component("formXmlWriter")
+public class FormsXmlWriterTask extends XmlWriterTemplate<Form> {
+
+    private FormService formService;
+
+    @Autowired
+    public FormsXmlWriterTask(AsyncTaskService asyncTaskService, 
+    		FormService formService) {
+        super(asyncTaskService, AsyncTaskService.FORM_TASK_NAME);
+        this.formService = formService;
+    }
+
+    @Override
+    protected Form makeCopyOf(Form original) {
+        return ShallowCopier.copyForm(original);
+    }
+
+    @Override
+    protected List<Form> getEntitiesInRange(TaskContext taskContext, int i, int pageSize) {
+        return formService.getAllActiveForms();
+    }
+
+
+
+    @Override
+    protected String getStartElementName() {
+        return "forms";
+    }
+
+    @Override
+    protected int getTotalEntityCount(TaskContext taskContext) {
+        return (int) formService.getTotalFormCount();
+    }
+
+	@Override
+	protected Class<?> getBoundClass() {
+		// TODO Auto-generated method stub
+		return Form.class;
+	}
+
+}

src/main/java/org/openhds/task/IndividualXmlWriterTask.java

@@ -0,0 +1,64 @@
+package org.openhds.task;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.openhds.service.IndividualService;
+import org.openhds.domain.Individual;
+import org.openhds.util.ShallowCopier;
+import org.openhds.service.AsyncTaskService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component("individualXmlWriter")
+public class IndividualXmlWriterTask extends XmlWriterTemplate<Individual> {
+    private IndividualService individualService;
+
+    @Autowired
+    public IndividualXmlWriterTask(AsyncTaskService asyncTaskService, IndividualService individualService) {
+        super(asyncTaskService, AsyncTaskService.INDIVIDUAL_TASK_NAME);
+        this.individualService = individualService;
+    }
+
+    @Override
+    protected Individual makeCopyOf(Individual original) {
+        return ShallowCopier.shallowCopyIndividual(original);
+    }
+
+    @Override
+    protected List<Individual> getEntitiesInRange(TaskContext taskContext, int start, int pageSize) {
+        return getAllIndividualsWithResidencies(start, pageSize);
+    }
+
+    private List<Individual> getAllIndividualsWithResidencies(int start,
+			int pageSize) {
+		Individual indiv;
+		List<Individual> indivList= individualService.getAllIndividualsInRange(start,pageSize);
+		Iterator<Individual> it= indivList.iterator();
+		List<Individual> indivList2 = new ArrayList<Individual>();
+		while(it.hasNext()){
+			indiv=(Individual)it.next();
+			if(indiv.getCurrentResidency()!=null){
+				indivList2.add(indiv);
+			}
+		}
+		return indivList2;
+	}
+
+	@Override
+    protected Class<?> getBoundClass() {
+        return Individual.class;
+    }
+
+    @Override
+    protected String getStartElementName() {
+        return "individuals";
+    }
+
+    @Override
+    protected int getTotalEntityCount(TaskContext taskContext) {
+        return (int) individualService.getTotalIndividualCount();
+    }
+
+}

src/main/java/org/openhds/task/LocationXmlWriterTask.java

@@ -0,0 +1,50 @@
+package org.openhds.task;
+
+import java.util.List;
+
+import org.openhds.service.LocationHierarchyService;
+import org.openhds.domain.Location;
+import org.openhds.util.CalendarUtil;
+import org.openhds.util.ShallowCopier;
+import org.openhds.service.AsyncTaskService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component("locationXmlWriter")
+public class LocationXmlWriterTask extends XmlWriterTemplate<Location> {
+
+    private LocationHierarchyService locationHierarchyService;
+
+    @Autowired
+    public LocationXmlWriterTask(AsyncTaskService asyncTaskService, CalendarUtil calendarUtil,
+            LocationHierarchyService locationHierarchyService) {
+        super(asyncTaskService, AsyncTaskService.LOCATION_TASK_NAME);
+        this.locationHierarchyService = locationHierarchyService;
+    }
+
+    @Override
+    protected Location makeCopyOf(Location original) {
+        return ShallowCopier.copyLocation(original);
+    }
+
+    @Override
+    protected List<Location> getEntitiesInRange(TaskContext taskContext, int i, int pageSize) {
+        return locationHierarchyService.getAllLocationsInRange(i, pageSize);
+    }
+
+    @Override
+    protected Class<?> getBoundClass() {
+        return Location.class;
+    }
+
+    @Override
+    protected String getStartElementName() {
+        return "locations";
+    }
+
+    @Override
+    protected int getTotalEntityCount(TaskContext taskContext) {
+        return (int) locationHierarchyService.getTotalLocationCount();
+    }
+
+}

src/main/java/org/openhds/task/RelationshipXmlWriterTask.java

@@ -0,0 +1,50 @@
+package org.openhds.task;
+
+import java.util.List;
+
+import org.openhds.service.RelationshipService;
+import org.openhds.domain.Relationship;
+import org.openhds.util.CalendarUtil;
+import org.openhds.util.ShallowCopier;
+import org.openhds.service.AsyncTaskService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component("relationshipXmlWriter")
+public class RelationshipXmlWriterTask extends XmlWriterTemplate<Relationship> {
+
+    private RelationshipService relationshipService;
+
+    @Autowired
+    public RelationshipXmlWriterTask(AsyncTaskService asyncTaskService, CalendarUtil calendarUtil,
+            RelationshipService relationshipService) {
+        super(asyncTaskService, AsyncTaskService.RELATIONSHIP_TASK_NAME);
+        this.relationshipService = relationshipService;
+    }
+
+    @Override
+    protected Relationship makeCopyOf(Relationship original) {
+        return ShallowCopier.copyRelationship(original);
+    }
+
+    @Override
+    protected List<Relationship> getEntitiesInRange(TaskContext taskContext,int i, int pageSize) {
+        return relationshipService.getAllRelationshipInRange(i, pageSize);
+    }
+
+    @Override
+    protected Class<?> getBoundClass() {
+        return Relationship.class;
+    }
+
+    @Override
+    protected String getStartElementName() {
+        return "relationships";
+    }
+
+    @Override
+    protected int getTotalEntityCount(TaskContext taskContext) {
+        return (int) relationshipService.getTotalRelationshipCount();
+    }
+
+}