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 (!getUriPathSegments().containsAll(request.getUriPathSegments())) {
  95             String aclid = request.getUriPathSegments()
  96                     .get(getUriPathSegments().size());
  97
  98             List<HashMap<String, Object>> aclist = null;
  99
 100             checkPayloadException(Constants.REQ_ACL_LIST, payloadData);
 101
 102             aclist = (List<HashMap<String, Object>>) payloadData
 103                     .get(Constants.REQ_ACL_LIST);
 104             mAclManager.addAclACE(aclid, aclist);
 105             return MessageBuilder.createResponse(request,
 106                     ResponseStatus.CHANGED);
 107         } else if (getUriPathSegments()
 108                 .containsAll(request.getUriPathSegments())) {
 109             String aclid = request.getUriPathSegments()
 110                     .get(getUriPathSegments().size());
 111             String aceid = request.getUriQueryMap().get(Constants.REQ_ACE_ID)
 112                     .get(0);
 113             HashMap<String, Object> ace = (HashMap<String, Object>) payloadData
 114                     .get(Constants.REQ_ACL_LIST);
 115             mAclManager.updateACE(aclid, aceid, ace);
 116             return MessageBuilder.createResponse(request,
 117                     ResponseStatus.CHANGED);
 118         }
 119
 120         throw new BadRequestException("uriPath is invalid");
 121
 122     }
 123
 124     @SuppressWarnings("unchecked")
 125
 126     private IResponse handleGetRequest(Device srcDevice, IRequest request)
 127             throws ServerException {
 128
 129         HashMap<String, Object> responsePayload = null;
 130         String di = null;
 131
 132         if (getUriPathSegments().containsAll(request.getUriPathSegments())) {
 133             di = request.getUriQueryMap().get(Constants.REQ_DEVICE_ID).get(0);
 134             if (di == null) {
 135                 throw new PreconditionFailedException("di is invalid");
 136             }
 137             responsePayload = mAclManager.getAclid(di);
 138         } else {
 139             String aclid = request.getUriPathSegments()
 140                     .get(getUriPathSegments().size());
 141             switch (request.getObserve()) {
 142                 case NOTHING:
 143                     responsePayload = mAclManager.getAclInfo(aclid);
 144                     break;
 145                 case SUBSCRIBE:
 146                     di = request.getUriQueryMap().get(Constants.REQ_DEVICE_ID)
 147                             .get(0);
 148                     responsePayload = mAclManager.addAclSubscriber(aclid, di,
 149                             srcDevice, request);
 150                     break;
 151                 case UNSUBSCRIBE:
 152                     di = request.getUriQueryMap().get(Constants.REQ_DEVICE_ID)
 153                             .get(0);
 154                     responsePayload = mAclManager.removeAclSubscriber(aclid,
 155                             di);
 156                     break;
 157                 default:
 158                     throw new BadRequestException(request.getObserve()
 159                             + " observe type is not supported");
 160             }
 161
 162         }
 163
 164         return MessageBuilder.createResponse(request, ResponseStatus.CONTENT,
 165                 ContentFormat.APPLICATION_CBOR,
 166                 mCbor.encodingPayloadToCbor(responsePayload));
 167
 168     }
 169
 170     private IResponse handleDeleteRequest(IRequest request)
 171             throws ServerException {
 172
 173         String aclid = null;
 174
 175         if (getUriPathSegments().containsAll(request.getUriPathSegments())) {
 176             aclid = request.getUriQueryMap().get(Constants.REQ_ACL_ID).get(0);
 177             if (aclid == null) {
 178                 throw new PreconditionFailedException("aclid is invalid");
 179             }
 180             mAclManager.deleteAcl(aclid);
 181         } else {
 182             aclid = request.getUriPathSegments()
 183                     .get(getUriPathSegments().size());
 184             String aceid = request.getUriQueryMap().get(Constants.REQ_ACE_ID)
 185                     .get(0);
 186             if (aceid == null) {
 187                 mAclManager.deleteAclAclist(aclid);
 188             } else {
 189                 mAclManager.deleteAclACE(aclid, aceid);
 190             }
 191         }
 192
 193         return MessageBuilder.createResponse(request, ResponseStatus.DELETED);
 194     }
 195
 196 }