osmclient/sol005/user.py

   1 #
   2 # Copyright 2018 Telefonica Investigacion y Desarrollo S.A.U.
   3 #
   4 # All Rights Reserved.
   5 #
   6 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   7 #    not use this file except in compliance with the License. You may obtain
   8 #    a copy of the License at
   9 #
  10 #         http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 #    Unless required by applicable law or agreed to in writing, software
  13 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  14 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  15 #    License for the specific language governing permissions and limitations
  16 #    under the License.
  17
  18 """
  19 OSM user mgmt API
  20 """
  21
  22 from osmclient.common import utils
  23 from osmclient.common.exceptions import ClientException
  24 from osmclient.common.exceptions import NotFound
  25 from osmclient.common.exceptions import OsmHttpException
  26 import json
  27 import logging
  28
  29
  30 class User(object):
  31     def __init__(self, http=None, client=None):
  32         self._http = http
  33         self._client = client
  34         self._logger = logging.getLogger('osmclient')
  35         self._apiName = '/admin'
  36         self._apiVersion = '/v1'
  37         self._apiResource = '/users'
  38         self._apiBase = '{}{}{}'.format(self._apiName,
  39                                         self._apiVersion, self._apiResource)
  40
  41     def create(self, name, user):
  42         """Creates a new OSM user
  43         """
  44         self._logger.debug("")
  45         self._client.get_token()
  46         if not user["projects"] or (len(user["projects"]) == 1 and not user["projects"][0]):
  47             del user["projects"]
  48         elif len(user["projects"]) == 1:
  49             user["projects"] = user["projects"][0].split(",")
  50
  51         if user["project_role_mappings"]:
  52             project_role_mappings = []
  53
  54             for set_mapping in user["project_role_mappings"]:
  55                 set_mapping_clean = [m.strip() for m in set_mapping.split(",")]
  56                 project, roles = set_mapping_clean[0], set_mapping_clean[1:]
  57
  58                 for role in roles:
  59                     mapping = {"project": project, "role": role}
  60
  61                     if mapping not in project_role_mappings:
  62                         project_role_mappings.append(mapping)
  63
  64             user["project_role_mappings"] = project_role_mappings
  65         else:
  66             del user["project_role_mappings"]
  67
  68         http_code, resp = self._http.post_cmd(endpoint=self._apiBase,
  69                                        postfields_dict=user)
  70         #print('HTTP CODE: {}'.format(http_code))
  71         #print('RESP: {}'.format(resp))
  72         #if http_code in (200, 201, 202, 204):
  73         if resp:
  74             resp = json.loads(resp)
  75         if not resp or 'id' not in resp:
  76             raise OsmHttpException('unexpected response from server - {}'.format(
  77                                   resp))
  78         print(resp['id'])
  79         #else:
  80         #    msg = ""
  81         #    if resp:
  82         #        try:
  83         #            msg = json.loads(resp)
  84         #        except ValueError:
  85         #            msg = resp
  86         #    raise ClientException("failed to create user {} - {}".format(name, msg))
  87
  88     def update(self, name, user):
  89         """Updates an existing OSM user identified by name
  90         """
  91         self._logger.debug("")
  92         self._client.get_token()
  93         # print(user)
  94         myuser = self.get(name)
  95         update_user = {
  96             "add_project_role_mappings": [],
  97             "remove_project_role_mappings": [],
  98         }
  99
 100         # if password is defined, update the password
 101         if user["password"]:
 102             update_user["password"] = user["password"]
 103         if user["username"]:
 104             update_user["username"] = user["username"]
 105
 106         if user["set-project"]:
 107             # Remove project and insert project role mapping
 108             for set_project in user["set-project"]:
 109
 110                 set_project_clean = [m.strip() for m in set_project.split(",")]
 111                 project, roles = set_project_clean[0], set_project_clean[1:]
 112
 113                 update_user["remove_project_role_mappings"].append({"project": project})
 114
 115                 for role in roles:
 116                     mapping = {"project": project, "role": role}
 117                     update_user["add_project_role_mappings"].append(mapping)
 118
 119         if user["remove-project"]:
 120             for remove_project in user["remove-project"]:
 121                 update_user["remove_project_role_mappings"].append({"project": remove_project})
 122
 123         if user["add-project-role"]:
 124             for add_project_role in user["add-project-role"]:
 125                 add_project_role_clean = [m.strip() for m in add_project_role.split(",")]
 126                 project, roles = add_project_role_clean[0], add_project_role_clean[1:]
 127
 128                 for role in roles:
 129                     mapping = {"project": project, "role": role}
 130                     update_user["add_project_role_mappings"].append(mapping)
 131
 132         if user["remove-project-role"]:
 133             for remove_project_role in user["remove-project-role"]:
 134                 remove_project_role_clean = [m.strip() for m in remove_project_role.split(",")]
 135                 project, roles = remove_project_role_clean[0], remove_project_role_clean[1:]
 136
 137                 for role in roles:
 138                     mapping = {"project": project, "role": role}
 139                     update_user["remove_project_role_mappings"].append(mapping)
 140
 141         if not update_user["remove_project_role_mappings"]:
 142             del update_user["remove_project_role_mappings"]
 143         if not update_user["add_project_role_mappings"]:
 144             del update_user["add_project_role_mappings"]
 145         if not update_user:
 146             raise ClientException("At least something should be changed.")
 147
 148         http_code, resp = self._http.patch_cmd(endpoint='{}/{}'.format(self._apiBase, myuser['_id']),
 149                                              postfields_dict=update_user)
 150         # print('HTTP CODE: {}'.format(http_code))
 151         # print('RESP: {}'.format(resp))
 152         if http_code in (200, 201, 202):
 153             if resp:
 154                 resp = json.loads(resp)
 155             if not resp or 'id' not in resp:
 156                 raise OsmHttpException('unexpected response from server - {}'.format(
 157                                       resp))
 158             print(resp['id'])
 159         elif http_code == 204:
 160             print('Updated')
 161         #else:
 162         #    msg = ""
 163         #    if resp:
 164         #        try:
 165         #            msg = json.loads(resp)
 166         #        except ValueError:
 167         #            msg = resp
 168         #    raise ClientException("failed to update user {} - {}".format(name, msg))
 169
 170     def delete(self, name, force=False):
 171         """Deletes an existing OSM user identified by name
 172         """
 173         self._logger.debug("")
 174         self._client.get_token()
 175         user = self.get(name)
 176         querystring = ''
 177         if force:
 178             querystring = '?FORCE=True'
 179         http_code, resp = self._http.delete_cmd('{}/{}{}'.format(self._apiBase,
 180                                          user['_id'], querystring))
 181         #print('HTTP CODE: {}'.format(http_code))
 182         #print('RESP: {}'.format(resp))
 183         if http_code == 202:
 184             print('Deletion in progress')
 185         elif http_code == 204:
 186             print('Deleted')
 187         elif resp and 'result' in resp:
 188             print('Deleted')
 189         else:
 190             msg = ""
 191             if resp:
 192                 try:
 193                     msg = json.loads(resp)
 194                 except ValueError:
 195                     msg = resp
 196             raise OsmHttpException("failed to delete user {} - {}".format(name, msg))
 197
 198     def list(self, filter=None):
 199         """Returns the list of OSM users
 200         """
 201         self._logger.debug("")
 202         self._client.get_token()
 203         filter_string = ''
 204         if filter:
 205             filter_string = '?{}'.format(filter)
 206         _, resp = self._http.get2_cmd('{}{}'.format(self._apiBase,filter_string))
 207         #print('RESP: {}'.format(resp))
 208         if resp:
 209             return json.loads(resp)
 210         return list()
 211
 212     def get(self, name):
 213         """Returns an OSM user based on name or id
 214         """
 215         self._logger.debug("")
 216         self._client.get_token()
 217         if utils.validate_uuid4(name):
 218             for user in self.list():
 219                 if name == user['_id']:
 220                     return user
 221         else:
 222             for user in self.list():
 223                 if name == user['username']:
 224                     return user
 225         raise NotFound("User {} not found".format(name))
 226