cloud/account/src/main/java/org/iotivity/cloud/accountserver/resources/AccountResource.java

   1 /*
   2  * //******************************************************************
   3  * //
   4  * // Copyright 2016 Samsung Electronics All Rights Reserved.
   5  * //
   6  * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   7  * //
   8  * // Licensed under the Apache License, Version 2.0 (the "License");
   9  * // you may not use this file except in compliance with the License.
  10  * // You may obtain a copy of the License at
  11  * //
  12  * //      http://www.apache.org/licenses/LICENSE-2.0
  13  * //
  14  * // Unless required by applicable law or agreed to in writing, software
  15  * // distributed under the License is distributed on an "AS IS" BASIS,
  16  * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * // See the License for the specific language governing permissions and
  18  * // limitations under the License.
  19  * //
  20  * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  21  */
  22 package org.iotivity.cloud.accountserver.resources;
  23
  24 import java.util.ArrayList;
  25 import java.util.HashMap;
  26 import java.util.List;
  27
  28 import org.iotivity.cloud.accountserver.AccountServerManager;
  29 import org.iotivity.cloud.accountserver.Constants;
  30 import org.iotivity.cloud.accountserver.util.CoapMessageBuilder;
  31 import org.iotivity.cloud.base.Resource;
  32 import org.iotivity.cloud.base.protocols.coap.CoapRequest;
  33 import org.iotivity.cloud.base.protocols.coap.CoapResponse;
  34 import org.iotivity.cloud.base.protocols.coap.enums.CoapMethod;
  35 import org.iotivity.cloud.base.protocols.coap.enums.CoapStatus;
  36 import org.iotivity.cloud.util.JSONUtil;
  37 import org.iotivity.cloud.util.Logger;
  38
  39 import io.netty.channel.ChannelHandlerContext;
  40
  41 /**
  42  *
  43  * This class provides a set of APIs to manage resources corresponding with user
  44  * account
  45  *
  46  */
  47 public class AccountResource extends Resource {
  48
  49     public AccountResource() {
  50         setUri(Constants.ACCOUNT_URI);
  51     }
  52
  53     @Override
  54     public void onRequestReceived(ChannelHandlerContext ctx,
  55             CoapRequest request) {
  56
  57         Logger.d("AccountResource IN");
  58
  59         if (ctx == null || request == null) {
  60             Logger.d("ctx or request msg is null");
  61         }
  62
  63         else {
  64             CoapMethod method = request.getRequestMethod();
  65
  66             switch (method) {
  67                 case GET:
  68                     try {
  69                         handleGetRequest(ctx, request);
  70                     } catch (Exception e) {
  71                         e.printStackTrace();
  72                     }
  73                     break;
  74
  75                 case POST:
  76                     try {
  77                         handlePostRequest(ctx, request);
  78                     } catch (Exception e) {
  79                         e.printStackTrace();
  80                     }
  81                     break;
  82
  83                 default:
  84                     Logger.w("method[" + method + "] is not supported");
  85                     break;
  86             }
  87         }
  88     }
  89
  90     private void handleGetRequest(ChannelHandlerContext ctx,
  91             CoapRequest request) throws Exception {
  92
  93         String reqType = extractQuery(request, Constants.REQ_TYPE);
  94
  95         if (reqType == null)
  96             throw new IllegalArgumentException(
  97                     "request type is null in query!");
  98
  99         CoapResponse response = null;
 100
 101         switch (reqType) {
 102             case Constants.TYPE_FIND:
 103                 response = handleFindRequest(request);
 104                 break;
 105             default:
 106                 Logger.w("reqType[" + reqType + "] is not supported");
 107         }
 108         if (response != null) {
 109             ctx.writeAndFlush(response);
 110         }
 111
 112     }
 113
 114     private void handlePostRequest(ChannelHandlerContext ctx,
 115             CoapRequest request) throws Exception {
 116
 117         String reqType = extractQuery(request, Constants.REQ_TYPE);
 118
 119         if (reqType == null)
 120             throw new IllegalArgumentException(
 121                     "request type is null in query!");
 122
 123         CoapResponse response;
 124
 125         switch (reqType) {
 126             case Constants.TYPE_PUBLISH:
 127                 response = handlePublishRequest(request);
 128                 break;
 129             default:
 130                 throw new IllegalArgumentException(
 131                         "request type is not supported");
 132         }
 133
 134         ctx.writeAndFlush(response);
 135     }
 136
 137     /**
 138      * API for handling request for publishing resource corresponding with user
 139      * account
 140      *
 141      * @param requeset
 142      *            CoAP request message
 143      * @return CoapResponse - CoAP response message with response result
 144      *         information
 145      */
 146     private CoapResponse handlePublishRequest(CoapRequest request) {
 147
 148         String payload = request.getPayloadString();
 149
 150         String userId = JSONUtil.parseJSON(payload, Constants.REQUEST_USER_ID);
 151         String deviceId = JSONUtil.parseJSON(payload,
 152                 Constants.REQUEST_DEVICE_ID);
 153
 154         Logger.d("userId: " + userId + ", deviceId: " + deviceId);
 155
 156         AccountServerManager oauthServerManager = new AccountServerManager();
 157         Boolean status = oauthServerManager.registerUserAccount(userId,
 158                 deviceId);
 159
 160         Logger.d("status : " + status);
 161
 162         CoapMessageBuilder responseMessage = new CoapMessageBuilder();
 163         CoapResponse coapResponse;
 164
 165         if (status) {
 166             coapResponse = responseMessage.buildCoapResponse(request.getToken(),
 167                     CoapStatus.CREATED);
 168         } else {
 169             coapResponse = responseMessage.buildCoapResponse(request.getToken(),
 170                     CoapStatus.INTERNAL_SERVER_ERROR);
 171         }
 172
 173         return coapResponse;
 174     }
 175
 176     /**
 177      * API for handling request for finding resource corresponding with user
 178      * account
 179      *
 180      * @param requeset
 181      *            CoAP request message
 182      * @return CoapResponse - CoAP response message with response result
 183      *         information
 184      */
 185     private CoapResponse handleFindRequest(CoapRequest request) {
 186
 187         String payload = request.getPayloadString();
 188         // String payload = getPayloadString(request.getPayload());
 189
 190         JSONUtil util = new JSONUtil();
 191         String userId = util.parseJSON(payload, Constants.REQUEST_USER_ID);
 192
 193         Logger.d("userId: " + userId);
 194
 195         AccountServerManager oauthServerManager = new AccountServerManager();
 196         ArrayList<String> deviceList = oauthServerManager
 197                 .requestAccountDevices(userId);
 198
 199         ResponseObject response = new ResponseObject();
 200         response.setDeviceList(deviceList);
 201
 202         String responseJson = convertFindResponseToJson(response);
 203         Logger.d("responseJson: " + responseJson);
 204
 205         CoapMessageBuilder responseMessage = new CoapMessageBuilder();
 206         CoapResponse coapResponse = responseMessage.buildCoapResponse(
 207                 request.getToken(), responseJson, CoapStatus.CONTENT);
 208
 209         return coapResponse;
 210     }
 211
 212     private String convertFindResponseToJson(ResponseObject response) {
 213
 214         HashMap<Object, Object> responseMap = new HashMap<Object, Object>();
 215
 216         ArrayList<String> deviceList = response.getDeviceList();
 217         responseMap.put(Constants.RESPONSE_DEVICES, deviceList);
 218
 219         String responseJson = JSONUtil.writeJSON(responseMap);
 220
 221         return responseJson;
 222     }
 223
 224     private String extractQuery(CoapRequest request, String key) {
 225
 226         String value = null;
 227
 228         List<String> Segments = request.getUriQuerySegments();
 229
 230         if (Segments != null) {
 231             for (String s : Segments) {
 232
 233                 String pair[] = s.split("=");
 234
 235                 if (pair[0].equals(key)) {
 236
 237                     value = pair[1];
 238                 }
 239             }
 240         }
 241
 242         return value;
 243     }
 244
 245     /*
 246      * private static String getPayloadString(byte[] payload) {
 247      *
 248      * if (payload == null) return "";
 249      *
 250      * return new String(payload, Charset.forName("UTF-8")); }
 251      */
 252
 253 }