cloud/account/src/main/java/org/iotivity/cloud/accountserver/resources/acl/invite/InviteManager.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.acl.invite;
  23
  24 import java.util.ArrayList;
  25 import java.util.HashMap;
  26 import java.util.List;
  27
  28 import org.iotivity.cloud.accountserver.Constants;
  29 import org.iotivity.cloud.accountserver.db.AccountDBManager;
  30 import org.iotivity.cloud.accountserver.db.InviteTable;
  31 import org.iotivity.cloud.accountserver.util.TypeCastingManager;
  32 import org.iotivity.cloud.base.device.Device;
  33 import org.iotivity.cloud.base.exception.ServerException.BadRequestException;
  34 import org.iotivity.cloud.base.protocols.IRequest;
  35 import org.iotivity.cloud.base.protocols.MessageBuilder;
  36 import org.iotivity.cloud.base.protocols.enums.ContentFormat;
  37 import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
  38 import org.iotivity.cloud.util.Cbor;
  39
  40 /**
  41  *
  42  * This class provides a set of APIs to invite a user to a group
  43  *
  44  */
  45
  46 public class InviteManager {
  47
  48     private TypeCastingManager<InviteTable> mTypeInvite = new TypeCastingManager<>();
  49
  50     private class InviteSubscriber {
  51         InviteSubscriber(Device subscriber, IRequest request) {
  52             mSubscriber = subscriber;
  53             mRequest = request;
  54         }
  55
  56         public Device   mSubscriber;
  57         public IRequest mRequest;
  58     }
  59
  60     // <uid, subscriber list>
  61     private HashMap<String, ArrayList<InviteSubscriber>> mSubscribers = new HashMap<>();
  62
  63     public void addInvitation(String uid, String gid, String mid) {
  64
  65         // create invitation table
  66         InviteTable newInviteTable = new InviteTable(uid, gid, mid);
  67
  68         HashMap<String, Object> condition = new HashMap<>();
  69         condition.put(Constants.KEYFIELD_INVITE_USER, uid);
  70         condition.put(Constants.KEYFIELD_GID, gid);
  71         condition.put(Constants.KEYFIELD_INVITED_USER, mid);
  72
  73         if (AccountDBManager.getInstance()
  74                 .selectRecord(Constants.INVITE_TABLE, condition).isEmpty()) {
  75             AccountDBManager.getInstance().insertRecord(Constants.INVITE_TABLE,
  76                     mTypeInvite.convertObjectToMap(newInviteTable));
  77             notifyToSubscriber(uid);
  78             notifyToSubscriber(mid);
  79         }
  80     }
  81
  82     public void deleteInvitation(String mid, String gid) {
  83         HashMap<String, Object> condition = new HashMap<>();
  84         condition.put(Constants.REQ_GROUP_ID, gid);
  85         condition.put(Constants.KEYFIELD_INVITED_USER, mid);
  86
  87         InviteTable getInviteTable = new InviteTable();
  88
  89         List<HashMap<String, Object>> getInviteList = AccountDBManager
  90                 .getInstance().selectRecord(Constants.INVITE_TABLE, condition);
  91
  92         ArrayList<String> uidList = new ArrayList<>();
  93         for (HashMap<String, Object> getInvite : getInviteList) {
  94             getInviteTable = mTypeInvite.convertMaptoObject(getInvite,
  95                     getInviteTable);
  96             uidList.add(getInviteTable.getInviteUser());
  97         }
  98
  99         AccountDBManager.getInstance().deleteRecord(Constants.INVITE_TABLE,
 100                 condition);
 101
 102         notifyToSubscriber(mid);
 103         for (String uid : uidList) {
 104             notifyToSubscriber(uid);
 105         }
 106     }
 107
 108     public void cancelInvitation(String uid, String gid, String mid) {
 109
 110         HashMap<String, Object> condition = new HashMap<>();
 111
 112         condition.put(Constants.REQ_GROUP_ID, gid);
 113         condition.put(Constants.KEYFIELD_INVITED_USER, mid);
 114         condition.put(Constants.KEYFIELD_INVITE_USER, uid);
 115
 116         AccountDBManager.getInstance().deleteRecord(Constants.INVITE_TABLE,
 117                 condition);
 118
 119         notifyToSubscriber(uid);
 120         notifyToSubscriber(mid);
 121     }
 122
 123     public HashMap<String, Object> getInvitationInfo(String uid) {
 124         HashMap<String, Object> responsePayload = new HashMap<>();
 125
 126         ArrayList<Object> invitePayloadData = null;
 127         ArrayList<Object> invitedPayloadData = null;
 128
 129         List<InviteTable> inviteList = getInviteTableList(
 130                 Constants.KEYFIELD_INVITE_USER, uid);
 131         if (!inviteList.isEmpty()) {
 132             invitePayloadData = new ArrayList<>();
 133             for (InviteTable invite : inviteList) {
 134                 HashMap<String, String> inviteElement = new HashMap<>();
 135                 inviteElement.put(Constants.REQ_GROUP_ID, invite.getGid());
 136                 inviteElement.put(Constants.REQ_MEMBER,
 137                         invite.getInvitedUser());
 138                 invitePayloadData.add(inviteElement);
 139             }
 140         }
 141
 142         List<InviteTable> invitedList = getInviteTableList(
 143                 Constants.KEYFIELD_INVITED_USER, uid);
 144         if (!invitedList.isEmpty()) {
 145             invitedPayloadData = new ArrayList<>();
 146             for (InviteTable invited : invitedList) {
 147                 HashMap<String, String> invitedElement = new HashMap<>();
 148                 invitedElement.put(Constants.REQ_GROUP_ID, invited.getGid());
 149                 invitedElement.put(Constants.REQ_MEMBER,
 150                         invited.getInviteUser());
 151                 invitedPayloadData.add(invitedElement);
 152             }
 153         }
 154
 155         responsePayload.put(Constants.RESP_INVITE, invitePayloadData);
 156         responsePayload.put(Constants.RESP_INVITED, invitedPayloadData);
 157
 158         return responsePayload;
 159     }
 160
 161     public HashMap<String, Object> addSubscriber(String uid, Device subscriber,
 162             IRequest request) {
 163
 164         InviteSubscriber newSubscriber = new InviteSubscriber(subscriber,
 165                 request);
 166
 167         synchronized (mSubscribers) {
 168             ArrayList<InviteSubscriber> subscriberList = mSubscribers.get(uid);
 169
 170             if (subscriberList == null) {
 171                 subscriberList = new ArrayList<>();
 172             }
 173
 174             subscriberList.add(newSubscriber);
 175             mSubscribers.put(uid, subscriberList);
 176         }
 177
 178         return getInvitationInfo(uid);
 179     }
 180
 181     public HashMap<String, Object> removeSubscriber(String uid, IRequest request) {
 182
 183         synchronized (mSubscribers) {
 184             if (mSubscribers.containsKey(uid)) {
 185
 186                 mSubscribers.get(uid).removeIf(
 187                         subscriber -> subscriber.mRequest.getRequestId()
 188                                 .equals(request.getRequestId()));
 189             }
 190         }
 191
 192         return getInvitationInfo(uid);
 193     }
 194
 195     private void notifyToSubscriber(String id) {
 196
 197         synchronized (mSubscribers) {
 198             if (!mSubscribers.containsKey(id)) {
 199                 return;
 200             }
 201
 202             Cbor<HashMap<String, Object>> cbor = new Cbor<>();
 203             byte[] payload = cbor.encodingPayloadToCbor(getInvitationInfo(id));
 204
 205             for (InviteSubscriber subscriber : mSubscribers.get(id)) {
 206
 207                 subscriber.mSubscriber.sendResponse(MessageBuilder
 208                         .createResponse(subscriber.mRequest,
 209                                 ResponseStatus.CONTENT,
 210                                 ContentFormat.APPLICATION_CBOR, payload));
 211             }
 212         }
 213     }
 214
 215     private List<InviteTable> getInviteTableList(String property, String uid) {
 216
 217         InviteTable getInviteTable = new InviteTable();
 218         ArrayList<InviteTable> inviteList = new ArrayList<>();
 219
 220         HashMap<String, Object> condition = new HashMap<>();
 221         condition.put(property, uid);
 222         ArrayList<HashMap<String, Object>> mapInviteList = AccountDBManager
 223                 .getInstance().selectRecord(Constants.INVITE_TABLE, condition);
 224         if (mapInviteList == null) {
 225             throw new BadRequestException("uid is invalid");
 226         }
 227         for (HashMap<String, Object> mapInviteTable : mapInviteList) {
 228
 229             getInviteTable = mTypeInvite.convertMaptoObject(mapInviteTable,
 230                     getInviteTable);
 231             inviteList.add(getInviteTable);
 232         }
 233         return inviteList;
 234
 235     }
 236
 237 }