def update_tag_names(tag, names):
names = util.icase_unique([name for name in names if name])
if not len(names):
raise InvalidTagNameError('At least one name must be specified.')
for name in names:
_verify_name_validity(name)
expr = sqlalchemy.sql.false()
for name in names:
if util.value_exceeds_column_size(name, db.TagName.name):
raise InvalidTagNameError('Name is too long.')
expr = expr | db.TagName.name.ilike(name)
if tag.tag_id:
expr = expr & (db.TagName.tag_id != tag.tag_id)
existing_tags = db.session.query(db.TagName).filter(expr).all()
if len(existing_tags):
raise TagAlreadyExistsError(
'One of names is already used by another tag.')
tag_names_to_remove = []
for tag_name in tag.names:
if not _check_name_intersection([tag_name.name], names):
tag_names_to_remove.append(tag_name)
for tag_name in tag_names_to_remove:
tag.names.remove(tag_name)
for name in names:
if not _check_name_intersection(_get_plain_names(tag), [name]):
tag.names.append(db.TagName(name))
def update_pool_names(pool: model.Pool, names: List[str]) -> None:
# sanitize
assert pool
names = util.icase_unique([name for name in names if name])
if not len(names):
raise InvalidPoolNameError("At least one name must be specified.")
for name in names:
_verify_name_validity(name)
# check for existing pools
expr = sa.sql.false()
for name in names:
expr = expr | (sa.func.lower(model.PoolName.name) == name.lower())
if pool.pool_id:
expr = expr & (model.PoolName.pool_id != pool.pool_id)
existing_pools = db.session.query(model.PoolName).filter(expr).all()
if len(existing_pools):
raise PoolAlreadyExistsError(
"One of names is already used by another pool.")
# remove unwanted items
for pool_name in pool.names[:]:
if not _check_name_intersection([pool_name.name], names, True):
pool.names.remove(pool_name)
# add wanted items
for name in names:
if not _check_name_intersection(_get_names(pool), [name], True):
pool.names.append(model.PoolName(name, -1))
# set alias order to match the request
for i, name in enumerate(names):
for pool_name in pool.names:
if pool_name.name.lower() == name.lower():
pool_name.order = i
def update_tag_names(tag: model.Tag, names: List[str]) -> None:
# sanitize
assert tag
names = util.icase_unique([name for name in names if name])
if not len(names):
raise InvalidTagNameError('최소 하나의 이름은 지정해야 합니다.')
for name in names:
_verify_name_validity(name)
# check for existing tags
expr = sa.sql.false()
for name in names:
expr = expr | (sa.func.lower(model.TagName.name) == name.lower())
if tag.tag_id:
expr = expr & (model.TagName.tag_id != tag.tag_id)
existing_tags = db.session.query(model.TagName).filter(expr).all()
if len(existing_tags):
raise TagAlreadyExistsError('이름 중 하나가 다른 태그에서 이미 사용중입니다.')
# remove unwanted items
for tag_name in tag.names[:]:
if not _check_name_intersection([tag_name.name], names, True):
tag.names.remove(tag_name)
# add wanted items
for name in names:
if not _check_name_intersection(_get_names(tag), [name], True):
tag.names.append(model.TagName(name, -1))
# set alias order to match the request
for i, name in enumerate(names):
for tag_name in tag.names:
if tag_name.name.lower() == name.lower():
tag_name.order = i
def get_or_create_tags_by_names(
names: List[str],
) -> Tuple[List[model.Tag], List[model.Tag]]:
names = util.icase_unique(names)
existing_tags = get_tags_by_names(names)
new_tags = []
tag_category_name = tag_categories.get_default_category_name()
for name in names:
found = False
for existing_tag in existing_tags:
if _check_name_intersection(
_get_names(existing_tag), [name], False
):
found = True
break
if not found:
new_tag = create_tag(
names=[name],
category_name=tag_category_name,
suggestions=[],
implications=[],
)
db.session.add(new_tag)
new_tags.append(new_tag)
return existing_tags, new_tags
def get_pools_by_names(names: List[str]) -> List[model.Pool]:
names = util.icase_unique(names)
if len(names) == 0:
return []
return (db.session.query(model.Pool).join(model.PoolName).filter(
sa.sql.or_(
sa.func.lower(model.PoolName.name) == name.lower()
for name in names)).all())
def get_tags_by_names(names):
names = util.icase_unique(names)
if len(names) == 0:
return []
expr = sqlalchemy.sql.false()
for name in names:
expr = expr | db.TagName.name.ilike(name)
return db.session.query(db.Tag).join(db.TagName).filter(expr).all()
def get_or_create_pools_by_names(
names: List[str], ) -> Tuple[List[model.Pool], List[model.Pool]]:
names = util.icase_unique(names)
existing_pools = get_pools_by_names(names)
new_pools = []
pool_category_name = pool_categories.get_default_category_name()
for name in names:
found = False
for existing_pool in existing_pools:
if _check_name_intersection(_get_names(existing_pool), [name],
False):
found = True
break
if not found:
new_pool = create_pool(names=[name],
category_name=pool_category_name,
post_ids=[])
db.session.add(new_pool)
new_pools.append(new_pool)
return existing_pools, new_pools
def get_or_create_tags_by_names(names):
names = util.icase_unique(names)
for name in names:
_verify_name_validity(name)
existing_tags = get_tags_by_names(names)
new_tags = []
tag_category_name = _get_default_category_name()
for name in names:
found = False
for existing_tag in existing_tags:
if _check_name_intersection(_get_plain_names(existing_tag), [name]):
found = True
break
if not found:
new_tag = create_tag(
names=[name],
category_name=tag_category_name,
suggestions=[],
implications=[])
db.session.add(new_tag)
new_tags.append(new_tag)
return existing_tags, new_tags
def test_icase_unique(input, output):
assert util.icase_unique(input) == output
