remindermodule.java

发泄网！ 发泄网！ 发泄网！ 发泄网！ 发泄网！ 发泄网！ 发泄网！ 发泄网！

    /* CRMS, customer relationship management system
    Copyright (C) 2003  Service To Youth Council

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    For further information contact the SYC ICT department on [e-mail]
    98 Kermode Street
    North Adelaide
    South Australia
    SA 5006 
    [phone]
    */
/*
 * ReminderModule.java
 *
 * Created on 7 April 2003, 00:00
 */

package crms.module;

import org.apache.log4j.*;
import crms.dao.*;
import crms.util.*;
import java.util.*;
import java.text.*;
import crms.vo.*;

/**
 *
 * @author  dmurphy
 */
public class ReminderModule {
    
    Logger logger = Logger.getLogger(CallModule.class);
    
    public static String PREFIX = "reminders.";
    public static String REMINDERS_SHOW = "reminders.show";
    public static String REMINDERS_SHOW_LIMITED = "reminders.show.limited";
    public static String REMINDERS_ADD_FORM = "reminders.add.form";
    
    public static String REMINDERS_ADD_SUBMIT = "reminders.add.submit";
    public static String REMINDERS_EDIT_FORM = "reminders.edit.form";
    public static String REMINDERS_DELETE = "reminders.delete";
    
    public static String REMINDERS_CAN_SMS = "reminders.can.sms";
    
    public static String PARAM_REMINDER_ID = "id";
    public static String PARAM_REMINDER_FOR = "for";
    public static String PARAM_REMINDER_FOR_ID = "for";

    public static String PARAM_REMINDER_FROM = "from";
    public static String PARAM_REMINDER_FROM_ID = "for";
    
    public static String PARAM_REMINDER_DATE = "date";
    public static String PARAM_REMINDER_TIME = "time";
    //public static String PARAM_REMINDER_COMPANY = "company";
    //public static String PARAM_REMINDER_CONTACT = "contact";
    //public static String PARAM_REMINDER_CONTACT_ID = "contact";
    public static String PARAM_REMINDER_MESSAGE = "message";
    public static String PARAM_REMINDER_PRIORITY = "priority";
    /*public static String PARAM_APPROVED_BY = "approvedBy";
    public static String PARAM_APPROVED = "approved"; */
    public static String PARAM_EMAIL_REMINDER = "isEmail";
    public static String PARAM_EMAIL_ADDR = "emailAddress";
    public static String PARAM_SMS_REMINDER = "isSMS";
    public static String PARAM_SMS_NUMBER = "SMSNumber";
    public static String PARAM_OWNER_HAS_READ = "ownerHasRead";
    
    /*public static String PARAM_CAN_APPROVE = "canApprove";*/
    
    private ReminderDAO reminderDAO = DAOFactory.getInstance().getReminderDAO();
    private ContactDAO contactDAO = DAOFactory.getInstance().getContactDAO();
    //private PermissionDAO permissionDAO = DAOFactory.getInstance().getPermissionDAO();
    private LDAPDAO ldapDAO = LDAPDAOFactory.getInstance().getLDAPDAO();
    
    //private PermissionModule pm = new PermissionModule();
    
    /** Creates a new instance of CallModule */
    public ReminderModule() {
        
    }
    
    public ServerResponse processCommand(ServerCommand command) throws Exception {
        
        String user = command.getUser();
        ServerResponse sr = new ServerResponse();
        
        if (command.getKey().equals(REMINDERS_SHOW)) {
            
            // Show Reminders
            sr.addPart("reminders", reminderDAO.getRemindersForUser(user));
            return sr;
        }
        else if (command.getKey().equals(REMINDERS_SHOW_LIMITED)) {
            sr.addPart("reminders", reminderDAO.getRemindersForUser(user, true));
            return sr;
        }
        else if (command.getKey().equals(REMINDERS_ADD_FORM)) {
            
            // Prepare the Add Reminder form

            //sr.addPart("staff", ldapDAO.listUsers());
            sr.addPart("date", new Date());
            
            return sr;
        }
        else if (command.getKey().equals(REMINDERS_EDIT_FORM)) {
            int reminderID = Integer.parseInt((String)command.getParameterValue(PARAM_REMINDER_ID));
            
            //Permission p = pm.getUserPermissionFor(reminderID, EntityType.REMINDER, user);
            //sr.addPart("permission", p);
            
            //if (p.canRead()) {
            
                Reminder r = reminderDAO.getReminder(reminderID, user);

                sr.addPart(PARAM_REMINDER_ID, String.valueOf(r.getReminderID()));

                StaffMember sm = ldapDAO.getUser(r.getOwner());
				if (sm == null) sm = StaffMember.STAFF_MEMBER_REMOVED;
                sr.addPart(PARAM_REMINDER_FOR, sm);

                sm = ldapDAO.getUser(r.getCreator());
				if (sm == null) sm = StaffMember.STAFF_MEMBER_REMOVED;
                sr.addPart(PARAM_REMINDER_FROM, sm);

                Contact contact = contactDAO.getContact(r.getContactID());
                //sr.addPart(PARAM_REMINDER_CONTACT, contact);

                sr.addPart(PARAM_REMINDER_DATE, r.getReminderDate());
                //sr.addPath(PARAM_REMINDER_COMPANY, r.getCompany());
                sr.addPart(PARAM_REMINDER_MESSAGE, r.getReminderMessage());
                sr.addPart(PARAM_REMINDER_PRIORITY, String.valueOf(r.getReminderRate()));
                /*sr.addPart(PARAM_APPROVED_BY, r.getApprovedBy());*/
                sr.addPart(PARAM_EMAIL_REMINDER, String.valueOf(r.isEmailReminder()));
                sr.addPart(PARAM_EMAIL_ADDR, r.getEmailReminderTo());
                sr.addPart(PARAM_SMS_REMINDER, String.valueOf(r.isSMSReminder()));
                sr.addPart(PARAM_SMS_NUMBER, r.getSMSReminderTo());
                /*sr.addPart(PARAM_APPROVED, String.valueOf(r.isApproved()));
                
                if (ldapDAO.isUserInGroup(user, "crmsapprove")) {
                    sr.addPart(PARAM_CAN_APPROVE, "true");   
                } else {
                    sr.addPart(PARAM_CAN_APPROVE, "false");   
                } */

                // Before returning the Reminder, if this reminder is being
                // viewed by it's owner, and it hasn't previously been set
                // to 'OwnerHasRead' - do that now.
                if (!r.getOwnerHasRead() && r.getOwner().equals(user)) {
                    r.setOwnerHasRead(true);
                    reminderDAO.updateReminder(r, user);
                }

                return sr;
            /*}
            else {
                return ServerResponse.PERMISSION_DENIED;   
            }*/
        }
        else if (command.getKey().equals(REMINDERS_ADD_SUBMIT)) {
            
            // User is either submitting a new reminder (no reminder id
            // passed) or updating an existing one.
            
            Reminder reminder = null;
            
            String idStr = (String) command.getParameterValue(PARAM_REMINDER_ID);
            if (idStr != null) {
                reminder = reminderDAO.getReminder(Integer.parseInt(idStr), user);
            } else {
                reminder = new Reminder();   
                reminder.setCreator(user);
                //reminder.setContactID(Integer.parseInt((String)command.getParameterValue(PARAM_REMINDER_CONTACT_ID)));
            }
            
            
            String date = (String) command.getParameterValue(PARAM_REMINDER_DATE);
            String time = (String) command.getParameterValue(PARAM_REMINDER_TIME);
            
            Date newDate = Reminder.fullFormat.parse(date + " " + time);
            
            reminder.setReminderDate(newDate);
            reminder.setReminderNext(newDate);

			// if editing an existing reminder, ensure frequency is set back to send another email/sms
			// TODO: implement UI for recurrance
			reminder.setFrequency(0);
            reminder.setReminderMessage((String) command.getParameterValue(PARAM_REMINDER_MESSAGE));
            reminder.setOwner((String) command.getParameterValue(PARAM_REMINDER_FOR_ID));
            
            /*if (!reminder.getOwner().equals("everyone")) {
                reminder.setApproved(true);
                reminder.setApprovedBy("auto");
            }*/
            
            reminder.setOwnerHasRead(false);
            StringTokenizer tok = new StringTokenizer( (String) command.getParameterValue(PARAM_REMINDER_PRIORITY), " ");
            String rate = tok.nextToken();
            reminder.setReminderRate(Integer.parseInt(rate));
            
            logger.debug("Set priority to: " + reminder.getReminderRate());

            boolean email = ((String) command.getParameterValue(PARAM_EMAIL_REMINDER)).equals("true");
            reminder.setEmailReminder(email);
            reminder.setEmailReminderTo((String) command.getParameterValue(PARAM_EMAIL_ADDR));
            
            boolean sms = ((String) command.getParameterValue(PARAM_SMS_REMINDER)).equals("true");
            reminder.setSMSReminder(sms);
            reminder.setSMSReminderTo((String) command.getParameterValue(PARAM_SMS_NUMBER));
            
            /*String approveString = (String) command.getParameterValue(PARAM_APPROVED);
            if (approveString != null) {
                 boolean approve = approveString.equals("true");   
                 reminder.setApproved(approve);
            }*/
            
            if (command.getParameterValue(PARAM_REMINDER_ID) != null) {
                int rid = Integer.parseInt((String)command.getParameterValue(PARAM_REMINDER_ID));
                reminder.setReminderID(rid);
                reminderDAO.updateReminder(reminder, user);
            } else {
               	reminderDAO.createReminder(reminder);
                //createDefaultReminderPermissions(reminder, user);
            }
			sr.addPart("reminder", reminder);
			return sr;
        }
        else if (command.getKey().equals(REMINDERS_DELETE)) {
            int reminderID = Integer.parseInt((String)command.getParameterValue(PARAM_REMINDER_ID));
            
            /*Permission p = pm.getUserPermissionFor(reminderID, EntityType.REMINDER, user);
            if (p.canDelete()) {*/
                reminderDAO.deleteReminder(reminderID);
                return ServerResponse.ACKNOWLEDGE_OKAY;
/*            } else {
                return ServerResponse.PERMISSION_DENIED;   
            }*/
        }
		/*
        else if (command.getKey().equals(REMINDERS_CAN_SMS)) {
            String id = (String) command.getParameterValue(PARAM_REMINDER_FOR_ID);
            
            if (ldapDAO.isUserInGroup(id, "crmssms")) {
               
                int smsThisMonth = reminderDAO.getSMSCountForMonth(id);
                
                if (smsThisMonth < 20) {
                     sr.addPart(PARAM_SMS_REMINDER, "true");  
                } else {
                    sr.addPart(PARAM_SMS_REMINDER, "false");   
                }
            } else {
                sr.addPart(PARAM_SMS_REMINDER, "false");   
            }
            return sr;
        }
		*/
        
        return null;
    }
    
    /**
     * <p>Creates and adds the default permissions for a new Reminder. These are:
     *  <ul>
     *      <li>Full access for creator</li>
     *      <li>Full access for owner (remindee)</li>
     *      <li>No access for 'everyone'</li>
     *  </ul>
     * </p>
     * <p><b>Note:</b> This treats reminders for "everyone" specially, giving
     *  an appropriate permission set for the reminder to be seen by all staff.
     * </p>
     * @param companyID The identifier of the newly created company
     * @param user Currently logged-in user
     */
    
    /*public void createDefaultReminderPermissions(Reminder reminder, String user) {
        // Set the creator's permissions (full)
        Permission p = new Permission();
        
        if (!reminder.getOwner().equals("everyone")) {
            // Standard single person reminder...
            p.setEntityID(reminder.getReminderID());
            p.setEntityType(EntityType.REMINDER);
            p.setID(user);
            p.setPermissionType(PermissionType.PERMISSION_USER);
            p.setPermission(Permission.READ_PERMISSION, true);
            p.setPermission(Permission.WRITE_PERMISSION, true);
            p.setPermission(Permission.DELETE_PERMISSION, true);
            permissionDAO.insertPermission(p);

            // Set the owner's permissions (full)
            String primaryGroup = ldapDAO.getPrimaryGroup(user);
            p.setID(reminder.getOwner());
            permissionDAO.insertPermission(p);
        } else {
            // Give the creator full access
            p.setEntityID(reminder.getReminderID());
            p.setEntityType(EntityType.REMINDER);
            p.setID(user);
            p.setPermissionType(PermissionType.PERMISSION_USER);
            p.setPermission(Permission.READ_PERMISSION, true);
            p.setPermission(Permission.WRITE_PERMISSION, true);
            p.setPermission(Permission.DELETE_PERMISSION, true);
            permissionDAO.insertPermission(p);
            
            // Give everyone read access
            p.setID(null);
            p.setPermissionType(PermissionType.PERMISSION_ALL);
            p.setPermission(Permission.READ_PERMISSION, true);
            p.setPermission(Permission.WRITE_PERMISSION, false);
            p.setPermission(Permission.DELETE_PERMISSION, false);
            permissionDAO.insertPermission(p);
            
            // Now add full group access for anyone in the 
            // 'crmsapprove' group - who can approve this.
            
            p.setID("crmsapprove");
            p.setPermissionType(PermissionType.PERMISSION_GROUP);
            p.setPermission(Permission.READ_PERMISSION, true);
            p.setPermission(Permission.WRITE_PERMISSION, true);
            p.setPermission(Permission.DELETE_PERMISSION, true);
            permissionDAO.insertPermission(p);
        }
        
    }
    
*/
    
}