/**
    * Copyright 2011 The Kuali Foundation Licensed under the
    * Educational Community License, Version 2.0 (the "License"); you may
    * not use this file except in compliance with the License. You may
    * obtain a copy of the License at
    *
    * http://www.osedu.org/licenses/ECL-2.0
    *
    * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an "AS IS"
   * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
   * or implied. See the License for the specific language governing
   * permissions and limitations under the License.
   */
  package org.kuali.mobility.push.controllers;
  
  import java.sql.Timestamp;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Properties;
  
  import javax.annotation.Resource;
  import javax.servlet.http.HttpServletRequest;
  
  import net.sf.json.JSONArray;
  import net.sf.json.JSONException;
  import net.sf.json.JSONObject;
  import net.sf.json.JSONSerializer;
  
  import org.apache.log4j.Logger;
  import org.kuali.mobility.push.entity.Device;
  import org.kuali.mobility.push.entity.Push;
  import org.kuali.mobility.push.entity.PushMessage;
  import org.kuali.mobility.push.entity.Sender;
  import org.kuali.mobility.push.service.DeviceService;
  import org.kuali.mobility.push.service.PushMessageService;
  import org.kuali.mobility.push.service.PushService;
  import org.kuali.mobility.push.service.SenderService;
  import org.kuali.mobility.security.group.api.Group;
  import org.kuali.mobility.security.user.api.User;
  import org.kuali.mobility.shared.Constants;
  import org.kuali.mobility.shared.controllers.AbstractMobilityController;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.beans.factory.annotation.Qualifier;
  import org.springframework.context.MessageSource;
  import org.springframework.http.HttpStatus;
  import org.springframework.http.ResponseEntity;
  import org.springframework.stereotype.Controller;
  import org.springframework.ui.Model;
  import org.springframework.validation.BindingResult;
  import org.springframework.validation.Errors;
  import org.springframework.web.bind.annotation.ModelAttribute;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RequestBody;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestMethod;
  import org.springframework.web.bind.annotation.RequestParam;
  import org.springframework.web.bind.annotation.ResponseBody;
  import org.springframework.web.servlet.LocaleResolver;
  import org.springframework.web.servlet.support.RequestContextUtils;
  
  /**
   * Controller for Push related pages
   *
   * @author Kuali Mobility Team (mobility.dev@kuali.org)
   * @since 2.0.0
   */
  @Controller
  @RequestMapping("/push")
  public class PushController extends AbstractMobilityController {
  
      /**
       * A reference to a logger
       */
      private static final Logger LOG = Logger.getLogger(PushController.class);
  
      private static final String RECIPIENTS = "recipients";
  
  	@Resource(name = "messageSource")
  	private MessageSource messageSource;
  
  	@Autowired
  	@Qualifier("kmeProperties")
  	private Properties kmeProperties;
  	
  	@Autowired
  	@Qualifier("senderKeysProperties")
  	private Properties senderKeysProperties;
  	
  	
  	/**
  	 * A reference 
  	 */
  	private String keyListFile;
  
     private Map<String, String> stockPushMessages;
     /*
 	 * static { stockPushMessages = new LinkedHashMap<String, String>(); //
 	 * stockPushMessages.put("Pre-defined Push", "");
 	 * stockPushMessages.put("Test Message STG", "Test Message Detail STG");
 	 * stockPushMessages.put("New Feature in KME",
 	 * "Check out the new {BLANK} in KME");
 	 * stockPushMessages.put("Log into a protected tool",
 	 * "Once you log into a CAS protected tool (such as My Classes or Classifieds) the push notifications you receive will be tailored specifically to you."
 	 * ); stockPushMessages.put("Tornado Warning",
 	 * "A Tornado warning has been issued for the area near campus and downtown. Please report to a shelter until all-clear has been sounded."
 	 * ); stockPushMessages.put("Crime: Local Car Thieves",
 	 * "Police have issued a warning for the downtown area regarding a series of car thefts. Take care when parking and locking your car."
 	 * ); }
 	 */
 
 
     /** Rendered obsolete by MOBILE-336 and MOBILE-386
      // These are "keys" for whom using the webservice. Without a key they
      // service will error out.
      // This is not ideal. They should be stripped out and not hard coded.
      private Map<String, String> senders;
      // static {
      // senders = new LinkedHashMap<String, String>();
      // senders.put("72241k6tlukzrs7mtqs4", "DINING");
      // senders.put("blo6iy4sj3szrdx5nyxg", "RPS");
      // senders.put("i6ijmfnwsj5n8pa327s7", "RES_HALLS");
      // senders.put("gs5z6ekg7jo8bev49jgv", "UITS");
      // senders.put("thsdzf0mmzp4vonkvr1h", "IUMOBILE");
      // senders.put("0l14yoyh38rbja14ynl6", "UIX");
      // }
      */
 
     /**
      * A reference to Default precipients.
      */
     private static final Map<String, String> RECIPIENTS_MAP;
 
 	static {
 		RECIPIENTS_MAP = new LinkedHashMap<String, String>();
 		// RECIPIENTS_MAP.put("Select Recipients", "");
 		RECIPIENTS_MAP.put("All", "all");
 		RECIPIENTS_MAP.put("All without Network ID", "usernameless");
 	}
 
     /**
      * A reference to the <code>PushService</code>.
      */
     @Autowired
     private PushService pushService;
 
     /**
      * A reference to the <code>DeviceService</code>.
      */
     @Autowired
     private DeviceService deviceService;
 
     /**
      * A reference to the <code>SenderService</code>.
      */
     @Autowired
     private SenderService senderService;
 
     @Autowired
     private PushMessageService pushMessageService;
 
 
     /**
      * A controller method for accessing and displaying the details of a specific push message.
      *
      * @param uiModel
      * @param request
      * @param pushHash Id of the Push message to display.
      * @return
      */
     @SuppressWarnings("unchecked")
     @RequestMapping(value = "/detail/{pushHash}", method = RequestMethod.GET)
     public String getPushDetails(Model uiModel, HttpServletRequest request,
                                  @PathVariable("pushHash") Long pushHash) {
 
         String isAdmin = "no";
         if (isAllowedAccess("KME-ADMINISTRATOR", request)) {
             isAdmin = "yes";
         }
 		User user = (User) request.getSession().getAttribute(Constants.KME_USER_KEY);
 		List<Group> groups = user.getGroups();
 		Iterator<Group> it = groups.iterator();
 		while(it.hasNext()){
 			Group group = it.next();
 			if("KME-ADMINISTRATOR".equals(group.getName())){
 				isAdmin = "yes";
 			}
 		}
         uiModel.addAttribute("isAdminMember", isAdmin);
 
         if (pushHash != null) {
             LOG.info("PushID is :" + pushHash);
         } else {
             return "push";
         }
         Push push = pushService.findPushById(pushHash);
         uiModel.addAttribute("thispush", push);
 
         List<Device> devices = pushService.findDevicesForPush(push);
         LOG.info("Found Devices for Push " + devices.size());
         uiModel.addAttribute("thesedevices", devices);
         return "push/pushdetail";
     }
 
 
     /**
      * A controller method to... I have no idea.
      *
      * @param uiModel
      * @param request
      * @param deviceID Id of device to which to send.
      * @return
      */
     @Deprecated
     @RequestMapping(value = "/send", method = RequestMethod.GET)
     public String sendToChosenDevice(Model uiModel, HttpServletRequest request,
                                      @RequestParam(value = "id", required = false) long deviceID) {
         String viewName = "push/index";
         if (!isAllowedAccess("KME-ADMINISTRATOR", request)) {
             viewName = "redirect:/errors/401";
         } else {
             stockPushMessages = getPushMessages();
             uiModel.addAttribute(RECIPIENTS, RECIPIENTS_MAP);
             uiModel.addAttribute("stockPushMessages", stockPushMessages);
             Push push = new Push();
             Device device = deviceService.findDeviceById(deviceID);
             uiModel.addAttribute("push", push);
             uiModel.addAttribute("device", device);
         }
         
     	if( "3".equalsIgnoreCase( getKmeProperties().getProperty("kme.uiVersion","classic") ) ) {
             viewName = "ui3/push/index";
     	}else{
     		viewName = "push/index";
     	}
         return viewName;
     }
 
 
     /**
      * A controller method to setup a UI form for sending a single push to a single device via a JSP. Will send to all devices or single selected device.
      *
      * @param uiModel
      * @return
      */
     @RequestMapping(value = "test", method = RequestMethod.GET)
     @ResponseBody
     public String test(Model uiModel, HttpServletRequest request) {
     	return "WTF!";
     }    
 
     @RequestMapping(value = "error", method = RequestMethod.GET)
     public String error(Model uiModel, HttpServletRequest request) {
     	return "redirect:/errors/401";
     } 
     
     
     
     /**
      * A controller method to setup a UI form for sending a single push to a single device via a JSP. Will send to all devices or single selected device.
      *
      * @param uiModel
      * @return
      */
     @RequestMapping(value = "", method = RequestMethod.GET)
     public String index(Model uiModel, HttpServletRequest request) {
         LOG.info("index() in Push Tool was called." );
     	
         String viewName;
         if (!isAllowedAccess("KME-ADMINISTRATOR", request)) {
         	viewName = "redirect:/errors/401.jsp";
             LOG.info("Redirecting to: " + viewName );
         } else {
             // Get Stock Push Messages.
             String source = getKmeProperties().getProperty("push.stock.messages.source");
             if ("database".equalsIgnoreCase(source)) {
                 LOG.info("GET Stock Messages from DB.");
                 LocaleResolver localeResolver = RequestContextUtils.getLocaleResolver(request);
                 Locale locale = localeResolver.resolveLocale(request);
                 this.setStockPushMessages(this.getPushMessages(locale));
             } else if ("properties".equalsIgnoreCase(source)) {
                 LOG.info("GET Stock Messages from Properties.");
                 this.setStockPushMessages(this.getPushMessages());
             }
 
             uiModel.addAttribute(RECIPIENTS, RECIPIENTS_MAP);
             uiModel.addAttribute("stockPushMessages", stockPushMessages);
             Push push = new Push();
 
             LOG.info("keyListFile: " + keyListFile);
 
             uiModel.addAttribute("push", push);
             
         	if( "3".equalsIgnoreCase( getKmeProperties().getProperty("kme.uiVersion","classic") ) ) {
                 viewName = "ui3/push/index";
         	}else{
         		viewName = "push/index";
         	}
         }
         return viewName;
     }
 
     @RequestMapping(value = "/js/history.js")
     public String getHistoryJavaScript(Model uiModel, HttpServletRequest request) {
         return "ui3/push/js/history";
     }
     
     @RequestMapping(value = "/js/push.js")
     public String getJavaScript(Model uiModel, HttpServletRequest request) {
         String source = getKmeProperties().getProperty("push.stock.messages.source");
         if ("database".equalsIgnoreCase(source)) {
             LOG.info("GET Stock Messages from DB.");
             LocaleResolver localeResolver = RequestContextUtils.getLocaleResolver(request);
             Locale locale = localeResolver.resolveLocale(request);
             this.setStockPushMessages(this.getPushMessages(locale));
         } else if ("properties".equalsIgnoreCase(source)) {
             LOG.info("GET Stock Messages from Properties.");
             this.setStockPushMessages(this.getPushMessages());
         }
 
         Sender defaultSender = senderService.findSenderByShortName("KME_PUSH");
         uiModel.addAttribute("senderKey", defaultSender.getSenderKey());
         
         uiModel.addAttribute(RECIPIENTS, RECIPIENTS_MAP);
         uiModel.addAttribute("stockPushMessages", stockPushMessages);
     	
         return "ui3/push/js/push";
     }
 
     /**
      * A controller method to return a Push notificaton in JSON format, used by native devices to display
      * the Push in app. Used in native apps to get more detail from the push object. Especially important
      * in iOS where Pushes are limited to 256bytes in length.
      *
      * @param uiModel
      * @param request
      * @param pushId  Id of Push to retrieve.
      * @return
      * @deprecated This method will be removed in future release
      */
     @Deprecated
     @RequestMapping(value = "/get/{pushId}", method = RequestMethod.GET)
     @ResponseBody
     public String getUserDetails(Model uiModel, HttpServletRequest request,
                                  @PathVariable("pushId") Long pushId) {
         Push push = new Push();
         push = pushService.findPushById(pushId);
 
         // wrapped JSON in a javascript function for JSONP used by BK tools.
         //		String value = "pushJSON('" + new JSONSerializer().toJSON(push).toString() + "');";
         String value = "pushJSON('" + JSONSerializer.toJSON(push).toString() + "');";
 
 
         return value;
     }
 
     /**
      * A controller method for displaying a historical list of push notifications.
      *
      * @param request
      * @param uiModel
      * @param key
      * @return
      */
     @RequestMapping(value = "/history", method = RequestMethod.GET)
     public String history(HttpServletRequest request, Model uiModel,
                           @RequestParam(value = "key", required = false) String key) {
     	if( "3".equalsIgnoreCase( getKmeProperties().getProperty("kme.uiVersion","classic") ) ) {
             return "ui3/push/pushhistory";
     	}
 
     	int pushCount = pushService.countPushes();
         uiModel.addAttribute("pushCount", pushCount);
 
         List<Push> pastPushes = pushService.findAllPush();
         uiModel.addAttribute("pastPushes", pastPushes);
                 
         return "push/history";
     }
 
     /**
      * A controller method for removing a push from history and then returning the resulting historical list of push notifications.
      *
      * @param request
      * @param uiModel
      * @param key
      * @param pushId
      * @return
      */
     @RequestMapping(value = "/remove/{pushHash}", method = RequestMethod.GET)
     public String remove(HttpServletRequest request,
                          Model uiModel,
                          @RequestParam(value = "key", required = false) String key,
                          @PathVariable("pushHash") Long pushHash) {
         String viewName;
         if (!isAllowedAccess("KME-ADMINISTRATOR", request)) {
             viewName = "redirect:/errors/401";
         } else {
             Push push = null;
             if (pushHash != null) {
                 push = pushService.findPushById(pushHash.longValue());
             }
             if (push != null) {
                 if (pushService.removePush(push)) {
                     LOG.info("Removed a Push from History");
                 } else {
                     LOG.info("Failed to removed a Push from History");
                 }
             } else {
                 LOG.info("No Push found to be removed.");
             }
 
             int pushCount = pushService.countPushes();
             uiModel.addAttribute("pushCount", pushCount);
 
             List<Push> pastPushes = pushService.findAllPush();
             uiModel.addAttribute("pastPushes", pastPushes);
             viewName = "push/history";
         }
         return viewName;
     }
 
 
     /**
      * A controller method for processing the submission of the form for sending a push notification.
      *
      * @param uiModel
      * @param push
      * @param result
      * @param id        Id of device to which to send a push.
      * @param sender    ShortName of the Sender that is sending the push.
      * @param recipient Recipients of push.
      * @return
      */
     @RequestMapping(method = RequestMethod.POST)
     public String submitPush(
             HttpServletRequest request,
             Model uiModel,
             @ModelAttribute("Push") Push push,
             BindingResult result,
             @RequestParam(value = "id", required = false) Long id,
             @RequestParam(value = "sender", required = false) String sender,
             @RequestParam(value = "recipientSelect", required = false) String recipient) {
         String viewName;
         if (!isAllowedAccess("KME-ADMINISTRATOR", request)) {
             viewName = "redirect:/errors/401";
         } else {
             push.setPostedTimestamp(new Timestamp(System.currentTimeMillis()));
             Sender defaultSender = senderService.findSenderByShortName("KME_PUSH");
             LOG.info(defaultSender);
 
             if (defaultSender != null) {
                 push.setSender(defaultSender.getShortName());
             } else {
                 push.setSender("KME_PUSH");
             }
             //		push.setSender(sender);
 
             LOG.info("---- Recipient Select: " + recipient);
 
             List<Device> devices = new ArrayList<Device>();
 
             if (id != null) {
                 LOG.info("---- Selected ID");
                 devices.add(deviceService.findDeviceById((long) id));
             }
 
             if (recipient != null) {
                 if (recipient.equals("all")) {
                     devices = deviceService.findAllDevices();
                 } else if (recipient.equals("usernameless")) {
                     devices = deviceService.findDevicesWithoutUsername();
                 }
             }
 
             LOG.info(devices.size() + " devices in list");
 
             if (isValidPush(push, result)) {
                 // pushService.savePush(push);
                 pushService.savePush(push, devices);
 
                 // TODO: SavePushDeviceTuple here.
 
                 int pushed = pushService.sendPush(push, devices);
                 LOG.info("Pushed Count: " + pushed);
                 push.setRecipients(pushed);
                 pushService.savePush(push);
                 LOG.info("Post Push:" + push.toString());
 
                 int pushCount = pushService.countPushes();
                 uiModel.addAttribute("pushCount", pushCount);
 
                 List<Push> pastPushes = pushService.findAllPush();
                 uiModel.addAttribute("pastPushes", pastPushes);
                 viewName = "push/history";
             } else {
                 viewName = "push/index";
             }
         }
         return viewName;
     }
 
     /**
      * A controller method for testing if a submitted push is valid.
      *
      * @param p      A Push to check for validity.
      * @param result
      * @return
      */
     private boolean isValidPush(Push p, BindingResult result) {
         Errors errors = ((Errors) result);
         boolean isValid = true;
         if (p.getMessage() == null || "".equals(p.getMessage().trim())) {
             errors.rejectValue("message",
                     "Please type a Message for the Push notification.");
             isValid = false;
         }
         if (p.getTitle() == null || "".equals(p.getTitle().trim())) {
             errors.rejectValue("title",
                     "Please type a Title for the Push notification.");
             isValid = false;
         }
 
         return isValid;
     }
 
     /**
      * A Controller method for processing an HTTP.Post submitted push notification.
      *
      * @param data String - A JSON formatted string containing details for the push to send as well as the recipient users or devices ids.
      * @return
      */
     @RequestMapping(value = "/service", method = RequestMethod.POST)
     public ResponseEntity<String> service(
             HttpServletRequest request,
             @RequestParam(value = "data", required = true) String data) {
         if (!isAllowedAccess("KME-ADMINISTRATOR", request)) {
             return new ResponseEntity<String>(HttpStatus.FORBIDDEN);
         } else {
 		LOG.info("Service JSON: " + data);
 		JSONObject queryParams;
 		List<Device> devices = new ArrayList<Device>();
 		String title;
 		String message;
 		String url;
 		String recipient;
 		String sender = "KME_PUSH";
 		String senderKey;
 		JSONArray recipients;
 		try {
 
 
                 queryParams = (JSONObject) JSONSerializer.toJSON(data);
                 title = queryParams.getString("title");
                 message = queryParams.getString("message");
                 url = queryParams.getString("url");
                 senderKey = queryParams.getString("senderKey");
 
 			String source = getKmeProperties().getProperty("push.sender.key.source", "database");
 			if("database".equalsIgnoreCase(source)){
 				LOG.info("Getting SenderKeys from database.");
 				Sender senderObj = senderService.findSenderBySenderKey(senderKey);
 				if (senderObj == null) {
 					LOG.info("---- " + senderKey + " is Not in LHM. May not Send Push Notifications");
 					return new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
 				} else {
 					sender = senderObj.getShortName();
 				}
 			}else if("properties".equalsIgnoreCase(source)){
 				LOG.info("Getting SenderKeys from properties file.");
 				String shortName = getSenderKeysProperties().getProperty(senderKey);
 				if(shortName == null){
 					LOG.info("---- " + senderKey + " is Not in LHM. May not Send Push Notifications");
 					return new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
 				}else{
 					sender = shortName;
 				}
 			}
 			
 			
 			if (queryParams.has(RECIPIENTS)) {
                     if ("net.sf.json.JSONArray".equals(queryParams.get(RECIPIENTS).getClass().getName())) {
 
                         recipients = queryParams.getJSONArray(RECIPIENTS);
                         LOG.info("recipients: " + recipients.toString());
                         Iterator i = recipients.iterator();
                         while (i.hasNext()) {
                             String username = i.next().toString();
                             LOG.info("username: " + username);
                             devices.addAll(deviceService
                                     .findDevicesByUsername(username));
                         }
                     } else {
                         recipient = queryParams.getString("recipients");
                         LOG.info(recipient);
                     }
                 }
 			if (queryParams.has("devices") && "net.sf.json.JSONArray".equals(queryParams.get("devices").getClass().getName()) ) {
 				JSONArray jDevices = queryParams.getJSONArray("devices");
 				LOG.info("devices: " + jDevices.toString());
 				Iterator i = jDevices.iterator();
 				while (i.hasNext()) {
 					String sDevice = i.next().toString();
 					LOG.info("device: " + sDevice);
 					devices.add(deviceService.findDeviceByDeviceId(sDevice));
 				}
                 }
 
             } catch (JSONException je) {
                 LOG.error("JSONException in :" + data + " : " + je.getMessage());
                 return new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
             } catch (ClassCastException cce) {
                 LOG.error(cce.getLocalizedMessage(), cce);
                 return new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
             }
 
             Push push = new Push();
             push.setEmergency(false);
             push.setMessage(message);
             push.setTitle(title);
             push.setUrl(url);
             push.setSender(sender);
             push.setPostedTimestamp(new Timestamp(System.currentTimeMillis()));
             pushService.savePush(push);
             int pushed = pushService.sendPush(push, devices);
             push.setRecipients(pushed);
             pushService.savePush(push);
             LOG.info(push.toString());
 
             return new ResponseEntity<String>(HttpStatus.OK);
         }
     }
 
 	
 
 	/**
 	 * Controller used by devices informing KME that a message has been received
 	 * on the device.
 	 * 
 	 * @param data
 	 *            JSON containing the device id and notification id
 	 * @return
 	 */
 	@Deprecated
 	@RequestMapping(value = "/received", method = RequestMethod.GET)
 	public ResponseEntity<String> receivedNotification(@RequestBody String data) {
 		try {
 			JSONObject inform = (JSONObject) JSONSerializer.toJSON(data);
 			String deviceId = inform.getString("deviceId");
 			List<Device> d = deviceService.findDevicesByDeviceId(deviceId);
 			if (d == null || d.size() == 0) {
 				return new ResponseEntity<String>(HttpStatus.OK);
 			}
 			// TODO update user push, update PushDeviceTuple
 			/*
 			 * String username = d.get(0).getUsername(); long notificationId =
 			 * inform.getLong("notificationId");
 			 * this.userPushService.markPushReceived(username, notificationId);
 			 */
         } catch (JSONException je) {
             LOG.error("JSONException in :" + data + " : " + je.getMessage());
             return new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
         } catch (ClassCastException cce) {
             LOG.error(cce.getLocalizedMessage(), cce);
             return new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
         }
         return new ResponseEntity<String>(HttpStatus.OK);
     }
 
     /**
      * A method to get predefined PushMessages. Pulled from localized *.properties files.
      *
      * @return Map<String, String>
      */
     // getPushMessages() method reads values from properties file
     public Map<String, String> getPushMessages() {
         Map<String, String> pushMessages = new LinkedHashMap<String, String>();
         String stockPushMessage1 = messageSource.getMessage(
                 "push.test.message.stg", null, null);
         String stockPushMessage2 = messageSource.getMessage(
                 "push.new.feature.kme", null, null);
         String stockPushMessage3 = messageSource.getMessage(
                 "push.log.protected.tool", null, null);
         String stockPushMessage4 = messageSource.getMessage(
                 "push.tornado.warning", null, null);
         String stockPushMessage5 = messageSource.getMessage(
                 "push.crime.local.car.thieves", null, null);
         pushMessages.put("Test Message STG", stockPushMessage1);
         pushMessages.put("New Feature in KME", stockPushMessage2);
         pushMessages.put("Log into a protected tool", stockPushMessage3);
         pushMessages.put("Tornado Warning", stockPushMessage4);
         pushMessages.put("Crime: Local Car Thieves", stockPushMessage5);
         return pushMessages;
     }
 
     /**
      * A method to get predefined PushMessages. Pulled from Database by Locale attribute.
      * Stock Push Messages are inserted during the PushBootListener bootstrapping.
      *
      * @param locale
      * @return Map<String, String> of push Messages.
      */
     public Map<String, String> getPushMessages(Locale locale) {
         List<PushMessage> pms = pushMessageService.findAllPushMessagesByLanguage(locale.getLanguage());
         Map<String, String> pushMessages = new LinkedHashMap<String, String>();
         Iterator<PushMessage> it = pms.iterator();
         while (it.hasNext()) {
             PushMessage pm = it.next();
             pushMessages.put(pm.getTitle(), pm.getMessage());
         }
         return pushMessages;
     }
 
 
     /**
      * A method for setting the keyListFile for the controller.
      *
      * @param keyListFile
      */
     public void setKeyListFile(String keyListFile) {
         this.keyListFile = keyListFile;
     }
 
     /**
      * A method for retrieving the keyListFile from the controller.
      *
      * @return
      */
     public String getKeyListFile() {
         return this.keyListFile;
     }
 
     /**
      * A method for setting the <code>PushService</code> for the controller.
      *
      * @param pushService
      */
     public void setPushService(PushService pushService) {
         this.pushService = pushService;
     }
 
     /**
      * A method for setting the <code>DeviceService</code> for the controller.
      *
      * @param deviceService
      */
     public void setDeviceService(DeviceService deviceService) {
         this.deviceService = deviceService;
     }
 
     /**
      * A method for setting the <code>SenderService</code> for the controller.
      *
      * @param senderService
      */
     public void setSenderService(SenderService senderService) {
         this.senderService = senderService;
     }
 
     public SenderService getSenderService() {
         return senderService;
     }
 
     /**
      * @return the messageSource
      */
     public MessageSource getMessageSource() {
         return messageSource;
     }
 
     /**
      * @param messageSource the messageSource to set
      */
     public void setMessageSource(MessageSource messageSource) {
         this.messageSource = messageSource;
     }
 
 
     /**
      * @param pmService the pmService to set
      */
     public void setPushMessageService(PushMessageService pmService) {
         this.pushMessageService = pmService;
     }
 
 
     /**
      * @return the stockPushMessages
      */
     public Map<String, String> getStockPushMessages() {
         return stockPushMessages;
     }
 
     /**
      * @param stockPushMessages the stockPushMessages to set
      */
     public void setStockPushMessages(Map<String, String> stockPushMessages) {
         this.stockPushMessages = stockPushMessages;
     }
 
     /**
      * @return the kmeProperties
      */
     public Properties getKmeProperties() {
         return kmeProperties;
     }
 
     /**
      * @param kmeProperties the kmeProperties to set
      */
     public void setKmeProperties(Properties kmeProperties) {
         this.kmeProperties = kmeProperties;
     }
 
 	/**
 	 * @return the senderKeysProperties
 	 */
 	public Properties getSenderKeysProperties() {
 		return senderKeysProperties;
 	}
 
 
 	/**
 	 * @param senderKeysProperties the senderKeysProperties to set
 	 */
 	public void setSenderKeysProperties(Properties senderKeysProperties) {
 		this.senderKeysProperties = senderKeysProperties;
 	}
 }