| # */ |
| # * Licensed to the Apache Software Foundation (ASF) under one |
| # * or more contributor license agreements. See the NOTICE file |
| # * distributed with this work for additional information |
| # * regarding copyright ownership. The ASF licenses this file |
| # * to you under the Apache License, Version 2.0 (the |
| # * "License"); you may not use this file except in compliance |
| # * with the License. You may obtain a copy of the License at |
| # * |
| # * http://www.apache.org/licenses/LICENSE-2.0 |
| # * |
| # * Unless required by applicable law or agreed to in writing, |
| # * software distributed under the License is distributed on an |
| # * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # * KIND, either express or implied. See the License for the |
| # * specific language governing permissions and limitations |
| # * under the License. |
| # */ |
| |
| import json |
| import logging |
| import requests |
| from usergrid.UsergridAuth import UsergridAppAuth |
| from usergrid.app_templates import get_entity_url_template, post_collection_url_template, put_entity_url_template, \ |
| delete_entity_url_template, connect_entities_by_type_template, assign_role_url_template |
| |
| __author__ = 'Jeff.West@yahoo.com' |
| |
| |
| def value_error(message): |
| raise ValueError(message) |
| |
| |
| def usergrid_error(r): |
| pass |
| |
| |
| class Usergrid(object): |
| client = None |
| |
| @staticmethod |
| def init(org_id, |
| app_id, |
| **kwargs): |
| Usergrid.client = UsergridClient(org_id, app_id, **kwargs) |
| |
| @staticmethod |
| def GET(collection, uuid_name, **kwargs): |
| return Usergrid.client.GET(collection, uuid_name, **kwargs) |
| |
| @staticmethod |
| def PUT(collection, uuid_name, data, **kwargs): |
| return Usergrid.client.PUT(collection, uuid_name, data, **kwargs) |
| |
| @staticmethod |
| def POST(collection, data, **kwargs): |
| return Usergrid.client.POST(collection, data, **kwargs) |
| |
| @staticmethod |
| def DELETE(collection, uuid_name, **kwargs): |
| return Usergrid.client.DELETE(collection, uuid_name, **kwargs) |
| |
| @staticmethod |
| def connect_entities(from_entity, relationship, to_entity, **kwargs): |
| return Usergrid.client.connect_entities(from_entity, relationship, to_entity, **kwargs) |
| |
| @staticmethod |
| def disconnect_entities(from_entity, relationship, to_entity, **kwargs): |
| return Usergrid.client.disconnect_entities(from_entity, relationship, to_entity, **kwargs) |
| |
| @staticmethod |
| def assign_role(role_uuid_name, user_entity, **kwargs): |
| return Usergrid.client.assign_role(role_uuid_name, user_entity, **kwargs) |
| |
| |
| class UsergridResponse(object): |
| def __init__(self, api_response, client): |
| self.api_response = api_response |
| self.client = client |
| |
| if api_response is None: |
| self.ok = False |
| self.body = 'No Response' |
| |
| else: |
| self.headers = api_response.headers |
| |
| if api_response.status_code == 200: |
| self.ok = True |
| self.body = api_response.json() |
| self.entities = self.body.get('entities', []) |
| |
| else: |
| self.ok = False |
| |
| if api_response.headers.get('Content-type') == 'application/json': |
| self.body = api_response.json() |
| else: |
| self.body = 'HTTP %s: %s' % (api_response.status_code, api_response.text) |
| |
| def __str__(self): |
| return json.dumps(self.body) |
| |
| def first(self): |
| return UsergridEntity(entity_data=self.entities[0]) if self.ok and self.entities and len( |
| self.entities) > 0 else None |
| |
| def entity(self): |
| return self.first() |
| |
| def last(self): |
| return UsergridEntity(entity_data=self.entities[len(self.entities) - 1]) if self.ok and self.entities and len( |
| self.entities) > 0 else None |
| |
| def has_next_page(self): |
| return 'cursor' in self.body if self.ok else False |
| |
| |
| class UsergridEntity(object): |
| def __init__(self, entity_data): |
| self.entity_data = entity_data |
| |
| def __str__(self): |
| return json.dumps(self.entity_data) |
| |
| def get(self, name, default=None): |
| return self.entity_data.get(name, default) |
| |
| def entity_id(self): |
| |
| if self.entity_data.get('type', '').lower() in ['users', 'user']: |
| return self.entity_data.get('uuid', self.entity_data.get('username')) |
| |
| return self.entity_data.get('uuid', self.entity_data.get('name')) |
| |
| def can_mutate_or_load(self): |
| entity_id = self.entity_id() |
| |
| if entity_id is None or self.entity_data.get('type') is None: |
| return False |
| |
| return True |
| |
| def put_property(self, name, value): |
| self.entity_data[name] = value |
| |
| def put_properties(self, properties): |
| if isinstance(properties, dict): |
| self.entity_data.update(properties) |
| |
| def remove_property(self, name): |
| |
| if name is not None and name in self.entity_data: |
| del self.entity_data[name] |
| |
| def remove_properties(self, properties): |
| if isinstance(properties, (list, dict)): |
| for property_name in properties: |
| self.remove_property(property_name) |
| |
| def append(self, array_name, value): |
| if array_name in self.entity_data: |
| if isinstance(self.entity_data[array_name], list): |
| self.entity_data[array_name].append(value) |
| else: |
| self.entity_data[array_name] = [value] |
| |
| def prepend(self, array_name, value): |
| if array_name in self.entity_data: |
| if isinstance(self.entity_data[array_name], list): |
| self.entity_data[array_name].pre(value) |
| else: |
| self.entity_data[array_name] = [value] |
| |
| def insert(self, array_name, value, index): |
| if array_name in self.entity_data: |
| if isinstance(self.entity_data[array_name], list): |
| self.entity_data[array_name].insert(index, value) |
| |
| def shift(self, array_name): |
| if array_name in self.entity_data: |
| if isinstance(self.entity_data[array_name], list): |
| value = self.entity_data[array_name][0] |
| self.entity_data[array_name] = self.entity_data[array_name][1:] |
| return value |
| |
| return None |
| |
| def reload(self): |
| if not self.can_mutate_or_load(): |
| raise ValueError('Unable to reload entity: No uuid nor name') |
| |
| response = Usergrid.GET(collection=self.entity_data.get('type'), |
| uuid_name=self.entity_id()) |
| if response.ok: |
| self.entity_data.update(response.entity().entity_data) |
| |
| else: |
| raise ValueError('Unable to reload entity: %s' % response) |
| |
| def save(self): |
| if not self.can_mutate_or_load(): |
| raise ValueError('Unable to save entity: No uuid nor name') |
| |
| response = Usergrid.PUT(collection=self.entity_data.get('type'), |
| uuid_name=self.entity_id(), |
| data=self.entity_data) |
| |
| if response.ok and 'uuid' not in self.entity_data: |
| self.entity_data['uuid'] = response.entity().get('uuid') |
| |
| return response |
| |
| def remove(self): |
| if not self.can_mutate_or_load(): |
| raise ValueError('Unable to delete entity: No uuid nor name') |
| |
| return Usergrid.DELETE(collection=self.entity_data.get('type'), |
| uuid_name=self.entity_id()) |
| |
| def get_connections(self, relationship, direction='connecting'): |
| pass |
| |
| def connect(self, relationship, to_entity): |
| |
| if not to_entity.can_mutate_or_load(): |
| raise ValueError('Unable to connect to entity - no uuid or name') |
| |
| if not self.can_mutate_or_load(): |
| raise ValueError('Unable from connect to entity - no uuid or name') |
| |
| return Usergrid.connect_entities(self, relationship, to_entity) |
| |
| def disconnect(self, relationship, to_entity): |
| if not to_entity.can_mutate_or_load(): |
| raise ValueError('Unable to connect to entity - no uuid or name') |
| |
| if not self.can_mutate_or_load(): |
| raise ValueError('Unable from connect to entity - no uuid or name') |
| |
| return Usergrid.disconnect_entities(self, relationship, to_entity) |
| |
| def attach_asset(self, filename, data, content_type): |
| pass |
| |
| def download_asset(self, content_type=None): |
| pass |
| |
| |
| class UsergridClient(object): |
| def __init__(self, |
| org_id, |
| app_id, |
| base_url='http://api.usergrid.com', |
| client_id=None, |
| client_secret=None, |
| token_ttl_seconds=86400, |
| auth_fallback="none"): |
| |
| self.base_url = base_url |
| self.org_id = org_id |
| self.app_id = app_id |
| self.auth_fallback = auth_fallback |
| self.logger = logging.getLogger('usergrid.UsergridClient') |
| self.session = requests.Session() |
| |
| self.url_data = { |
| 'base_url': base_url, |
| 'org_id': org_id, |
| 'app_id': app_id |
| } |
| |
| if client_id and not client_secret: |
| value_error('Client ID Specified but not Secret') |
| |
| elif client_secret and not client_id: |
| value_error('Client ID Specified but not Secret') |
| |
| elif client_secret and client_id: |
| self.auth = UsergridAppAuth(client_id=client_id, |
| client_secret=client_secret, |
| token_ttl_seconds=token_ttl_seconds) |
| |
| self.auth.authenticate(self) |
| self.session.headers.update({'Authorization': 'Bearer %s' % self.auth.access_token}) |
| |
| def __str__(self): |
| return json.dumps({ |
| 'base_url': self.base_url, |
| 'org_id': self.org_id, |
| 'app_id': self.app_id, |
| 'access_token': self.auth.access_token |
| }) |
| |
| def GET(self, collection, uuid_name, connections='none', auth=None, **kwargs): |
| url = get_entity_url_template.format(collection=collection, |
| uuid_name=uuid_name, |
| connections=connections, |
| **self.url_data) |
| if auth: |
| r = requests.get(url, headers={'Authorization': 'Bearer %s' % auth.access_token}) |
| |
| else: |
| r = self.session.get(url) |
| |
| return UsergridResponse(r, self) |
| |
| def PUT(self, collection, uuid_name, data, auth=None, **kwargs): |
| url = put_entity_url_template.format(collection=collection, |
| uuid_name=uuid_name, |
| **self.url_data) |
| |
| if auth: |
| r = requests.put(url, |
| data=json.dumps(data), |
| headers={'Authorization': 'Bearer %s' % auth.access_token}) |
| else: |
| r = self.session.put(url, data=json.dumps(data)) |
| |
| return UsergridResponse(r, self) |
| |
| def POST(self, collection, data, auth=None, **kwargs): |
| url = post_collection_url_template.format(collection=collection, |
| **self.url_data) |
| |
| if auth: |
| r = requests.post(url, |
| data=json.dumps(data), |
| headers={'Authorization': 'Bearer %s' % auth.access_token}) |
| else: |
| r = self.session.post(url, data=json.dumps(data)) |
| |
| return UsergridResponse(r, self) |
| |
| def DELETE(self, collection, uuid_name, auth=None, **kwargs): |
| url = delete_entity_url_template.format(collection=collection, |
| uuid_name=uuid_name, |
| **self.url_data) |
| |
| if auth: |
| r = requests.delete(url, headers={'Authorization': 'Bearer %s' % auth.access_token}) |
| else: |
| r = self.session.delete(url) |
| |
| return UsergridResponse(r, self) |
| |
| def connect_entities(self, from_entity, relationship, to_entity, auth=None, **kwargs): |
| |
| url = connect_entities_by_type_template.format(from_collection=from_entity.get('type'), |
| from_uuid_name=from_entity.entity_id(), |
| relationship=relationship, |
| to_collection=to_entity.get('type'), |
| to_uuid_name=to_entity.entity_id(), |
| **self.url_data) |
| |
| if auth: |
| r = requests.post(url, headers={'Authorization': 'Bearer %s' % auth.access_token}) |
| else: |
| r = self.session.post(url) |
| |
| return UsergridResponse(r, self) |
| |
| def assign_role(self, role_uuid_name, entity, auth=None, **kwargs): |
| url = assign_role_url_template.format(role_uuid_name=role_uuid_name, |
| entity_type=entity.get('type'), |
| entity_uuid_name=entity.entity_id(), |
| **self.url_data) |
| |
| if auth: |
| r = requests.delete(url, headers={'Authorization': 'Bearer %s' % auth.access_token}) |
| else: |
| r = self.session.delete(url) |
| |
| return UsergridResponse(r, self) |
| |
| def disconnect_entities(self, from_entity, relationship, to_entity, auth=None, **kwargs): |
| url = connect_entities_by_type_template.format(from_collection=from_entity.get('type'), |
| from_uuid_name=from_entity.entity_id(), |
| relationship=relationship, |
| to_collection=to_entity.get('type'), |
| to_uuid_name=to_entity.entity_id(), |
| **self.url_data) |
| |
| if auth: |
| r = requests.delete(url, headers={'Authorization': 'Bearer %s' % auth.access_token}) |
| else: |
| r = self.session.delete(url) |
| |
| return UsergridResponse(r, self) |
| |
| |
| class UsergridUser(object): |
| def __init__(self): |
| pass |
| |
| |
| class UsergridAsset(object): |
| def __init__(self, filename, data, content_type): |
| self.filename = filename |
| self.data = data |
| self.content_type = content_type |
