cloud/account/src/main/java/org/iotivity/cloud/accountserver/resources/acl/id/AclResource.java

   1 package org.iotivity.cloud.accountserver.resources.acl.id;
   2
   3 import java.util.Arrays;
   4 import java.util.HashMap;
   5 import java.util.List;
   6
   7 import org.iotivity.cloud.accountserver.Constants;
   8 import org.iotivity.cloud.base.device.Device;
   9 import org.iotivity.cloud.base.exception.ServerException;
  10 import org.iotivity.cloud.base.exception.ServerException.BadRequestException;
  11 import org.iotivity.cloud.base.exception.ServerException.PreconditionFailedException;
  12 import org.iotivity.cloud.base.protocols.IRequest;
  13 import org.iotivity.cloud.base.protocols.IResponse;
  14 import org.iotivity.cloud.base.protocols.MessageBuilder;
  15 import org.iotivity.cloud.base.protocols.enums.ContentFormat;
  16 import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
  17 import org.iotivity.cloud.base.resource.Resource;
  18 import org.iotivity.cloud.util.Cbor;
  19
  20 public class AclResource extends Resource {
  21
  22     private Cbor<HashMap<String, Object>> mCbor       = new Cbor<>();
  23     private static AclManager             mAclManager = new AclManager();
  24
  25     public AclResource() {
  26         super(Arrays.asList(Constants.PREFIX_OIC, Constants.ACL_URI,
  27                 Constants.ID_URI));
  28     }
  29
  30     public static AclManager getInstance() {
  31         return mAclManager;
  32     }
  33
  34     @Override
  35     public void onDefaultRequestReceived(Device srcDevice, IRequest request)
  36             throws ServerException {
  37
  38         IResponse response = null;
  39
  40         if (request.getUriPathSegments().size() > getUriPathSegments().size()
  41                 + 1) {
  42             throw new BadRequestException("uriPath is invalid");
  43         }
  44
  45         switch (request.getMethod()) {
  46             case PUT:
  47                 response = handlePutRequest(request);
  48                 break;
  49             case POST:
  50                 response = handlePostRequest(request);
  51                 break;
  52             case GET:
  53                 response = handleGetRequest(srcDevice, request);
  54                 break;
  55             case DELETE:
  56                 response = handleDeleteRequest(request);
  57                 break;
  58             default:
  59                 throw new BadRequestException(
  60                         request.getMethod() + " request type is not support");
  61         }
  62
  63         srcDevice.sendResponse(response);
  64     }
  65
  66     private IResponse handlePutRequest(IRequest request)
  67             throws ServerException {
  68
  69         if (getUriPathSegments().containsAll(request.getUriPathSegments())) {
  70             String oid = request.getUriQueryMap().get(Constants.REQ_OWNER_ID)
  71                     .get(0);
  72             String di = request.getUriQueryMap().get(Constants.REQ_DEVICE_ID)
  73                     .get(0);
  74             if (mAclManager.getAclid(di) == null) {
  75                 return MessageBuilder.createResponse(request,
  76                         ResponseStatus.CREATED, ContentFormat.APPLICATION_CBOR,
  77                         mCbor.encodingPayloadToCbor(
  78                                 mAclManager.createAcl(oid, di)));
  79             } else {
  80                 throw new BadRequestException(
  81                         "aclid already exists for the given di");
  82             }
  83         }
  84
  85         throw new BadRequestException("uriPath is invalid");
  86     }
  87
  88     private IResponse handlePostRequest(IRequest request)
  89         throws ServerException {
  90
  91             HashMap<String, Object> payloadData = mCbor
  92                 .parsePayloadFromCbor(request.getPayload(), HashMap.class);
  93
  94             if (null !=request.getUriQueryMap()) {
  95                 String aclid = request.getUriPathSegments().get(getUriPathSegments().size());
  96                 String aceid = request.getUriQueryMap().get(Constants.REQ_ACE_ID).get(0);
  97                 List<HashMap<String, Object>> aclist = (List<HashMap<String, Object>>) payloadData
  98                     .get(Constants.REQ_ACL_LIST);
  99                 mAclManager.updateACE(aclid, aceid, aclist.get(0));
 100                 return MessageBuilder.createResponse(request, ResponseStatus.CHANGED);
 101             }
 102             else if (!getUriPathSegments().containsAll(request.getUriPathSegments())) {
 103                 String aclid = request.getUriPathSegments().get(getUriPathSegments().size());
 104
 105                 List<HashMap<String, Object>> aclist = null;
 106                 if (!payloadData.containsKey(Constants.REQ_ACL_LIST)) {
 107                     throw new BadRequestException("aclist not included in payload");
 108                 }
 109                 aclist = (List<HashMap<String, Object>>) payloadData
 110                     .get(Constants.REQ_ACL_LIST);
 111                 aclist= mAclManager.addAclACE(aclid, aclist);
 112                 payloadData.put(Constants.REQ_ACL_LIST, aclist);
 113                 return MessageBuilder.createResponse(request, ResponseStatus.CHANGED,
 114                         ContentFormat.APPLICATION_CBOR,
 115                         mCbor.encodingPayloadToCbor(payloadData));
 116             }
 117             throw new BadRequestException("uriPath is invalid");
 118         }
 119
 120
 121     @SuppressWarnings("unchecked")
 122
 123     private IResponse handleGetRequest(Device srcDevice, IRequest request)
 124             throws ServerException {
 125
 126         HashMap<String, Object> responsePayload = null;
 127         String di = null;
 128
 129         if (getUriPathSegments().containsAll(request.getUriPathSegments())) {
 130             di = request.getUriQueryMap().get(Constants.REQ_DEVICE_ID).get(0);
 131             if (di == null) {
 132                 throw new PreconditionFailedException("di is invalid");
 133             }
 134             responsePayload = mAclManager.getAclid(di);
 135         } else {
 136             String aclid = request.getUriPathSegments()
 137                     .get(getUriPathSegments().size());
 138             switch (request.getObserve()) {
 139                 case NOTHING:
 140                     responsePayload = mAclManager.getAclInfo(aclid);
 141                     break;
 142                 case SUBSCRIBE:
 143                     di = request.getUriQueryMap().get(Constants.REQ_DEVICE_ID)
 144                             .get(0);
 145                     responsePayload = mAclManager.addAclSubscriber(aclid, di,
 146                             srcDevice, request);
 147                     break;
 148                 case UNSUBSCRIBE:
 149                     di = request.getUriQueryMap().get(Constants.REQ_DEVICE_ID)
 150                             .get(0);
 151                     responsePayload = mAclManager.removeAclSubscriber(aclid,
 152                             di);
 153                     break;
 154                 default:
 155                     throw new BadRequestException(request.getObserve()
 156                             + " observe type is not supported");
 157             }
 158
 159         }
 160
 161         return MessageBuilder.createResponse(request, ResponseStatus.CONTENT,
 162                 ContentFormat.APPLICATION_CBOR,
 163                 mCbor.encodingPayloadToCbor(responsePayload));
 164
 165     }
 166
 167     private IResponse handleDeleteRequest(IRequest request)
 168             throws ServerException {
 169
 170         String aclid = null;
 171
 172         if (getUriPathSegments().containsAll(request.getUriPathSegments())) {
 173             aclid = request.getUriQueryMap().get(Constants.REQ_ACL_ID).get(0);
 174             if (aclid == null) {
 175                 throw new PreconditionFailedException("aclid is invalid");
 176             }
 177             mAclManager.deleteAcl(aclid);
 178         } else {
 179             aclid = request.getUriPathSegments()
 180                     .get(getUriPathSegments().size());
 181
 182             if (request.getUriQueryMap() == null)
 183             {
 184                 mAclManager.deleteAclAclist(aclid);
 185             }
 186             else if (request.getUriQueryMap()
 187                     .containsKey(Constants.REQ_ACE_ID)) {
 188                 String aceid = request.getUriQueryMap().get(Constants.REQ_ACE_ID)
 189                         .get(0);
 190                 mAclManager.deleteAclACE(aclid, aceid);
 191             }
 192             else {
 193                 throw new BadRequestException("uriPath is invalid");
 194             }
 195         }
 196
 197         return MessageBuilder.createResponse(request, ResponseStatus.DELETED);
 198     }
 199
 200 }