aiteamutils 0.2.140__py3-none-any.whl → 0.2.141__py3-none-any.whl

aiteamutils/base_service.py

@@ -1,10 +1,11 @@
 #기본 라이브러리
 from fastapi import Request
-from typing import TypeVar, Generic, Type, Dict, Any, Union, List, Optional, Literal
+from typing import TypeVar, Generic, Type, Dict, Any, Union, List, Optional, Literal, Tuple
 from sqlalchemy.orm import DeclarativeBase
 from sqlalchemy.ext.asyncio import AsyncSession
 from datetime import datetime
 from ulid import ULID
+from sqlalchemy import text
 
 #패키지 라이브러리
 from .exceptions import ErrorCode, CustomException
@@ -35,42 +36,31 @@ class BaseService(Generic[ModelType]):
     #######################
     # 입력 및 수정, 삭제 #
     #######################
-    async def create(
+    async def _process_files(
         self,
-        request: Request,
         entity_data: Dict[str, Any],
-        response_model: Any = None,
-        exclude_entities: List[str] | None = None,
-        unique_check: List[Dict[str, Any]] | None = None,
-        fk_check: List[Dict[str, Any]] | None = None,
-        org_ulid_position: str = "organization_ulid",
-        role_permission: str | None = None,
-        token_settings: Dict[str, Any] | None = None,
-        storage_dir: str | None = None
-    ) -> ModelType:
-        
-        if role_permission:
-            permission_result = await verify_role_permission(
-                request=request,
-                role_permission=role_permission,
-                token_settings=token_settings,
-                org_ulid_position=org_ulid_position
-            )
-        
-            if not permission_result:
-                raise CustomException(
-                    ErrorCode.FORBIDDEN,
-                    detail=f"{role_permission}",
-                    source_function=f"base_service.{self.__class__.__name__}.create.permission_result"
-                )
+        entity_result: Any,
+        storage_dir: str,
+        operation: Literal["create", "update", "delete"] = "create"
+    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """파일 처리를 위한 내부 메서드
         
+        Args:
+            entity_data (Dict[str, Any]): 엔티티 데이터
+            entity_result (Any): 생성/수정된 엔티티 결과
+            storage_dir (str): 저장 디렉토리 경로
+            operation (str): 수행할 작업 유형 ("create", "update", "delete")
+            
+        Returns:
+            Tuple[Dict[str, Any], Dict[str, Any]]: (처리된 엔티티 데이터, 파일 정보)
+        """
         try:
-            # 파일 데이터 분리
             entity_data_copy = entity_data.copy()
-            separated_files = {}
+            file_infos = {}
             
-            # extra_data 내의 파일 필드 분리
-            if 'extra_data' in entity_data_copy and isinstance(entity_data_copy['extra_data'], dict):
+            # 파일 데이터 분리
+            separated_files = {}
+            if operation != "delete" and 'extra_data' in entity_data_copy and isinstance(entity_data_copy['extra_data'], dict):
                 extra_data = entity_data_copy['extra_data'].copy()
                 file_fields = {k: v for k, v in extra_data.items() if k.endswith('_files')}
                 
@@ -78,18 +68,144 @@ class BaseService(Generic[ModelType]):
                     raise CustomException(
                         ErrorCode.INVALID_INPUT,
                         detail="storage_dir is required for file upload",
-                        source_function=f"base_service.{self.__class__.__name__}.create.file_fields"
+                        source_function=f"{self.__class__.__name__}._process_files"
                     )
                 
                 # 파일 필드 분리 및 제거
                 for field_name, files in file_fields.items():
                     if files:
                         separated_files[field_name] = files
-                        # extra_data에서 파일 필드 제거
                         del extra_data[field_name]
                 
                 entity_data_copy['extra_data'] = extra_data
 
+            # 기존 파일 삭제 (update 또는 delete 작업 시)
+            if operation in ["update", "delete"]:
+                from .files import FileHandler
+                # files 테이블에서 기존 파일 정보 조회
+                existing_files = await self.db_session.execute(
+                    text("""
+                        SELECT storage_path 
+                        FROM files 
+                        WHERE entity_name = :entity_name 
+                        AND entity_ulid = :entity_ulid
+                    """),
+                    {
+                        "entity_name": self.model.__tablename__,
+                        "entity_ulid": entity_result.ulid
+                    }
+                )
+                existing_files = existing_files.fetchall()
+                
+                # 기존 파일 삭제
+                for file_info in existing_files:
+                    await FileHandler.delete_files(file_info[0])
+                
+                # files 테이블에서 레코드 삭제
+                await self.db_session.execute(
+                    text("""
+                        DELETE FROM files 
+                        WHERE entity_name = :entity_name 
+                        AND entity_ulid = :entity_ulid
+                    """),
+                    {
+                        "entity_name": self.model.__tablename__,
+                        "entity_ulid": entity_result.ulid
+                    }
+                )
+
+            # 새 파일 저장 (create 또는 update 작업 시)
+            if operation != "delete" and separated_files:
+                from .files import FileHandler
+                for field_name, files in separated_files.items():
+                    saved_files = await FileHandler.save_files(
+                        files=files,
+                        storage_dir=storage_dir,
+                        entity_name=self.model.__tablename__,
+                        entity_ulid=entity_result.ulid,
+                        db_session=self.db_session,
+                        column_name=field_name.replace('_files', '')
+                    )
+                    file_infos[field_name] = saved_files
+                    
+                    # extra_data 업데이트 - 파일 정보 캐싱
+                    if not hasattr(entity_result, 'extra_data'):
+                        entity_result.extra_data = {}
+                    if not entity_result.extra_data:
+                        entity_result.extra_data = {}
+                        
+                    entity_result.extra_data[field_name] = [
+                        {
+                            'original_name': f['original_name'],
+                            'storage_path': f['storage_path'],
+                            'mime_type': f['mime_type'],
+                            'size': f['size'],
+                            'checksum': f['checksum'],
+                            'column_name': f['column_name']
+                        } for f in saved_files
+                    ]
+                
+                # extra_data 업데이트된 엔티티 저장
+                await self.db_session.flush()
+
+            return entity_data_copy, file_infos
+
+        except CustomException as e:
+            # 파일 저장 실패 시 저장된 파일들 삭제
+            if file_infos:
+                from .files import FileHandler
+                for file_list in file_infos.values():
+                    for file_info in file_list:
+                        await FileHandler.delete_files(file_info["storage_path"])
+            raise CustomException(
+                e.error_code,
+                detail=e.detail,
+                source_function=f"{self.__class__.__name__}._process_files",
+                original_error=e
+            )
+        except Exception as e:
+            # 파일 저장 실패 시 저장된 파일들 삭제
+            if file_infos:
+                from .files import FileHandler
+                for file_list in file_infos.values():
+                    for file_info in file_list:
+                        await FileHandler.delete_files(file_info["storage_path"])
+            raise CustomException(
+                ErrorCode.FILE_SYSTEM_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}._process_files",
+                original_error=e
+            )
+
+    async def create(
+        self,
+        request: Request,
+        entity_data: Dict[str, Any],
+        response_model: Any = None,
+        exclude_entities: List[str] | None = None,
+        unique_check: List[Dict[str, Any]] | None = None,
+        fk_check: List[Dict[str, Any]] | None = None,
+        org_ulid_position: str = "organization_ulid",
+        role_permission: str | None = None,
+        token_settings: Dict[str, Any] | None = None,
+        storage_dir: str | None = None
+    ) -> ModelType:
+        try:
+            if role_permission:
+                permission_result = await verify_role_permission(
+                    request=request,
+                    role_permission=role_permission,
+                    token_settings=token_settings,
+                    org_ulid_position=org_ulid_position
+                )
+            
+                if not permission_result:
+                    raise CustomException(
+                        ErrorCode.FORBIDDEN,
+                        detail=f"{role_permission}",
+                        source_function=f"base_service.{self.__class__.__name__}.create.permission_result"
+                    )
+
             async with self.db_session.begin():
                 # 고유 검사 수행
                 if unique_check:
@@ -98,69 +214,30 @@ class BaseService(Generic[ModelType]):
                 if fk_check:
                     await validate_unique_fields(self.db_session, fk_check, find_value=False)
                 
-                # 엔티티 생성
+                # 파일 데이터 분리를 위한 임시 엔티티 생성
+                temp_entity = type('TempEntity', (), {'ulid': str(ULID())})()
+                
+                # 파일 데이터 분리
+                entity_data_copy, _ = await self._process_files(
+                    entity_data=entity_data,
+                    entity_result=temp_entity,
+                    storage_dir=storage_dir,
+                    operation="create"
+                )
+                
+                # 엔티티 생성 (파일 데이터가 제거된 상태)
                 result = await self.repository.create(
                     entity_data=entity_data_copy,
                     exclude_entities=exclude_entities
                 )
                 
-                # 파일 처리 및 저장
-                file_infos = {}
-                if separated_files:
-                    try:
-                        from .files import FileHandler
-                        for field_name, files in separated_files.items():
-                            saved_files = await FileHandler.save_files(
-                                files=files,
-                                storage_dir=storage_dir,
-                                entity_name=self.model.__tablename__,
-                                entity_ulid=result.ulid,
-                                db_session=self.db_session,
-                                column_name=field_name.replace('_files', '')  # _files 접미사 제거
-                            )
-                            file_infos[field_name] = saved_files
-                            
-                            # extra_data 업데이트 - 파일 정보 캐싱
-                            if not hasattr(result, 'extra_data'):
-                                result.extra_data = {}
-                            if not result.extra_data:
-                                result.extra_data = {}
-                                
-                            result.extra_data[field_name] = [
-                                {
-                                    'original_name': f['original_name'],
-                                    'storage_path': f['storage_path'],
-                                    'mime_type': f['mime_type'],
-                                    'size': f['size'],
-                                    'checksum': f['checksum'],
-                                    'column_name': f['column_name']
-                                } for f in saved_files
-                            ]
-                        
-                        # extra_data 업데이트된 엔티티 저장
-                        await self.db_session.flush()
-                    except CustomException as e:
-                        # 파일 저장 실패 시 저장된 파일들 삭제
-                        for file_list in file_infos.values():
-                            for file_info in file_list:
-                                await FileHandler.delete_files(file_info["storage_path"])
-                        raise CustomException(
-                            e.error_code,
-                            detail=e.detail,
-                            source_function=f"{self.__class__.__name__}.create.file_processing",
-                            original_error=e
-                        )
-                    except Exception as e:
-                        # 파일 저장 실패 시 저장된 파일들 삭제
-                        for file_list in file_infos.values():
-                            for file_info in file_list:
-                                await FileHandler.delete_files(file_info["storage_path"])
-                        raise CustomException(
-                            ErrorCode.FILE_SYSTEM_ERROR,
-                            detail=str(e),
-                            source_function=f"{self.__class__.__name__}.create.file_processing",
-                            original_error=e
-                        )
+                # 실제 파일 처리
+                _, file_infos = await self._process_files(
+                    entity_data=entity_data,
+                    entity_result=result,
+                    storage_dir=storage_dir,
+                    operation="create"
+                )
 
                 # 결과 반환
                 if response_model:
@@ -173,22 +250,15 @@ class BaseService(Generic[ModelType]):
                     return result
 
         except CustomException as e:
-            # 파일 저장 실패 시 저장된 파일들 삭제
-            if 'file_infos' in locals():
-                for file_list in file_infos.values():
-                    for file_info in file_list:
-                        from .files import FileHandler
-                        await FileHandler.delete_files(file_info["storage_path"])
             raise e
         except Exception as e:
-            # 다른 예외 처리
             raise CustomException(
                 ErrorCode.INTERNAL_ERROR,
                 detail=str(e),
                 source_function=f"base_service.{self.__class__.__name__}.create",
                 original_error=e
             )
-        
+
     async def update(
         self,
         request: Request,
@@ -200,7 +270,8 @@ class BaseService(Generic[ModelType]):
         response_model: Any = None,
         org_ulid_position: str = "organization_ulid",
         role_permission: str = "update",
-        token_settings: Dict[str, Any] | None = None
+        token_settings: Dict[str, Any] | None = None,
+        storage_dir: str | None = None
     ) -> ModelType:
         try:
             async with self.db_session.begin():
@@ -226,16 +297,47 @@ class BaseService(Generic[ModelType]):
                     
                     conditions = {"ulid": ulid}
 
-                result = await self.repository.update(
+                # 기존 엔티티 조회
+                existing_entity = await self.repository.get(conditions=conditions)
+                if not existing_entity:
+                    raise CustomException(
+                        ErrorCode.NOT_FOUND,
+                        detail=str(ulid or conditions),
+                        source_function=f"base_service.{self.__class__.__name__}.update.get_entity"
+                    )
+
+                # 파일 데이터 분리
+                entity_data_copy, _ = await self._process_files(
                     entity_data=entity_data,
+                    entity_result=existing_entity,
+                    storage_dir=storage_dir,
+                    operation="update"
+                )
+
+                # 엔티티 수정 (파일 데이터가 제거된 상태)
+                result = await self.repository.update(
+                    entity_data=entity_data_copy,
                     conditions=conditions,
                     exclude_entities=exclude_entities
                 )
 
+                # 실제 파일 처리
+                _, file_infos = await self._process_files(
+                    entity_data=entity_data,
+                    entity_result=result,
+                    storage_dir=storage_dir,
+                    operation="update"
+                )
+
                 if response_model:
-                    return process_response(result, response_model)
+                    processed_result = process_response(result, response_model)
+                    # 파일 정보 추가
+                    for key, value in file_infos.items():
+                        processed_result[key] = value
+                    return processed_result
                 else:
                     return result
+
         except CustomException as e:
             raise e
         except Exception as e:
@@ -253,7 +355,8 @@ class BaseService(Generic[ModelType]):
         conditions: Dict[str, Any] | None = None,
         org_ulid_position: str = "organization_ulid",
         role_permission: str = "delete",
-        token_settings: Dict[str, Any] | None = None
+        token_settings: Dict[str, Any] | None = None,
+        storage_dir: str | None = None
     ) -> bool:
         try:
             if not ULID.from_str(ulid):
@@ -276,6 +379,19 @@ class BaseService(Generic[ModelType]):
 
             conditions["is_deleted"] = False
 
+            # 엔티티 조회 (파일 삭제를 위해)
+            entity = await self.repository.get(conditions=conditions)
+            if not entity:
+                return False
+
+            # 파일 처리 (삭제)
+            _, _ = await self._process_files(
+                entity_data={},
+                entity_result=entity,
+                storage_dir=storage_dir,
+                operation="delete"
+            )
+
             return await self.repository.delete(
                 conditions=conditions
             )

aiteamutils/version.py

@@ -1,2 +1,2 @@
 """버전 정보"""
-__version__ = "0.2.140"
+__version__ = "0.2.141"

{aiteamutils-0.2.140.dist-info → aiteamutils-0.2.141.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiteamutils
-Version: 0.2.140
+Version: 0.2.141
 Summary: AI Team Utilities
 Project-URL: Homepage, https://github.com/yourusername/aiteamutils
 Project-URL: Issues, https://github.com/yourusername/aiteamutils/issues

{aiteamutils-0.2.140.dist-info → aiteamutils-0.2.141.dist-info}/RECORD

@@ -1,7 +1,7 @@
 aiteamutils/__init__.py,sha256=kRBpRjark0M8ZwFfmKiMFol6CbIILN3WE4f6_P6iIq0,1089
 aiteamutils/base_model.py,sha256=yBZqzTDF9PA4wCAvmYfG12FdVwLtxOEUCcA3z2i6fXU,4176
 aiteamutils/base_repository.py,sha256=Oy2zE1i5qx60Xf1tnsaKLyFWapiPqt5JH8NejwNrPWg,4647
-aiteamutils/base_service.py,sha256=qzg7_rtnXFglg36RDsMScHkILrUbdsm67lmqicnFnlk,16051
+aiteamutils/base_service.py,sha256=3M2Mnt5Woz9upNethadxrRTd8kpmxgE_uPIgYYjqTWA,20223
 aiteamutils/cache.py,sha256=07xBGlgAwOTAdY5mnMOQJ5EBxVwe8glVD7DkGEkxCtw,1373
 aiteamutils/config.py,sha256=YdalpJb70-txhGJAS4aaKglEZAFVWgfzw5BXSWpkUz4,3232
 aiteamutils/database.py,sha256=msvBKtxWeQVOo0v2Q9i2azuTNtnUItuNNar52gdRZTo,20418
@@ -10,7 +10,7 @@ aiteamutils/exceptions.py,sha256=pgf3ersezObyl17wAO3I2fb8m9t2OzWDX1mSjwAWm2Y,160
 aiteamutils/files.py,sha256=Dfi1rYMBZwV-3GMqZ77_I4BNMpnyL-OBaj9WwZVhCbs,8999
 aiteamutils/security.py,sha256=McUl3t5Z5SyUDVUHymHdDkYyF4YSeg4g9fFMML4W6Kw,11630
 aiteamutils/validators.py,sha256=_WHN6jqJQzKM5uPTg-Da8U2qqevS84XeKMkCCF4C_lY,9591
-aiteamutils/version.py,sha256=lUYyf6EhBRHxkbymtXrWeCpibvn_CBwk1pD92zTG0TU,43
-aiteamutils-0.2.140.dist-info/METADATA,sha256=Y48xQbnxkdGCnlCjL7QuEfUyq4Ou0h65b6bUy3KkXck,1743
-aiteamutils-0.2.140.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aiteamutils-0.2.140.dist-info/RECORD,,
+aiteamutils/version.py,sha256=0QCUDt0xcylZJRMZSBiqnFqBsyUsdARPHNxrKiKuxJs,43
+aiteamutils-0.2.141.dist-info/METADATA,sha256=p5daz8rrb2jslha3DxpLf38auLU9H7tIv8va5uxj_Ak,1743
+aiteamutils-0.2.141.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aiteamutils-0.2.141.dist-info/RECORD,,