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 import json
  26 import logging
  27
  28
  29 class User(object):
  30     def __init__(self, http=None, client=None):
  31         self._http = http
  32         self._client = client
  33         self._logger = logging.getLogger('osmclient')
  34         self._apiName = '/admin'
  35         self._apiVersion = '/v1'
  36         self._apiResource = '/users'
  37         self._apiBase = '{}{}{}'.format(self._apiName,
  38                                         self._apiVersion, self._apiResource)
  39
  40     def create(self, name, user):
  41         """Creates a new OSM user
  42         """
  43         self._logger.debug("")
  44         self._client.get_token()
  45         if not user["projects"] or (len(user["projects"]) == 1 and not user["projects"][0]):
  46             del user["projects"]
  47         elif len(user["projects"]) == 1:
  48             user["projects"] = user["projects"][0].split(",")
  49
  50         if user["project_role_mappings"]:
  51             project_role_mappings = []
  52
  53             for set_mapping in user["project_role_mappings"]:
  54                 set_mapping_clean = [m.strip() for m in set_mapping.split(",")]
  55                 project, roles = set_mapping_clean[0], set_mapping_clean[1:]
  56
  57                 for role in roles:
  58                     mapping = {"project": project, "role": role}
  59
  60                     if mapping not in project_role_mappings:
  61                         project_role_mappings.append(mapping)
  62
  63             user["project_role_mappings"] = project_role_mappings
  64         else:
  65             del user["project_role_mappings"]
  66
  67         http_code, resp = self._http.post_cmd(endpoint=self._apiBase,
  68                                        postfields_dict=user)
  69         #print('HTTP CODE: {}'.format(http_code))
  70         #print('RESP: {}'.format(resp))
  71         #if http_code in (200, 201, 202, 204):
  72         if resp:
  73             resp = json.loads(resp)
  74         if not resp or 'id' not in resp:
  75             raise ClientException('unexpected response from server - {}'.format(
  76                 resp))
  77         print(resp['id'])
  78         #else:
  79         #    msg = ""
  80         #    if resp:
  81         #        try:
  82         #            msg = json.loads(resp)
  83         #        except ValueError:
  84         #            msg = resp
  85         #    raise ClientException("failed to create user {} - {}".format(name, msg))
  86
  87     def update(self, name, user):
  88         """Updates an existing OSM user identified by name
  89         """
  90         self._logger.debug("")
  91         self._client.get_token()
  92         # print(user)
  93         myuser = self.get(name)
  94         update_user = {
  95             "add_project_role_mappings": [],
  96             "remove_project_role_mappings": [],
  97         }
  98
  99         # if password is defined, update the password
 100         if user["password"]:
 101             update_user["password"] = user["password"]
 102         if user["username"]:
 103             update_user["username"] = user["username"]
 104
 105         if user["set-project"]:
 106             # Remove project and insert project role mapping
 107             for set_project in user["set-project"]:
 108
 109                 set_project_clean = [m.strip() for m in set_project.split(",")]
 110                 project, roles = set_project_clean[0], set_project_clean[1:]
 111
 112                 update_user["remove_project_role_mappings"].append({"project": project})
 113
 114                 for role in roles:
 115                     mapping = {"project": project, "role": role}
 116                     update_user["add_project_role_mappings"].append(mapping)
 117
 118         if user["remove-project"]:
 119             for remove_project in user["remove-project"]:
 120                 update_user["remove_project_role_mappings"].append({"project": remove_project})
 121
 122         if user["add-project-role"]:
 123             for add_project_role in user["add-project-role"]:
 124                 add_project_role_clean = [m.strip() for m in add_project_role.split(",")]
 125                 project, roles = add_project_role_clean[0], add_project_role_clean[1:]
 126
 127                 for role in roles:
 128                     mapping = {"project": project, "role": role}
 129                     update_user["add_project_role_mappings"].append(mapping)
 130
 131         if user["remove-project-role"]:
 132             for remove_project_role in user["remove-project-role"]:
 133                 remove_project_role_clean = [m.strip() for m in remove_project_role.split(",")]
 134                 project, roles = remove_project_role_clean[0], remove_project_role_clean[1:]
 135
 136                 for role in roles:
 137                     mapping = {"project": project, "role": role}
 138                     update_user["remove_project_role_mappings"].append(mapping)
 139
 140         if not update_user["remove_project_role_mappings"]:
 141             del update_user["remove_project_role_mappings"]
 142         if not update_user["add_project_role_mappings"]:
 143             del update_user["add_project_role_mappings"]
 144         if not update_user:
 145             raise ClientException("At least something should be changed.")
 146
 147         http_code, resp = self._http.patch_cmd(endpoint='{}/{}'.format(self._apiBase, myuser['_id']),
 148                                              postfields_dict=update_user)
 149         # print('HTTP CODE: {}'.format(http_code))
 150         # print('RESP: {}'.format(resp))
 151         if http_code in (200, 201, 202):
 152             if resp:
 153                 resp = json.loads(resp)
 154             if not resp or 'id' not in resp:
 155                 raise ClientException('unexpected response from server - {}'.format(
 156                                       resp))
 157             print(resp['id'])
 158         elif http_code == 204:
 159             print('Updated')
 160         #else:
 161         #    msg = ""
 162         #    if resp:
 163         #        try:
 164         #            msg = json.loads(resp)
 165         #        except ValueError:
 166         #            msg = resp
 167         #    raise ClientException("failed to update user {} - {}".format(name, msg))
 168
 169     def delete(self, name, force=False):
 170         """Deletes an existing OSM user identified by name
 171         """
 172         self._logger.debug("")
 173         self._client.get_token()
 174         user = self.get(name)
 175         querystring = ''
 176         if force:
 177             querystring = '?FORCE=True'
 178         http_code, resp = self._http.delete_cmd('{}/{}{}'.format(self._apiBase,
 179                                          user['_id'], querystring))
 180         #print('HTTP CODE: {}'.format(http_code))
 181         #print('RESP: {}'.format(resp))
 182         if http_code == 202:
 183             print('Deletion in progress')
 184         elif http_code == 204:
 185             print('Deleted')
 186         elif resp and 'result' in resp:
 187             print('Deleted')
 188         else:
 189             msg = resp or ""
 190             # if resp:
 191             #     try:
 192             #         msg = json.loads(resp)
 193             #     except ValueError:
 194             #         msg = resp
 195             raise ClientException("failed to delete user {} - {}".format(name, msg))
 196
 197     def list(self, filter=None):
 198         """Returns the list of OSM users
 199         """
 200         self._logger.debug("")
 201         self._client.get_token()
 202         filter_string = ''
 203         if filter:
 204             filter_string = '?{}'.format(filter)
 205         _, resp = self._http.get2_cmd('{}{}'.format(self._apiBase,filter_string))
 206         #print('RESP: {}'.format(resp))
 207         if resp:
 208             return json.loads(resp)
 209         return list()
 210
 211     def get(self, name):
 212         """Returns an OSM user based on name or id
 213         """
 214         self._logger.debug("")
 215         self._client.get_token()
 216         if utils.validate_uuid4(name):
 217             for user in self.list():
 218                 if name == user['_id']:
 219                     return user
 220         else:
 221             for user in self.list():
 222                 if name == user['username']:
 223                     return user
 224         raise NotFound("User {} not found".format(name))
 225