@PUT
 @Path("device/{deviceId}/policy")
 public Response updatePolicy(
     @PathParam("deviceId") String deviceId,
     @QueryParam("protocol") String protocol,
     @FormParam("policy") String policy) {
   String protocolString = protocol.toUpperCase();
   if (log.isDebugEnabled()) {
     log.debug(
         "Sending request to update-policy of device [" + deviceId + "] via " + protocolString);
   }
   try {
     if (!APIUtil.getDeviceAccessAuthorizationService()
         .isUserAuthorized(
             new DeviceIdentifier(deviceId, VirtualFireAlarmConstants.DEVICE_TYPE),
             DeviceGroupConstants.Permissions.DEFAULT_MANAGE_POLICIES_PERMISSIONS)) {
       return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
     }
     PrivateKey serverPrivateKey = VirtualFirealarmSecurityManager.getServerPrivateKey();
     String actualMessage = VirtualFireAlarmConstants.POLICY_CONTEXT + ":" + policy;
     String encryptedMsg =
         VirtualFireAlarmServiceUtils.prepareSecurePayLoad(actualMessage, serverPrivateKey);
     Map<String, String> dynamicProperties = new HashMap<>();
     switch (protocolString) {
       case XMPP_PROTOCOL:
         dynamicProperties.put(
             VirtualFireAlarmConstants.JID_PROPERTY_KEY,
             deviceId + "@" + XmppConfig.getInstance().getServerName());
         dynamicProperties.put(VirtualFireAlarmConstants.SUBJECT_PROPERTY_KEY, "POLICTY-REQUEST");
         dynamicProperties.put(
             VirtualFireAlarmConstants.MESSAGE_TYPE_PROPERTY_KEY,
             VirtualFireAlarmConstants.CHAT_PROPERTY_KEY);
         APIUtil.getOutputEventAdapterService()
             .publish(
                 VirtualFireAlarmConstants.XMPP_ADAPTER_NAME, dynamicProperties, encryptedMsg);
         break;
       default:
         String publishTopic =
             APIUtil.getTenantDomainOftheUser()
                 + "/"
                 + VirtualFireAlarmConstants.DEVICE_TYPE
                 + "/"
                 + deviceId;
         dynamicProperties.put(VirtualFireAlarmConstants.ADAPTER_TOPIC_PROPERTY, publishTopic);
         APIUtil.getOutputEventAdapterService()
             .publish(
                 VirtualFireAlarmConstants.MQTT_ADAPTER_NAME, dynamicProperties, encryptedMsg);
         break;
     }
     return Response.ok().build();
   } catch (DeviceAccessAuthorizationException e) {
     log.error(e.getErrorMessage(), e);
     return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
   } catch (VirtualFireAlarmException e) {
     log.error(e);
     return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
   }
 }
 @Path("device/stats/{deviceId}")
 @GET
 @Consumes("application/json")
 @Produces("application/json")
 public Response getVirtualFirealarmStats(
     @PathParam("deviceId") String deviceId,
     @QueryParam("from") long from,
     @QueryParam("to") long to) {
   String fromDate = String.valueOf(from);
   String toDate = String.valueOf(to);
   String query =
       "deviceId:"
           + deviceId
           + " AND deviceType:"
           + VirtualFireAlarmConstants.DEVICE_TYPE
           + " AND time : ["
           + fromDate
           + " TO "
           + toDate
           + "]";
   String sensorTableName = VirtualFireAlarmConstants.TEMPERATURE_EVENT_TABLE;
   try {
     if (!APIUtil.getDeviceAccessAuthorizationService()
         .isUserAuthorized(
             new DeviceIdentifier(deviceId, VirtualFireAlarmConstants.DEVICE_TYPE),
             DeviceGroupConstants.Permissions.DEFAULT_STATS_MONITOR_PERMISSIONS)) {
       return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
     }
     List<SortByField> sortByFields = new ArrayList<>();
     SortByField sortByField = new SortByField("time", SORT.ASC, false);
     sortByFields.add(sortByField);
     List<SensorRecord> sensorRecords =
         APIUtil.getAllEventsForDevice(sensorTableName, query, sortByFields);
     return Response.status(Response.Status.OK.getStatusCode()).entity(sensorRecords).build();
   } catch (AnalyticsException e) {
     String errorMsg =
         "Error on retrieving stats on table " + sensorTableName + " with query " + query;
     log.error(errorMsg);
     return Response.status(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode())
         .entity(errorMsg)
         .build();
   } catch (DeviceAccessAuthorizationException e) {
     log.error(e.getErrorMessage(), e);
     return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
   }
 }
  @POST
  @Path("device/{deviceId}/buzz")
  public Response switchBuzzer(
      @PathParam("deviceId") String deviceId, @FormParam("state") String state) {
    if (state == null || state.isEmpty()) {
      log.error("State is not defined for the buzzer operation");
      return Response.status(Response.Status.BAD_REQUEST).build();
    }
    String switchToState = state.toUpperCase();
    if (!switchToState.equals(VirtualFireAlarmConstants.STATE_ON)
        && !switchToState.equals(VirtualFireAlarmConstants.STATE_OFF)) {
      log.error("The requested state change shoud be either - 'ON' or 'OFF'");
      return Response.status(Response.Status.BAD_REQUEST).build();
    }
    try {
      if (!APIUtil.getDeviceAccessAuthorizationService()
          .isUserAuthorized(
              new DeviceIdentifier(deviceId, VirtualFireAlarmConstants.DEVICE_TYPE),
              DeviceGroupConstants.Permissions.DEFAULT_OPERATOR_PERMISSIONS)) {
        return Response.status(Response.Status.UNAUTHORIZED.getStatusCode()).build();
      }
      String resource = VirtualFireAlarmConstants.BULB_CONTEXT.replace("/", "");
      PrivateKey serverPrivateKey = VirtualFirealarmSecurityManager.getServerPrivateKey();
      String actualMessage = resource + ":" + switchToState;
      String encryptedMsg =
          VirtualFireAlarmServiceUtils.prepareSecurePayLoad(actualMessage, serverPrivateKey);
      String publishTopic =
          APIUtil.getTenantDomainOftheUser()
              + "/"
              + VirtualFireAlarmConstants.DEVICE_TYPE
              + "/"
              + deviceId;

      Operation commandOp = new CommandOperation();
      commandOp.setCode("buzz");
      commandOp.setType(Operation.Type.COMMAND);
      commandOp.setEnabled(true);
      commandOp.setPayLoad(encryptedMsg);

      Properties props = new Properties();
      props.setProperty(VirtualFireAlarmConstants.MQTT_ADAPTER_TOPIC_PROPERTY_NAME, publishTopic);
      props.setProperty(
          VirtualFireAlarmConstants.CLIENT_JID_PROPERTY_KEY,
          deviceId + "@" + XmppConfig.getInstance().getServerName());
      props.setProperty(VirtualFireAlarmConstants.SUBJECT_PROPERTY_KEY, "CONTROL-REQUEST");
      props.setProperty(
          VirtualFireAlarmConstants.MESSAGE_TYPE_PROPERTY_KEY,
          VirtualFireAlarmConstants.CHAT_PROPERTY_KEY);
      commandOp.setProperties(props);

      List<DeviceIdentifier> deviceIdentifiers = new ArrayList<>();
      deviceIdentifiers.add(new DeviceIdentifier(deviceId, VirtualFireAlarmConstants.DEVICE_TYPE));
      APIUtil.getDeviceManagementService()
          .addOperation(VirtualFireAlarmConstants.DEVICE_TYPE, commandOp, deviceIdentifiers);
      return Response.ok().build();
    } catch (DeviceAccessAuthorizationException e) {
      log.error(e.getErrorMessage(), e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
    } catch (VirtualFireAlarmException e) {
      String errorMsg = "Preparing Secure payload failed for device - [" + deviceId + "]";
      log.error(errorMsg);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
    } catch (OperationManagementException e) {
      String msg = "Error occurred while executing command operation upon ringing the buzzer";
      log.error(msg, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
    }
  }