def __init__(self, parent, name=None):
if isinstance(name, backend.users.User):
self.user = name
elif isinstance(name, int):
self.user = parent.request.backend.users[name]
else:
ident = make_identifier(name)
self.user = parent.request.backend.users[ident]
super().__init__(parent, self.user.identifier)
def remove(self, text, *, _flush=True):
if not access_allowed(allow_owner, self):
raise AccessError('Not the owner')
identifier = make_identifier(text)
try:
kw = self._query.filter_by(text=text).one()
except NoResultFound:
raise LookupError(text)
self.artwork._obj.artwork_user_keywords.remove(kw)
self.backend._db.delete(kw)
if _flush:
self.backend._db.flush()
def add(self, text, *, _flush=True):
if not access_allowed(allow_owner, self):
raise AccessError('Not the owner')
identifier = make_identifier(text)
if text in self:
raise ValueError('Duplicate value: {0!r}'.format(identifier))
keyword = tables.ArtworkUserKeyword(
user=self.user._obj,
artwork=self.artwork._obj,
text=text,
identifier=identifier)
self.artwork._obj.artwork_user_keywords.append(keyword)
if _flush:
self.backend._db.flush()
def __getitem__(self, item):
try:
return super().__getitem__(item)
except LookupError:
query = self._query
try:
ident = make_identifier(item)
except (TypeError, ValueError):
raise LookupError(item)
query = query.filter(self.item_table.normalized_name == ident)
try:
user = query.one()
except orm.exc.NoResultFound:
raise LookupError(item)
else:
return self.item_class(self.backend, user)
def add(self, name, password, _crypt_strength=None):
if self.name_taken(name):
raise ValueError('Name already exists')
if _crypt_strength is None:
salt = bcrypt.gensalt()
else:
salt = bcrypt.gensalt(_crypt_strength)
db = self.backend._db
max_id = (db.query(functions.max(self.item_table.id)).one()[0] or 0)
user = self.item_table(
id=max_id + 1,
name=name,
normalized_name=make_identifier(name),
password=bcrypt.hashpw(password, salt),
joined_at=datetime.utcnow(),
)
db.add(user)
db.flush()
return self.item_class(self.backend, user)
def gen_identifiers():
# We don't want "-" (empty)
# We also don't want things that DON'T include a "-"
# (i.e. single words): those might clash with future
# additions to the URL namespace
# And we also don't want numbers; reserve those for
# numeric IDs.
if art_identifier != '-' and '-' in art_identifier:
try:
int(art_identifier)
except ValueError:
yield art_identifier
# If that's taken, prepend the author's name(s)
bases = [
make_identifier('{}-{}'.format(
a.name, art_identifier))
for a in self.authors]
for base in bases:
yield base
# And if that's still not enough, append a number
for i in itertools.count(start=1):
for base in bases:
yield '{}-{}'.format(base, i)
def set_identifier(self):
"""Auto-create a unique identifier for the art"""
if not self.hidden and self.name and not self.identifier:
# For all of these, use make_identifier to keep
# these within [a-z0-9-]*
art_identifier = make_identifier(self.name)
def gen_identifiers():
# We don't want "-" (empty)
# We also don't want things that DON'T include a "-"
# (i.e. single words): those might clash with future
# additions to the URL namespace
# And we also don't want numbers; reserve those for
# numeric IDs.
if art_identifier != '-' and '-' in art_identifier:
try:
int(art_identifier)
except ValueError:
yield art_identifier
# If that's taken, prepend the author's name(s)
bases = [
make_identifier('{}-{}'.format(
a.name, art_identifier))
for a in self.authors]
for base in bases:
yield base
# And if that's still not enough, append a number
for i in itertools.count(start=1):
for base in bases:
yield '{}-{}'.format(base, i)
for identifier in gen_identifiers():
query = self.backend._db.query(tables.Artwork)
query = query.filter(tables.Artwork.identifier == identifier)
if not query.count():
self._obj.identifier = identifier
break
self.backend.schedule_task('try_publish_art',
{'artwork_id': self.id})
def test_make_identifier(input, expected):
assert helpers.make_identifier(input) == expected
def name_taken(self, name):
normalized_name = make_identifier(name)
if self._query.filter_by(normalized_name=normalized_name).count():
return True
else:
return False
