def test_create_creator_with_roles(use_test_db, test_creator_dict):
test_work_id = testing_utils.create_fake_work()['id']
test_creator_dict['roles'] = {'illustrator': [test_work_id]}
new_test_creator = logic.create_creator(test_creator_dict)
with session_scope() as session:
created_role_id = session.query(Role)\
.filter_by(work_id=test_work_id, creator_id=new_test_creator['id'])\
.first().id
assert new_test_creator['roles'] == [created_role_id]
def creators_with_id(creator_id):
if request.method == 'GET':
creator = None
with session_scope() as session:
creator = session.query(models.Creator).filter_by(id=creator_id).scalar()
if creator:
return {'creator': creator.to_dict()}
elif request.method == 'PUT':
model_data = api_to_model_dict(request.get_json())
response = logic.update_creator(creator_id, model_data)
return {'creator': response}
elif request.method == 'DELETE':
with session_scope() as session:
creator = session.query(models.Creator).filter_by(id=creator_id).scalar()
if creator:
session.delete(creator)
return {}
return {}, 404
def work(work_id):
if request.method == 'GET':
work = None
with session_scope() as session:
work = session.query(models.Work).filter_by(id=work_id).scalar()
if work:
return {'work': work.to_dict()}
elif request.method == 'PUT':
model_data = api_to_model_dict(request.get_json())
response = logic.update_work(work_id, model_data)
return {'work': response}
elif request.method == 'DELETE':
with session_scope() as session:
work = session.query(models.Work).filter_by(id=work_id).scalar()
if work:
session.delete(work)
return {}
return {}, 404
def test_poop(use_test_db):
with session_scope() as poop_session:
poop_work = models.Work(title='poop')
poop_creator_1 = models.Creator(name='creapoop1')
poop_work_creator_ass = models.Role(
poop_work,
poop_creator_1,
'rectum',
)
poop_work.creators = [poop_work_creator_ass]
poop_creator_2 = models.Creator(name='creapoop2')
poop_creator_1.related_creators = [poop_creator_2]
poop_session.add(poop_creator_1)
poop_session.add(poop_work)
def create_work(work_dict):
work_dict = dict(work_dict)
work_dict.pop('id', None)
with session_scope() as session:
roles = work_dict.pop('roles', None)
tags = work_dict.pop('tags', None)
new_work = Work(**work_dict)
session.add(new_work)
if roles:
_update_roles_for_work(session, roles, new_work)
if tags:
#TODO: Add tags
pass
session.commit()
return new_work.to_dict()
def update_work(work_id, work_dict):
work_dict = dict(work_dict)
work_dict.pop('id', None)
with session_scope() as session:
work = session.query(Work).filter_by(id=work_id).first()
if not work:
return
roles = work_dict.pop('roles', None)
tags = work_dict.pop('tags', None)
if roles:
_update_roles_for_work(session, roles, work)
if tags:
#TODO: Add tags
pass
for field, value in work_dict.items():
setattr(work, field, value)
session.commit()
return work.to_dict()
def test_update_creator_with_roles(use_test_db, test_creator_dict):
test_creator_id = testing_utils.create_fake_creator()['id']
test_work_id = testing_utils.create_fake_work()['id']
test_creator_dict['roles'] = {'illustrator': [test_work_id], 'author': [test_work_id]}
test_creator_dict['related_creators'] = [test_creator_id]
new_test_creator = logic.create_creator(test_creator_dict)
test_creator_dict['aliases'].pop()
test_creator_dict['roles'].pop('illustrator')
updated_test_creator = logic.update_creator(new_test_creator['id'], test_creator_dict)
with session_scope() as session:
created_role = session.query(Role)\
.filter_by(work_id=test_work_id, creator_id=new_test_creator['id'])\
.first().to_dict()
test_work = session.query(Work).filter_by(id=test_work_id).first().to_dict()
assert test_work['roles'] == updated_test_creator['roles']
assert test_creator_dict['aliases'] == updated_test_creator['aliases']
assert 'author' == created_role['role']
def create_fake_creator(
name=None,
is_group=False,
alias_names=None
):
creator_dict = {
'name': name or random_word_generator(2),
'is_group': is_group
}
alias_names = alias_names or []
with session_scope() as session:
new_fake_creator = Creator(**creator_dict)
for alias_name in alias_names:
new_alias = CreatorAlias(name=alias_name, creator=new_fake_creator)
session.add(new_fake_creator)
session.commit()
creator_dict = api_to_model_dict({'creator': new_fake_creator.to_dict()})
return creator_dict
def create_creator(creator_dict):
creator_dict = dict(creator_dict)
creator_dict.pop('id', None)
with session_scope() as session:
roles = creator_dict.pop('roles', None)
related_creators = creator_dict.pop('related_creators', [])
aliases = creator_dict.pop('aliases', [])
new_creator = Creator(**creator_dict)
session.add(new_creator)
if roles:
_update_roles_for_creator(session, roles, new_creator)
if related_creators:
related_creator_rows = session.query(Creator)\
.filter(Creator.id.in_(related_creators))\
.all()
new_creator.related_creators = related_creator_rows
if aliases:
_update_creator_aliases(session, aliases, new_creator)
session.commit()
return new_creator.to_dict()
def create_fake_work(
type=None,
title=None,
catalog_number=None,
release_date=None,
description=None,
is_active=True,
):
work_dict = {
'type': type or random_word_generator(), # Change this if types become enums
'title': title or random_word_generator(2),
'catalog_number': catalog_number or 'CAT-{0}'.format(random.randint(10000,99999)),
'release_date': release_date or datetime.datetime.today(),
'description': description or random_word_generator(15),
'is_active': is_active
}
with session_scope() as session:
new_fake_work = Work(**work_dict)
session.add(new_fake_work)
session.commit()
work_dict = api_to_model_dict({'work': new_fake_work.to_dict()})
return work_dict
def update_creator(creator_id, creator_dict):
creator_dict = dict(creator_dict)
creator_dict.pop('id', None)
with session_scope() as session:
creator = session.query(Creator).filter_by(id=creator_id).first()
if not creator:
return
roles = creator_dict.pop('roles', None)
related_creators = creator_dict.pop('related_creators', [])
aliases = creator_dict.pop('aliases', [])
if roles:
_update_roles_for_creator(session, roles, creator)
if related_creators:
related_creator_rows = session.query(Creator)\
.filter(Creator.id.in_(related_creators))\
.all()
creator.related_creators = related_creator_rows
if aliases:
_update_creator_aliases(session, aliases, creator)
for field, value in creator_dict.items():
setattr(creator, field, value)
session.commit()
return creator.to_dict()
