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 public class InviteManager {
  41
  42     private TypeCastingManager<InviteTable> mTypeInvite = new TypeCastingManager<>();
  43
  44     private class InviteSubscriber {
  45         InviteSubscriber(Device subscriber, IRequest request) {
  46             mSubscriber = subscriber;
  47             mRequest = request;
  48         }
  49
  50         public Device   mSubscriber;
  51         public IRequest mRequest;
  52     }
  53
  54     private HashMap<String, InviteSubscriber> mSubscribers = new HashMap<>();
  55
  56     public void addInvitation(String uid, String gid, String mid) {
  57
  58         InviteTable newInviteTable = new InviteTable(uid, gid, mid);
  59
  60         HashMap<String, Object> condition = new HashMap<>();
  61         condition.put(Constants.KEYFIELD_INVITE_USER, uid);
  62         condition.put(Constants.KEYFIELD_GID, gid);
  63         condition.put(Constants.KEYFIELD_INVITED_USER, mid);
  64
  65         if (AccountDBManager.getInstance()
  66                 .selectRecord(Constants.INVITE_TABLE, condition).isEmpty()) {
  67             AccountDBManager.getInstance().insertRecord(Constants.INVITE_TABLE,
  68                     mTypeInvite.convertObjectToMap(newInviteTable));
  69             notifyToSubscriber(uid);
  70             notifyToSubscriber(mid);
  71         }
  72     }
  73
  74     public void deleteInvitation(String mid, String gid) {
  75         HashMap<String, Object> condition = new HashMap<>();
  76         condition.put(Constants.REQ_GROUP_ID, gid);
  77         condition.put(Constants.KEYFIELD_INVITED_USER, mid);
  78
  79         InviteTable getInviteTable = new InviteTable();
  80
  81         List<HashMap<String, Object>> getInviteList = AccountDBManager
  82                 .getInstance().selectRecord(Constants.INVITE_TABLE, condition);
  83
  84         ArrayList<String> uidList = new ArrayList<>();
  85         for (HashMap<String, Object> getInvite : getInviteList) {
  86             getInviteTable = mTypeInvite.convertMaptoObject(getInvite,
  87                     getInviteTable);
  88             uidList.add(getInviteTable.getInviteUser());
  89         }
  90
  91         AccountDBManager.getInstance().deleteRecord(Constants.INVITE_TABLE,
  92                 condition);
  93
  94         notifyToSubscriber(mid);
  95         for (String uid : uidList) {
  96             notifyToSubscriber(uid);
  97         }
  98     }
  99
 100     public void cancelInvitation(String uid, String gid, String mid) {
 101
 102         HashMap<String, Object> condition = new HashMap<>();
 103
 104         condition.put(Constants.REQ_GROUP_ID, gid);
 105         condition.put(Constants.KEYFIELD_INVITED_USER, mid);
 106         condition.put(Constants.KEYFIELD_INVITE_USER, uid);
 107
 108         AccountDBManager.getInstance().deleteRecord(Constants.INVITE_TABLE,
 109                 condition);
 110
 111         notifyToSubscriber(uid);
 112         notifyToSubscriber(mid);
 113     }
 114
 115     public HashMap<String, Object> getInvitationInfo(String uid) {
 116         HashMap<String, Object> responsePayload = new HashMap<>();
 117
 118         ArrayList<Object> invitePayloadData = null;
 119         ArrayList<Object> invitedPayloadData = null;
 120
 121         List<InviteTable> inviteList = getInviteTableList(
 122                 Constants.KEYFIELD_INVITE_USER, uid);
 123         if (!inviteList.isEmpty()) {
 124             invitePayloadData = new ArrayList<>();
 125             for (InviteTable invite : inviteList) {
 126                 HashMap<String, String> inviteElement = new HashMap<>();
 127                 inviteElement.put(Constants.REQ_GROUP_ID, invite.getGid());
 128                 inviteElement.put(Constants.REQ_MEMBER,
 129                         invite.getInvitedUser());
 130                 invitePayloadData.add(inviteElement);
 131             }
 132         }
 133
 134         List<InviteTable> invitedList = getInviteTableList(
 135                 Constants.KEYFIELD_INVITED_USER, uid);
 136         if (inviteList.isEmpty()) {
 137             invitedPayloadData = new ArrayList<>();
 138             for (InviteTable invited : invitedList) {
 139                 HashMap<String, String> invitedElement = new HashMap<>();
 140                 invitedElement.put(Constants.REQ_GROUP_ID, invited.getGid());
 141                 invitedElement.put(Constants.REQ_MEMBER,
 142                         invited.getInviteUser());
 143                 invitedPayloadData.add(invitedElement);
 144             }
 145         }
 146
 147         responsePayload.put(Constants.RESP_INVITE, invitePayloadData);
 148         responsePayload.put(Constants.RESP_INVITED, invitedPayloadData);
 149
 150         return responsePayload;
 151     }
 152
 153     public HashMap<String, Object> addSubscriber(String uid, Device subscriber,
 154             IRequest request) {
 155
 156         InviteSubscriber newSubscriber = new InviteSubscriber(subscriber,
 157                 request);
 158         mSubscribers.put(uid, newSubscriber);
 159
 160         return getInvitationInfo(uid);
 161     }
 162
 163     public HashMap<String, Object> removeSubscriber(String uid) {
 164
 165         if (mSubscribers.containsKey(uid)) {
 166             mSubscribers.remove(uid);
 167         }
 168
 169         return getInvitationInfo(uid);
 170     }
 171
 172     private void notifyToSubscriber(String id) {
 173
 174         synchronized (mSubscribers) {
 175             if (!mSubscribers.containsKey(id)) {
 176                 return;
 177             }
 178             Cbor<HashMap<String, Object>> cbor = new Cbor<>();
 179             mSubscribers.get(id).mSubscriber.sendResponse(
 180                     MessageBuilder.createResponse(mSubscribers.get(id).mRequest,
 181                             ResponseStatus.CONTENT,
 182                             ContentFormat.APPLICATION_CBOR,
 183                             cbor.encodingPayloadToCbor(getInvitationInfo(id))));
 184         }
 185     }
 186
 187     private List<InviteTable> getInviteTableList(String property, String uid) {
 188
 189         InviteTable getInviteTable = new InviteTable();
 190         ArrayList<InviteTable> inviteList = new ArrayList<>();
 191
 192         HashMap<String, Object> condition = new HashMap<>();
 193         condition.put(property, uid);
 194         ArrayList<HashMap<String, Object>> mapInviteList = AccountDBManager
 195                 .getInstance().selectRecord(Constants.INVITE_TABLE, condition);
 196         if (mapInviteList == null) {
 197             throw new BadRequestException("uid is invalid");
 198         }
 199         for (HashMap<String, Object> mapInviteTable : mapInviteList) {
 200
 201             getInviteTable = mTypeInvite.convertMaptoObject(mapInviteTable,
 202                     getInviteTable);
 203             inviteList.add(getInviteTable);
 204         }
 205         return inviteList;
 206
 207     }
 208
 209 }