nik/newdwh2021
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat:マスタメンテの廃止、不要になる箇所のコメントアウト

Browse Source
This commit is contained in:
yono 2025-05-22 09:51:03 +09:00
parent 66aad6d4af
commit 41d92378c2
29 changed files with 2185 additions and 2156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

633
ecs/jskult-webapp/src/controller/master_mainte.py
View File

@ -1,371 +1,372 @@
from io import BytesIO, TextIOWrapper # # ファイル削除予定
from typing import Optional # from io import BytesIO, TextIOWrapper
# from typing import Optional
from fastapi import APIRouter, Depends, HTTPException, Request # from fastapi import APIRouter, Depends, HTTPException, Request
from fastapi.responses import HTMLResponse # from fastapi.responses import HTMLResponse
from starlette import status # from starlette import status
from src.depends.services import get_service # from src.depends.services import get_service
from src.logging.get_logger import get_logger # from src.logging.get_logger import get_logger
from src.model.internal.session import UserSession # from src.model.internal.session import UserSession
from src.model.request.master_mainte_csvdl import MasterMainteCsvDlModel # from src.model.request.master_mainte_csvdl import MasterMainteCsvDlModel
from src.model.request.master_mainte_csvup import MasterMainteCsvUpModel # from src.model.request.master_mainte_csvup import MasterMainteCsvUpModel
from src.model.view.inst_emp_csv_download_view_model import \ # from src.model.view.inst_emp_csv_download_view_model import \
InstEmpCsvDownloadViewModel # InstEmpCsvDownloadViewModel
from src.model.view.inst_emp_csv_upload_view_model import \ # from src.model.view.inst_emp_csv_upload_view_model import \
InstEmpCsvUploadViewModel # InstEmpCsvUploadViewModel
from src.model.view.master_mainte_menu_view_model import \ # from src.model.view.master_mainte_menu_view_model import \
MasterMainteMenuViewModel # MasterMainteMenuViewModel
from src.model.view.table_override_view_model import TableOverrideViewModel # from src.model.view.table_override_view_model import TableOverrideViewModel
from src.router.session_router import AuthenticatedRoute # from src.router.session_router import AuthenticatedRoute
from src.services.batch_status_service import BatchStatusService # from src.services.batch_status_service import BatchStatusService
from src.services.login_service import LoginService # from src.services.login_service import LoginService
from src.services.master_mainte_service import MasterMainteService # from src.services.master_mainte_service import MasterMainteService
from src.system_var import constants # from src.system_var import constants
from src.templates import templates # from src.templates import templates
logger = get_logger('マスターメンテ') # logger = get_logger('マスターメンテ')
router = APIRouter() # router = APIRouter()
router.route_class = AuthenticatedRoute # router.route_class = AuthenticatedRoute
######################### # #########################
# Views # # # Views #
######################### # #########################
@router.get('/masterMainteMenu', response_class=HTMLResponse) # @router.get('/masterMainteMenu', response_class=HTMLResponse)
def menu_view( # def menu_view(
request: Request, # request: Request,
batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService)) # batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService))
): # ):
session: UserSession = request.session # session: UserSession = request.session
# マスタメンテメニューへのアクセス権がない場合、ログアウトさせる # # マスタメンテメニューへのアクセス権がない場合、ログアウトさせる
if session.master_mainte_flg == constants.PERMISSION_DISABLED: # if session.master_mainte_flg == constants.PERMISSION_DISABLED:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
# バッチ処理中の場合、ログアウトさせる # # バッチ処理中の場合、ログアウトさせる
if batch_status_service.is_batch_processing(): # if batch_status_service.is_batch_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE) # detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE)
# dump処理中の場合、ログアウトさせる # # dump処理中の場合、ログアウトさせる
if batch_status_service.is_dump_processing(): # if batch_status_service.is_dump_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING)
# 画面表示用のモデル # # 画面表示用のモデル
menu = MasterMainteMenuViewModel() # menu = MasterMainteMenuViewModel()
# レスポンス # # レスポンス
session_key = session.session_key # session_key = session.session_key
templates_response = templates.TemplateResponse( # templates_response = templates.TemplateResponse(
'masterMainteMenu.html', # 'masterMainteMenu.html',
{ # {
'request': request, # 'request': request,
'menu': menu # 'menu': menu
}, # },
headers={'session_key': session_key} # headers={'session_key': session_key}
) # )
return templates_response # return templates_response
@router.get('/instEmpCsvUL', response_class=HTMLResponse) # @router.get('/instEmpCsvUL', response_class=HTMLResponse)
def inst_emp_csv_upload_view( # def inst_emp_csv_upload_view(
request: Request, # request: Request,
batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService)) # batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService))
): # ):
session: UserSession = request.session # session: UserSession = request.session
# マスタメンテメニューへのアクセス権がない場合、ログアウトさせる # # マスタメンテメニューへのアクセス権がない場合、ログアウトさせる
if session.master_mainte_flg == constants.PERMISSION_DISABLED: # if session.master_mainte_flg == constants.PERMISSION_DISABLED:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
# バッチ処理中の場合、ログアウトさせる # # バッチ処理中の場合、ログアウトさせる
if batch_status_service.is_batch_processing(): # if batch_status_service.is_batch_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE) # detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE)
# dump処理中の場合、ログアウトさせる # # dump処理中の場合、ログアウトさせる
if batch_status_service.is_dump_processing(): # if batch_status_service.is_dump_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING)
# 画面表示用のモデル # # 画面表示用のモデル
mainte_csv_up = InstEmpCsvUploadViewModel() # mainte_csv_up = InstEmpCsvUploadViewModel()
# レスポンス # # レスポンス
session_key = session.session_key # session_key = session.session_key
templates_response = templates.TemplateResponse( # templates_response = templates.TemplateResponse(
'instEmpCsvUL.html', # 'instEmpCsvUL.html',
{ # {
'request': request, # 'request': request,
'mainte_csv_up': mainte_csv_up # 'mainte_csv_up': mainte_csv_up
}, # },
headers={'session_key': session_key} # headers={'session_key': session_key}
) # )
return templates_response # return templates_response
@router.post('/instEmpCsvUL', response_class=HTMLResponse) # @router.post('/instEmpCsvUL', response_class=HTMLResponse)
async def inst_emp_csv_upload( # async def inst_emp_csv_upload(
request: Request, # request: Request,
csv_upload_form: MasterMainteCsvUpModel = Depends(MasterMainteCsvUpModel.as_form), # csv_upload_form: MasterMainteCsvUpModel = Depends(MasterMainteCsvUpModel.as_form),
master_mainte_service: MasterMainteService = Depends(get_service(MasterMainteService)), # master_mainte_service: MasterMainteService = Depends(get_service(MasterMainteService)),
batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService)) # batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService))
): # ):
session: UserSession = request.session # session: UserSession = request.session
# マスタメンテメニューへのアクセス権がない場合、ログアウトさせる # # マスタメンテメニューへのアクセス権がない場合、ログアウトさせる
if session.master_mainte_flg == constants.PERMISSION_DISABLED: # if session.master_mainte_flg == constants.PERMISSION_DISABLED:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
# バッチ処理中の場合、ログアウトさせる # # バッチ処理中の場合、ログアウトさせる
if batch_status_service.is_batch_processing(): # if batch_status_service.is_batch_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE) # detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE)
# dump処理中の場合、ログアウトさせる # # dump処理中の場合、ログアウトさせる
if batch_status_service.is_dump_processing(): # if batch_status_service.is_dump_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING)
# 画面表示用のモデル # # 画面表示用のモデル
error_message_list = [] # error_message_list = []
csv_filename: str = csv_upload_form.csv_file.filename # csv_filename: str = csv_upload_form.csv_file.filename
if csv_upload_form.csv_file.size == 0: # if csv_upload_form.csv_file.size == 0:
error_message_list.append('選択されたファイルが見つかりませんでした。') # error_message_list.append('選択されたファイルが見つかりませんでした。')
elif not csv_filename.endswith('.csv'): # elif not csv_filename.endswith('.csv'):
error_message_list.append('選択されたファイル形式が"csv"ではありません。') # error_message_list.append('選択されたファイル形式が"csv"ではありません。')
elif csv_upload_form.csv_file.size >= constants.MENTE_CSV_UPLOAD_MAX_FILE_SIZE_BYTE: # elif csv_upload_form.csv_file.size >= constants.MENTE_CSV_UPLOAD_MAX_FILE_SIZE_BYTE:
error_message_list.append('選択されたCSVファイルサイズが大きいです。20MB未満にしてください。') # error_message_list.append('選択されたCSVファイルサイズが大きいです。20MB未満にしてください。')
else: # else:
mainte_csv_up = master_mainte_service.prepare_mainte_csv_up_view( # mainte_csv_up = master_mainte_service.prepare_mainte_csv_up_view(
TextIOWrapper(BytesIO(await csv_upload_form.csv_file.read()), encoding='utf-8'), # TextIOWrapper(BytesIO(await csv_upload_form.csv_file.read()), encoding='utf-8'),
csv_upload_form.csv_file.filename, # csv_upload_form.csv_file.filename,
csv_upload_form) # csv_upload_form)
if len(error_message_list) > 0: # if len(error_message_list) > 0:
mainte_csv_up = InstEmpCsvUploadViewModel( # mainte_csv_up = InstEmpCsvUploadViewModel(
is_verified=True, # is_verified=True,
error_message_list=error_message_list, # error_message_list=error_message_list,
select_function=csv_upload_form.select_function, # select_function=csv_upload_form.select_function,
select_table=csv_upload_form.select_table) # select_table=csv_upload_form.select_table)
# レスポンス # # レスポンス
session_key = session.session_key # session_key = session.session_key
templates_response = templates.TemplateResponse( # templates_response = templates.TemplateResponse(
'instEmpCsvUL.html', # 'instEmpCsvUL.html',
{ # {
'request': request, # 'request': request,
'mainte_csv_up': mainte_csv_up # 'mainte_csv_up': mainte_csv_up
}, # },
headers={'session_key': session_key} # headers={'session_key': session_key}
) # )
return templates_response # return templates_response
@router.post('/newInst', response_class=HTMLResponse) # @router.post('/newInst', response_class=HTMLResponse)
def new_inst_result_view( # def new_inst_result_view(
request: Request, # request: Request,
csv_upload_form: Optional[MasterMainteCsvUpModel] = Depends(MasterMainteCsvUpModel.as_form), # csv_upload_form: Optional[MasterMainteCsvUpModel] = Depends(MasterMainteCsvUpModel.as_form),
master_mainte_service: MasterMainteService = Depends(get_service(MasterMainteService)), # master_mainte_service: MasterMainteService = Depends(get_service(MasterMainteService)),
batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService)), # batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService)),
login_service: LoginService = Depends(get_service(LoginService)) # login_service: LoginService = Depends(get_service(LoginService))
): # ):
session: UserSession = request.session # session: UserSession = request.session
# マスタメンテメニューへのアクセス権がない場合、ログアウトさせる # # マスタメンテメニューへのアクセス権がない場合、ログアウトさせる
if session.master_mainte_flg == constants.PERMISSION_DISABLED: # if session.master_mainte_flg == constants.PERMISSION_DISABLED:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
# バッチ処理中の場合、ログアウトさせる # # バッチ処理中の場合、ログアウトさせる
if batch_status_service.is_batch_processing(): # if batch_status_service.is_batch_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE) # detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE)
# dump処理中の場合、ログアウトさせる # # dump処理中の場合、ログアウトさせる
if batch_status_service.is_dump_processing(): # if batch_status_service.is_dump_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING)
# ユーザIDからユーザ名を取得 # # ユーザIDからユーザ名を取得
user_name = login_service.logged_in_user(session.user_id).user_name # user_name = login_service.logged_in_user(session.user_id).user_name
# CSVデータを登録し、登録完了画面のモデルを返却する # # CSVデータを登録し、登録完了画面のモデルを返却する
mainte_csv_up = master_mainte_service.prepare_mainte_new_inst_view(user_name, csv_upload_form) # mainte_csv_up = master_mainte_service.prepare_mainte_new_inst_view(user_name, csv_upload_form)
# レスポンス # # レスポンス
session_key = session.session_key # session_key = session.session_key
templates_response = templates.TemplateResponse( # templates_response = templates.TemplateResponse(
'instEmpCsvUL.html', # 'instEmpCsvUL.html',
{ # {
'request': request, # 'request': request,
'mainte_csv_up': mainte_csv_up # 'mainte_csv_up': mainte_csv_up
}, # },
headers={'session_key': session_key} # headers={'session_key': session_key}
) # )
return templates_response # return templates_response
@router.get('/instEmpCsvDL', response_class=HTMLResponse) # @router.get('/instEmpCsvDL', response_class=HTMLResponse)
def inst_emp_csv_download_view( # def inst_emp_csv_download_view(
request: Request, # request: Request,
batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService)) # batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService))
): # ):
session: UserSession = request.session # session: UserSession = request.session
# マスタメンテメニューへのアクセス権がない場合、ログアウトさせる # # マスタメンテメニューへのアクセス権がない場合、ログアウトさせる
if session.master_mainte_flg == constants.PERMISSION_DISABLED: # if session.master_mainte_flg == constants.PERMISSION_DISABLED:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
# バッチ処理中の場合、ログアウトさせる # # バッチ処理中の場合、ログアウトさせる
if batch_status_service.is_batch_processing(): # if batch_status_service.is_batch_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE) # detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE)
# dump処理中の場合、ログアウトさせる # # dump処理中の場合、ログアウトさせる
if batch_status_service.is_dump_processing(): # if batch_status_service.is_dump_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING)
# 画面表示用のモデル # # 画面表示用のモデル
mainte_csv_dl = InstEmpCsvDownloadViewModel( # mainte_csv_dl = InstEmpCsvDownloadViewModel(
is_search=False # is_search=False
) # )
# レスポンス # # レスポンス
session_key = session.session_key # session_key = session.session_key
templates_response = templates.TemplateResponse( # templates_response = templates.TemplateResponse(
'instEmpCsvDL.html', # 'instEmpCsvDL.html',
{ # {
'request': request, # 'request': request,
'mainte_csv_dl': mainte_csv_dl # 'mainte_csv_dl': mainte_csv_dl
}, # },
headers={'session_key': session_key} # headers={'session_key': session_key}
) # )
return templates_response # return templates_response
@router.post('/download', response_class=HTMLResponse) # @router.post('/download', response_class=HTMLResponse)
def inst_emp_csv_download( # def inst_emp_csv_download(
request: Request, # request: Request,
csv_download_form: Optional[MasterMainteCsvDlModel] = Depends(MasterMainteCsvDlModel.as_form), # csv_download_form: Optional[MasterMainteCsvDlModel] = Depends(MasterMainteCsvDlModel.as_form),
master_mainte_service: MasterMainteService = Depends(get_service(MasterMainteService)), # master_mainte_service: MasterMainteService = Depends(get_service(MasterMainteService)),
batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService)) # batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService))
): # ):
session: UserSession = request.session # session: UserSession = request.session
# マスタメンテメニューへのアクセス権がない場合、ログアウトさせる # # マスタメンテメニューへのアクセス権がない場合、ログアウトさせる
if session.master_mainte_flg == constants.PERMISSION_DISABLED: # if session.master_mainte_flg == constants.PERMISSION_DISABLED:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
# バッチ処理中の場合、ログアウトさせる # # バッチ処理中の場合、ログアウトさせる
if batch_status_service.is_batch_processing(): # if batch_status_service.is_batch_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE) # detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE)
# dump処理中の場合、ログアウトさせる # # dump処理中の場合、ログアウトさせる
if batch_status_service.is_dump_processing(): # if batch_status_service.is_dump_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING)
search_result_df = master_mainte_service.search_emp_chg_inst_data(csv_download_form) # search_result_df = master_mainte_service.search_emp_chg_inst_data(csv_download_form)
(result_msg, download_file_url) = master_mainte_service.upload_emp_chg_inst_data_file( # (result_msg, download_file_url) = master_mainte_service.upload_emp_chg_inst_data_file(
search_result_df, # search_result_df,
session.user_id, # session.user_id,
csv_download_form.select_table) # csv_download_form.select_table)
# 画面表示用のモデル # # 画面表示用のモデル
mainte_csv_dl = InstEmpCsvDownloadViewModel( # mainte_csv_dl = InstEmpCsvDownloadViewModel(
is_search=True, # is_search=True,
ta_cd=csv_download_form.ta_cd, # ta_cd=csv_download_form.ta_cd,
inst_cd=csv_download_form.inst_cd, # inst_cd=csv_download_form.inst_cd,
emp_cd=csv_download_form.emp_cd, # emp_cd=csv_download_form.emp_cd,
emp_chg_type_cd=csv_download_form.emp_chg_type_cd, # emp_chg_type_cd=csv_download_form.emp_chg_type_cd,
apply_date_from=csv_download_form.apply_date_from, # apply_date_from=csv_download_form.apply_date_from,
start_date_from=csv_download_form.start_date_from, # start_date_from=csv_download_form.start_date_from,
start_date_to=csv_download_form.start_date_to, # start_date_to=csv_download_form.start_date_to,
end_date_from=csv_download_form.end_date_from, # end_date_from=csv_download_form.end_date_from,
end_date_to=csv_download_form.end_date_to, # end_date_to=csv_download_form.end_date_to,
create_date_from=csv_download_form.create_date_from, # create_date_from=csv_download_form.create_date_from,
create_date_to=csv_download_form.create_date_to, # create_date_to=csv_download_form.create_date_to,
update_date_from=csv_download_form.update_date_from, # update_date_from=csv_download_form.update_date_from,
update_date_to=csv_download_form.update_date_to, # update_date_to=csv_download_form.update_date_to,
select_table=csv_download_form.select_table, # select_table=csv_download_form.select_table,
data_count=search_result_df.shape[0], # data_count=search_result_df.shape[0],
download_file_url=download_file_url, # download_file_url=download_file_url,
file_name=constants.MENTE_CSV_DOWNLOAD_FILE_NAME, # file_name=constants.MENTE_CSV_DOWNLOAD_FILE_NAME,
result_msg=result_msg # result_msg=result_msg
) # )
# レスポンス # # レスポンス
session_key = session.session_key # session_key = session.session_key
templates_response = templates.TemplateResponse( # templates_response = templates.TemplateResponse(
'instEmpCsvDL.html', # 'instEmpCsvDL.html',
{ # {
'request': request, # 'request': request,
'mainte_csv_dl': mainte_csv_dl # 'mainte_csv_dl': mainte_csv_dl
}, # },
headers={'session_key': session_key} # headers={'session_key': session_key}
) # )
return templates_response # return templates_response
@router.get('/tableOverride', response_class=HTMLResponse) # @router.get('/tableOverride', response_class=HTMLResponse)
def table_override_view( # def table_override_view(
request: Request, # request: Request,
batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService)) # batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService))
): # ):
session: UserSession = request.session # session: UserSession = request.session
# マスタメンテメニューへのアクセス権がない場合、ログアウトさせる # # マスタメンテメニューへのアクセス権がない場合、ログアウトさせる
if session.master_mainte_flg == constants.PERMISSION_DISABLED: # if session.master_mainte_flg == constants.PERMISSION_DISABLED:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
# バッチ処理中の場合、ログアウトさせる # # バッチ処理中の場合、ログアウトさせる
if batch_status_service.is_batch_processing(): # if batch_status_service.is_batch_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE) # detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE)
# dump処理中の場合、ログアウトさせる # # dump処理中の場合、ログアウトさせる
if batch_status_service.is_dump_processing(): # if batch_status_service.is_dump_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING)
# 画面表示用のモデル # # 画面表示用のモデル
table_override = TableOverrideViewModel() # table_override = TableOverrideViewModel()
# レスポンス # # レスポンス
session_key = session.session_key # session_key = session.session_key
templates_response = templates.TemplateResponse( # templates_response = templates.TemplateResponse(
'tableOverride.html', # 'tableOverride.html',
{ # {
'request': request, # 'request': request,
'table_override': table_override # 'table_override': table_override
}, # },
headers={'session_key': session_key} # headers={'session_key': session_key}
) # )
return templates_response # return templates_response
@router.post('/tableOverride', response_class=HTMLResponse) # @router.post('/tableOverride', response_class=HTMLResponse)
def table_override_result_view( # def table_override_result_view(
request: Request, # request: Request,
master_mainte_service: MasterMainteService = Depends(get_service(MasterMainteService)), # master_mainte_service: MasterMainteService = Depends(get_service(MasterMainteService)),
batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService)) # batch_status_service: BatchStatusService = Depends(get_service(BatchStatusService))
): # ):
session: UserSession = request.session # session: UserSession = request.session
# マスタメンテメニューへのアクセス権がない場合、ログアウトさせる # # マスタメンテメニューへのアクセス権がない場合、ログアウトさせる
if session.master_mainte_flg == constants.PERMISSION_DISABLED: # if session.master_mainte_flg == constants.PERMISSION_DISABLED:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
# バッチ処理中の場合、ログアウトさせる # # バッチ処理中の場合、ログアウトさせる
if batch_status_service.is_batch_processing(): # if batch_status_service.is_batch_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE) # detail=constants.LOGOUT_REASON_BATCH_PROCESSING_FOR_MAINTE)
# dump処理中の場合、ログアウトさせる # # dump処理中の場合、ログアウトさせる
if batch_status_service.is_dump_processing(): # if batch_status_service.is_dump_processing():
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING) # raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.LOGOUT_REASON_BACKUP_PROCESSING)
# 画面表示用のモデル # # 画面表示用のモデル
table_override = master_mainte_service.copy_data_real_to_dummy() # table_override = master_mainte_service.copy_data_real_to_dummy()
# レスポンス # # レスポンス
session_key = session.session_key # session_key = session.session_key
templates_response = templates.TemplateResponse( # templates_response = templates.TemplateResponse(
'tableOverride.html', # 'tableOverride.html',
{ # {
'request': request, # 'request': request,
'table_override': table_override # 'table_override': table_override
}, # },
headers={'session_key': session_key} # headers={'session_key': session_key}
) # )
return templates_response # return templates_response

2
ecs/jskult-webapp/src/main.py
View File

@ -32,7 +32,7 @@ app.include_router(ultmarc.router, prefix='/ultmarc')
# クライアントから非同期呼出しされるため、共通ルーターとは異なる扱いとする。 # クライアントから非同期呼出しされるため、共通ルーターとは異なる扱いとする。
app.include_router(bio_api.router, prefix='/bio') app.include_router(bio_api.router, prefix='/bio')
# マスタメンテ # マスタメンテ
app.include_router(master_mainte.router, prefix='/masterMainte') # 削除予定app.include_router(master_mainte.router, prefix='/masterMainte')
# ヘルスチェック用のルーター # ヘルスチェック用のルーター
app.include_router(healthcheck.router, prefix='/healthcheck') app.include_router(healthcheck.router, prefix='/healthcheck')

13
ecs/jskult-webapp/src/model/db/master_mente_count.py
View File

@ -1,9 +1,10 @@
from typing import Optional # ファイル削除予定
# from typing import Optional
from src.model.db.base_db_model import BaseDBModel # from src.model.db.base_db_model import BaseDBModel
from src.util.sanitize import sanitize # from src.util.sanitize import sanitize
@sanitize # @sanitize
class MasterMenteCountModel(BaseDBModel): # class MasterMenteCountModel(BaseDBModel):
count: Optional[int] # count: Optional[int]

1415
ecs/jskult-webapp/src/model/internal/master_mainte_csv.py
View File

File diff suppressed because it is too large Load Diff

289
ecs/jskult-webapp/src/model/internal/master_mainte_emp_chg_inst_function.py
View File

@ -1,166 +1,167 @@
from abc import ABCMeta, abstractmethod # # ファイル削除予定
from src.repositories.emp_chg_inst_repository import EmpChgInstRepository # from abc import ABCMeta, abstractmethod
from src.logging.get_logger import get_logger # from src.repositories.emp_chg_inst_repository import EmpChgInstRepository
# from src.logging.get_logger import get_logger
logger = get_logger('マスターメンテ') # logger = get_logger('マスターメンテ')
class MasterMainteEmpChgInstFunction(metaclass=ABCMeta): # class MasterMainteEmpChgInstFunction(metaclass=ABCMeta):
insert_data: list[dict] # insert_data: list[dict]
table_name: str # table_name: str
select_table_message: str # select_table_message: str
user_name: str # user_name: str
emp_chginst_repository: EmpChgInstRepository # emp_chginst_repository: EmpChgInstRepository
def __init__( # def __init__(
self, # self,
insert_data, # insert_data,
table_name: str, # table_name: str,
select_table_message: str, # select_table_message: str,
user_name: str, # user_name: str,
emp_chginst_repository: EmpChgInstRepository # emp_chginst_repository: EmpChgInstRepository
): # ):
self.insert_data = insert_data # self.insert_data = insert_data
self.table_name = table_name # self.table_name = table_name
self.select_table_message = select_table_message # self.select_table_message = select_table_message
self.user_name = user_name # self.user_name = user_name
self.emp_chginst_repository = emp_chginst_repository # self.emp_chginst_repository = emp_chginst_repository
def save(self): # def save(self):
error_list = [] # error_list = []
try: # try:
self.emp_chginst_repository.begin() # self.emp_chginst_repository.begin()
self.emp_chginst_repository.to_jst() # self.emp_chginst_repository.to_jst()
(result_message, error_list) = self.write_emp_chg_inst_table() # (result_message, error_list) = self.write_emp_chg_inst_table()
if len(error_list) > 0: # if len(error_list) > 0:
self.emp_chginst_repository.rollback() # self.emp_chginst_repository.rollback()
else: # else:
self.emp_chginst_repository.commit() # self.emp_chginst_repository.commit()
except Exception as e: # except Exception as e:
self.emp_chginst_repository.rollback() # self.emp_chginst_repository.rollback()
raise e # raise e
return (result_message, error_list) # return (result_message, error_list)
def add_emp_chg_inst_table(self, data, start_date, end_date): # def add_emp_chg_inst_table(self, data, start_date, end_date):
self.emp_chginst_repository.insert_emp_chg_inst( # self.emp_chginst_repository.insert_emp_chg_inst(
data['施設コード'], # data['施設コード'],
data['領域コード'], # data['領域コード'],
data['担当者種別コード'], # data['担当者種別コード'],
data['MUID'], # data['MUID'],
data['ビジネスユニットコード'], # data['ビジネスユニットコード'],
start_date, # start_date,
end_date, # end_date,
self.user_name, # self.user_name,
self.table_name) # self.table_name)
@abstractmethod # @abstractmethod
def write_emp_chg_inst_table(self): # def write_emp_chg_inst_table(self):
pass # pass
class NewEmpChgInstFunction(MasterMainteEmpChgInstFunction): # class NewEmpChgInstFunction(MasterMainteEmpChgInstFunction):
def __init__( # def __init__(
self, # self,
insert_data_list: list[dict], # insert_data_list: list[dict],
table_name: str, # table_name: str,
select_table_message: str, # select_table_message: str,
user_name: str, # user_name: str,
emp_chginst_repository: EmpChgInstRepository # emp_chginst_repository: EmpChgInstRepository
): # ):
super().__init__( # super().__init__(
insert_data_list, # insert_data_list,
table_name, # table_name,
select_table_message, # select_table_message,
user_name, # user_name,
emp_chginst_repository # emp_chginst_repository
) # )
def write_emp_chg_inst_table(self): # def write_emp_chg_inst_table(self):
error_list = [] # error_list = []
add_count = 0 # add_count = 0
for row_no, data in enumerate(self.insert_data, start=1): # for row_no, data in enumerate(self.insert_data, start=1):
try: # try:
self.add_emp_chg_inst_table(data, data['適用開始日'], data['適用終了日']) # self.add_emp_chg_inst_table(data, data['適用開始日'], data['適用終了日'])
add_count += 1 # add_count += 1
except Exception as e: # except Exception as e:
error_list.append(f'{str(row_no)}行目がSQL実行エラーです。CSVファイルを確認してください。') # error_list.append(f'{str(row_no)}行目がSQL実行エラーです。CSVファイルを確認してください。')
logger.info(f'新規施設登録時に{row_no}行目でエラーが発生しました: {e}') # logger.info(f'新規施設登録時に{row_no}行目でエラーが発生しました: {e}')
result_message_list = [] # result_message_list = []
if len(error_list) == 0: # if len(error_list) == 0:
result_message_list.append('新規施設登録を行いました') # result_message_list.append('新規施設登録を行いました')
result_message_list.append('対象：' + self.select_table_message) # result_message_list.append('対象：' + self.select_table_message)
result_message_list.append('追加：' + str(add_count) + '件') # result_message_list.append('追加：' + str(add_count) + '件')
return (result_message_list, error_list) # return (result_message_list, error_list)
class ChangeEmpChgInstFunction(MasterMainteEmpChgInstFunction): # class ChangeEmpChgInstFunction(MasterMainteEmpChgInstFunction):
def __init__( # def __init__(
self, # self,
insert_data: list[dict], # insert_data: list[dict],
table_name: str, # table_name: str,
select_table_message: str, # select_table_message: str,
user_name: str, # user_name: str,
emp_chginst_repository: EmpChgInstRepository # emp_chginst_repository: EmpChgInstRepository
): # ):
super().__init__( # super().__init__(
insert_data, # insert_data,
table_name, # table_name,
select_table_message, # select_table_message,
user_name, # user_name,
emp_chginst_repository # emp_chginst_repository
) # )
def write_emp_chg_inst_table(self): # def write_emp_chg_inst_table(self):
add_count = 0 # add_count = 0
end_count = 0 # end_count = 0
modify_count = 0 # modify_count = 0
error_list = [] # error_list = []
for row_no, data in enumerate(self.insert_data, start=1): # for row_no, data in enumerate(self.insert_data, start=1):
try: # try:
if data['コメント'] == '追加': # if data['コメント'] == '追加':
self.add_emp_chg_inst_table(data, data['施設担当_開始日'], data['施設担当_終了日']) # self.add_emp_chg_inst_table(data, data['施設担当_開始日'], data['施設担当_終了日'])
add_count += 1 # add_count += 1
elif data['コメント'] == '終了': # elif data['コメント'] == '終了':
self.__end_emp_chg_inst(data) # self.__end_emp_chg_inst(data)
end_count += 1 # end_count += 1
elif data['コメント'] == '担当者修正': # elif data['コメント'] == '担当者修正':
self.__modify_emp_chg_inst(data) # self.__modify_emp_chg_inst(data)
modify_count += 1 # modify_count += 1
except Exception as e: # except Exception as e:
error_list.append(f'{str(row_no)}行目がSQL実行エラーです。CSVファイルを確認してください。') # error_list.append(f'{str(row_no)}行目がSQL実行エラーです。CSVファイルを確認してください。')
logger.info(f'施設担当者変更時に{row_no}行目でエラーが発生しました: {e}') # logger.info(f'施設担当者変更時に{row_no}行目でエラーが発生しました: {e}')
result_message_list = [] # result_message_list = []
if len(error_list) == 0: # if len(error_list) == 0:
result_message_list.append('施設担当者変更を行いました') # result_message_list.append('施設担当者変更を行いました')
result_message_list.append('対象：' + self.select_table_message) # result_message_list.append('対象：' + self.select_table_message)
result_message_list.append('追加：' + str(add_count) + '件') # result_message_list.append('追加：' + str(add_count) + '件')
result_message_list.append('修正：' + str(modify_count) + '件') # result_message_list.append('修正：' + str(modify_count) + '件')
result_message_list.append('終了：' + str(end_count) + '件') # result_message_list.append('終了：' + str(end_count) + '件')
return (result_message_list, error_list) # return (result_message_list, error_list)
def __end_emp_chg_inst(self, data: dict): # def __end_emp_chg_inst(self, data: dict):
self.emp_chginst_repository.end_emp_chg_inst( # self.emp_chginst_repository.end_emp_chg_inst(
data['施設コード'], # data['施設コード'],
data['領域コード'], # data['領域コード'],
data['担当者種別コード'], # data['担当者種別コード'],
data['施設担当_開始日'], # data['施設担当_開始日'],
data['終了日の変更'], # data['終了日の変更'],
self.user_name, # self.user_name,
self.table_name) # self.table_name)
def __modify_emp_chg_inst(self, data: dict): # def __modify_emp_chg_inst(self, data: dict):
self.emp_chginst_repository.modify_emp_chg_inst( # self.emp_chginst_repository.modify_emp_chg_inst(
data['施設コード'], # data['施設コード'],
data['領域コード'], # data['領域コード'],
data['施設担当_開始日'], # data['施設担当_開始日'],
data['担当者種別コード'], # data['担当者種別コード'],
data['MUID'], # data['MUID'],
self.user_name, # self.user_name,
self.table_name) # self.table_name)

331
ecs/jskult-webapp/src/model/request/master_mainte_csvdl.py
View File

@ -1,177 +1,178 @@
from typing import Optional # ファイル削除予定
# from typing import Optional
from fastapi import Form # from fastapi import Form
from src.model.request.request_base_model import RequestBaseModel # from src.model.request.request_base_model import RequestBaseModel
from src.util.sanitize import sanitize # from src.util.sanitize import sanitize
from src.util.string_util import is_not_empty # from src.util.string_util import is_not_empty
@sanitize # @sanitize
class MasterMainteCsvDlModel(RequestBaseModel): # class MasterMainteCsvDlModel(RequestBaseModel):
# adaptは検索に使用する値 # # adaptは検索に使用する値
ta_cd: Optional[str] # ta_cd: Optional[str]
adapt_ta_cd: Optional[str] # adapt_ta_cd: Optional[str]
inst_cd: Optional[str] # inst_cd: Optional[str]
adapt_inst_cd: Optional[str] # adapt_inst_cd: Optional[str]
emp_cd: Optional[str] # emp_cd: Optional[str]
adapt_emp_cd: Optional[str] # adapt_emp_cd: Optional[str]
emp_chg_type_cd: Optional[str] # emp_chg_type_cd: Optional[str]
adapt_emp_chg_type_cd: Optional[str] # adapt_emp_chg_type_cd: Optional[str]
apply_date_from: Optional[str] # apply_date_from: Optional[str]
adapt_apply_date_from: Optional[str] # adapt_apply_date_from: Optional[str]
start_date_from: Optional[str] # start_date_from: Optional[str]
adapt_start_date_from: Optional[str] # adapt_start_date_from: Optional[str]
start_date_to: Optional[str] # start_date_to: Optional[str]
adapt_start_date_to: Optional[str] # adapt_start_date_to: Optional[str]
end_date_from: Optional[str] # end_date_from: Optional[str]
adapt_end_date_from: Optional[str] # adapt_end_date_from: Optional[str]
end_date_to: Optional[str] # end_date_to: Optional[str]
adapt_end_date_to: Optional[str] # adapt_end_date_to: Optional[str]
select_table: Optional[str] # select_table: Optional[str]
create_date_from: Optional[str] # create_date_from: Optional[str]
adapt_create_date_from: Optional[str] # adapt_create_date_from: Optional[str]
create_date_to: Optional[str] # create_date_to: Optional[str]
adapt_create_date_to: Optional[str] # adapt_create_date_to: Optional[str]
update_date_from: Optional[str] # update_date_from: Optional[str]
adapt_update_date_from: Optional[str] # adapt_update_date_from: Optional[str]
update_date_to: Optional[str] # update_date_to: Optional[str]
adapt_update_date_to: Optional[str] # adapt_update_date_to: Optional[str]
@classmethod # @classmethod
def as_form( # def as_form(
cls, # cls,
ctrl_ta_cd: Optional[str] = Form(None), # ctrl_ta_cd: Optional[str] = Form(None),
ctrl_inst_cd: Optional[str] = Form(None), # ctrl_inst_cd: Optional[str] = Form(None),
ctrl_emp_cd: Optional[str] = Form(None), # ctrl_emp_cd: Optional[str] = Form(None),
ctrl_emp_chg_type_cd: Optional[str] = Form(None), # ctrl_emp_chg_type_cd: Optional[str] = Form(None),
ctrl_apply_date_from: Optional[str] = Form(None), # ctrl_apply_date_from: Optional[str] = Form(None),
ctrl_start_date_from: Optional[str] = Form(None), # ctrl_start_date_from: Optional[str] = Form(None),
ctrl_start_date_to: Optional[str] = Form(None), # ctrl_start_date_to: Optional[str] = Form(None),
ctrl_end_date_from: Optional[str] = Form(None), # ctrl_end_date_from: Optional[str] = Form(None),
ctrl_end_date_to: Optional[str] = Form(None), # ctrl_end_date_to: Optional[str] = Form(None),
radio_select_table: Optional[str] = Form(None), # radio_select_table: Optional[str] = Form(None),
ctrl_create_date_from: Optional[str] = Form(None), # ctrl_create_date_from: Optional[str] = Form(None),
ctrl_create_date_to: Optional[str] = Form(None), # ctrl_create_date_to: Optional[str] = Form(None),
ctrl_update_date_from: Optional[str] = Form(None), # ctrl_update_date_from: Optional[str] = Form(None),
ctrl_update_date_to: Optional[str] = Form(None) # ctrl_update_date_to: Optional[str] = Form(None)
): # ):
return cls.__convert_request_param( # return cls.__convert_request_param(
cls, # cls,
ctrl_ta_cd, # ctrl_ta_cd,
ctrl_inst_cd, # ctrl_inst_cd,
ctrl_emp_cd, # ctrl_emp_cd,
ctrl_emp_chg_type_cd, # ctrl_emp_chg_type_cd,
ctrl_apply_date_from, # ctrl_apply_date_from,
ctrl_start_date_from, # ctrl_start_date_from,
ctrl_start_date_to, # ctrl_start_date_to,
ctrl_end_date_from, # ctrl_end_date_from,
ctrl_end_date_to, # ctrl_end_date_to,
radio_select_table, # radio_select_table,
ctrl_create_date_from, # ctrl_create_date_from,
ctrl_create_date_to, # ctrl_create_date_to,
ctrl_update_date_from, # ctrl_update_date_from,
ctrl_update_date_to # ctrl_update_date_to
) # )
def __convert_request_param( # def __convert_request_param(
cls, # cls,
ctrl_ta_cd: str, # ctrl_ta_cd: str,
ctrl_inst_cd: str, # ctrl_inst_cd: str,
ctrl_emp_cd: str, # ctrl_emp_cd: str,
ctrl_emp_chg_type_cd, # ctrl_emp_chg_type_cd,
ctrl_apply_date_from: str, # ctrl_apply_date_from: str,
ctrl_start_date_from: str, # ctrl_start_date_from: str,
ctrl_start_date_to: str, # ctrl_start_date_to: str,
ctrl_end_date_from: str, # ctrl_end_date_from: str,
ctrl_end_date_to: str, # ctrl_end_date_to: str,
radio_select_table: str, # radio_select_table: str,
ctrl_create_date_from: str, # ctrl_create_date_from: str,
ctrl_create_date_to: str, # ctrl_create_date_to: str,
ctrl_update_date_from: str, # ctrl_update_date_from: str,
ctrl_update_date_to: str # ctrl_update_date_to: str
): # ):
ctrl_ta_cd = ctrl_ta_cd if is_not_empty(ctrl_ta_cd) else '' # ctrl_ta_cd = ctrl_ta_cd if is_not_empty(ctrl_ta_cd) else ''
ctrl_inst_cd = ctrl_inst_cd if is_not_empty(ctrl_inst_cd) else '' # ctrl_inst_cd = ctrl_inst_cd if is_not_empty(ctrl_inst_cd) else ''
ctrl_emp_cd = ctrl_emp_cd if is_not_empty(ctrl_emp_cd) else '' # ctrl_emp_cd = ctrl_emp_cd if is_not_empty(ctrl_emp_cd) else ''
ctrl_emp_chg_type_cd = ctrl_emp_chg_type_cd if is_not_empty(ctrl_emp_chg_type_cd) else '' # ctrl_emp_chg_type_cd = ctrl_emp_chg_type_cd if is_not_empty(ctrl_emp_chg_type_cd) else ''
adapt_apply_date_from = '' # adapt_apply_date_from = ''
if is_not_empty(ctrl_apply_date_from): # if is_not_empty(ctrl_apply_date_from):
adapt_apply_date_from = ctrl_apply_date_from.replace('/', '') # adapt_apply_date_from = ctrl_apply_date_from.replace('/', '')
else: # else:
ctrl_apply_date_from = '' # ctrl_apply_date_from = ''
adapt_start_date_from = '' # adapt_start_date_from = ''
adapt_start_date_to = '' # adapt_start_date_to = ''
if is_not_empty(ctrl_start_date_from): # if is_not_empty(ctrl_start_date_from):
adapt_start_date_from = ctrl_start_date_from.replace('/', '') # adapt_start_date_from = ctrl_start_date_from.replace('/', '')
else: # else:
ctrl_start_date_from = '' # ctrl_start_date_from = ''
if is_not_empty(ctrl_start_date_to): # if is_not_empty(ctrl_start_date_to):
adapt_start_date_to = ctrl_start_date_to.replace('/', '') # adapt_start_date_to = ctrl_start_date_to.replace('/', '')
else: # else:
ctrl_start_date_to = '' # ctrl_start_date_to = ''
adapt_end_date_from = '' # adapt_end_date_from = ''
adapt_end_date_to = '' # adapt_end_date_to = ''
if is_not_empty(ctrl_end_date_from): # if is_not_empty(ctrl_end_date_from):
adapt_end_date_from = ctrl_end_date_from.replace('/', '') # adapt_end_date_from = ctrl_end_date_from.replace('/', '')
else: # else:
ctrl_end_date_from = '' # ctrl_end_date_from = ''
if is_not_empty(ctrl_end_date_to): # if is_not_empty(ctrl_end_date_to):
adapt_end_date_to = ctrl_end_date_to.replace('/', '') # adapt_end_date_to = ctrl_end_date_to.replace('/', '')
else: # else:
ctrl_end_date_to = '' # ctrl_end_date_to = ''
adapt_create_date_from = '' # adapt_create_date_from = ''
adapt_create_date_to = '' # adapt_create_date_to = ''
if is_not_empty(ctrl_create_date_from): # if is_not_empty(ctrl_create_date_from):
adapt_create_date_from = ctrl_create_date_from.replace('/', '-') + ' 00:00:00' # adapt_create_date_from = ctrl_create_date_from.replace('/', '-') + ' 00:00:00'
else: # else:
ctrl_create_date_from = '' # ctrl_create_date_from = ''
if is_not_empty(ctrl_create_date_to): # if is_not_empty(ctrl_create_date_to):
adapt_create_date_to = ctrl_create_date_to.replace('/', '-') + ' 23:59:59' # adapt_create_date_to = ctrl_create_date_to.replace('/', '-') + ' 23:59:59'
else: # else:
ctrl_create_date_to = '' # ctrl_create_date_to = ''
adapt_update_date_from = '' # adapt_update_date_from = ''
adapt_update_date_to = '' # adapt_update_date_to = ''
if is_not_empty(ctrl_update_date_from): # if is_not_empty(ctrl_update_date_from):
adapt_update_date_from = ctrl_update_date_from.replace('/', '-') + ' 00:00:00' # adapt_update_date_from = ctrl_update_date_from.replace('/', '-') + ' 00:00:00'
else: # else:
ctrl_update_date_from = '' # ctrl_update_date_from = ''
if is_not_empty(ctrl_update_date_to): # if is_not_empty(ctrl_update_date_to):
adapt_update_date_to = ctrl_update_date_to.replace('/', '-') + ' 23:59:59' # adapt_update_date_to = ctrl_update_date_to.replace('/', '-') + ' 23:59:59'
else: # else:
ctrl_update_date_to = '' # ctrl_update_date_to = ''
return cls( # return cls(
ta_cd=ctrl_ta_cd, # ta_cd=ctrl_ta_cd,
adapt_ta_cd=ctrl_ta_cd, # adapt_ta_cd=ctrl_ta_cd,
inst_cd=ctrl_inst_cd, # inst_cd=ctrl_inst_cd,
adapt_inst_cd=ctrl_inst_cd, # adapt_inst_cd=ctrl_inst_cd,
emp_cd=ctrl_emp_cd, # emp_cd=ctrl_emp_cd,
adapt_emp_cd=ctrl_emp_cd, # adapt_emp_cd=ctrl_emp_cd,
emp_chg_type_cd=ctrl_emp_chg_type_cd, # emp_chg_type_cd=ctrl_emp_chg_type_cd,
adapt_emp_chg_type_cd=ctrl_emp_chg_type_cd, # adapt_emp_chg_type_cd=ctrl_emp_chg_type_cd,
apply_date_from=ctrl_apply_date_from, # apply_date_from=ctrl_apply_date_from,
adapt_apply_date_from=adapt_apply_date_from, # adapt_apply_date_from=adapt_apply_date_from,
start_date_from=ctrl_start_date_from, # start_date_from=ctrl_start_date_from,
adapt_start_date_from=adapt_start_date_from, # adapt_start_date_from=adapt_start_date_from,
start_date_to=ctrl_start_date_to, # start_date_to=ctrl_start_date_to,
adapt_start_date_to=adapt_start_date_to, # adapt_start_date_to=adapt_start_date_to,
select_table=radio_select_table, # select_table=radio_select_table,
end_date_from=ctrl_end_date_from, # end_date_from=ctrl_end_date_from,
adapt_end_date_from=adapt_end_date_from, # adapt_end_date_from=adapt_end_date_from,
end_date_to=ctrl_end_date_to, # end_date_to=ctrl_end_date_to,
adapt_end_date_to=adapt_end_date_to, # adapt_end_date_to=adapt_end_date_to,
create_date_from=ctrl_create_date_from, # create_date_from=ctrl_create_date_from,
adapt_create_date_from=adapt_create_date_from, # adapt_create_date_from=adapt_create_date_from,
create_date_to=ctrl_create_date_to, # create_date_to=ctrl_create_date_to,
adapt_create_date_to=adapt_create_date_to, # adapt_create_date_to=adapt_create_date_to,
update_date_from=ctrl_update_date_from, # update_date_from=ctrl_update_date_from,
adapt_update_date_from=adapt_update_date_from, # adapt_update_date_from=adapt_update_date_from,
update_date_to=ctrl_update_date_to, # update_date_to=ctrl_update_date_to,
adapt_update_date_to=adapt_update_date_to # adapt_update_date_to=adapt_update_date_to
) # )

51
ecs/jskult-webapp/src/model/request/master_mainte_csvup.py
View File

@ -1,31 +1,32 @@
from typing import Optional, Annotated # # ファイル削除予定
# from typing import Optional, Annotated
from fastapi import Form # from fastapi import Form
from src.util.sanitize import sanitize # from src.util.sanitize import sanitize
from fastapi import File, UploadFile # from fastapi import File, UploadFile
from src.model.request.request_base_model import RequestBaseModel # from src.model.request.request_base_model import RequestBaseModel
@sanitize # @sanitize
class MasterMainteCsvUpModel(RequestBaseModel): # class MasterMainteCsvUpModel(RequestBaseModel):
csv_file: Optional[Annotated[UploadFile, File()]] # csv_file: Optional[Annotated[UploadFile, File()]]
select_function: Optional[str] # select_function: Optional[str]
select_table: Optional[str] # select_table: Optional[str]
json_upload_data: Optional[str] # json_upload_data: Optional[str]
@classmethod # @classmethod
def as_form( # def as_form(
cls, # cls,
ctrl_csv_file: UploadFile = Form(None), # ctrl_csv_file: UploadFile = Form(None),
ctrl_select_function: Optional[str] = Form(None), # ctrl_select_function: Optional[str] = Form(None),
ctrl_select_table: Optional[str] = Form(None), # ctrl_select_table: Optional[str] = Form(None),
ctrl_json_upload_data: Optional[str] = Form(None) # ctrl_json_upload_data: Optional[str] = Form(None)
): # ):
return cls( # return cls(
csv_file=ctrl_csv_file, # csv_file=ctrl_csv_file,
select_function=ctrl_select_function, # select_function=ctrl_select_function,
select_table=ctrl_select_table, # select_table=ctrl_select_table,
json_upload_data=ctrl_json_upload_data # json_upload_data=ctrl_json_upload_data
) # )

55
ecs/jskult-webapp/src/model/view/inst_emp_csv_download_view_model.py
View File

@ -1,32 +1,33 @@
from pydantic import BaseModel #ファイル削除予定
# from pydantic import BaseModel
from src.util.string_util import is_not_empty # from src.util.string_util import is_not_empty
class InstEmpCsvDownloadViewModel(BaseModel): # class InstEmpCsvDownloadViewModel(BaseModel):
subtitle: str = '施設担当者データCSVダウンロード' # subtitle: str = '施設担当者データCSVダウンロード'
is_search: bool = False # is_search: bool = False
ta_cd: str = '' # ta_cd: str = ''
inst_cd: str = '' # inst_cd: str = ''
emp_cd: str = '' # emp_cd: str = ''
emp_chg_type_cd: str = '' # emp_chg_type_cd: str = ''
apply_date_from: str = '' # apply_date_from: str = ''
start_date_from: str = '' # start_date_from: str = ''
start_date_to: str = '' # start_date_to: str = ''
end_date_from: str = '' # end_date_from: str = ''
end_date_to: str = '' # end_date_to: str = ''
create_date_from: str = '' # create_date_from: str = ''
create_date_to: str = '' # create_date_to: str = ''
update_date_from: str = '' # update_date_from: str = ''
update_date_to: str = '' # update_date_to: str = ''
select_table: str = '' # select_table: str = ''
data_count: int = 0 # data_count: int = 0
result_msg: str = '' # result_msg: str = ''
download_file_url: str = '' # download_file_url: str = ''
file_name: str = '' # file_name: str = ''
def is_select_table_empty(self): # def is_select_table_empty(self):
return not is_not_empty(self.select_table) # return not is_not_empty(self.select_table)
def is_download_file_url_empty(self): # def is_download_file_url_empty(self):
return not is_not_empty(self.download_file_url) # return not is_not_empty(self.download_file_url)

73
ecs/jskult-webapp/src/model/view/inst_emp_csv_upload_view_model.py
View File

@ -1,48 +1,49 @@
from pydantic import BaseModel #ファイル削除予定
# from pydantic import BaseModel
from src.system_var import constants # from src.system_var import constants
class InstEmpCsvUploadViewModel(BaseModel): # class InstEmpCsvUploadViewModel(BaseModel):
subtitle: str = '施設担当者データCSVアップロード' # subtitle: str = '施設担当者データCSVアップロード'
is_verified: bool = False # is_verified: bool = False
is_insert: bool = False # is_insert: bool = False
error_message_list: list[str] = None # error_message_list: list[str] = None
select_function: str = None # select_function: str = None
select_table: str = None # select_table: str = None
csv_file_name: str = None # csv_file_name: str = None
csv_upload_list: list[dict] = None # csv_upload_list: list[dict] = None
json_upload_data: str = None # json_upload_data: str = None
result_message_list: list[str] = None # result_message_list: list[str] = None
select_function_message: str = None # select_function_message: str = None
def select_table_message(self): # def select_table_message(self):
return self.__dummy_table() if self.select_table == 'dummy' else self.__real_table() # return self.__dummy_table() if self.select_table == 'dummy' else self.__real_table()
def upload_data_columns(self) -> list[str]: # def upload_data_columns(self) -> list[str]:
return self.__inst_emp_columns() # return self.__inst_emp_columns()
def is_select_function_empty(self): # def is_select_function_empty(self):
return self.select_function is None or len(self.select_function) == 0 # return self.select_function is None or len(self.select_function) == 0
def is_select_table_empty(self): # def is_select_table_empty(self):
return self.select_table is None or len(self.select_table) == 0 # return self.select_table is None or len(self.select_table) == 0
def is_error_message_list_empty(self): # def is_error_message_list_empty(self):
return self.error_message_list is None or len(self.error_message_list) == 0 # return self.error_message_list is None or len(self.error_message_list) == 0
def csv_data_count(self): # def csv_data_count(self):
return 0 if self.csv_upload_list is None else len(self.csv_upload_list) # return 0 if self.csv_upload_list is None else len(self.csv_upload_list)
def __inst_emp_columns(self) -> list[str]: # def __inst_emp_columns(self) -> list[str]:
if self.select_function == 'new': # if self.select_function == 'new':
return constants.NEW_INST_EMP_CSV_LOGICAL_NAMES # return constants.NEW_INST_EMP_CSV_LOGICAL_NAMES
if self.select_function == 'change': # if self.select_function == 'change':
return constants.CHANGE_INST_CSV_LOGICAL_NAMES # return constants.CHANGE_INST_CSV_LOGICAL_NAMES
return [] # return []
def __real_table(self): # def __real_table(self):
return constants.CSV_REAL_TABLE_NAME # return constants.CSV_REAL_TABLE_NAME
def __dummy_table(self): # def __dummy_table(self):
return constants.CSV_CHANGE_TABLE_NAME # return constants.CSV_CHANGE_TABLE_NAME

7
ecs/jskult-webapp/src/model/view/master_mainte_menu_view_model.py
View File

@ -1,5 +1,6 @@
from pydantic import BaseModel # ファイル削除予定
# from pydantic import BaseModel
class MasterMainteMenuViewModel(BaseModel): # class MasterMainteMenuViewModel(BaseModel):
subtitle: str = 'MeDaCA マスターメンテメニュー' # subtitle: str = 'MeDaCA マスターメンテメニュー'

9
ecs/jskult-webapp/src/model/view/menu_view_model.py
View File

@ -13,8 +13,8 @@ class MenuViewModel(BaseModel):
def is_batch_processing(self): def is_batch_processing(self):
return self.batch_status == constants.BATCH_STATUS_PROCESSING return self.batch_status == constants.BATCH_STATUS_PROCESSING
def is_backup_processing(self): #TODO 削除予定 def is_backup_processing(self):
return self.dump_status != constants.DUMP_STATUS_UNPROCESSED # return self.dump_status != constants.DUMP_STATUS_UNPROCESSED
def is_available_ult_doctor_menu(self): def is_available_ult_doctor_menu(self):
return self.user_model.has_ult_doctor_permission() return self.user_model.has_ult_doctor_permission()
@ -24,6 +24,7 @@ class MenuViewModel(BaseModel):
def is_available_bio_menu(self): def is_available_bio_menu(self):
return self.user_model.has_bio_permission() return self.user_model.has_bio_permission()
#TODO 削除予定 def is_available_master_maintenance_menu(self):
# return self.user_model.has_master_maintenance_permission()
def is_available_master_maintenance_menu(self):
return self.user_model.has_master_maintenance_permission()

9
ecs/jskult-webapp/src/model/view/table_override_view_model.py
View File

@ -1,7 +1,8 @@
from pydantic import BaseModel # ファイル削除予定
# from pydantic import BaseModel
class TableOverrideViewModel(BaseModel): # class TableOverrideViewModel(BaseModel):
subtitle: str = 'テーブル上書きコピー' # subtitle: str = 'テーブル上書きコピー'
is_override: bool = False # is_override: bool = False

5
ecs/jskult-webapp/src/model/view/user_view_model.py
View File

@ -19,6 +19,7 @@ class UserViewModel(BaseModel):
def has_bio_permission(self): def has_bio_permission(self):
return self.bio_flg == constants.PERMISSION_ENABLED return self.bio_flg == constants.PERMISSION_ENABLED
#TODO 削除予定 def has_master_maintenance_permission(self):
# return self.master_mainte_flg == constants.PERMISSION_ENABLED
def has_master_maintenance_permission(self):
return self.master_mainte_flg == constants.PERMISSION_ENABLED

49
ecs/jskult-webapp/src/repositories/bu_master_cd_repository.py
View File

@ -1,29 +1,30 @@
from src.repositories.base_repository import BaseRepository # # file削除予定
from src.model.db.master_mente_count import MasterMenteCountModel # from src.repositories.base_repository import BaseRepository
from src.logging.get_logger import get_logger # from src.model.db.master_mente_count import MasterMenteCountModel
# from src.logging.get_logger import get_logger
logger = get_logger('ビジネスユニットマスタ') # logger = get_logger('ビジネスユニットマスタ')
class BuMasterRepository(BaseRepository): # class BuMasterRepository(BaseRepository):
FETCH_COUNT_SQL = """\ # FETCH_COUNT_SQL = """\
SELECT # SELECT
COUNT(*) AS count # COUNT(*) AS count
FROM # FROM
src05.bu # src05.bu
WHERE # WHERE
bu.bu_cd = :bu_cd # bu.bu_cd = :bu_cd
""" # """
def fetch_count(self, bu_cd) -> MasterMenteCountModel: # def fetch_count(self, bu_cd) -> MasterMenteCountModel:
try: # try:
query = self.FETCH_COUNT_SQL # query = self.FETCH_COUNT_SQL
result = self._database.execute_select(query, {'bu_cd': bu_cd}) # result = self._database.execute_select(query, {'bu_cd': bu_cd})
models = [MasterMenteCountModel(**r) for r in result] # models = [MasterMenteCountModel(**r) for r in result]
if len(models) == 0: # if len(models) == 0:
return 0 # return 0
return models[0].count # return models[0].count
except Exception as e: # except Exception as e:
logger.exception(f"DB Error : Exception={e.args}") # logger.exception(f"DB Error : Exception={e.args}")
raise e # raise e

503
ecs/jskult-webapp/src/repositories/emp_chg_inst_repository.py
View File

@ -1,289 +1,290 @@
from src.db import sql_condition as condition # ファイル削除予定
from src.db.sql_condition import SQLCondition # from src.db import sql_condition as condition
from src.logging.get_logger import get_logger # from src.db.sql_condition import SQLCondition
from src.model.db.master_mente_count import MasterMenteCountModel # from src.logging.get_logger import get_logger
from src.model.request.master_mainte_csvdl import MasterMainteCsvDlModel # from src.model.db.master_mente_count import MasterMenteCountModel
from src.repositories.base_repository import BaseRepository # from src.model.request.master_mainte_csvdl import MasterMainteCsvDlModel
from src.util.string_util import is_not_empty # from src.repositories.base_repository import BaseRepository
# from src.util.string_util import is_not_empty
logger = get_logger('従業員担当施設マスタ') # logger = get_logger('従業員担当施設マスタ')
class EmpChgInstRepository(BaseRepository): # class EmpChgInstRepository(BaseRepository):
def to_jst(self): # def to_jst(self):
self._database.to_jst() # self._database.to_jst()
def begin(self): # def begin(self):
self._database.begin() # self._database.begin()
def commit(self): # def commit(self):
self._database.commit() # self._database.commit()
def rollback(self): # def rollback(self):
self._database.rollback() # self._database.rollback()
INSERT_SQL = """\ # INSERT_SQL = """\
INSERT INTO {table_name} # INSERT INTO {table_name}
( # (
inst_cd, # inst_cd,
ta_cd, # ta_cd,
emp_chg_type_cd, # emp_chg_type_cd,
emp_cd, # emp_cd,
bu_cd, # bu_cd,
start_date, # start_date,
end_date, # end_date,
main_chg_flg, # main_chg_flg,
enabled_flg, # enabled_flg,
creater, # creater,
create_date, # create_date,
updater, # updater,
update_date # update_date
) # )
VALUES ( # VALUES (
:inst_cd, # :inst_cd,
:ta_cd, # :ta_cd,
:emp_chg_type_cd, # :emp_chg_type_cd,
:emp_cd, # :emp_cd,
:bu_cd, # :bu_cd,
:start_date, # :start_date,
:end_date, # :end_date,
'1', # '1',
'Y', # 'Y',
:create_user_name, # :create_user_name,
NOW(), # NOW(),
:update_user_name, # :update_user_name,
NOW() # NOW()
) # )
""" # """
def insert_emp_chg_inst(self, inst_cd, ta_cd, emp_chg_type_cd, emp_cd, bu_cd, start_date, # def insert_emp_chg_inst(self, inst_cd, ta_cd, emp_chg_type_cd, emp_cd, bu_cd, start_date,
end_date, create_user_name, table_name): # end_date, create_user_name, table_name):
try: # try:
query = self.INSERT_SQL.format(table_name=table_name) # query = self.INSERT_SQL.format(table_name=table_name)
self._database.execute(query, { # self._database.execute(query, {
'inst_cd': inst_cd, # 'inst_cd': inst_cd,
'ta_cd': ta_cd, # 'ta_cd': ta_cd,
'emp_chg_type_cd': emp_chg_type_cd, # 'emp_chg_type_cd': emp_chg_type_cd,
'emp_cd': emp_cd, # 'emp_cd': emp_cd,
'bu_cd': bu_cd, # 'bu_cd': bu_cd,
'start_date': start_date, # 'start_date': start_date,
'end_date': end_date, # 'end_date': end_date,
'create_user_name': create_user_name, # 'create_user_name': create_user_name,
'update_user_name': create_user_name # 'update_user_name': create_user_name
}) # })
except Exception as e: # except Exception as e:
logger.exception(f'DB Error : Exception={e.args}') # logger.exception(f'DB Error : Exception={e.args}')
raise e # raise e
UPDATE_END_DATE_SQL = """\ # UPDATE_END_DATE_SQL = """\
UPDATE # UPDATE
{table_name} # {table_name}
SET # SET
end_date = :end_date, # end_date = :end_date,
updater = :update_user_name, # updater = :update_user_name,
update_date = NOW() # update_date = NOW()
WHERE # WHERE
inst_cd = :inst_cd # inst_cd = :inst_cd
AND ta_cd = :ta_cd # AND ta_cd = :ta_cd
AND emp_chg_type_cd = :emp_chg_type_cd # AND emp_chg_type_cd = :emp_chg_type_cd
AND start_date = :start_date # AND start_date = :start_date
""" # """
def end_emp_chg_inst(self, inst_cd, ta_cd, emp_chg_type_cd, start_date, # def end_emp_chg_inst(self, inst_cd, ta_cd, emp_chg_type_cd, start_date,
end_date, update_user_name, table_name): # end_date, update_user_name, table_name):
try: # try:
query = self.UPDATE_END_DATE_SQL.format(table_name=table_name) # query = self.UPDATE_END_DATE_SQL.format(table_name=table_name)
self._database.execute(query, { # self._database.execute(query, {
'inst_cd': inst_cd, # 'inst_cd': inst_cd,
'ta_cd': ta_cd, # 'ta_cd': ta_cd,
'emp_chg_type_cd': emp_chg_type_cd, # 'emp_chg_type_cd': emp_chg_type_cd,
'start_date': start_date, # 'start_date': start_date,
'end_date': end_date, # 'end_date': end_date,
'update_user_name': update_user_name # 'update_user_name': update_user_name
}) # })
except Exception as e: # except Exception as e:
logger.exception(f'DB Error : Exception={e.args}') # logger.exception(f'DB Error : Exception={e.args}')
raise e # raise e
UPDATE_EMP_CD_SQL = """\ # UPDATE_EMP_CD_SQL = """\
UPDATE # UPDATE
{table_name} # {table_name}
SET # SET
emp_cd = :emp_cd, # emp_cd = :emp_cd,
updater = :update_user_name, # updater = :update_user_name,
update_date = NOW() # update_date = NOW()
where # where
inst_cd = :inst_cd # inst_cd = :inst_cd
AND ta_cd = :ta_cd # AND ta_cd = :ta_cd
AND emp_chg_type_cd = :emp_chg_type_cd # AND emp_chg_type_cd = :emp_chg_type_cd
AND start_date = :start_date # AND start_date = :start_date
""" # """
def modify_emp_chg_inst(self, inst_cd, ta_cd, start_date, emp_chg_type_cd, emp_cd, update_user_name, table_name): # def modify_emp_chg_inst(self, inst_cd, ta_cd, start_date, emp_chg_type_cd, emp_cd, update_user_name, table_name):
try: # try:
query = self.UPDATE_EMP_CD_SQL.format(table_name=table_name) # query = self.UPDATE_EMP_CD_SQL.format(table_name=table_name)
self._database.execute(query, { # self._database.execute(query, {
'inst_cd': inst_cd, # 'inst_cd': inst_cd,
'ta_cd': ta_cd, # 'ta_cd': ta_cd,
'emp_chg_type_cd': emp_chg_type_cd, # 'emp_chg_type_cd': emp_chg_type_cd,
'start_date': start_date, # 'start_date': start_date,
'emp_cd': emp_cd, # 'emp_cd': emp_cd,
'update_user_name': update_user_name # 'update_user_name': update_user_name
}) # })
except Exception as e: # except Exception as e:
logger.exception(f'DB Error : Exception={e.args}') # logger.exception(f'DB Error : Exception={e.args}')
raise e # raise e
FETCH_COUNT_SQL = """\ # FETCH_COUNT_SQL = """\
SELECT # SELECT
COUNT(*) AS count # COUNT(*) AS count
FROM # FROM
{table_name} # {table_name}
WHERE # WHERE
inst_cd = :inst_cd # inst_cd = :inst_cd
AND ta_cd = :ta_cd # AND ta_cd = :ta_cd
AND emp_chg_type_cd = :emp_chg_type_cd # AND emp_chg_type_cd = :emp_chg_type_cd
AND start_date = :start_date # AND start_date = :start_date
""" # """
def fetch_count(self, inst_cd, ta_cd, emp_chg_type_cd, start_date, table_name) -> MasterMenteCountModel: # def fetch_count(self, inst_cd, ta_cd, emp_chg_type_cd, start_date, table_name) -> MasterMenteCountModel:
try: # try:
query = self.FETCH_COUNT_SQL.format(table_name=table_name) # query = self.FETCH_COUNT_SQL.format(table_name=table_name)
result = self._database.execute_select(query, {'inst_cd': inst_cd, 'ta_cd': ta_cd, # result = self._database.execute_select(query, {'inst_cd': inst_cd, 'ta_cd': ta_cd,
'emp_chg_type_cd': emp_chg_type_cd, 'start_date': start_date}) # 'emp_chg_type_cd': emp_chg_type_cd, 'start_date': start_date})
models = [MasterMenteCountModel(**r) for r in result] # models = [MasterMenteCountModel(**r) for r in result]
if len(models) == 0: # if len(models) == 0:
return 0 # return 0
return models[0].count # return models[0].count
except Exception as e: # except Exception as e:
logger.exception(f'DB Error : Exception={e.args}') # logger.exception(f'DB Error : Exception={e.args}')
raise e # raise e
FETCH_SQL = """\ # FETCH_SQL = """\
SELECT DISTINCT # SELECT DISTINCT
eci.inst_cd AS inst_cd, # eci.inst_cd AS inst_cd,
mi.inst_name AS inst_name, # mi.inst_name AS inst_name,
eci.ta_cd AS ta_cd, # eci.ta_cd AS ta_cd,
eci.emp_chg_type_cd AS emp_chg_type_cd, # eci.emp_chg_type_cd AS emp_chg_type_cd,
eci.emp_cd AS emp_cd, # eci.emp_cd AS emp_cd,
CONCAT(emp.emp_name_family, " ", emp.emp_name_first) AS emp_name_full, # CONCAT(emp.emp_name_family, " ", emp.emp_name_first) AS emp_name_full,
eci.bu_cd AS bu_cd, # eci.bu_cd AS bu_cd,
bu.bu_name AS bu_name, # bu.bu_name AS bu_name,
eci.start_date AS start_date, # eci.start_date AS start_date,
eci.end_date AS end_date, # eci.end_date AS end_date,
eci.creater AS creater, # eci.creater AS creater,
eci.create_date AS create_date, # eci.create_date AS create_date,
eci.updater AS updater, # eci.updater AS updater,
eci.update_date AS update_date # eci.update_date AS update_date
FROM # FROM
{table_name} AS eci # {table_name} AS eci
LEFT JOIN mst_inst AS mi # LEFT JOIN mst_inst AS mi
ON eci.inst_cd = mi.inst_cd # ON eci.inst_cd = mi.inst_cd
LEFT JOIN emp # LEFT JOIN emp
ON eci.emp_cd = emp.emp_cd # ON eci.emp_cd = emp.emp_cd
LEFT JOIN bu # LEFT JOIN bu
ON eci.bu_cd = bu.bu_cd # ON eci.bu_cd = bu.bu_cd
WHERE # WHERE
{where_clause} # {where_clause}
""" # """
def fetch_as_data_frame(self, table_name: str, parameter: MasterMainteCsvDlModel): # def fetch_as_data_frame(self, table_name: str, parameter: MasterMainteCsvDlModel):
try: # try:
where_clause = self.__build_condition(parameter) # where_clause = self.__build_condition(parameter)
query = self.FETCH_SQL.format(table_name=table_name, where_clause=where_clause) # query = self.FETCH_SQL.format(table_name=table_name, where_clause=where_clause)
logger.debug(f'SQL: {query}') # logger.debug(f'SQL: {query}')
df = self._to_data_frame(query, parameter) # df = self._to_data_frame(query, parameter)
logger.debug(f'count= {df.shape[0]}') # logger.debug(f'count= {df.shape[0]}')
return df # return df
except Exception as e: # except Exception as e:
logger.exception(f'DB Error : Exception={e.args}') # logger.exception(f'DB Error : Exception={e.args}')
raise e # raise e
def __build_condition(self, parameter: MasterMainteCsvDlModel): # def __build_condition(self, parameter: MasterMainteCsvDlModel):
where_clauses: list[SQLCondition] = [] # where_clauses: list[SQLCondition] = []
# 検索条件が指定されずにSQLが壊れることを予防するため、常に真の固定条件を追加しておく # # 検索条件が指定されずにSQLが壊れることを予防するため、常に真の固定条件を追加しておく
where_clauses.append(SQLCondition('', '', '1 = 1', literal=True)) # where_clauses.append(SQLCondition('', '', '1 = 1', literal=True))
# 領域コードが入力されていた場合 # # 領域コードが入力されていた場合
if is_not_empty(parameter.ta_cd): # if is_not_empty(parameter.ta_cd):
parameter.adapt_ta_cd = f'%{parameter.ta_cd}%' # parameter.adapt_ta_cd = f'%{parameter.ta_cd}%'
where_clauses.append(SQLCondition('eci.ta_cd', condition.LIKE, 'adapt_ta_cd')) # where_clauses.append(SQLCondition('eci.ta_cd', condition.LIKE, 'adapt_ta_cd'))
# 施設コードが入力されていた場合 # # 施設コードが入力されていた場合
if is_not_empty(parameter.inst_cd): # if is_not_empty(parameter.inst_cd):
parameter.adapt_inst_cd = f'%{parameter.inst_cd}%' # parameter.adapt_inst_cd = f'%{parameter.inst_cd}%'
where_clauses.append(SQLCondition('eci.inst_cd', condition.LIKE, 'adapt_inst_cd')) # where_clauses.append(SQLCondition('eci.inst_cd', condition.LIKE, 'adapt_inst_cd'))
# MUIDが入力されていた場合 # # MUIDが入力されていた場合
if is_not_empty(parameter.emp_cd): # if is_not_empty(parameter.emp_cd):
parameter.adapt_emp_cd = f'%{parameter.emp_cd}%' # parameter.adapt_emp_cd = f'%{parameter.emp_cd}%'
where_clauses.append(SQLCondition('eci.emp_cd', condition.LIKE, 'adapt_emp_cd')) # where_clauses.append(SQLCondition('eci.emp_cd', condition.LIKE, 'adapt_emp_cd'))
# 担当者種別コードが入力されていた場合 # # 担当者種別コードが入力されていた場合
if is_not_empty(parameter.emp_chg_type_cd): # if is_not_empty(parameter.emp_chg_type_cd):
parameter.adapt_emp_chg_type_cd = f'%{parameter.emp_chg_type_cd}%' # parameter.adapt_emp_chg_type_cd = f'%{parameter.emp_chg_type_cd}%'
where_clauses.append(SQLCondition('eci.emp_chg_type_cd', condition.LIKE, 'adapt_emp_chg_type_cd')) # where_clauses.append(SQLCondition('eci.emp_chg_type_cd', condition.LIKE, 'adapt_emp_chg_type_cd'))
# 適用期間内が入力されていた場合 # # 適用期間内が入力されていた場合
if is_not_empty(parameter.adapt_apply_date_from): # if is_not_empty(parameter.adapt_apply_date_from):
where_clauses.append(SQLCondition('eci.start_date', condition.LE, 'adapt_apply_date_from')) # where_clauses.append(SQLCondition('eci.start_date', condition.LE, 'adapt_apply_date_from'))
where_clauses.append(SQLCondition('eci.end_date', condition.GE, 'adapt_apply_date_from')) # where_clauses.append(SQLCondition('eci.end_date', condition.GE, 'adapt_apply_date_from'))
# 適用開始日（FROM）が入力されていた場合 # # 適用開始日（FROM）が入力されていた場合
if is_not_empty(parameter.adapt_start_date_from): # if is_not_empty(parameter.adapt_start_date_from):
where_clauses.append(SQLCondition('eci.start_date', condition.GE, 'adapt_start_date_from')) # where_clauses.append(SQLCondition('eci.start_date', condition.GE, 'adapt_start_date_from'))
# 適用開始日（TO）が入力されていた場合 # # 適用開始日（TO）が入力されていた場合
if is_not_empty(parameter.adapt_start_date_to): # if is_not_empty(parameter.adapt_start_date_to):
where_clauses.append(SQLCondition('eci.start_date', condition.LE, 'adapt_start_date_to')) # where_clauses.append(SQLCondition('eci.start_date', condition.LE, 'adapt_start_date_to'))
# 適用終了日（FROM）が入力されていた場合 # # 適用終了日（FROM）が入力されていた場合
if is_not_empty(parameter.adapt_end_date_from): # if is_not_empty(parameter.adapt_end_date_from):
where_clauses.append(SQLCondition('eci.end_date', condition.GE, 'adapt_end_date_from')) # where_clauses.append(SQLCondition('eci.end_date', condition.GE, 'adapt_end_date_from'))
# 適用終了日（TO）が入力されていた場合 # # 適用終了日（TO）が入力されていた場合
if is_not_empty(parameter.adapt_end_date_to): # if is_not_empty(parameter.adapt_end_date_to):
where_clauses.append(SQLCondition('eci.end_date', condition.LE, 'adapt_end_date_to')) # where_clauses.append(SQLCondition('eci.end_date', condition.LE, 'adapt_end_date_to'))
# データ作成日（FROM）が入力されていた場合 # # データ作成日（FROM）が入力されていた場合
if is_not_empty(parameter.adapt_create_date_from): # if is_not_empty(parameter.adapt_create_date_from):
where_clauses.append(SQLCondition('eci.create_date', condition.GE, 'adapt_create_date_from')) # where_clauses.append(SQLCondition('eci.create_date', condition.GE, 'adapt_create_date_from'))
# データ作成日（TO）が入力されていた場合 # # データ作成日（TO）が入力されていた場合
if is_not_empty(parameter.adapt_create_date_to): # if is_not_empty(parameter.adapt_create_date_to):
where_clauses.append(SQLCondition('eci.create_date', condition.LE, 'adapt_create_date_to')) # where_clauses.append(SQLCondition('eci.create_date', condition.LE, 'adapt_create_date_to'))
# データ更新日（FROM）が入力されていた場合 # # データ更新日（FROM）が入力されていた場合
if is_not_empty(parameter.adapt_update_date_from): # if is_not_empty(parameter.adapt_update_date_from):
where_clauses.append(SQLCondition('eci.update_date', condition.GE, 'adapt_update_date_from')) # where_clauses.append(SQLCondition('eci.update_date', condition.GE, 'adapt_update_date_from'))
# データ更新日（TO）が入力されていた場合 # # データ更新日（TO）が入力されていた場合
if is_not_empty(parameter.adapt_update_date_to): # if is_not_empty(parameter.adapt_update_date_to):
where_clauses.append(SQLCondition('eci.update_date', condition.LE, 'adapt_update_date_to')) # where_clauses.append(SQLCondition('eci.update_date', condition.LE, 'adapt_update_date_to'))
where_clauses_str = ' AND '.join([condition.apply() for condition in where_clauses]) # where_clauses_str = ' AND '.join([condition.apply() for condition in where_clauses])
logger.debug(f'条件設定終了:{where_clauses_str}') # logger.debug(f'条件設定終了:{where_clauses_str}')
return where_clauses_str # return where_clauses_str
DELETE_SQL = "DELETE FROM emp_chg_inst_wrk" # DELETE_SQL = "DELETE FROM emp_chg_inst_wrk"
def delete_dummy_table(self): # def delete_dummy_table(self):
try: # try:
query = self.DELETE_SQL # query = self.DELETE_SQL
self._database.execute(query) # self._database.execute(query)
except Exception as e: # except Exception as e:
logger.exception(f'DB Error : Exception={e.args}') # logger.exception(f'DB Error : Exception={e.args}')
raise e # raise e
COPY_TABLE_SQL = "INSERT INTO emp_chg_inst_wrk SELECT * FROM emp_chg_inst" # COPY_TABLE_SQL = "INSERT INTO emp_chg_inst_wrk SELECT * FROM emp_chg_inst"
def copy_real_to_dummy(self): # def copy_real_to_dummy(self):
try: # try:
query = self.COPY_TABLE_SQL # query = self.COPY_TABLE_SQL
self._database.execute(query) # self._database.execute(query)
except Exception as e: # except Exception as e:
logger.exception(f'DB Error : Exception={e.args}') # logger.exception(f'DB Error : Exception={e.args}')
raise e # raise e

53
ecs/jskult-webapp/src/repositories/emp_master_repository.py
View File

@ -1,31 +1,32 @@
from src.repositories.base_repository import BaseRepository # ファイル削除予定
from src.model.db.master_mente_count import MasterMenteCountModel # from src.repositories.base_repository import BaseRepository
from src.logging.get_logger import get_logger # from src.model.db.master_mente_count import MasterMenteCountModel
# from src.logging.get_logger import get_logger
logger = get_logger('従業員マスタ') # logger = get_logger('従業員マスタ')
class EmpMasterRepository(BaseRepository): # class EmpMasterRepository(BaseRepository):
FETCH_COUNT_SQL = """\ # FETCH_COUNT_SQL = """\
SELECT # SELECT
COUNT(*) AS count # COUNT(*) AS count
FROM # FROM
src05.emp # src05.emp
WHERE # WHERE
emp.emp_cd = :emp_cd # emp.emp_cd = :emp_cd
AND str_to_date(emp.start_date, '%Y%m%d') <= str_to_date(:start_work_date, '%Y%m%d') # AND str_to_date(emp.start_date, '%Y%m%d') <= str_to_date(:start_work_date, '%Y%m%d')
AND str_to_date(:start_work_date, '%Y%m%d') <= str_to_date(emp.end_date ,'%Y%m%d') # AND str_to_date(:start_work_date, '%Y%m%d') <= str_to_date(emp.end_date ,'%Y%m%d')
""" # """
def fetch_count(self, emp_cd, start_work_date) -> MasterMenteCountModel: # def fetch_count(self, emp_cd, start_work_date) -> MasterMenteCountModel:
try: # try:
query = self.FETCH_COUNT_SQL # query = self.FETCH_COUNT_SQL
result = self._database.execute_select(query, {'emp_cd': emp_cd, 'start_work_date': start_work_date}) # result = self._database.execute_select(query, {'emp_cd': emp_cd, 'start_work_date': start_work_date})
models = [MasterMenteCountModel(**r) for r in result] # models = [MasterMenteCountModel(**r) for r in result]
if len(models) == 0: # if len(models) == 0:
return 0 # return 0
return models[0].count # return models[0].count
except Exception as e: # except Exception as e:
logger.exception(f"DB Error : Exception={e.args}") # logger.exception(f"DB Error : Exception={e.args}")
raise e # raise e

57
ecs/jskult-webapp/src/repositories/generic_kbn_mst_repository.py
View File

@ -1,33 +1,34 @@
from src.repositories.base_repository import BaseRepository # ファイル削除予定
from src.model.db.master_mente_count import MasterMenteCountModel # from src.repositories.base_repository import BaseRepository
from src.logging.get_logger import get_logger # from src.model.db.master_mente_count import MasterMenteCountModel
# from src.logging.get_logger import get_logger
logger = get_logger('汎用区分マスタ') # logger = get_logger('汎用区分マスタ')
class GenericKbnMstRepository(BaseRepository): # class GenericKbnMstRepository(BaseRepository):
FETCH_SQL = """\ # FETCH_SQL = """\
SELECT # SELECT
COUNT(*) AS count # COUNT(*) AS count
FROM # FROM
src05.generic_kbn_mst # src05.generic_kbn_mst
WHERE # WHERE
generic_kbn_mst.generic_kbn_cd = :generic_kbn_cd # generic_kbn_mst.generic_kbn_cd = :generic_kbn_cd
AND # AND
generic_kbn_mst.kbn_cd = :kbn_cd # generic_kbn_mst.kbn_cd = :kbn_cd
AND # AND
STR_TO_DATE( :start_date , '%Y%m%d') BETWEEN generic_kbn_mst.start_date AND generic_kbn_mst.end_date\ # STR_TO_DATE( :start_date , '%Y%m%d') BETWEEN generic_kbn_mst.start_date AND generic_kbn_mst.end_date\
""" # """
def fetch_count(self, generic_kbn_cd: str, kbn_cd: str, start_date: str) -> MasterMenteCountModel: # def fetch_count(self, generic_kbn_cd: str, kbn_cd: str, start_date: str) -> MasterMenteCountModel:
try: # try:
query = self.FETCH_SQL # query = self.FETCH_SQL
result = self._database.execute_select(query, {'generic_kbn_cd': generic_kbn_cd, 'kbn_cd': kbn_cd, 'start_date' : start_date}) # result = self._database.execute_select(query, {'generic_kbn_cd': generic_kbn_cd, 'kbn_cd': kbn_cd, 'start_date' : start_date})
models = [MasterMenteCountModel(**r) for r in result] # models = [MasterMenteCountModel(**r) for r in result]
if len(models) == 0: # if len(models) == 0:
return 0 # return 0
return models[0].count # return models[0].count
except Exception as e: # except Exception as e:
logger.error(f"DB Error : Exception={e.args}") # logger.error(f"DB Error : Exception={e.args}")
raise e # raise e

49
ecs/jskult-webapp/src/repositories/mst_inst_repository.py
View File

@ -1,29 +1,30 @@
from src.repositories.base_repository import BaseRepository # ファイル削除予定
from src.model.db.master_mente_count import MasterMenteCountModel # from src.repositories.base_repository import BaseRepository
from src.logging.get_logger import get_logger # from src.model.db.master_mente_count import MasterMenteCountModel
# from src.logging.get_logger import get_logger
logger = get_logger('メルク施設マスタ') # logger = get_logger('メルク施設マスタ')
class MstInstRepository(BaseRepository): # class MstInstRepository(BaseRepository):
FETCH_COUNT_SQL = """\ # FETCH_COUNT_SQL = """\
SELECT # SELECT
COUNT(*) AS count # COUNT(*) AS count
FROM # FROM
src05.mst_inst # src05.mst_inst
WHERE # WHERE
mst_inst.inst_cd = :inst_cd # mst_inst.inst_cd = :inst_cd
""" # """
def fetch_count(self, inst_cd) -> MasterMenteCountModel: # def fetch_count(self, inst_cd) -> MasterMenteCountModel:
try: # try:
query = self.FETCH_COUNT_SQL # query = self.FETCH_COUNT_SQL
result = self._database.execute_select(query, {'inst_cd': inst_cd}) # result = self._database.execute_select(query, {'inst_cd': inst_cd})
models = [MasterMenteCountModel(**r) for r in result] # models = [MasterMenteCountModel(**r) for r in result]
if len(models) == 0: # if len(models) == 0:
return 0 # return 0
return models[0].count # return models[0].count
except Exception as e: # except Exception as e:
logger.exception(f"DB Error : Exception={e.args}") # logger.exception(f"DB Error : Exception={e.args}")
raise e # raise e

11
ecs/jskult-webapp/src/services/batch_status_service.py
View File

@ -40,12 +40,13 @@ class BatchStatusService(BaseService):
self.__assert_record_exists() self.__assert_record_exists()
return self.hdke_table_record.bch_actf == constants.BATCH_STATUS_PROCESSING return self.hdke_table_record.bch_actf == constants.BATCH_STATUS_PROCESSING
def is_dump_processing(self): # 削除予定
"""dump処理処理中かどうかを判定する""" # def is_dump_processing(self):
# """dump処理処理中かどうかを判定する"""
# 日付マスタのレコードがあることを確認 # # 日付マスタのレコードがあることを確認
self.__assert_record_exists() # self.__assert_record_exists()
return self.hdke_table_record.dump_sts_kbn != constants.DUMP_STATUS_UNPROCESSED # return self.hdke_table_record.dump_sts_kbn != constants.DUMP_STATUS_UNPROCESSED
def __assert_record_exists(self): def __assert_record_exists(self):
"""日付テーブルが有ることを保証する""" """日付テーブルが有ることを保証する"""

447
ecs/jskult-webapp/src/services/master_mainte_service.py
View File

@ -1,265 +1,266 @@
import os # # ファイル削除予定
import json # import os
import html # import json
import csv # import html
# import csv
import pandas as pd # import pandas as pd
from fastapi import HTTPException # from fastapi import HTTPException
from io import TextIOWrapper # from io import TextIOWrapper
from src.aws.aws_api_client import AWSAPIClient # from src.aws.aws_api_client import AWSAPIClient
from src.aws.s3 import S3Client # from src.aws.s3 import S3Client
from src.error.exceptions import DBException # from src.error.exceptions import DBException
from starlette import status # from starlette import status
from datetime import datetime # from datetime import datetime
from src.services.base_service import BaseService # from src.services.base_service import BaseService
from src.system_var import constants, environment # from src.system_var import constants, environment
from src.repositories.base_repository import BaseRepository # from src.repositories.base_repository import BaseRepository
from src.repositories.mst_inst_repository import MstInstRepository # from src.repositories.mst_inst_repository import MstInstRepository
from src.repositories.bu_master_cd_repository import BuMasterRepository # from src.repositories.bu_master_cd_repository import BuMasterRepository
from src.repositories.emp_master_repository import EmpMasterRepository # from src.repositories.emp_master_repository import EmpMasterRepository
from src.repositories.emp_chg_inst_repository import EmpChgInstRepository # from src.repositories.emp_chg_inst_repository import EmpChgInstRepository
from src.repositories.generic_kbn_mst_repository import GenericKbnMstRepository # from src.repositories.generic_kbn_mst_repository import GenericKbnMstRepository
from src.model.internal.master_mainte_csv import MasterMainteCSVItems # from src.model.internal.master_mainte_csv import MasterMainteCSVItems
from src.model.internal.master_mainte_emp_chg_inst_function import NewEmpChgInstFunction # from src.model.internal.master_mainte_emp_chg_inst_function import NewEmpChgInstFunction
from src.model.internal.master_mainte_emp_chg_inst_function import ChangeEmpChgInstFunction # from src.model.internal.master_mainte_emp_chg_inst_function import ChangeEmpChgInstFunction
from src.model.view.inst_emp_csv_upload_view_model import InstEmpCsvUploadViewModel # from src.model.view.inst_emp_csv_upload_view_model import InstEmpCsvUploadViewModel
from src.model.view.table_override_view_model import TableOverrideViewModel # from src.model.view.table_override_view_model import TableOverrideViewModel
from src.model.request.master_mainte_csvup import MasterMainteCsvUpModel # from src.model.request.master_mainte_csvup import MasterMainteCsvUpModel
from src.model.request.master_mainte_csvdl import MasterMainteCsvDlModel # from src.model.request.master_mainte_csvdl import MasterMainteCsvDlModel
from src.logging.get_logger import get_logger # from src.logging.get_logger import get_logger
logger = get_logger('マスターメンテ') # logger = get_logger('マスターメンテ')
class MasterMainteService(BaseService): # class MasterMainteService(BaseService):
REPOSITORIES = { # REPOSITORIES = {
'mst_inst_repository': MstInstRepository, # 'mst_inst_repository': MstInstRepository,
'emp_master_repository': EmpMasterRepository, # 'emp_master_repository': EmpMasterRepository,
'bu_master_repository': BuMasterRepository, # 'bu_master_repository': BuMasterRepository,
'emp_chginst_repository': EmpChgInstRepository, # 'emp_chginst_repository': EmpChgInstRepository,
'generic_kbn_mst_repository': GenericKbnMstRepository, # 'generic_kbn_mst_repository': GenericKbnMstRepository,
} # }
CLIENTS = { # CLIENTS = {
's3_client': S3Client # 's3_client': S3Client
} # }
mst_inst_repository: MstInstRepository # mst_inst_repository: MstInstRepository
emp_master_repository: EmpMasterRepository # emp_master_repository: EmpMasterRepository
bu_master_repository: BuMasterRepository # bu_master_repository: BuMasterRepository
emp_chginst_repository: EmpChgInstRepository # emp_chginst_repository: EmpChgInstRepository
generic_kbn_mst_repository: GenericKbnMstRepository # generic_kbn_mst_repository: GenericKbnMstRepository
s3_client: S3Client # s3_client: S3Client
def __init__(self, repositories: dict[str, BaseRepository], clients: dict[str, AWSAPIClient]) -> None: # def __init__(self, repositories: dict[str, BaseRepository], clients: dict[str, AWSAPIClient]) -> None:
super().__init__(repositories, clients) # super().__init__(repositories, clients)
self.mst_inst_repository = repositories['mst_inst_repository'] # self.mst_inst_repository = repositories['mst_inst_repository']
self.emp_master_repository = repositories['emp_master_repository'] # self.emp_master_repository = repositories['emp_master_repository']
self.bu_master_repository = repositories['bu_master_repository'] # self.bu_master_repository = repositories['bu_master_repository']
self.emp_chginst_repository = repositories['emp_chginst_repository'] # self.emp_chginst_repository = repositories['emp_chginst_repository']
self.generic_kbn_mst_repository = repositories['generic_kbn_mst_repository'] # self.generic_kbn_mst_repository = repositories['generic_kbn_mst_repository']
self.s3_client = clients['s3_client'] # self.s3_client = clients['s3_client']
def prepare_mainte_csv_up_view(self, # def prepare_mainte_csv_up_view(self,
file: TextIOWrapper, # file: TextIOWrapper,
csv_file_name: str, # csv_file_name: str,
csv_upload_form: MasterMainteCsvUpModel) -> InstEmpCsvUploadViewModel: # csv_upload_form: MasterMainteCsvUpModel) -> InstEmpCsvUploadViewModel:
if csv_upload_form.select_function != 'new' and csv_upload_form.select_function != 'change': # if csv_upload_form.select_function != 'new' and csv_upload_form.select_function != 'change':
raise Exception(f'機能の選択値が不正です: {csv_upload_form.select_function}') # raise Exception(f'機能の選択値が不正です: {csv_upload_form.select_function}')
if csv_upload_form.select_table != 'dummy' and csv_upload_form.select_table != 'real': # if csv_upload_form.select_table != 'dummy' and csv_upload_form.select_table != 'real':
raise Exception(f'登録テーブルの選択値が不正です: {csv_upload_form.select_table}') # raise Exception(f'登録テーブルの選択値が不正です: {csv_upload_form.select_table}')
(table_name, selected_table_msg) = self.__choose_target_table(csv_upload_form.select_table) # (table_name, selected_table_msg) = self.__choose_target_table(csv_upload_form.select_table)
csv_items = MasterMainteCSVItems( # csv_items = MasterMainteCSVItems(
file, # file,
csv_upload_form.select_function, # csv_upload_form.select_function,
table_name, # table_name,
self.mst_inst_repository, # self.mst_inst_repository,
self.emp_master_repository, # self.emp_master_repository,
self.bu_master_repository, # self.bu_master_repository,
self.emp_chginst_repository, # self.emp_chginst_repository,
self.generic_kbn_mst_repository # self.generic_kbn_mst_repository
) # )
error_message_list = [] # error_message_list = []
# CSVファイル0件(ヘッダ行のみ)チェック # # CSVファイル0件(ヘッダ行のみ)チェック
if len(csv_items.lines) == 0: # if len(csv_items.lines) == 0:
error_message_list.append('選択されたCSVファイルの2行目以降に値が記入されておりません。') # error_message_list.append('選択されたCSVファイルの2行目以降に値が記入されておりません。')
else: # else:
for row_item in csv_items: # for row_item in csv_items:
error_message_list.extend([data for data in row_item.validate()]) # error_message_list.extend([data for data in row_item.validate()])
csv_upload_list = [] # csv_upload_list = []
json_upload_data = '' # json_upload_data = ''
if len(error_message_list) == 0: # if len(error_message_list) == 0:
csv_upload_list: list[dict] = csv_items.to_dict() # csv_upload_list: list[dict] = csv_items.to_dict()
# json作成 # # json作成
json_upload_data = csv_items.to_json() # json_upload_data = csv_items.to_json()
mainte_csv_up = InstEmpCsvUploadViewModel( # mainte_csv_up = InstEmpCsvUploadViewModel(
is_verified=True, # is_verified=True,
error_message_list=error_message_list, # error_message_list=error_message_list,
select_function=csv_upload_form.select_function, # select_function=csv_upload_form.select_function,
select_table=csv_upload_form.select_table, # select_table=csv_upload_form.select_table,
csv_upload_list=csv_upload_list, # csv_upload_list=csv_upload_list,
json_upload_data=json_upload_data, # json_upload_data=json_upload_data,
csv_file_name=csv_file_name, # csv_file_name=csv_file_name,
select_function_message=self.__make_dialog_confirm_message( # select_function_message=self.__make_dialog_confirm_message(
csv_upload_form.select_function, # csv_upload_form.select_function,
selected_table_msg) # selected_table_msg)
) # )
return mainte_csv_up # return mainte_csv_up
def prepare_mainte_new_inst_view(self, # def prepare_mainte_new_inst_view(self,
user_name: str, # user_name: str,
csv_upload_form: MasterMainteCsvUpModel) -> InstEmpCsvUploadViewModel: # csv_upload_form: MasterMainteCsvUpModel) -> InstEmpCsvUploadViewModel:
(table_name, selected_table_msg) = self.__choose_target_table(csv_upload_form.select_table) # (table_name, selected_table_msg) = self.__choose_target_table(csv_upload_form.select_table)
csv_data_list = json.loads(html.unescape(csv_upload_form.unescape().json_upload_data)) # csv_data_list = json.loads(html.unescape(csv_upload_form.unescape().json_upload_data))
if csv_upload_form.select_function == 'new': # if csv_upload_form.select_function == 'new':
emp_chg_inst = NewEmpChgInstFunction( # emp_chg_inst = NewEmpChgInstFunction(
csv_data_list, # csv_data_list,
table_name, # table_name,
selected_table_msg, # selected_table_msg,
user_name, # user_name,
self.emp_chginst_repository) # self.emp_chginst_repository)
elif csv_upload_form.select_function == 'change': # elif csv_upload_form.select_function == 'change':
emp_chg_inst = ChangeEmpChgInstFunction( # emp_chg_inst = ChangeEmpChgInstFunction(
csv_data_list, # csv_data_list,
table_name, # table_name,
selected_table_msg, # selected_table_msg,
user_name, # user_name,
self.emp_chginst_repository) # self.emp_chginst_repository)
else: # else:
raise Exception(f'機能の選択値が不正です: {csv_upload_form.select_function}') # raise Exception(f'機能の選択値が不正です: {csv_upload_form.select_function}')
(result_message_list, raw_error_list) = emp_chg_inst.save() # (result_message_list, raw_error_list) = emp_chg_inst.save()
error_message_list = [] # error_message_list = []
error_message_list.extend(raw_error_list) # error_message_list.extend(raw_error_list)
mainte_csv_up = InstEmpCsvUploadViewModel( # mainte_csv_up = InstEmpCsvUploadViewModel(
is_insert=True, # is_insert=True,
result_message_list=result_message_list, # result_message_list=result_message_list,
error_message_list=error_message_list # error_message_list=error_message_list
) # )
return mainte_csv_up # return mainte_csv_up
def copy_data_real_to_dummy(self) -> TableOverrideViewModel: # def copy_data_real_to_dummy(self) -> TableOverrideViewModel:
try: # try:
self.emp_chginst_repository.begin() # self.emp_chginst_repository.begin()
self.emp_chginst_repository.to_jst() # self.emp_chginst_repository.to_jst()
self.emp_chginst_repository.delete_dummy_table() # self.emp_chginst_repository.delete_dummy_table()
self.emp_chginst_repository.copy_real_to_dummy() # self.emp_chginst_repository.copy_real_to_dummy()
self.emp_chginst_repository.commit() # self.emp_chginst_repository.commit()
except Exception as e: # except Exception as e:
self.emp_chginst_repository.rollback() # self.emp_chginst_repository.rollback()
raise e # raise e
# コピー完了をマークして画面に返却 # # コピー完了をマークして画面に返却
table_override = TableOverrideViewModel( # table_override = TableOverrideViewModel(
is_override=True # is_override=True
) # )
return table_override # return table_override
def search_emp_chg_inst_data(self, csv_download_form: MasterMainteCsvDlModel) -> pd.DataFrame: # def search_emp_chg_inst_data(self, csv_download_form: MasterMainteCsvDlModel) -> pd.DataFrame:
try: # try:
csv_download_form.unescape() # csv_download_form.unescape()
# 施設担当者データを検索 # # 施設担当者データを検索
search_result_df = self.search_download_emp_chg_inst_data(csv_download_form) # search_result_df = self.search_download_emp_chg_inst_data(csv_download_form)
except DBException as e: # except DBException as e:
raise HTTPException( # raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, # status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail={'error': 'db_error', 'message': e.args} # detail={'error': 'db_error', 'message': e.args}
) # )
return search_result_df # return search_result_df
def search_download_emp_chg_inst_data(self, csv_download_form: MasterMainteCsvDlModel): # def search_download_emp_chg_inst_data(self, csv_download_form: MasterMainteCsvDlModel):
(table_name, _) = self.__choose_target_table(csv_download_form.select_table) # (table_name, _) = self.__choose_target_table(csv_download_form.select_table)
search_result_df = self.emp_chginst_repository.fetch_as_data_frame(table_name, csv_download_form) # search_result_df = self.emp_chginst_repository.fetch_as_data_frame(table_name, csv_download_form)
return search_result_df # return search_result_df
def write_csv_file(self, data_frame: pd.DataFrame, header: list[str], download_file_name: str): # def write_csv_file(self, data_frame: pd.DataFrame, header: list[str], download_file_name: str):
# csvに書き込み # # csvに書き込み
output_file_path = os.path.join(constants.MENTE_CSV_TEMPORARY_FILE_DIR_PATH, download_file_name) # output_file_path = os.path.join(constants.MENTE_CSV_TEMPORARY_FILE_DIR_PATH, download_file_name)
# 横長のDataFrameとするため、ヘッダーの加工処理 # # 横長のDataFrameとするため、ヘッダーの加工処理
header_data = {} # header_data = {}
for df_column, header_column in zip(data_frame.columns, header): # for df_column, header_column in zip(data_frame.columns, header):
header_data[df_column] = header_column # header_data[df_column] = header_column
header_df = pd.DataFrame([header_data], index=None) # header_df = pd.DataFrame([header_data], index=None)
output_df = pd.concat([header_df, data_frame]) # output_df = pd.concat([header_df, data_frame])
# ヘッダー行としてではなく、1レコードとして出力する # # ヘッダー行としてではなく、1レコードとして出力する
output_df.to_csv(output_file_path, encoding="utf-8_sig", quoting=csv.QUOTE_ALL, index=False, header=False) # output_df.to_csv(output_file_path, encoding="utf-8_sig", quoting=csv.QUOTE_ALL, index=False, header=False)
return output_file_path # return output_file_path
def upload_emp_chg_inst_data_file(self, df: pd.DataFrame, user_id: str, select_table: str) -> tuple[str, str]: # def upload_emp_chg_inst_data_file(self, df: pd.DataFrame, user_id: str, select_table: str) -> tuple[str, str]:
if df.shape[0] == 0: # if df.shape[0] == 0:
return '該当データが存在しないためCSVファイルを出力しませんでした', '' # return '該当データが存在しないためCSVファイルを出力しませんでした', ''
# ファイル名に使用するタイムスタンプを初期化しておく # # ファイル名に使用するタイムスタンプを初期化しておく
current_timestamp = datetime.now() # current_timestamp = datetime.now()
download_file_name = f'Result_{user_id}_{current_timestamp:%Y%m%d%H%M%S%f}.csv' # download_file_name = f'Result_{user_id}_{current_timestamp:%Y%m%d%H%M%S%f}.csv'
# ファイルを書き出し(CSV) # # ファイルを書き出し(CSV)
local_file_path = self.__write_emp_chg_inst_data_to_file(df, download_file_name) # local_file_path = self.__write_emp_chg_inst_data_to_file(df, download_file_name)
# ローカルファイルからS3にアップロードし、ダウンロード用URLを取得する # # ローカルファイルからS3にアップロードし、ダウンロード用URLを取得する
download_file_url = '' # download_file_url = ''
try: # try:
bucket_name = environment.MASTER_MAINTENANCE_BUCKET # bucket_name = environment.MASTER_MAINTENANCE_BUCKET
file_key = f'data/{os.path.basename(local_file_path)}' # file_key = f'data/{os.path.basename(local_file_path)}'
self.s3_client.upload_file(local_file_path, bucket_name, file_key) # self.s3_client.upload_file(local_file_path, bucket_name, file_key)
# アップロード後、ローカルからは削除する # # アップロード後、ローカルからは削除する
self.delete_local_file(local_file_path) # self.delete_local_file(local_file_path)
download_file_url = self.generate_download_file_url(local_file_path) # download_file_url = self.generate_download_file_url(local_file_path)
except Exception as e: # except Exception as e:
logger.exception(f'S3 アクセスエラー{e}') # logger.exception(f'S3 アクセスエラー{e}')
raise HTTPException( # raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, # status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail={'error': 'aws_error', 'message': e.args} # detail={'error': 'aws_error', 'message': e.args}
) # )
if select_table == 'dummy': # if select_table == 'dummy':
result_msg = f'ダミーテーブルのデータ{df.shape[0]}件をCSVファイルに出力しました' # result_msg = f'ダミーテーブルのデータ{df.shape[0]}件をCSVファイルに出力しました'
else: # else:
result_msg = f'本番テーブルのデータ{df.shape[0]}件をCSVファイルに出力しました' # result_msg = f'本番テーブルのデータ{df.shape[0]}件をCSVファイルに出力しました'
return result_msg, download_file_url # return result_msg, download_file_url
def generate_download_file_url(self, local_file_path: str) -> str: # def generate_download_file_url(self, local_file_path: str) -> str:
bucket_name = environment.MASTER_MAINTENANCE_BUCKET # bucket_name = environment.MASTER_MAINTENANCE_BUCKET
file_key = f'data/{os.path.basename(local_file_path)}' # file_key = f'data/{os.path.basename(local_file_path)}'
return self.s3_client.generate_presigned_url(bucket_name, file_key, constants.MENTE_CSV_DOWNLOAD_FILE_NAME) # return self.s3_client.generate_presigned_url(bucket_name, file_key, constants.MENTE_CSV_DOWNLOAD_FILE_NAME)
def __write_emp_chg_inst_data_to_file(self, df: pd.DataFrame, download_file_name: str) -> str: # def __write_emp_chg_inst_data_to_file(self, df: pd.DataFrame, download_file_name: str) -> str:
logger.info('CSVファイルを出力する') # logger.info('CSVファイルを出力する')
local_file_path = self.write_csv_file( # local_file_path = self.write_csv_file(
df, header=constants.MENTE_CSV_DOWNLOAD_HEADER, download_file_name=download_file_name) # df, header=constants.MENTE_CSV_DOWNLOAD_HEADER, download_file_name=download_file_name)
return local_file_path # return local_file_path
def __choose_target_table(self, select_table: str): # def __choose_target_table(self, select_table: str):
if select_table == 'dummy': # if select_table == 'dummy':
table_name = 'src05.emp_chg_inst_wrk' # table_name = 'src05.emp_chg_inst_wrk'
selected_table_msg = constants.CSV_CHANGE_TABLE_NAME # selected_table_msg = constants.CSV_CHANGE_TABLE_NAME
elif select_table == 'real': # elif select_table == 'real':
table_name = 'src05.emp_chg_inst' # table_name = 'src05.emp_chg_inst'
selected_table_msg = constants.CSV_REAL_TABLE_NAME # selected_table_msg = constants.CSV_REAL_TABLE_NAME
else: # else:
raise Exception(f'登録テーブルの選択値が不正です: {select_table}') # raise Exception(f'登録テーブルの選択値が不正です: {select_table}')
return (table_name, selected_table_msg) # return (table_name, selected_table_msg)
def __make_dialog_confirm_message(self, select_function: str, selected_table_msg: str) -> str: # def __make_dialog_confirm_message(self, select_function: str, selected_table_msg: str) -> str:
select_function_msg = '新規施設登録' if select_function == 'new' else '施設担当者変更' # select_function_msg = '新規施設登録' if select_function == 'new' else '施設担当者変更'
return f'{selected_table_msg}に{select_function_msg}を行いますか？' # return f'{selected_table_msg}に{select_function_msg}を行いますか？'
def delete_local_file(self, local_file_path: str): # def delete_local_file(self, local_file_path: str):
os.remove(local_file_path) # os.remove(local_file_path)

1
ecs/jskult-webapp/src/static/css/masterMainte.css
View File

@ -1,3 +1,4 @@
/* ファイル削除予定 */
/* Bootstrap 5.10以降、box-sizingのデフォルト値によってテーブルがずれるため、このページ限定的にリセット */ /* Bootstrap 5.10以降、box-sizingのデフォルト値によってテーブルがずれるため、このページ限定的にリセット */
/* @see https://bootstrap-guide.com/content/reboot#page-defaults */ /* @see https://bootstrap-guide.com/content/reboot#page-defaults */
table { table {

47
ecs/jskult-webapp/src/static/function/businessLogicScript.js
View File

@ -289,31 +289,32 @@ function checkNumberOnlyForm($this)
$this.value=str; $this.value=str;
} }
// TODO 削除予定
// メニューへボタンの関数 // メニューへボタンの関数
// 機能概要：マスターメンテメニュー画面に遷移する // 機能概要：マスターメンテメニュー画面に遷移する
function backToMainteMenu(loadingElemId = '_loading'){ // function backToMainteMenu(loadingElemId = '_loading'){
sessionStorage.clear(); // sessionStorage.clear();
// ローディング表示 // // ローディング表示
showLoading(loadingElemId); // showLoading(loadingElemId);
location.href = "/masterMainte/masterMainteMenu"; // location.href = "/masterMainte/masterMainteMenu";
} // }
// 確認ダイアログ // // 確認ダイアログ
function confirmDialog(strMesssage) { // function confirmDialog(strMesssage) {
var result = confirm(strMesssage); // var result = confirm(strMesssage);
return result; // return result;
} // }
function formInsertBtDisabled(){ //　TODO 削除予定 function formInsertBtDisabled(){
var validFlg = false; // var validFlg = false;
if(document.getElementById("csvFile").value === ""){ // if(document.getElementById("csvFile").value === ""){
validFlg = true; // validFlg = true;
} // }
if (validFlg == true) { // if (validFlg == true) {
document.getElementById("confirm").disabled = true; // document.getElementById("confirm").disabled = true;
} // }
else { // else {
document.getElementById("confirm").disabled = false; // document.getElementById("confirm").disabled = false;
} // }
} // }

217
ecs/jskult-webapp/src/system_var/constants.py
View File

@ -7,8 +7,9 @@ PERMISSION_DISABLED = 0
# 日付テーブル.バッチ処理ステータス：未処理 # 日付テーブル.バッチ処理ステータス：未処理
BATCH_STATUS_PROCESSING = '1' BATCH_STATUS_PROCESSING = '1'
# 削除予定
# 日付テーブル.dump取得状態区分：未処理 # 日付テーブル.dump取得状態区分：未処理
DUMP_STATUS_UNPROCESSED = '0' # DUMP_STATUS_UNPROCESSED = '0'
# 生物由来照会 # 生物由来照会
@ -76,134 +77,136 @@ LOGOUT_REASON_MESSAGE_MAP = {
LOGOUT_REASON_UNEXPECTED: '予期しないエラーが発生しました。<br>再度Loginするか、<br>管理者に問い合わせてください。', LOGOUT_REASON_UNEXPECTED: '予期しないエラーが発生しました。<br>再度Loginするか、<br>管理者に問い合わせてください。',
LOGOUT_REASON_LOGIN_FAILED_LIMIT_EXCEEDED: 'ログイン失敗回数の上限を超えましたので<br>アカウントをロックしました。<br>管理者に連絡してください' LOGOUT_REASON_LOGIN_FAILED_LIMIT_EXCEEDED: 'ログイン失敗回数の上限を超えましたので<br>アカウントをロックしました。<br>管理者に連絡してください'
} }
#削除予定
# 新規施設担当者登録CSV(マスターメンテ) # 新規施設担当者登録CSV(マスターメンテ)
NEW_INST_EMP_CSV_LOGICAL_NAMES = [ # NEW_INST_EMP_CSV_LOGICAL_NAMES = [
'施設コード', # '施設コード',
'施設名', # '施設名',
'領域コード', # '領域コード',
'担当者種別コード', # '担当者種別コード',
'MUID', # 'MUID',
'担当者名（姓）', # '担当者名（姓）',
'担当者名（名）', # '担当者名（名）',
'ビジネスユニットコード', # 'ビジネスユニットコード',
'適用開始日', # '適用開始日',
'適用終了日' # '適用終了日'
] # ]
# 施設コードの列No # 施設コードの列No
CSV_NEW_INST_CD_COL_NO = 0 # CSV_NEW_INST_CD_COL_NO = 0
# 施設名の列No # 施設名の列No
CSV_NEW_INST_NAME_COL_NO = 1 # CSV_NEW_INST_NAME_COL_NO = 1
# 領域コードの列No # 領域コードの列No
CSV_NEW_TA_CD_COL_NO = 2 # CSV_NEW_TA_CD_COL_NO = 2
# 担当者種別コードの列No # 担当者種別コードの列No
CSV_NEW_EMP_CHG_TYPE_CD_COL_NO = 3 # CSV_NEW_EMP_CHG_TYPE_CD_COL_NO = 3
# MUIDの列No # MUIDの列No
CSV_NEW_EMP_CD_COL_NO = 4 # CSV_NEW_EMP_CD_COL_NO = 4
# 担当者名（姓）の列No # 担当者名（姓）の列No
CSV_NEW_EMP_NAME_FAMILY_COL_NO = 5 # CSV_NEW_EMP_NAME_FAMILY_COL_NO = 5
# 担当者名（名）の列No # 担当者名（名）の列No
CSV_NEW_EMP_NAME_FIRST_COL_NO = 6 # CSV_NEW_EMP_NAME_FIRST_COL_NO = 6
# ビジネスユニットコードの列No # ビジネスユニットコードの列No
CSV_NEW_BU_CD_COL_NO = 7 # CSV_NEW_BU_CD_COL_NO = 7
# 適用開始日の列No # 適用開始日の列No
CSV_NEW_START_DATE = 8 # CSV_NEW_START_DATE = 8
# 適用終了日の列No # 適用終了日の列No
CSV_NEW_END_DATE = 9 # CSV_NEW_END_DATE = 9
#削除予定
# 施設担当者変更登録CSV(マスターメンテ) # 施設担当者変更登録CSV(マスターメンテ)
CHANGE_INST_CSV_LOGICAL_NAMES = [ # CHANGE_INST_CSV_LOGICAL_NAMES = [
'ビジネスユニットコード', # 'ビジネスユニットコード',
'ビジネスユニット名', # 'ビジネスユニット名',
'組織コード', # '組織コード',
'組織名略称', # '組織名略称',
'施設コード', # '施設コード',
'施設名', # '施設名',
'領域コード', # '領域コード',
'説明', # '説明',
'担当者種別コード', # '担当者種別コード',
'MUID', # 'MUID',
'担当者名', # '担当者名',
'施設担当_開始日', # '施設担当_開始日',
'施設担当_終了日', # '施設担当_終了日',
'終了日の変更', # '終了日の変更',
'コメント' # 'コメント'
] # ]
# ビジネスユニットコードの列No # ビジネスユニットコードの列No
CSV_CHANGE_BU_CD_COL_NO = 0 # CSV_CHANGE_BU_CD_COL_NO = 0
# ビジネスユニット名の列No # # ビジネスユニット名の列No
CSV_CHANGE_BU_NAME_COL_NO = 1 # CSV_CHANGE_BU_NAME_COL_NO = 1
# 組織コードの列No # # 組織コードの列No
CSV_CHANGE_ORG_CD_COL_NO = 2 # CSV_CHANGE_ORG_CD_COL_NO = 2
# 組織名略称の列No # # 組織名略称の列No
CSV_CHANGE_ORG_SHORT_NAME_COL_NO = 3 # CSV_CHANGE_ORG_SHORT_NAME_COL_NO = 3
# 施設コードの列No # # 施設コードの列No
CSV_CHANGE_INST_CD_COL_NO = 4 # CSV_CHANGE_INST_CD_COL_NO = 4
# 施設名の列No # # 施設名の列No
CSV_CHANGE_INST_NAME_COL_NO = 5 # CSV_CHANGE_INST_NAME_COL_NO = 5
# 領域コードの列No # # 領域コードの列No
CSV_CHANGE_TA_CD_COL_NO = 6 # CSV_CHANGE_TA_CD_COL_NO = 6
# 説明の列No # # 説明の列No
CSV_CHANGE_EXPLAIN_COL_NO = 7 # CSV_CHANGE_EXPLAIN_COL_NO = 7
# 担当者種別コード # # 担当者種別コード
CSV_CHANGE_EMP_CHG_TYPE_CD_COL_NO = 8 # CSV_CHANGE_EMP_CHG_TYPE_CD_COL_NO = 8
# MUIDの列No # # MUIDの列No
CSV_CHANGE_EMP_CD_COL_NO = 9 # CSV_CHANGE_EMP_CD_COL_NO = 9
# 担当者名の列No # # 担当者名の列No
CSV_CHANGE_EMP_FULL_NAME_COL_NO = 10 # CSV_CHANGE_EMP_FULL_NAME_COL_NO = 10
# 施設担当_開始日の列No # # 施設担当_開始日の列No
CSV_CHANGE_INST_EMP_START_DATE_COL_NO = 11 # CSV_CHANGE_INST_EMP_START_DATE_COL_NO = 11
# 施設担当_終了日の列No # # 施設担当_終了日の列No
CSV_CHANGE_INST_EMP_END_DATE_COL_NO = 12 # CSV_CHANGE_INST_EMP_END_DATE_COL_NO = 12
# 終了日の変更の列No # # 終了日の変更の列No
CSV_CHANGE_CHANGE_END_DATE_COL_NO = 13 # CSV_CHANGE_CHANGE_END_DATE_COL_NO = 13
# コメントの列No # # コメントの列No
CSV_CHANGE_COMMENT = 14 # CSV_CHANGE_COMMENT = 14
# 削除予定
# CSVアップロードテーブル名(マスターメンテ) # CSVアップロードテーブル名(マスターメンテ)
CSV_REAL_TABLE_NAME = '本番テーブル' # CSV_REAL_TABLE_NAME = '本番テーブル'
CSV_CHANGE_TABLE_NAME = 'ダミーテーブル' # CSV_CHANGE_TABLE_NAME = 'ダミーテーブル'
MENTE_CSV_TEMPORARY_FILE_DIR_PATH = path.join(path.curdir, 'src', 'data') # MENTE_CSV_TEMPORARY_FILE_DIR_PATH = path.join(path.curdir, 'src', 'data')
MENTE_CSV_DOWNLOAD_EXTRACT_COLUMNS = [ # MENTE_CSV_DOWNLOAD_EXTRACT_COLUMNS = [
'inst_cd', # 'inst_cd',
'inst_name', # 'inst_name',
'ta_cd', # 'ta_cd',
'emp_chg_type_cd', # 'emp_chg_type_cd',
'emp_cd', # 'emp_cd',
'emp_name_full', # 'emp_name_full',
'bu_cd', # 'bu_cd',
'bu_name', # 'bu_name',
'start_date', # 'start_date',
'end_date', # 'end_date',
'creater', # 'creater',
'create_date', # 'create_date',
'updater', # 'updater',
'update_date' # 'update_date'
] # ]
MENTE_CSV_DOWNLOAD_HEADER = [ # MENTE_CSV_DOWNLOAD_HEADER = [
'施設コード', # '施設コード',
'施設名', # '施設名',
'領域コード', # '領域コード',
'担当者種別コード', # '担当者種別コード',
'MUID', # 'MUID',
'担当者名', # '担当者名',
'ビジネスユニットコード', # 'ビジネスユニットコード',
'ビジネスユニット名', # 'ビジネスユニット名',
'適用開始日', # '適用開始日',
'適用終了日', # '適用終了日',
'作成者', # '作成者',
'作成日', # '作成日',
'更新者', # '更新者',
'更新日' # '更新日'
] # ]
MENTE_CSV_DOWNLOAD_FILE_NAME = 'instEmpData.csv' # MENTE_CSV_DOWNLOAD_FILE_NAME = 'instEmpData.csv'
# CSVアップロードの制限サイズ＝20MB # CSVアップロードの制限サイズ＝20MB
MENTE_CSV_UPLOAD_MAX_FILE_SIZE_BYTE = 20971520 # MENTE_CSV_UPLOAD_MAX_FILE_SIZE_BYTE = 20971520
# 利用停止区分 # 利用停止区分
DISPLAY_USER_STOP_DIV = { DISPLAY_USER_STOP_DIV = {

2
ecs/jskult-webapp/src/system_var/environment.py
View File

@ -11,7 +11,7 @@ COGNITO_CLIENT_SECRET = os.environ['COGNITO_CLIENT_SECRET']
AWS_REGION = os.environ['AWS_REGION'] AWS_REGION = os.environ['AWS_REGION']
SESSION_TABLE_NAME = os.environ['SESSION_TABLE_NAME'] SESSION_TABLE_NAME = os.environ['SESSION_TABLE_NAME']
BIO_ACCESS_LOG_BUCKET = os.environ['BIO_ACCESS_LOG_BUCKET'] BIO_ACCESS_LOG_BUCKET = os.environ['BIO_ACCESS_LOG_BUCKET']
MASTER_MAINTENANCE_BUCKET = os.environ['MASTER_MAINTENANCE_BUCKET'] #　削除予定 MASTER_MAINTENANCE_BUCKET = os.environ['MASTER_MAINTENANCE_BUCKET']
DB_HOST = os.environ['DB_HOST'] DB_HOST = os.environ['DB_HOST']
DB_PORT = int(os.environ['DB_PORT']) DB_PORT = int(os.environ['DB_PORT'])

1
ecs/jskult-webapp/src/templates/instEmpCsvDL.html
View File

@ -1,3 +1,4 @@
<!-- ファイル削除予定 -->
<!DOCTYPE html> <!DOCTYPE html>
<html lang="ja"> <html lang="ja">
<head> <head>

3
ecs/jskult-webapp/src/templates/instEmpCsvUL.html
View File

@ -1,3 +1,4 @@
<!-- ファイル削除予定 -->
<!DOCTYPE html> <!DOCTYPE html>
<html lang="ja"> <html lang="ja">
<head> <head>
@ -210,4 +211,4 @@
{% include '_loading.html' %} {% include '_loading.html' %}
{% endwith %} {% endwith %}
</body> </body>
</html> </html>

1
ecs/jskult-webapp/src/templates/masterMainteMenu.html
View File

@ -1,3 +1,4 @@
<!-- ファイル削除予定 -->
<!DOCTYPE html> <!DOCTYPE html>
<html lang="ja"> <html lang="ja">
<head> <head>

5
ecs/jskult-webapp/src/templates/menu.html
View File

@ -23,7 +23,7 @@
<div class="notUseBioMsg">生物由来データ参照は <br> 日次バッチ処理中のため利用出来ません</div> <div class="notUseBioMsg">生物由来データ参照は <br> 日次バッチ処理中のため利用出来ません</div>
{% endif %} {% endif %}
{% endif %} {% endif %}
{% if menu.is_available_master_maintenance_menu() %} <!--　TODO 削除予定 {% if menu.is_available_master_maintenance_menu() %}
{% if menu.is_batch_processing() %} {% if menu.is_batch_processing() %}
<div class="notUseMainteMsg"> マスターメンテメニューは <br> 日次バッチ処理中のため利用出来ません </div> <div class="notUseMainteMsg"> マスターメンテメニューは <br> 日次バッチ処理中のため利用出来ません </div>
{% elif menu.is_backup_processing() %} {% elif menu.is_backup_processing() %}
@ -31,7 +31,8 @@
{% else %} {% else %}
<a href="javascript:void(0);" onclick="transitionTo('/masterMainte/masterMainteMenu')" class="btn btn-primary btn-lg btn_width">マスターメンテメニュー</a><br><br> <a href="javascript:void(0);" onclick="transitionTo('/masterMainte/masterMainteMenu')" class="btn btn-primary btn-lg btn_width">マスターメンテメニュー</a><br><br>
{% endif %} {% endif %}
{% endif %} {% endif %} -->
<br><br><a href="javascript:void(0);" onclick="transitionTo('/logout/?reason=do_logout')" class="btn btn-info btn-lg btn_width">Logout</a> <br><br><a href="javascript:void(0);" onclick="transitionTo('/logout/?reason=do_logout')" class="btn btn-info btn-lg btn_width">Logout</a>
</div> </div>
<!-- ローディング --> <!-- ローディング -->

3
ecs/jskult-webapp/src/templates/tableOverride.html
View File

@ -1,3 +1,4 @@
<!-- ファイル削除予定 -->
<!DOCTYPE html> <!DOCTYPE html>
<html lang="ja"> <html lang="ja">
<head> <head>
@ -62,4 +63,4 @@
{% include '_loading.html' %} {% include '_loading.html' %}
{% endwith %} {% endwith %}
</body> </body>
</html> </html>