def create_post(self, dto: CreatePostDto) -> Optional[PostEntity]:
try:
post = PostModel(
user_id=dto.user_id,
title=dto.title,
region_group_id=dto.region_group_id,
type=dto.type,
is_comment_disabled=dto.is_comment_disabled,
amount=dto.amount,
unit=dto.unit,
price_per_unit=dto.price_per_unit,
status=dto.status,
)
session.add(post)
session.commit()
article = ArticleModel(post_id=post.id, body=dto.body)
session.add(article)
session.commit()
self.create_post_categories(post_id=post.id, dto=dto)
return post.to_entity()
except Exception as e:
logger.error(
f"[BoardRepository][create_post] user_id : {dto.user_id} title : {dto.title} "
f"region_group_id : {dto.region_group_id} type : {dto.type} "
f"is_comment_disabled : {dto.is_comment_disabled} amount : {dto.amount} unit : {dto.unit} "
f"price_per_unit : {dto.price_per_unit} status : {dto.status} error : {e}"
)
session.rollback()
return None
def create_attachment(
self,
post_id: int,
type: str,
file_name: str,
path: str,
extension: str,
uuid: str,
) -> Optional[AttachmentEntity]:
try:
attachment = AttachmentModel(
post_id=post_id,
type=type,
file_name=file_name,
path=path,
extension=extension,
uuid=uuid,
)
session.add(attachment)
session.commit()
return attachment.to_entity() if attachment else None
except Exception as e:
session.rollback()
logger.error(
f"[BoardRepository][create_attachment] post_id : {post_id} type : {type} file_name : {file_name} "
f"path : {path} extension : {extension} uuid : {uuid} error : {e}"
)
return None
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_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 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 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 create_post_like_count(self, post_id) -> Optional[PostLikeCountEntity]:
try:
post_like_count = PostLikeCountModel(post_id=post_id)
session.add(post_like_count)
session.commit()
return post_like_count.to_entity()
except Exception as e:
logger.error(
f"[BoardRepository][create_post_like_count] post_id : {post_id} error : {e}"
)
session.rollback()
return None
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 create_post_like_state(self, user_id: int, post_id: int):
try:
post_like_state = PostLikeStateModel(
user_id=user_id,
post_id=post_id,
state=PostLikeStateEnum.LIKE.value)
session.add(post_like_state)
session.commit()
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} error : {e}"
)
session.rollback()
return False
def create_post_categories(self, post_id: int, dto: CreatePostDto):
post_categories = []
try:
for category_id in dto.category_ids:
post_categories.append(
PostCategoryModel(post_id=post_id,
category_id=category_id))
session.add_all(post_categories)
session.commit()
except Exception as e:
logger.error(
f"[BoardRepository][create_post_categories] post_id : {post_id} error : {e}"
)
session.rollback()
return False
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 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 create_notification_history(
self, notification_list: List[NotificationHistoryDto]
) -> None:
try:
for dto in notification_list:
notification_history = NotificationHistoryModel(
user_id=dto.user_id,
status=dto.status,
type=dto.type,
category=dto.category,
message=dto.message,
)
session.add(notification_history)
session.commit()
self._set_notification_info(notification_history.id, dto.message)
except Exception as e:
# TODO : log e 필요
print("-------------------> ", e)
session.rollback()
def create_post_report(
self, dto: CreatePostReportDto) -> Optional[PostReportEntity]:
try:
post_report = PostReportModel(
post_id=dto.post_id,
report_user_id=dto.report_user_id,
status=dto.status,
context=dto.status,
confirm_admin_id=dto.confirm_admin_id,
is_system_report=dto.is_system_report,
)
session.add(post_report)
session.commit()
return post_report.to_entity() if post_report else None
except Exception as e:
logger.error(
f"[ReportRepository][create_post_report] post_id : {dto.post_id} report_user_id : {dto.report_user_id} "
f"error : {e}")
session.rollback()
return None
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
