def main():
try:
ns = NamespaceManager().get_namespace('card-app')
except exceptions.NotFound:
ns = NamespaceManager().create_namespace('card-app', creator)
try:
ns.get_collection('placements')
except exceptions.NotFound:
ns.create_collection('placements', creator, permissions={
'anon-*': Permissions.CREATE
})
try:
collection = ns.get_collection('cards')
except exceptions.NotFound:
collection = ns.create_collection('cards', creator, permissions={'*': Permissions.READ})
with open(cards_loc) as cards:
for card in json.load(cards)['cards']:
try:
entry = collection.read(card['id'])
assert entry.data['content'] == card['content']
except AssertionError:
collection.update(card['id'], {'content': card['content']}, '')
except exceptions.NotFound:
collection.create(card['id'], {'content': card['content']}, '')
def before_scenario(context, senario):
context.resources = {
'namespace': {},
'collection': {},
'document': {},
}
context.ignored_auth = []
for v in EphemeralBackend._cls_cache.values():
v.clear()
context.manager = NamespaceManager()
class NamespaceView(View):
name = 'namespace'
plural = 'namespaces'
MANAGER = NamespaceManager()
@classmethod
def load(self, id):
return self.MANAGER.get_namespace(id)
def __init__(self, resource=None):
super().__init__(resource=resource)
self._namespace = resource
self.loaded = (resource, ) if resource else (self.MANAGER, )
def get_required_permissions(self, request):
if request.method == 'GET' and self.resource is None:
return Permissions.NONE
if request.method == 'DELETE' and self.resource is not None:
return Permissions.ADMIN
return super().get_required_permissions(request)
def do_create(self, id, attributes, user):
return self.MANAGER.create_namespace(id, user.uid,
**attributes).document
def read(self, user):
return self._namespace.document
def update(self, patch, user):
return self.MANAGER.update(self._namespace.ref, patch, user.uid)
def list(self, filter, sort, page, page_size, user):
query = functools.reduce(operator.or_, [
Q('data.permissions.*', 'and', Permissions.READ),
Q('data.permissions.{0.type}-*'.format(user), 'and',
Permissions.READ),
Q('data.permissions.{0.type}-{0.provider}-*'.format(user), 'and',
Permissions.READ),
Q('data.permissions.{0.type}-{0.provider}-{0.id}'.format(user),
'and', Permissions.READ),
])
if filter:
filter &= query
else:
filter = query
return self.MANAGER.select().where(filter).page(
page, page_size).order_by(sort)
import asyncio
import bcrypt
from jam import exceptions
from jam import NamespaceManager
from jam.plugins.user import UserPlugin
from jam.auth.providers.base import BaseAuthProvider
manager = NamespaceManager()
class SelfAuthProvider(BaseAuthProvider):
name = 'self'
type = 'jam'
PASSWORD_SCHEMA = {
'id': 'password',
'type': 'string',
'pattern': '^\$2b\$1[0-3]\$\S{53}$'
}
async def _authenticate(self, data):
namespace = manager.get_namespace(data['namespace'])
collection = namespace.get_collection(data['collection'])
if not UserPlugin.is_enabled(collection):
raise exceptions.PluginNotEnabled(UserPlugin.NAME)
if not (
collection.schema
def main():
try:
ns = NamespaceManager().get_namespace('SHARE')
except exceptions.NotFound:
ns = NamespaceManager().create_namespace('SHARE', creator)
try:
ns.get_collection('curations')
except exceptions.NotFound:
ns.create_collection('curations', creator, permissions={
'*': Permissions.READ,
'tracked-SHARE|users-*': Permissions.CREATE
})
try:
ns.get_collection('normalized')
except exceptions.NotFound:
ns.create_collection('normalized', creator, permissions={
'*': Permissions.READ
})
try:
ns.get_collection('authors')
except exceptions.NotFound:
ns.create_collection('authors', creator, permissions={
'*': Permissions.READ
})
try:
collection = ns.get_collection('users')
except exceptions.NotFound:
collection = ns.create_collection('users', creator, permissions={
'tracked-SHARE|users-chris': Permissions.ADMIN
}, schema={'type': 'jsonschema', 'schema': {
'id': '/',
'type': 'object',
'properties': {
'username': {
'id': 'username',
'type': 'string',
'pattern': '^\w{1,64}$'
},
'password': {
'id': 'password',
'type': 'string',
'pattern': '^\$2b\$1[0-3]\$\S{53}$'
}
},
'required': ['username', 'password']
}})
try:
collection.create('chris', {
'username': '******',
'password': '******'
}, 'tracked-SHARE|users-chris')
except exceptions.KeyExists:
pass
