Changeset 17851

Timestamp:

08/07/08 12:36:23 (3 weeks ago)

Author:

avinash

Message:

blog it - Added code for work capture for selected assignment on blog it pop up on Assignments (Beta) page

Files:

• trunk/core/src/net/project/hibernate/service/IPnAssignmentWorkService.java (modified) (2 diffs)
• trunk/core/src/net/project/hibernate/service/impl/PnAssignmentWorkServiceImpl.java (modified) (2 diffs)
• trunk/core/src/net/project/view/pages/assignments/MyAssignments.java (modified) (5 diffs)
• trunk/core/web/src/blogit.js (modified) (15 diffs)

trunk/core/src/net/project/hibernate/service/IPnAssignmentWorkService.java

@@ -1 +1 @@
-package net.project.hibernate.service;
-
+import java.text.ParseException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+
+import org.apache.commons.collections.MultiMap;
+
+import net.project.form.assignment.FormAssignment;
-import net.project.hibernate.model.PnAssignmentWork;
+import net.project.persistence.PersistenceException;
+import net.project.resource.ActivityAssignment;
+import net.project.resource.mvc.handler.AssignmentDate;
+import net.project.schedule.Schedule;
+import net.project.schedule.ScheduleEntry;
+import net.project.util.NumberFormat;
+import net.project.util.TimeQuantity;
-
-public interface IPnAssignmentWorkService {
@@ -29 +47 @@
-         */
-        public void updateAssignmentWork(PnAssignmentWork pnAssignmentWork);
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}

trunk/core/src/net/project/hibernate/service/impl/PnAssignmentWorkServiceImpl.java

@@ -1 +1 @@
-package net.project.hibernate.service.impl;
-
+import java.math.BigDecimal;
+import java.sql.SQLException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.StringTokenizer;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+
+import org.apache.commons.collections.MultiHashMap;
+import org.apache.commons.collections.MultiMap;
+import org.apache.log4j.Logger;
+
+import net.project.base.Module;
+import net.project.base.ObjectType;
+import net.project.base.PnetRuntimeException;
+import net.project.base.finder.FinderFilterList;
+import net.project.base.finder.StringDomainFilter;
+import net.project.base.finder.TextComparator;
+import net.project.base.finder.TextFilter;
+import net.project.base.mvc.AbstractJavaScriptView;
+import net.project.base.property.PropertyProvider;
+import net.project.calendar.PnCalendar;
+import net.project.calendar.workingtime.DateCalculatorHelper;
+import net.project.calendar.workingtime.DefinitionBasedWorkingTimeCalendar;
+import net.project.calendar.workingtime.IWorkingTimeCalendar;
+import net.project.calendar.workingtime.IWorkingTimeCalendarProvider;
+import net.project.database.DBBean;
+import net.project.database.DatabaseUtils;
+import net.project.form.assignment.FormAssignment;
-import net.project.hibernate.dao.IPnAssignmentWorkDAO;
-import net.project.hibernate.model.PnAssignmentWork;
-import net.project.hibernate.service.IPnAssignmentWorkService;
-import net.project.hibernate.service.IUtilService;
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        
-        private IPnAssignmentWorkDAO pnAssignmentWorkDAO;       
@@ -35 +155 @@
-                pnAssignmentWorkDAO.update(pnAssignmentWork);
-        }
+        public String getTimeValueForJS(String dateToStart)
+        {
+                PnCalendar cal = new PnCalendar();
+                if (dateToStart != null) {
+            startDate = new Date(Long.parseLong(dateToStart));
+        } else {
+            cal.setTime(new Date());
+            startDate = cal.startOfWeek();
+        }
+                cal.setTime(startDate);
+        cal.add(PnCalendar.DATE, -7);
+        scrollBackStartDate=cal.getTime();
+        
+        cal.setTime(startDate);
+        cal.add(PnCalendar.DATE, 7);
+        scrollForwardStartDate=cal.getTime();
+
+        endDate = cal.endOfDay();
+        
+        getDateHeaders();
+                setDateValues();
+                String timesValueString="";
+                for (Iterator it = dateLongNames.iterator(); it.hasNext();) {
+                String timeValue = (String)it.next();
+                timesValueString+=timeValue+"" + (it.hasNext() ? "," : "");
+            }
+                
+                return timesValueString;
+        }
+        public void setDateValues(){
+        dateValues = new HashMap();
+        summaryDateValues = new HashMap();
+
+        PnCalendar cal = new PnCalendar();
+        DBBean db = new DBBean();
+        try {
+            db.prepareStatement(
+                "select" +
+                "  aw.object_id, aw.work_start, aw.work_end, aw.work, aw.work_units "+
+                "from " +
+                "  pn_assignment_work aw," +
+                "  pn_object o "+
+                "where " +
+                "  aw.person_id = ? " +
+                "  and aw.work_start <= ? " +
+                "  and aw.work_end >= ? " +
+                "  and o.object_id = aw.object_id " +
+                "  and o.record_status = 'A' "
+            );
+
+            db.pstmt.setString(1, SessionManager.getUser().getID());
+            DatabaseUtils.setTimestamp(db.pstmt, 2, endDate);
+            DatabaseUtils.setTimestamp(db.pstmt, 3, startDate);
+
+            db.executePrepared();
+
+            //Iterate through all the assignment work and assign it to the
+            //correct day in our map.
+            while (db.result.next()) {
+                String objectID = db.result.getString(1);
+                Date workStart = DatabaseUtils.getTimestamp(db.result, 2);
+                Date workEnd = DatabaseUtils.getTimestamp(db.result, 3);
+                TimeQuantity work = DatabaseUtils.getTimeQuantity(db.result,  4, 5);
+
+                Date endOfDay = cal.endOfDay(workStart);
+                if (workEnd.after(endOfDay)) {
+                    //This work occurs on two days according to our current time
+                    //zone.  Separate it accordingly.
+
+                    //We'll keep track of all the work we are recording to make
+                    //sure it is the same as what is in the database
+                    TimeQuantity totalWork = new TimeQuantity(0, TimeQuantityUnit.HOUR);
+
+                    //Figure out how much work is now done on the first day
+                    AssignmentDate dateID = new AssignmentDate(cal.startOfDay(workStart), objectID);
+                    TimeQuantity dayWork = new DateRange(workStart, endOfDay).getTimeQuantity(TimeQuantityUnit.HOUR, 2);
+                    totalWork = totalWork.add(dayWork);
+
+                    addWorkToDay(dateValues, summaryDateValues, dateID, dayWork);
+
+                    //Now figure out how much work was done on the second day
+                    Date startOfSecondDay = cal.startOfDay(workEnd);
+                    dateID = new AssignmentDate(startOfSecondDay, objectID);
+                    dayWork = new DateRange(startOfSecondDay, workEnd).getTimeQuantity(TimeQuantityUnit.HOUR, 2);
+                    totalWork = totalWork.add(dayWork);
+
+                    addWorkToDay(dateValues, summaryDateValues, dateID, dayWork);
+
+                    //Make sure that the amount of work we assigned matches what's in the database
+                    assert totalWork.equals(work) : "Unexpected error: Work " +
+                        "spanned multiple days.  When we attempted to split that " +
+                        "work, our splitting algorithm didn't yield the same " +
+                        "work as the database indicated that we should have.";
+                } else {
+                    //All work is on the same day
+                    AssignmentDate dateID = new AssignmentDate(cal.startOfDay(workStart), objectID);
+                    addWorkToDay(dateValues, summaryDateValues, dateID, work);
+                }
+            }
+        }catch(SQLException e){
+                e.printStackTrace();
+        } finally {
+            db.release();
+        }
+    }
+        public void addWorkToDay(Map dateValues, Map summaryDateValues, AssignmentDate dateID, TimeQuantity work) {
+        //First, add the work to the summary we are collecting for that day.
+        TimeQuantity existingSummaryWork = (TimeQuantity)summaryDateValues.get(dateID.date);
+        if (existingSummaryWork == null) {
+            summaryDateValues.put(dateID.date, work);
+        } else {
+            summaryDateValues.put(dateID.date, existingSummaryWork.add(work));
+        }
+
+        //Second, add the work for this object/day
+        TimeQuantity existingDayWork = (TimeQuantity)dateValues.get(dateID);
+        if (existingDayWork != null) {
+            work = work.add(existingDayWork);
+        }
+
+        dateValues.put(dateID, work);
+    }
+        /**
+         * To get the dataHeaders list. by Nilesh
+         * 
+         */
+        
+        public void getDateHeaders() {
+        PnCalendar cal = new PnCalendar();
+        dateHeaders =new LinkedList();
+        dateLongNames = new ArrayList();
+
+        //Iterate through 7 days, storing a header for each
+        DateFormat dateFormat = SessionManager.getUser().getDateFormatter();
+        SimpleDateFormat dayOfWeekFormatter = new SimpleDateFormat("EEE");
+        //sjmittal: please set the timezone for fix of bfd 2897
+        dayOfWeekFormatter.setTimeZone(cal.getTimeZone());
+        cal.setTime(startDate);
+        for (int i = 0; i < 7; i++) {
+            DateHeader dh = new DateHeader();
+            dh.date = dateFormat.formatDate(cal.getTime(), java.text.DateFormat.SHORT);
+            dh.dayOfWeek = dayOfWeekFormatter.format(cal.getTime());
+            dateHeaders.add(dh);
+            dateLongNames.add(String.valueOf(cal.getTime().getTime()));
+            cal.add(Calendar.DATE,  1);
+        }
+    }
+        public void getAssignments(String objectID1) throws PersistenceException {
+        String objectID = objectID1;
+        String[] objectIDList = {objectID1};
+        assignments = null;
+
+        String personId = SessionManager.getUser().getID();
+        if (!Validator.isBlankOrNull(objectID)) {
+            //sjmittal:
+            //this has been click for capture work so we are loading 
+            //assignments from pn_assignment table.
+            //if no assignment is present is creates a dummy assignment object in memory
+            //and the work against that is logged only in the pn_assignment_work table
+            
+                //objectIDList = request.getParameterValues("objectID");
+            FinderFilterList filters = new FinderFilterList();
+            filters.setSelected(true);
+            AssignmentManager mgr = new AssignmentManager();
+
+            if (objectIDList.length == 1) {
+                TextFilter objectIDFilter = new TextFilter("objectID", AssignmentFinder.OBJECT_ID_COLUMN, false);
+                objectIDFilter.setSelected(true);
+                objectIDFilter.setComparator((TextComparator)TextComparator.EQUALS);
+                objectIDFilter.setValue(objectID);
+                filters.add(objectIDFilter);
+            } else {
+                StringDomainFilter filter = new StringDomainFilter("objectID", "", AssignmentFinder.OBJECT_ID_COLUMN, (TextComparator)TextComparator.EQUALS);
+                filter.setSelected(true);
+                filter.setSelectedValues(objectIDList);
+                
+                filters.add(filter);
+            }
+
+            mgr.setPersonID(personId);
+            
+            mgr.addFilters(filters);
+            mgr.loadAssignments();
+            assignments = mgr.getAssignments();
+            showFilterPane= new Boolean(false);
+        } else {
+            //sjmittal: 
+            // this has been clicked from the timesheet module
+            // we need to get all the assignments and activities for this person
+            // best is to fetch it from pn_assignment_work as all the work
+            //is stored in this table
+            Iterator iter = dateValues.keySet().iterator();
+            //get all the object ids against which work has been logged
+            //in the timesheet period
+            Set<String> objectIdSet = new HashSet<String>();
+            while(iter.hasNext()) {
+                AssignmentDate aDate = (AssignmentDate) iter.next();
+                TimeQuantity work = (TimeQuantity) dateValues.get(aDate);
+                objectIdSet.add(aDate.id);
+            }
+            
+            Object[] srcArray = objectIdSet.toArray();
+            //populate the objectIDList
+            objectIDList = new String[srcArray.length];
+            System.arraycopy(srcArray, 0, objectIDList, 0, srcArray.length);
+            //here assignments is blank
+            assignments = new ArrayList();
+            showFilterPane= new Boolean(true);
+        }
+
+        //passThru(model, "objectID");
+
+        assignmentMap = CollectionUtils.listToMap(assignments, new CollectionUtils.MapKeyLocator() {
+            public Object getKey(Object listObject) {
+                return ((Assignment)listObject).getObjectID();
+            }
+        });
+
+        Map spaceIDMap = new HashMap();
+        Map nameMap = new HashMap();
+        Map typeMap = new HashMap();
+        //Load the name and space id for each object
+        if (objectIDList.length > 0) {
+            DBBean db = new DBBean();
+            try {
+                //Construct where clause to match object ids
+                String whereClause = "  and (";
+                for (int i = 0; i < objectIDList.length; i++) {
+                    if (i > 0) {
+                        whereClause += " or ";
+                    }
+                    whereClause += " oname.object_id = " + objectIDList[i];
+                }
+                whereClause += ")";
+
+                //needed for decoupling tasks from assignmment's work
+                db.prepareStatement(
+                        "select /*+ USE_NL(o oname) USE_NL(oname spc) */ "+
+                        "  oname.object_id, "+
+                        "  oname.name, "+
+                        "  spc.space_id, "+
+                        "  o.object_type "+                                             
+//                      "  coalesce(shp.space_id, spc.space_id) as space_id "+
+                        "from "+
+                        "  pn_object o,"+
+                        "  pn_object_name oname, "+
+//                      "  pn_space_has_plan shp, "+
+//                      "  pn_plan_has_task pht, "+
+                        "  pn_object_space spc "+
+                        "where "+
+//                      "  oname.object_id = pht.task_id(+) "+
+//                      "  and pht.plan_id = shp.plan_id(+) "+
+                        "  o.object_id = oname.object_id(+) "+
+                        "  and oname.object_id = spc.object_id(+) "+
+                        whereClause
+                );
+                db.executePrepared();
+
+                while (db.result.next()) {
+                    String currentObjectID = db.result.getString(1);
+                    nameMap.put(currentObjectID, db.result.getString(2));
+                    spaceIDMap.put(currentObjectID, db.result.getString(3));
+                    typeMap.put(currentObjectID, db.result.getString(4));
+                }
+            } catch (SQLException sqle) {
+                throw new PersistenceException("Unable to load names and space id's for objects", sqle);
+            } finally {
+                db.release();
+            }
+        }
+
+        //Now we will look through the id's to see if we have already loaded them,
+        //if not, we can assume they aren't in the database.  We'll create unsaved
+        //assignments.
+        boolean assignmentsNotLookedUp = ((Boolean ) showFilterPane).booleanValue();
+        for (int i = 0; i < objectIDList.length; i++) {
+            String id = objectIDList[i];
+            Assignment assn = (Assignment)assignmentMap.get(id);
+
+            //sjmittal: note currently assignments can be non tasks
+            //also. In future more Assignment objects would be added
+            //like forms. Each assignment type might have to be handled differently
+            if (assn == null) {
+                //try to get the assignment from the pn_assignment if not fetched before
+                if (assignmentsNotLookedUp) {
+                    AssignmentFinder finder = new AssignmentFinder();
+                    //add the object id
+                    TextFilter objectIDFilter = new TextFilter("objectID", AssignmentFinder.OBJECT_ID_COLUMN, false);
+                    objectIDFilter.setSelected(true);
+                    objectIDFilter.setComparator((TextComparator)TextComparator.EQUALS);
+                    objectIDFilter.setValue(id);
+
+                    //add the space id
+                    TextFilter spaceIDFilter = new TextFilter("spaceID", AssignmentFinder.SPACE_ID_COLUMN, false);
+                    spaceIDFilter.setSelected(true);
+                    spaceIDFilter.setComparator((TextComparator)TextComparator.EQUALS);
+                    spaceIDFilter.setValue((String)spaceIDMap.get(id));
+
+                    //add the person id
+                    TextFilter personIDFilter = new TextFilter("personID", AssignmentFinder.PERSON_ID_COLUMN, false);
+                    personIDFilter.setSelected(true);
+                    personIDFilter.setComparator((TextComparator)TextComparator.EQUALS);
+                    personIDFilter.setValue(personId);
+
+                    finder.addFinderFilter(objectIDFilter);
+                    finder.addFinderFilter(spaceIDFilter);
+                    finder.addFinderFilter(personIDFilter);
+                    //sjmittal: note this would at max return 1 row because objectid, spaceid, personid
+                    //consitute the primary key for this table
+                    Collection collection = finder.findAll();
+                    if(collection.size() > 0) {
+                        assn = (Assignment) collection.iterator().next();
+                        
+                        assignments.add(assn);
+                        assignmentMap.put(id, assn);
+                    }
+                }
+            }
+                
+            if(assn == null) {
+                String type = (String) typeMap.get(id);
+
+                if(ObjectType.TASK.equals(type)) {
+                    //create a new task type assignment
+                    //sjmittal:
+                    //this case would occur if the resource wants to enter time against
+                    //task that is not yet assigned to him. thus there is no assignment entry
+                    ScheduleEntryAssignment seAssn = new ScheduleEntryAssignment();
+                    List assignmentLogs = new AssignmentWorkLogFinder().findByObjectIDPersonID(id, personId);
+                    TimeQuantity totalWork = AssignmentWorkLogUtils.getWorkLoggedForAssignee(assignmentLogs, personId);
+
+                    seAssn.setWork(totalWork);
+                    seAssn.setWorkComplete(totalWork);
+                    seAssn.setPercentComplete(new BigDecimal(1));
+                    seAssn.setComplete(false);
+                    seAssn.setPercentAssigned(100);
+                    seAssn.setPersonID(personId);
+                    seAssn.setSpaceID((String)spaceIDMap.get(id));
+                    seAssn.setObjectID(id);
+                    seAssn.setObjectName((String)nameMap.get(id));
+
+                    assignments.add(seAssn);
+                    assignmentMap.put(id, seAssn);
+                } else {
+                    //sjmittal: as of now no other assignment type needs to be created
+                    continue;
+                }
+            }
+            else if(assn instanceof ScheduleEntryAssignment) {
+                ScheduleEntryAssignment seAssn = (ScheduleEntryAssignment) assn;
+                //load the underlying object ie the task
+                TaskFinder finder = new TaskFinder();
+                ScheduleEntry task = finder.findObjectByID(id);
+
+                //Don't create assignments for summary tasks.  Their work is
+                //created based on the work of their children.
+                //sjmittal: I think the work for summary task gets added to to 
+                //the work performed by its children
+                //                if (task.getTaskType().equals(TaskType.SUMMARY)) {
+                //                    errorReporter.addError(
+                //                        PropertyProvider.get("prm.personal.assignments.summaryTaskWarning",
+                //                            task.getNameMaxLength40())
+                //                    );
+                //                    continue;
+                //                }
+
+                //bfd-set the plan finnished date
+                seAssn.setEndTime(task.getEndTime());
+            } else if(assn instanceof ActivityAssignment) {
+                //sjmittal: unlike task assignment as of now nothing special needs to be done here as of now
+                continue;
+            } else if(assn instanceof FormAssignment) {
+                //sjmittal: unlike task assignment as of now nothing special needs to be done here as of now
+                continue;
+            } else {
+                //remove the entries which cannot have work log againts them as of now
+                assignments.remove(assignmentMap.remove(id));
+            }
+        } 
+
+         
+    }
+        public String findUpdatedPercentComplete(HttpServletRequest request, String id) throws ParseException {
+                errorReporter = new ErrorReporter();
+                Date earliestStartDate = null;
+        Date latestStartDate = null;
+        calendarProvider = (ResourceWorkingTimeCalendarProvider)request.getSession().getAttribute("updateAssignmentsCalendarProvider");
+        planIDMap = (Map)request.getSession().getAttribute("updateAssignmentsPlanIDMap");
+        //String otherparams=request.getParameter("otherparams");
+        
+        //Find all of the work complete.
+        //sjmittal added the validations for fix of bfd 3076
+        List workCompleteStrings = new ArrayList();
+        //Total work check. It should not be below zero.
+        double totalRowWork = 0;
+        for (int i = 0; i < 7; i++) {
+            String workString = request.getParameter("wc"+i);
+            Date startDate = new Date(Long.parseLong(request.getParameter("tv"+i)));
+            
+            if (Validator.isBlankOrNull(workString)) {
+                continue;
+            } else if (!Validator.isNumeric(workString)) {
+                errorReporter.addError(new ErrorDescription(PropertyProvider.get("prm.resource.updatework.error.invalid.message", workString, DateFormat.getInstance().formatDate(startDate))));
+                continue;
+            } else {
+                workCompleteStrings.add(workString);
+                if (earliestStartDate == null || earliestStartDate.after(startDate)) {
+                        earliestStartDate = startDate;
+                    }
+                if (latestStartDate == null || latestStartDate.before(startDate)) {
+                    latestStartDate = startDate;
+                }
+            }
+            totalRowWork += Double.parseDouble(workString);
+        }
+        //this is for all the rows ie tasks for that particular datecolumn
+        double totalColumnWork = 0;
+        String dateLongName = request.getParameter("dateLongName");
+        int totalAssignments = Integer.parseInt(request.getParameter("totalAssignments"));
+        Date workDate = new Date(Long.parseLong(dateLongName));
+        for (int i = 0; i < totalAssignments; i++) {
+            String workString = request.getParameter("dln"+i);;            
+            if (Validator.isBlankOrNull(workString)) {
+                continue;
+            } else if (!Validator.isNumeric(workString)) {
+                //sjmittal: this is verified above
+//                errorReporter.addError(new ErrorDescription(PropertyProvider.get("prm.resource.updatework.error.invalid.message", workString, DateFormat.getInstance().formatDate(workDate))));
+                continue;
+            } 
+            totalColumnWork += Double.parseDouble(workString);
+        }
+//        if(Validator.isNegative(""+totalColumnWork)) {
+//            errorReporter.addError(new ErrorDescription(PropertyProvider.get("prm.resource.updatework.total.negative.error.message")));
+//        }
+        
+//        String percentComplete = null;
+//        TimeQuantity assnWork = TimeQuantity.O_HOURS;
+//        TimeQuantity currentWork = assnWork;
+        NumberFormat nf = NumberFormat.getInstance();
+        assignmentMap = (Map)request.getSession().getAttribute("updateAssignmentsMap");
+        assignments = (List)request.getSession().getAttribute("updateAssignmentsList");
+        summaryDateValues = (Map)request.getSession().getAttribute("summaryDateValues");
+        Assignment baseAssn = (Assignment)assignmentMap.get(id);
+
+        //one final check
+        TimeQuantity newWorkForDay = new TimeQuantity(nf.parseNumber(""+totalColumnWork), TimeQuantityUnit.HOUR);
+        TimeQuantity oldWorkForDay = (TimeQuantity) summaryDateValues.get(workDate);
+        //no old work added till now for this week
+        if(oldWorkForDay == null)
+            oldWorkForDay = TimeQuantity.O_HOURS;
+        if (newWorkForDay.add(oldWorkForDay).abs().compareTo(MAXIMUM_WORK_HOURS) > 0) {
+            errorReporter.addError(new ErrorDescription(PropertyProvider.get(
+                    "prm.resource.assignments.update.error.invalidwork.message", 
+                    newWorkForDay.add(oldWorkForDay).formatAmount(), 
+                    MAXIMUM_WORK_HOURS.formatAmount())));
+        }
+
+        //We decide to wait until we have a list of work complete strings so we
+        //only have to load the assignment if there are really updates to do.
+        if (workCompleteStrings.size() > 0 && !errorReporter.errorsFound()) {
+
+            if (baseAssn != null && baseAssn instanceof ScheduleEntryAssignment) {
+                //case of schedule entry assignment created
+                ScheduleEntryAssignment assn = (ScheduleEntryAssignment) baseAssn;
+                currentWork = ScheduleTimeQuantity.convertToHour(assn.getWorkComplete());
+                assnWork = ScheduleTimeQuantity.convertToHour(assn.getWork());
+                
+                currentWork = getCurrentWork(workCompleteStrings, nf, currentWork);
+                //Make sure we know the total amount of work in the task which might
+                //be changed if the user has reported more work than is assigned
+                if (assnWork.compareTo(currentWork) < 0) {
+                    assnWork = currentWork;
+                }
+                //Calculate the percent complete.  We do a clone first so we don't mess
+                //up the preloaded assignments.
+                percentComplete = getPercentComplete(currentWork, assnWork.isZero() ? new TimeQuantity(1, TimeQuantityUnit.HOUR) : assnWork, nf);
+                //finally calculate the esimated finnish date
+                if (assn.getActualStart() == null || assn.getActualStart().after(earliestStartDate)) {
+                    assn.setActualStart(earliestStartDate);
+    
+                    DefinitionBasedWorkingTimeCalendar cal = calendarProvider.getCalendarForPlan((String)planIDMap.get(id));
+                    assn.calculateEstimatedFinish(cal);
+
+                } else if (assn.getEstimatedFinish() == null) {
+                    DefinitionBasedWorkingTimeCalendar cal = calendarProvider.getCalendarForPlan((String)planIDMap.get(id));
+                    assn.calculateEstimatedFinish(cal);
+
+                }
+                
+                
+                //updateWorkModel(model, percentComplete, assnWork, currentWork);
+            }   else if (baseAssn != null && baseAssn instanceof FormAssignment) {
+                //case of form assignment created
+                FormAssignment assn = (FormAssignment) baseAssn;
+                currentWork = assn.getWorkComplete();
+                assnWork = assn.getWork();
+                
+                currentWork = getCurrentWork(workCompleteStrings, nf, currentWork);
+                //Make sure we know the total amount of work in the form assignment which might
+                //be changed if the user has reported more work than is assigned
+                if (assnWork.compareTo(currentWork) < 0) {
+                    assnWork = currentWork;
+                }
+                //Calculate the percent complete.
+                percentComplete = getPercentComplete(currentWork, assnWork, nf);
+                assn.setStartTime(earliestStartDate);
+                assn.setEndTime(latestStartDate);
+    
+                //updateWorkModel(model, percentComplete, assnWork, currentWork);
+            } else  if (baseAssn != null && baseAssn instanceof ActivityAssignment) {
+                //case of activity assignment created or already present in the Map
+                ActivityAssignment assn = (ActivityAssignment) baseAssn;
+                assnWork = assn.getWork();
+
+                assnWork = getCurrentWork(workCompleteStrings, nf, assnWork == null ? TimeQuantity.O_HOURS: assnWork);
+                currentWork = assnWork;
+                percentComplete = nf.formatPercent(1.0, 2);
+                assn.setStartTime(earliestStartDate);
+                assn.setEndTime(latestStartDate);
+                
+                //updateWorkModel(model, percentComplete, assnWork, currentWork);
+            } else {
+                //case of new activity or task added just now in the Map
+                //sjmittal (note*): form assignment cannot be added on fly in the Map
+                //as these are added from a seperate module so personal assignments or timesheet page
+                //would always show form assignments the are already there. so this case in not considered
+                //for form assignments
+                ScheduleEntryAssignment seAssn = null;
+                try {
+                    AssignmentFinder finder = new AssignmentFinder();
+                    FinderFilterList filters = new FinderFilterList();
+                    filters.setSelected(true);
+                    
+                    TextFilter personFilter = new TextFilter("person_id", AssignmentFinder.PERSON_ID_COLUMN, false);
+                    personFilter.setSelected(true);
+                    personFilter.setComparator((TextComparator)TextComparator.EQUALS);
+                    personFilter.setValue(SessionManager.getUser().getID());
+                    filters.add(personFilter);
+                    
+                    TextFilter objectIDFilter = new TextFilter("object_id", AssignmentFinder.OBJECT_ID_COLUMN, false);
+                    objectIDFilter.setSelected(true);
+                    objectIDFilter.setComparator((TextComparator)TextComparator.EQUALS);
+                    objectIDFilter.setValue(id);
+                    filters.add(objectIDFilter);
+                    
+                    finder.addFinderFilterList(filters);
+                    Collection asignments = finder.findAll();
+                    if(asignments.size() == 1) {
+                        Assignment assn = (Assignment) asignments.iterator().next();
+                        if(assn instanceof ScheduleEntryAssignment) {
+                            seAssn = (ScheduleEntryAssignment) assn;
+                        }
+                    }
+                } catch (PersistenceException e) {
+                }                
+                if(seAssn != null) {
+                    assignmentMap.put(id, seAssn);
+                    assignments.add(seAssn);
+                    
+                    currentWork = ScheduleTimeQuantity.convertToHour(seAssn.getWorkComplete());
+                    assnWork = ScheduleTimeQuantity.convertToHour(seAssn.getWork());
+                    
+                    currentWork = getCurrentWork(workCompleteStrings, nf, currentWork);
+                    //Make sure we know the total amount of work in the task which might
+                    //be changed if the user has reported more work than is assigned
+                    if (assnWork.compareTo(currentWork) < 0) {
+                        assnWork = currentWork;
+                    }
+                    //Calculate the percent complete.  We do a clone first so we don't mess
+                    //up the preloaded assignments.
+                    percentComplete = getPercentComplete(currentWork, assnWork.isZero() ? new TimeQuantity(1, TimeQuantityUnit.HOUR) : assnWork, nf);
+                    //finally calculate the esimated finnish date
+                    if (seAssn.getActualStart() == null || seAssn.getActualStart().after(earliestStartDate)) {
+                        seAssn.setActualStart(earliestStartDate);
+        
+                        DefinitionBasedWorkingTimeCalendar cal = calendarProvider.getCalendarForPlan((String)planIDMap.get(id));
+                        seAssn.calculateEstimatedFinish(cal);
+
+                    } else if (seAssn.getEstimatedFinish() == null) {
+                        DefinitionBasedWorkingTimeCalendar cal = calendarProvider.getCalendarForPlan((String)planIDMap.get(id));
+                        seAssn.calculateEstimatedFinish(cal);
+
+                    }
+                }
+                else {
+                    ActivityAssignment assn = new ActivityAssignment();
+                    assignmentMap.put(id, assn);
+                    assignments.add(assn);
+
+                    
+                    assnWork = getCurrentWork(workCompleteStrings, nf, assnWork);
+                    currentWork = assnWork;
+                    percentComplete = nf.formatPercent(1.0, 2);
+                    assn.setStartTime(earliestStartDate);
+                    assn.setEndTime(latestStartDate);
+                }
+                
+                //updateWorkModel(model, percentComplete, assnWork, currentWork);
+            }
+            
+           
+        } else {
+            //sjmittal: this is the case if some error occured in work change handler 
+            if (baseAssn != null && baseAssn instanceof ScheduleEntryAssignment) {
+                //case of schedule entry assignment created
+                ScheduleEntryAssignment assn = (ScheduleEntryAssignment) baseAssn;
+                percentComplete = getPercentComplete(ScheduleTimeQuantity.convertToHour(assn.getWorkComplete()), ScheduleTimeQuantity.convertToHour(assn.getWork()), nf);
+            } else if (baseAssn != null && baseAssn instanceof FormAssignment) {
+                //case of schedule entry assignment created
+                FormAssignment assn = (FormAssignment) baseAssn;
+                percentComplete = getPercentComplete(assn.getWorkComplete(), assn.getWork(), nf);
+
+            } else if(baseAssn != null && baseAssn instanceof ActivityAssignment) {
+                //case of activity assignment created or already present in the Map
+                ActivityAssignment assn = (ActivityAssignment) baseAssn;
+                percentComplete = nf.formatPercent(1.0, 2);
+            } else {
+                percentComplete = nf.formatPercent(0.0, 2);
+            }
+            
+        }
+        
+        try{
+                        putObjectsInSession(request, request.getSes