def block(self, post_id: int) -> bool:
try:
session.query(PostModel).filter_by(id=post_id).update(
{"is_blocked": True})
return True
except Exception as e:
logger.error(
f"[BoardRepository][block] post_id : {post_id} error : {e}")
session.rollback()
return False
def delete_attachments(self, post_id: int) -> bool:
try:
session.query(AttachmentModel).filter_by(post_id=post_id).delete()
return True
except Exception as e:
logger.error(
f"[BoardRepository][delete_attachments] post_id : {post_id} error : {e}"
)
session.rollback()
return False
def add_read_count(self, post_id: int) -> bool:
try:
session.query(PostModel).filter_by(id=post_id).update(
{"read_count": PostModel.read_count + 1})
return True
except Exception as e:
logger.error(
f"[BoardRepository][add_read_count] post_id : {post_id} error : {e}"
)
session.rollback()
return False
def add_report_count(self, post_id: int) -> Union[int, bool]:
try:
session.query(PostModel).filter_by(id=post_id).update(
{"report_count": PostModel.report_count + 1})
return self._get_post(post_id=post_id).report_count
except Exception as e:
logger.error(
f"[BoardRepository][add_report_count] post_id : {post_id} error : {e}"
)
session.rollback()
return False
def update_notification_status(
self, notification_history_id: int, status: str
) -> None:
try:
session.query(NotificationHistoryModel).filter_by(
id=notification_history_id
).update({"status": status})
except Exception as e:
# TODO : log e 필요
print("-------------------> ", e)
session.rollback()
def delete_post(self, dto: DeletePostDto) -> Optional[PostEntity]:
try:
session.query(PostModel).filter_by(id=dto.post_id).update(
{"is_deleted": True})
return self._get_post(post_id=dto.post_id)
except Exception as e:
session.rollback()
logger.error(
f"[BoardRepository][delete_post] post_id : {dto.post_id} error : {e}"
)
return None
def update_post_like_count(self, post_id: int, count: int) -> bool:
try:
session.query(PostLikeCountModel).filter_by(
post_id=post_id).update(
{"count": PostLikeCountModel.count + count})
return True
except Exception as e:
logger.error(
f"[BoardRepository][update_post_like_count] post_id : {post_id} count : {count} error : {e}"
)
session.rollback()
return False
def update_post_like_state(self, user_id: int, post_id: int,
state: str) -> Optional[PostLikeStateEntity]:
try:
session.query(PostLikeStateModel).filter_by(
user_id=user_id,
post_id=post_id,
).update({"state": state})
return self.get_post_like_state(user_id=user_id, post_id=post_id)
except Exception as e:
logger.error(
f"[BoardRepository][create_post_like_state] post_id : {post_id} user_id : {user_id} state : {state}"
f" error : {e}")
session.rollback()
return None
def get_board(self, board_id: int = None) -> Board:
bm = aliased(BoardModels)
board = session.query(bm).filter(bm.id == board_id).first()
if not board:
raise NotFoundException()
return board.to_entity()
def get_keyword_target_user(self) -> List[dict]:
target_user_group = (
session.query(NotificationModel)
.with_entities(
NotificationModel.user_id,
UserNotificationTokenModel.token,
KeywordModel.name_1,
KeywordModel.name_2,
KeywordModel.name_3,
)
.join(
UserNotificationTokenModel,
NotificationModel.user_id == UserNotificationTokenModel.user_id,
)
.join(KeywordModel, NotificationModel.user_id == KeywordModel.user_id)
.filter(
NotificationModel.is_available == True,
NotificationModel.use_keyword == True,
)
.all()
)
result = []
for target_user in target_user_group:
info_dict = dict(
user_id=target_user.user_id,
token=target_user.token,
keyword_1=target_user.name_1,
keyword_2=target_user.name_2,
keyword_3=target_user.name_3,
)
result.append(info_dict)
return result
def get_user_profile(self,
user_profile_id: int) -> Optional[UserProfileEntity]:
user_profile = (session.query(UserProfileModel).filter_by(
id=user_profile_id).first())
if user_profile:
return user_profile.to_entity()
return None
def edit_board(self, dto: EditBoardDto = None) -> Board:
board = (session.query(BoardModels).filter(
BoardModels.id == dto.board_id).first())
board.title = dto.title or board.title
board.body = dto.body or board.body
session.commit()
return board.to_entity()
def get_post(self,
post_id: int,
is_deleted: bool = False,
is_blocked: bool = False) -> Optional[PostEntity]:
post = (session.query(PostModel).filter_by(
id=post_id, is_deleted=is_deleted, is_blocked=is_blocked).first())
return post.to_entity() if post else None
def update_user(self, user_id: int, nickname: str, status: str,
region_id: int) -> Optional[UserEntity]:
try:
session.query(UserModel).filter_by(id=user_id).update({
"nickname":
nickname,
"status":
status,
"region_id":
region_id
})
return self.get_user(user_id=user_id)
except Exception as e:
logger.error(
f"[UserRepository][update_user] user_id : {user_id} error : {e}"
)
session.rollback()
return None
def update_user_profile(self, user_profile_id: int, uuid: str,
file_name: str, path: str,
extension: str) -> Optional[UserProfileEntity]:
try:
session.query(UserProfileModel).filter_by(
id=user_profile_id).update({
"uuid": uuid,
"file_name": file_name,
"path": path,
"extension": extension,
})
return self.get_user_profile(user_profile_id=user_profile_id)
except Exception as e:
logger.error(
f"[UserRepository][update_user] user_profile_id : {user_profile_id} error : {e}"
)
session.rollback()
return None
def get_selling_post_list(self,
user_id: int,
previous_post_id: int = None) -> list:
previous_post_id_filter = []
if previous_post_id:
previous_post_id_filter.append(PostModel.id < previous_post_id)
post_list = (session.query(PostModel).filter(
PostModel.user_id == user_id, *previous_post_id_filter).order_by(
PostModel.id.desc()).limit(PostLimitEnum.LIMIT.value).all())
return [post.to_entity() for post in post_list]
def update_post(self, dto: UpdatePostDto) -> Optional[PostEntity]:
try:
(session.query(PostModel).filter(
PostModel.id == dto.post_id).update({
"title":
dto.title,
"region_group_id":
dto.region_group_id,
"type":
dto.type,
"is_comment_disabled":
dto.is_comment_disabled,
}))
session.query(ArticleModel).filter_by(post_id=dto.post_id).update(
{"body": dto.body})
post_entity = self._get_post(post_id=dto.post_id)
return post_entity if post_entity else None
except Exception as e:
session.rollback()
logger.error(
f"[BoardRepository][update_post] title : {dto.title} region_group_id : {dto.region_group_id} "
f"type : {dto.type} is_comment_disabled : {dto.is_comment_disabled} error : {e}"
)
return None
def get_board_list(self,
search_type: str = None,
search_word: str = None,
page: int = None) -> List:
search_filter = []
if search_word:
if search_type == BoardSearchTypeEnum.TITLE:
search_filter.append(BoardModels.title.ilike(search_word))
if search_type == BoardSearchTypeEnum.USER_ID:
search_filter.append(BoardModels.user_id.ilike(search_word))
board_pagination = (session.query(BoardModels).filter(
*search_filter).paginate(page=page,
per_page=BoardPaginationEnum.BOARD_PAGE))
return [
[item.to_entity() for item in board_pagination.items],
Paginate(
total=board_pagination.total,
count=len(board_pagination.items),
per_page=board_pagination.per_page,
current_page=board_pagination.page,
total_pages=board_pagination.pages,
),
]
def get_attachments(self, post_id: int) -> list:
attachments = session.query(AttachmentModel).filter_by(
post_id=post_id).all()
return [attachment.to_entity() for attachment in attachments]
def _get_post(self, post_id) -> PostEntity:
return session.query(PostModel).filter_by(
id=post_id).first().to_entity()
def delete_board(self, dto: DeleteBoardDto = None) -> None:
session.query(BoardModels).filter(
BoardModels.id == dto.board_id).delete()
session.commit()
def get_post_list(
self,
region_group_id: int,
previous_post_id: int = None,
title: str = "",
category_ids: list = None,
status: str = None,
) -> Optional[List[Union[PostEntity, list]]]:
"""
:param category_ids: 상품 카테고리
:param status: post 판매 상태
:param region_group_id: 유저가 속한 동네 식별자
:param previous_post_id: 유저가 바로 직전 조회한 post id
:param title: 게시글 제목
:return: post list
1. 동일 지역의 post 가져오기, deleted, blocked 제외
2. title like 검색, 선택된 type, category 등에 맞게 응답
"""
if not category_ids:
category_ids = self.get_category_ids()
search_filter = []
if title:
search_filter.append(PostModel.title.like(f"%{title}%"))
previous_post_id_filter = []
if previous_post_id:
previous_post_id_filter.append(PostModel.id < previous_post_id)
status_filters = []
if status == PostStatusEnum.EXCLUDE_COMPLETED.value: # 거래 완료 글 안보기
status_filters.append(
PostModel.status == PostStatusEnum.SELLING.value)
elif status == PostStatusEnum.ALL.value: # 판매중, 거래 완료 글 보기
status_filters.append(
[PostModel.status == PostStatusEnum.SELLING.value])
status_filters.append(
[PostModel.status == PostStatusEnum.COMPLETED.value])
try:
# TODO:코드 메서드로 분리해서 호출
# status에 따라 판매중 or 판매중 + 거래 완료 선택
if len(status_filters) >= 2:
query_list = []
for status_filter in status_filters:
query_list.append(
session.query(PostModel).filter(
PostModel.region_group_id == region_group_id,
PostModel.is_blocked == False,
PostModel.is_deleted == False,
*search_filter,
*previous_post_id_filter,
*status_filter,
))
query = query_list[0].union(*query_list[1:])
else:
query = session.query(PostModel).filter(
PostModel.region_group_id == region_group_id,
PostModel.is_blocked == False,
PostModel.is_deleted == False,
*search_filter,
*previous_post_id_filter,
*status_filters,
)
query_list = []
for category_id in category_ids:
q = query
query_list.append(
q.filter(
PostModel.id == PostCategoryModel.post_id,
PostCategoryModel.category_id == CategoryModel.id,
CategoryModel.id == category_id,
))
post_list = []
if query_list:
query = query_list[0].union(*query_list[1:])
post_list = (query.order_by(PostModel.id.desc()).limit(
PostLimitEnum.LIMIT.value).all())
return [post.to_post_list_entity() for post in post_list]
except Exception as e:
logger.error(f"[BoardRepository][get_post_list] error : {e}")
return []
def is_post_exist(self, post_id: int) -> bool:
return session.query(
session.query(PostModel).filter_by(id=post_id).exists()).scalar()
def get_post_like_count(self,
post_id: int) -> Optional[PostLikeCountEntity]:
post_like_count = (session.query(PostLikeCountModel).filter_by(
post_id=post_id).first())
return post_like_count.to_entity() if post_like_count else None
def get_user(self, user_id: int) -> Optional[UserEntity]:
user = session.query(UserModel).filter_by(id=user_id).first()
return user.to_entity() if user else None
def get_post_like_state(self, user_id: int,
post_id: int) -> Optional[PostLikeStateEntity]:
post_like_state = (session.query(PostLikeStateModel).filter_by(
user_id=user_id, post_id=post_id).first())
return post_like_state.to_entity() if post_like_state else None
def get_category_ids(self) -> list:
category_ids = (session.query(CategoryModel).with_entities(
CategoryModel.id).all())
return [category_id[0] for category_id in category_ids]
def get_post_report(self, report_user_id: int,
post_id) -> Optional[PostReportEntity]:
post_report = (session.query(PostReportModel).filter_by(
report_user_id=report_user_id, post_id=post_id).first())
return post_report.to_entity() if post_report else None
def get_user(self, username: str = None) -> UserModels:
user = session.query(UserModels).filter_by(username=username).first()
if not user:
raise NotFoundException()
return user.to_entity()
def get_region_group(self, id: int) -> Optional[RegionGroupEntity]:
region_group = session.query(RegionGroupModel).filter_by(id=id).first()
return region_group.to_entity() if region_group else None
