def create(self, name, **options):
"""
creates a province.
:param str name: province name.
"""
province = ProvinceEntity(name=name)
store = get_current_store()
store.add(province)
def exists(self, name):
"""
gets a value indicating that a language with given name exists.
:param str name: language name.
:rtype: bool
"""
store = get_current_store()
return store.query(LanguageEntity.id).filter(LanguageEntity.name.ilike(name)).existed()
def create(self, name, province_id, **options):
"""
creates a city.
:param str name: city name.
:param int province_id: province id.
"""
city = CityEntity(name=name, province_id=province_id)
store = get_current_store()
store.add(city)
def _get_all(self, *expressions):
"""
gets all genres using provided expressions.
:param object expressions: expressions to be applied by filter.
:rtype: list[GenreEntity]
"""
store = get_current_store()
return store.query(GenreEntity).filter(*expressions).all()
def _exists(self, permission_id):
"""
gets a value indicating that given permission exists in database.
:param int permission_id: permission id.
:rtype: bool
"""
store = get_current_store()
return store.query(PermissionEntity.id).filter(
PermissionEntity.id == permission_id).existed()
def delete(self, id):
"""
deletes a language with given id.
:param int id: language id.
:returns: count of deleted items.
:rtype: int
"""
store = get_current_store()
return store.query(LanguageEntity.id).filter(LanguageEntity.id == id).delete()
def _get(self, id):
"""
gets person with given id.
it returns None if person does not exist.
:param int id: person id.
:rtype: PersonEntity
"""
store = get_current_store()
return store.query(PersonEntity).get(id)
def get_by_name(self, name):
"""
gets a language by name.
it returns None if language does not exist.
:param str name: language name.
:rtype: LanguageEntity
"""
store = get_current_store()
return store.query(LanguageEntity).filter(LanguageEntity.name.ilike(name)).one_or_none()
def _get(self, id):
"""
gets genre with given id.
it returns None if genre does not exist.
:param int id: genre id.
:rtype: GenreEntity
"""
store = get_current_store()
return store.query(GenreEntity).get(id)
def delete(self, id):
"""
deletes an actor with given id.
:param int id: person id.
:returns: count of deleted items.
:rtype: int
"""
store = get_current_store()
return store.query(ActorEntity.person_id)\
.filter(ActorEntity.person_id == id).delete()
def _get(self, id):
"""
gets language with given id.
it returns None if language does not exist.
:param int id: language id.
:rtype: LanguageEntity
"""
store = get_current_store()
return store.query(LanguageEntity).get(id)
def _actor_exists(self, id):
"""
gets the required expression to check that given id is related to an actor.
the result of this method must be used inside a where clause of another query.
:param int id: person id.
:returns: exists expression.
"""
store = get_current_store()
return store.query(ActorEntity.person_id)\
.filter(ActorEntity.person_id == id).exists()
def _get(self, id):
"""
gets actor with given id.
it returns None if actor does not exist.
:param int id: person id.
:rtype: ActorEntity
"""
store = get_current_store()
return store.query(PersonEntity)\
.filter(self._actor_exists(id), PersonEntity.id == id).one_or_none()
def delete(self, id):
"""
deletes a person with given id.
:param int id: person id.
:returns: count of deleted items.
:rtype: int
"""
for name, handler in self._handlers.items():
handler.delete(id)
store = get_current_store()
return store.query(
PersonEntity.id).filter(PersonEntity.id == id).delete()
def find(self, **filters):
"""
finds provinces with given filters.
:keyword str name: province name.
:returns: list[dict(int id,
str name)]
:rtype: list
"""
clauses = self._make_find_clause(**filters)
store = get_current_store()
entities = store.query(ProvinceEntity).filter(*clauses).all()
return entities
def _get_by_imdb_page(self, imdb_page, **options):
"""
gets a person by its imdb page link.
it returns None if person not found.
:param str imdb_page: imdb page link.
:rtype: PersonEntity
"""
identifier = self._get_identifier(imdb_page)
store = get_current_store()
query = store.query(PersonEntity)
query = self._prepare_query(query)
return query.filter(
PersonEntity.identifier.ilike(identifier)).one_or_none()
def _exists_by_imdb_page(self, imdb_page, **options):
"""
gets a value indicating a person with given imdb page exists.
:param str imdb_page: imdb page link.
:rtype: bool
"""
if imdb_page in (None, ''):
return False
identifier = self._get_identifier(imdb_page)
store = get_current_store()
query = store.query(PersonEntity.id)
query = self._prepare_query(query)
return query.filter(
PersonEntity.identifier.ilike(identifier)).existed()
def _get_all(self, *expressions, **options):
"""
gets all persons using provided expressions.
:param object expressions: expressions to be applied by filter.
:keyword list[CoreColumn | CoreEntity] columns: list of columns or entity types
to be used in select list.
if not provided, `PersonEntity`
will be used.
:rtype: list[PersonEntity]
"""
columns = options.get('columns') or [PersonEntity]
store = get_current_store()
query = store.query(*columns)
query = self._prepare_query(query)
return query.filter(*expressions).all()
def _get_by_fullname(self, fullname, **options):
"""
gets a person by its fullname.
it returns None if person not found.
it only returns if found person has no imdb page link.
:param str fullname: fullname.
:rtype: PersonEntity
"""
search_name = self._get_search_name(fullname)
store = get_current_store()
query = store.query(PersonEntity)
query = self._prepare_query(query)
return query.filter(
PersonEntity.search_name.ilike(search_name),
or_(PersonEntity.imdb_page == None,
PersonEntity.imdb_page == '')).first()
def login(self, username, password, **options):
"""
logs in the provided user and gets a valid token.
:param str username: username.
:param str password: password.
:raises InvalidUserInfoError: invalid user info error.
:raises UserNotFoundError: user not found error.
:raises UserIsNotActiveError: user is not active error.
:returns: a valid token.
:rtype: str
"""
if username is None or password is None:
raise InvalidUsernameOrPasswordError(_('Username or password is invalid.'))
store = get_current_store()
user = store.query(UserEntity).filter(UserEntity.username == username).one_or_none()
fail_message = _('User not found, make sure that '
'username and password are correct.')
if user is None:
raise UserNotFoundError(fail_message)
if hashing_services.is_match(password, user.password_hash) is not True:
raise UserNotFoundError(fail_message)
if user.is_active is False:
raise UserIsNotActiveError(_('User [{user_id}] is not active.'
.format(user_id=user.id)))
user.last_login_date = datetime_services.now()
store.add(user)
payload = DTO(user_id=user.id)
return DTO(access_token=toke_services.generate_access_token(payload, is_fresh=True),
refresh_token=toke_services.generate_refresh_token(payload))
def get(self, province_id, **options):
"""
gets the specified province.
:param int province_id: province id to get its info.
:raises ProvinceNotFoundError: province not found error.
:returns: dict(int id,
str name)
:rtype: dict
"""
store = get_current_store()
province = store.query(ProvinceEntity).get(province_id)
if province is None:
raise ProvinceNotFoundError(_('Province [{province_id}] not found.'
.format(province_id=province_id)))
return province.to_dict()
def get(self, city_id, **options):
"""
gets the specified city.
:param int city_id: city id to get its info.
:raises CityNotFoundError: city not found error.
:returns: dict(int id,
str name,
int province_id: province id)
:rtype: dict
"""
store = get_current_store()
city = store.query(CityEntity).get(city_id)
if city is None:
raise CityNotFoundError(
_('City [{city_id}] not found.'.format(city_id=city_id)))
return city.to_dict()
def _exists_by_fullname(self, fullname, **options):
"""
gets a value indicating a person with given fullname exists.
it only returns True if found person has no imdb page link.
:param str fullname: fullname.
:rtype: bool
"""
if fullname in (None, ''):
return False
search_name = self._get_search_name(fullname)
store = get_current_store()
query = store.query(PersonEntity.id)
query = self._prepare_query(query)
return query.filter(
PersonEntity.search_name.ilike(search_name),
or_(PersonEntity.imdb_page == None,
PersonEntity.imdb_page == '')).existed()
