def keys(self,
order=None,
size=None,
start=None,
owner=None,
**reqSettings):
"""
:param order:
:param size:
:param start:
:param owner:
:param reqSettings:
:return: result set {"keys":[strings], "start":number, "size":number, "total":number}
"""
values = dict()
if order is not None:
values["order"] = order
if size is not None:
values["size"] = size
if start is not None:
values["start"] = start
if owner is not None:
values["owner"] = owner
content, response = self.call('keys', values, reqSettings)
# todo result set class with iterator
if not content:
return endpoint.Result(keys=(), start=1, size=0, response=response)
return endpoint.Result(response=response, **content)
def list(self, active=None, pending=None, start=None, size=None, sort=None, order=None, **reqSettings):
"""
Administration command. Each returned user contains (reference, name, email, realname, pending, active, activity)
:param active: only active, inactive or both
:param pending: only pending
:param sort:
:param order:
:param size:
:param start: batch start value
:param reqSettings:
:return: users
"""
values = dict(start=start)
if active is not None:
values["active"] = active
if pending is not None:
values["pending"] = pending
if sort is not None:
values["sort"] = sort
if order is not None:
values["order"] = order
if size is not None:
values["size"] = size
if start is not None:
values["start"] = start
content, response = self.call('list', values, reqSettings)
# todo iterator
return endpoint.Result(response=response,
**content)
def setItem(self,
path,
contents=None,
mime=None,
header=None,
decode=False,
**reqSettings):
"""
:param path:
:param contents:
:param mime:
:param header:
:param decode:
:param reqSettings:
:return: Result(result, invalid, message)
"""
values = dict(contents=contents,
mime=mime,
header=header,
decode=decode)
content, response = self.call('@setItem', values, reqSettings, path)
return endpoint.Result(result=content.get('result'),
invalid=content.get('invalid', ()),
message=content.get('message', ()),
response=response)
def setOwner(self,
newOwner,
items=None,
key=None,
owner=None,
id=None,
**reqSettings):
"""
:param newOwner:
:param items:
:param key:
:param owner:
:param id:
:param items:
:param reqSettings:
:return: Result(result, message)
"""
values = dict(newOwner=newOwner)
if items is not None:
values["items"] = items
if key is not None:
values["key"] = key
if owner is not None:
values["owner"] = owner
if id is not None:
values["id"] = id
content, response = self.call('setOwner', values, reqSettings)
return endpoint.Result(response=response, **content)
def identities(self, active=None, pending=None, start=None, size=None, order=None, **reqSettings):
"""
Administration command. Lists user identites as string only (reference, name/email ).
:param active: only active, inactive or both
:param pending: only pending
:param order:
:param size:
:param start: batch start value
:param reqSettings:
:return: users
"""
values = dict(start=start)
if active is not None:
values["active"] = active
if pending is not None:
values["pending"] = pending
if order is not None:
values["order"] = order
if size is not None:
values["size"] = size
if start is not None:
values["start"] = start
content, response = self.call('identities', values, reqSettings)
# todo iterator
return endpoint.Result(response=response,
**content)
def token(self, identity=None, password=None, storeInSession=False, **reqSettings):
"""
Obtain a security for authentication of future calls. You can either manage the
returned auth-token yourself and pass it manually to calls or set `storeInSession`
to True to handle the token automatically. In this case a valid session created
by `newSession()` is required.
Raises `AuthorizationFailure` if no valid token is returned.
:param identity:
:param password:
:param storeInSession:
:param reqSettings:
:return: (string) auth-token
"""
content, response = self.call('token', dict(identity=identity, password=password), reqSettings)
if not content or not content.get('token'):
msg = self._fmtMsgs(content, 'token_failure')
raise endpoint.AuthorizationFailure(msg)
token = content.get('token')
if storeInSession and self.session:
# store token in session for future requests
self.session.authtoken = token
return endpoint.Result(token=token,
message=content.get('message'),
response=response)
def setItem(self,
items=None,
key=None,
value=None,
owner=None,
id=None,
**reqSettings):
"""
:param items:
:param key:
:param value:
:param owner:
:param id:
:param reqSettings:
:return: result, success. number of stored items, list of keys or ids successfully updated
"""
values = dict()
if items is not None:
values["items"] = items
if key is not None:
values["key"] = key
if owner is not None:
values["owner"] = owner
if value is not None:
values["value"] = value
if id is not None:
values["id"] = id
content, response = self.call('setItem', values, reqSettings)
return endpoint.Result(result=content.get('result'),
success=content.get('success', ()),
invalid=content.get('invalid', ()),
message=content.get('message', ()),
response=response)
def delete(self, **reqSettings):
"""
:param reqSettings:
:return: True or False, message
"""
content, response = self.call('delete', {}, reqSettings)
return endpoint.Result(response=response,
**content)
def getItem(self, path, **reqSettings):
"""
:param path:
:param reqSettings:
:return: file infos: name, type, size, mime, header, ctime, mtime
"""
values = dict()
content, response = self.call('@getItem', values, reqSettings, path)
return endpoint.Result(response=response, **content)
def name(self, **reqSettings):
"""
Returns the users name.
:param reqSettings:
:return: {name, realname}
"""
content, response = self.call('name', {}, reqSettings)
return endpoint.Result(response=response,
**content)
def identity(self, **reqSettings):
"""
Returns the users identity.
:param reqSettings:
:return: {name, email, reference, realname}
"""
content, response = self.call('identity', {}, reqSettings)
return endpoint.Result(response=response,
**content)
def allowed(self, permissions, **reqSettings):
"""
:param permission: one or multiple permission names
:param reqSettings:
:return: dict {permission: True or False}
"""
values = dict(permissions=permissions)
content, response = self.call('allowed', values, reqSettings)
return endpoint.Result(response=response, **content)
def verifyEmail(self, email, **reqSettings):
"""
:param email:
:param reqSettings:
:return: result, invalid, message
"""
values = dict(email=email)
content, response = self.call('verifyEmail', values, reqSettings)
return endpoint.Result(response=response,
**content)
def resetPassword(self, identity, **reqSettings):
"""
:param identity:
:param reqSettings:
:return: result, message
"""
values = dict(identity=identity)
content, response = self.call('resetPassword', values, reqSettings)
return endpoint.Result(response=response,
**content)
def message(self, message, **reqSettings):
"""
:param message:
:param reqSettings:
:return: result, invalid
"""
values = dict(message=message)
content, response = self.call('message', values, reqSettings)
return endpoint.Result(response=response,
**content)
def verifyEmail2(self, token, **reqSettings):
"""
:param token:
:param reqSettings:
:return: result, message
"""
values = dict(token=token)
content, response = self.call('verifyEmail2', values, reqSettings)
return endpoint.Result(response=response,
**content)
def profile(self, **reqSettings):
"""
Returns the users profile values. `data`, `realname` and `notify` can
be changed by calling `update()`. `data` can be used to store arbitrary
values or json strings.
:param reqSettings:
:return: {data, realname, notify, email, name, lastlogin}
"""
content, response = self.call('profile', {}, reqSettings)
return endpoint.Result(response=response,
**content)
def setPermissions(self, permissions, **reqSettings):
"""
:param permissions: dict/list. one or multiple permissions {permission, group, action="replace"}
:param reqSettings:
:return: Result(result, message)
"""
values = dict(permissions=permissions)
content, response = self.call('setPermissions', values, reqSettings)
return endpoint.Result(result=content.get('result'),
message=content.get('message',()),
response=response)
def updatePassword(self, password, newpassword, **reqSettings):
"""
:param password:
:param newpassword:
:param reqSettings:
:return: result, invalid, message
"""
values = dict(password=password, newpassword=newpassword)
content, response = self.call('updatePassword', values, reqSettings)
return endpoint.Result(response=response,
**content)
def resetPassword2(self, token, newpassword, **reqSettings):
"""
:param token:
:param newpassword:
:param reqSettings:
:return: result, invalid, message
"""
values = dict(token=token, newpassword=newpassword)
content, response = self.call('resetPassword2', values, reqSettings)
return endpoint.Result(response=response,
**content)
def getUser(self, identity, **reqSettings):
"""
Retrieve a users profile.
:param identity: the users identity.
:param reqSettings:
:return: profile values
"""
values = dict(identity=identity)
content, response = self.call('getUser', values, reqSettings)
return endpoint.Result(response=response,
**content)
def list(self,
key=None,
sort=None,
order=None,
size=None,
start=None,
owner=None,
**reqSettings):
"""
:param key:
:param sort:
:param order:
:param size:
:param start:
:param owner:
:param reqSettings:
:return: item result set {"items":[items], "start":number, "size":number, "total":number}
"""
values = dict()
if key is not None:
values["key"] = key
if sort is not None:
values["sort"] = sort
if order is not None:
values["order"] = order
if size is not None:
values["size"] = size
if start is not None:
values["start"] = start
if owner is not None:
values["owner"] = owner
content, response = self.call('list', values, reqSettings)
# todo result set class with iterator
if not content:
return endpoint.Result(items=(),
start=1,
size=0,
response=response)
return endpoint.Result(response=response, **content)
def getOwner(self, key=None, id=None, **reqSettings):
"""
:param key:
:param id:
:param reqSettings:
:return: owner
"""
values = dict(key=key, id=id)
content, response = self.call('getOwner', values, reqSettings)
return endpoint.Result(items=content.get('items'),
message=content.get('message', ()),
response=response)
def removeItem(self, path, recursive=False, **reqSettings):
"""
:param path:
:param recursive:
:param reqSettings:
:return: Result(result (count deleted), message)
"""
values = dict(recursive=recursive)
content, response = self.call('@removeItem', values, reqSettings, path)
return endpoint.Result(result=content.get('result'),
message=content.get('message', ()),
response=response)
def removeUser(self, identity, **reqSettings):
"""
Review a new user account. Step 1 is triggered by calling `signupReview()`. The account to be
reviewed can be accepted or rejected.
:param identity: the users identity.
:param reqSettings:
:return: result
"""
values = dict(identity=identity)
content, response = self.call('removeUser', values, reqSettings)
return endpoint.Result(response=response,
**content)
def setUser(self, identity, values, **reqSettings):
"""
Update a users profile.
:param identity: the users identity.
:param values: profile values to be updated
:param reqSettings:
:return: result, message, invalid
"""
values = dict(identity=identity, values=values)
content, response = self.call('setUser', values, reqSettings)
return endpoint.Result(response=response,
**content)
def setOwner(self, path, owner, **reqSettings):
"""
:param path:
:param owner:
:param reqSettings:
:return: Result(result, message)
"""
values = dict(owner=owner)
content, response = self.call('@setOwner', values, reqSettings, path)
return endpoint.Result(result=content.get('result'),
message=content.get('message', ()),
response=response)
def activate(self, token, **reqSettings):
"""
Activate a new user account. Step 1 is triggered either by calling `signupOptin()` or
`signupReview()`.
:param token:
:param reqSettings:
:return: result, message
"""
values = dict(token=token)
content, response = self.call('activate', values, reqSettings)
return endpoint.Result(response=response,
**content)
def review(self, identity, action, **reqSettings):
"""
Review a new user account. Step 1 is triggered by calling `signupReview()`. The account to be
reviewed can be accepted or rejected.
:param identity: the users identity.
:param action: `accept`, `optin`, `reject`, `activate` or `disable`
:param reqSettings:
:return: result, message
"""
values = dict(identity=identity, action=action)
content, response = self.call('review', values, reqSettings)
return endpoint.Result(response=response,
**content)
def signout(self, **reqSettings):
"""
Calls the servers signout method and removes stored credentials (cookie, token) from the
current session. Also the services' signout method is called to terminate any user-session
handled by the service.
The session itself can still be used for further calls.
:param reqSettings:
:return: None
"""
content, response = self.call('signout', {}, reqSettings)
if self.session:
# the cookie is reset by the server. the token is reset here.
self.session.authtoken = None
return endpoint.Result(result=content.get('result'),
response=response)
