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()