def test_gyomu_app_load(self, environment_setup):
app = GyomuAppsInfoCdtbl()
app.application_id = TEST_APPLICATION_ID2
app.description = "Test Application"
user: User = UserFactory.get_current_user()
app.mail_from_name = user.userid
app.mail_from_address = "*****@*****.**"
json_data = gyomuapps_schema_load.dumps(app)
dictionary = gyomuapps_schema.loads(json_data=json_data)
with DbConnectionFactory.get_gyomu_db_session() as session:
app_loaded = gyomuapps_schema_load.load(dictionary,
session=session)
assert app.application_id == app_loaded.application_id
app2 = GyomuAppsInfoCdtbl()
app2.application_id = TEST_APPLICAIONT_ID3
app2.description = "Testw Application"
user: User = UserFactory.get_current_user()
app2.mail_from_name = user.userid
app2.mail_from_address = "*****@*****.**"
app_list = [app, app2]
json_data = gyomuapps_total_list_schema.dumps(app_list)
dictionary = gyomuapps_total_list_schema.loads(json_data=json_data)
with DbConnectionFactory.get_gyomu_db_session() as session:
apps = gyomuapps_total_list_schema_load.load(dictionary,
session=session)
assert len(apps) == 2
def status_handler_setup(application_info_setup):
with DbConnectionFactory.get_gyomu_db_session() as session:
app2 = session.query(GyomuStatusHandler).filter(
GyomuStatusHandler.application_id == TEST_APPLICATION_ID).first()
if app2 is not None:
session.delete(app2)
session.commit()
handler = GyomuStatusHandler()
handler.application_id = TEST_APPLICATION_ID
handler.recipient_address = '*****@*****.**'
handler.status_type = StatusCode.ERROR_DEVELOPER
handler.recipient_type = "TO"
handler.recipient_address = "*****@*****.**"
with DbConnectionFactory.get_gyomu_db_session() as session:
session.add(handler)
session.commit()
config: Configurator = ConfigurationFactory.get_instance()
config.set_application_id(TEST_APPLICATION_ID)
yield config
with DbConnectionFactory.get_gyomu_db_session() as session:
session.delete(handler)
session.commit()
def current_task_info(self) -> GyomuTaskInfoCdtbl:
if self.__current_task_info is None:
with DbConnectionFactory.get_gyomu_db_session() as session:
self.__current_task_info = session.query(GyomuTaskInfoCdtbl).filter(
GyomuTaskInfoCdtbl.application_id == self.application_id
and GyomuTaskInfoCdtbl.task_id == self.task_info_id).one()
return self.__current_task_info
def __load_task_data(self, upper_session=None):
if self.__task_data_loaded:
return
task_data: GyomuTaskData
if upper_session is not None:
session = upper_session
else:
session = DbConnectionFactory.get_gyomu_db_session()
if self._current_task is None:
task_data = session.get(GyomuTaskData, self.task_data_id)
self._current_task = task_data
self._task_data_parameter = self._current_task.parameter
self.__instances = session.query(GyomuTaskInstance). \
filter(GyomuTaskInstance.task_data_id == self._current_task.id).order_by(
GyomuTaskInstance.entry_date.desc()).all()
self._latest_instance = self.__instances[0]
self.__access_list = session.query(GyomuTaskInfoAccessList). \
filter(
GyomuTaskInfoAccessList.application_id == self.application_id
and GyomuTaskInfoAccessList.task_info_id == self.task_info_id).all()
if upper_session is None:
with session:
pass
self.__task_data_loaded = True
def _do_register(self):
application_information: GyomuAppsInfoCdtbl
status_record: GyomuStatusInfo = GyomuStatusInfo()
status_record.application_id = self._application_id
status_record.entry_author = self._config.username
status_record.status_type = self.status_type
status_record.error_id = self.code
status_record.instance_id = self._config.unique_instance_id_per_machine
status_record.hostname = self._config.machine_name
status_record.summary = self._custom_summary if self._custom_summary != "" else self._get_title(
)
status_record.description = self._custom_description if self._custom_summary != "" else self._get_description(
)
status_record.developer_info = self._get_developer_information()
try:
session = DbConnectionFactory.get_gyomu_db_session()
mail_handler_list: list[GyomuStatusHandler]
with session:
application_information = session.get(GyomuAppsInfoCdtbl,
self._application_id)
session.add(status_record)
mail_handler_list = session.query(GyomuStatusHandler).filter(
GyomuStatusHandler.application_id == self._application_id
and GyomuStatusHandler.status_type
== self.status_type).all()
session.commit()
self._gyomu_status_info_id = status_record.id
if application_information is not None and mail_handler_list is not None and len(
mail_handler_list) > 0:
to = [
m.recipient_address for m in mail_handler_list
if m.recipient_type == "TO"
]
# filter(lambda x: x.recipient_type=="TO", mail_handler_list).map(lambda m: m.recipient_address)
cc = [
m.recipient_address for m in mail_handler_list
if m.recipient_type == "CC"
]
# filter(lambda x: x.recipient_type=="CC", mail_handler_list).map(lambda m: m.recipient_address)
subject: str = application_information.description + " " + self._get_title(
)
subject = subject.replace('\r', ' ').replace('\n', ' ')
body = self._get_mail_body()
EmailBuilder.send_html_message(
from_address=application_information.mail_from_address,
to_address=to,
cc_address=cc,
subject=subject,
body=body)
except:
pass
finally:
self._registered_event.set()
def __load_parameter(cls,
key: str,
session: Session = None) -> list[GyomuParamMaster]:
if session is None:
session = DbConnectionFactory.get_gyomu_db_session()
with session:
return session.query(GyomuParamMaster).filter(
GyomuParamMaster.item_key == key).all()
def exists(milestone_id: str,
target_date: date,
is_monthly: bool = False) -> bool:
target_date_yyyymmdd = MilestoneAccess.__get_target_date(
target_date, is_monthly)
with DbConnectionFactory.get_gyomu_db_session() as session:
return session.query(
exists().where(GyomuMilestoneDaily.milestone_id == milestone_id
and GyomuMilestoneDaily.target_date
== target_date_yyyymmdd)).scalar()
def __init(self, parameter: str, comment: str) -> StatusCode:
result: StatusCode
try:
result = self.__check_status_and_owner(self.STATUS_INIT)
if not result.is_success:
return result
self._task_data_parameter = parameter
if self.task_data_id != -1:
return StatusCode(CommonStatusCode.TASK_ALREADY_GENERATED,
arguments=[self.application_id, self.task_info_id, self._task_data_parameter,
self.task_data_id],
config=self.config, target_application_id=self.application_id)
try:
with DbConnectionFactory.get_gyomu_db_session() as session:
task_data = GyomuTaskData()
task_data.application_id = self.application_id
task_data.task_info_id = self.task_info_id
task_data.entry_author = self.config.username
task_data.parameter = parameter
session.add(task_data)
session.flush()
task_instance = GyomuTaskInstance()
task_instance.task_data_id = task_data.id
task_instance.entry_date = task_data.entry_date
task_instance.entry_author = task_data.entry_author
task_instance.task_status = "INIT"
task_instance.is_done = False
task_instance.parameter = parameter
task_instance.comment = comment
session.add(task_instance)
session.flush()
task_status = GyomuTaskDataStatus()
task_status.task_data_id = task_data.id
task_status.latest_task_instance_id = task_instance.id
task_status.latest_update_date = task_instance.entry_date
task_status.task_status = task_instance.task_status
session.add(task_status)
session.commit()
self._current_task = task_data
self._task_data_id = task_data.id
self._latest_instance = task_instance
self.__instances = [task_instance]
self._latest_instance_id = task_instance.id
except Exception as ex:
return StatusCode(CommonStatusCode.TASK_GENERATE_ERROR,
arguments=[self.application_id, self.task_info_id, parameter],
config=self.config, target_application_id=self.application_id,
exception=ex)
except Exception as ex:
return StatusCode(CommonStatusCode.TASK_LIBRARY_INTERNAL_ERROR,
arguments=[self.application_id, self.task_info_id, parameter, self.task_data_id],
config=self.config, target_application_id=self.application_id,
exception=ex)
return result
def update(app: GyomuAppsInfoCdtbl,
original_application_id=-1) -> StatusCode.SUCCEED_STATUS:
with DbConnectionFactory.get_gyomu_db_session() as session:
application_id = app.application_id if original_application_id == -1 else original_application_id
current_app: GyomuAppsInfoCdtbl = session.query(
GyomuAppsInfoCdtbl).get(application_id)
if original_application_id != -1:
current_app.application_id = app.application_id
current_app.description = app.description
current_app.mail_from_name = app.mail_from_name
current_app.mail_from_address = app.mail_from_address
session.commit()
return StatusCode.SUCCEED_STATUS
def unregister(milestone_id: str,
target_date: date,
is_monthly: bool = False):
target_date_yyyymmdd = MilestoneAccess.__get_target_date(
target_date, is_monthly)
record: GyomuMilestoneDaily
with DbConnectionFactory.get_gyomu_db_session() as session:
record = session.query(GyomuMilestoneDaily).\
filter(GyomuMilestoneDaily.milestone_id == milestone_id
and GyomuMilestoneDaily.target_date == target_date_yyyymmdd).first()
if record is not None:
session.delete(record)
session.commit()
def register(milestone_id: str,
target_date: date,
is_monthly: bool = False):
if MilestoneAccess.exists(milestone_id, target_date, is_monthly):
return
target_date_yyyymmdd = MilestoneAccess.__get_target_date(
target_date, is_monthly)
with DbConnectionFactory.get_gyomu_db_session() as session:
milestone = GyomuMilestoneDaily()
milestone.milestone_id = milestone_id
milestone.target_date = target_date_yyyymmdd
session.add(milestone)
session.commit()
def exception_task_info_cdtbl_setup(application_info_setup):
task_info = GyomuTaskInfoCdtbl()
task_info.application_id = application_info_setup
task_info.task_id = 3
task_info.assembly_name = 'tests.test_tasksample'
task_info.class_name = 'SimpleExceptionTask'
task_info.description = 'Simple Exception Task Test'
task_info.restartable = False
with DbConnectionFactory.get_gyomu_db_session() as session:
existing_record = session.query(GyomuTaskInfoCdtbl).filter(
GyomuTaskInfoCdtbl.application_id == task_info.application_id
and GyomuTaskInfoCdtbl.task_id == task_info.task_id).first()
if existing_record is None:
session.add(task_info)
session.commit()
existing_record = task_info
yield existing_record
with DbConnectionFactory.get_gyomu_db_session() as session:
session.delete(existing_record)
session.commit()
def application_info_setup(environment_setup):
with DbConnectionFactory.get_gyomu_db_session() as session:
app2 = session.query(GyomuAppsInfoCdtbl).get(TEST_APPLICATION_ID)
if app2 is not None:
session.delete(app2)
session.commit()
app = GyomuAppsInfoCdtbl()
app.application_id = TEST_APPLICATION_ID
app.description = "Test Application"
user: User = UserFactory.get_current_user()
app.mail_from_name = user.userid
app.mail_from_address = "*****@*****.**"
with DbConnectionFactory.get_gyomu_db_session() as session:
session.add(app)
session.commit()
yield TEST_APPLICATION_ID
with DbConnectionFactory.get_gyomu_db_session() as session:
session.delete(app)
session.commit()
def __create_new_instance(self, parameter: str, status: str, submit_to: list[User] = None,
status_code: StatusCode = None, comment: str = '') -> StatusCode:
try:
new_instance = GyomuTaskInstance()
with DbConnectionFactory.get_gyomu_db_session() as session:
new_instance.task_data_id = self._current_task.id
new_instance.is_done = status in [self.STATUS_COMPLETE, self.STATUS_FAIL, self.STATUS_CANCEL]
# new_instance.entry_date = self._current_task.entry_date
new_instance.entry_author = self.config.username
new_instance.task_status = status
new_instance.parameter = parameter
new_instance.comment = comment
new_instance.status_info_id = None if status_code is None else status_code.get_status_id()
session.add(new_instance)
session.flush()
task_status = session.get(GyomuTaskDataStatus, self._current_task.id)
if task_status is None:
task_status = GyomuTaskDataStatus()
task_status.task_data_id = self._current_task.id
task_status.latest_task_instance_id = new_instance.id
task_status.latest_update_date = new_instance.entry_date
task_status.task_status = new_instance.task_status
session.add(task_status)
else:
task_status.latest_task_instance_id = new_instance.id
task_status.latest_update_date = new_instance.entry_date
task_status.task_status = new_instance.task_status
if submit_to is not None and len(submit_to) > 0:
for user in submit_to:
if user.is_valid:
submit_information = GyomuTaskInstanceSubmitInformation()
submit_information.task_instance_id = self.latest_instance_id
submit_information.submit_to = user.userid
session.add(submit_information)
session.commit()
self._latest_instance = new_instance
self._latest_instance_id = new_instance.id
self.__instances.append(new_instance)
return StatusCode.SUCCEED_STATUS
except Exception as ex:
return StatusCode(CommonStatusCode.TASK_INSTANCE_GENERATE_ERROR,
arguments=[self.application_id, self.task_info_id, self.task_data_id, parameter],
config=self.config, target_application_id=self.application_id,
exception=ex)
def __init_data(self):
with MarketDateAccess.__lock:
if self.__market in MarketDateAccess.__load_market_holidays():
self.__holidays = MarketDateAccess.__load_market_holidays()[
self.__market]
return
self.__holidays = list()
with DbConnectionFactory.get_gyomu_db_session() as session:
holiday_row: GyomuMarketHoliday
for holiday_row in session.query(GyomuMarketHoliday).filter(
GyomuMarketHoliday.market == self.__market).all():
self.__holidays.append(
datetime.strptime(holiday_row.holiday,
'%Y%m%d').date())
MarketDateAccess.__market_holidays[self.__market] = self.__holidays
def __set_string_value(cls, key: str, string_value: str, user: User = None):
key = cls.__get_key(key, user)
target_object: GyomuParamMaster
with DbConnectionFactory.get_gyomu_db_session() as session:
if cls.__key_exists(key, session):
target_object = session.query(GyomuParamMaster).filter(GyomuParamMaster.item_key == key).first()
if string_value == "":
if target_object is not None:
session.delete(target_object)
else:
target_object.item_value = string_value
elif string_value != "":
target_object = GyomuParamMaster()
target_object.item_key = key
target_object.item_value = string_value
target_object.item_fromdate = ""
session.add(target_object)
session.commit()
def create_new_task(
application_id: int,
task_id: int,
config: Configurator = None) -> (AbstractBaseTask, StatusCode):
task_info: GyomuTaskInfoCdtbl
try:
if config is None:
config = gyomu.configurator.ConfigurationFactory.get_instance()
with DbConnectionFactory.get_gyomu_db_session() as session:
task_info = session.query(GyomuTaskInfoCdtbl).filter(
GyomuTaskInfoCdtbl.application_id == application_id
and GyomuTaskInfoCdtbl.task_id == task_id).one()
except NoResultFound:
return None, StatusCode(
error_id=CommonStatusCode.TASK_NOT_REGISTERED,
arguments=[application_id, task_id],
config=config,
target_application_id=application_id)
if task_info is not None:
return TaskAccess.__create_new_task(task_info, config)
def __lock_instance_and_refresh_task_data(self):
with DbConnectionFactory.get_gyomu_db_session() as session:
task_data = session.query(GyomuTaskData).filter(
GyomuTaskData.id == self.task_data_id).with_for_update().one()
self.__load_task_data(session)
def get_all() -> (list[GyomuAppsInfoCdtbl], StatusCode):
with DbConnectionFactory.get_gyomu_db_session() as session:
return session.query(
GyomuAppsInfoCdtbl).all(), StatusCode.SUCCEED_STATUS
def get(application_id: int) -> (GyomuAppsInfoCdtbl, StatusCode):
with DbConnectionFactory.get_gyomu_db_session() as session:
return session.query(GyomuAppsInfoCdtbl).get(
application_id), StatusCode.SUCCEED_STATUS
def __get_supported_market() -> [str]:
with DbConnectionFactory.get_gyomu_db_session() as session:
return session.query(GyomuMarketHoliday).distinct(GyomuMarketHoliday.market).all()
def add(app: GyomuAppsInfoCdtbl) -> StatusCode:
with DbConnectionFactory.get_gyomu_db_session() as session:
session.add(app)
session.commit()
return StatusCode.SUCCEED_STATUS
def test_invalid_environment():
with pytest.raises(InvalidEnvironmentSetupError) as ie:
session = DbConnectionFactory.get_gyomu_db_session()
print(ie.__str__())
def test_invalid_connection():
os.environ[GYOMU_COMMON_MAINDB_CONNECTION] = 'aaab'
with pytest.raises(InvalidEnvironmentSetupError) as ie:
session = DbConnectionFactory.get_gyomu_db_session()
print(ie.__str__())
def delete(app: GyomuAppsInfoCdtbl) -> StatusCode.SUCCEED_STATUS:
with DbConnectionFactory.get_gyomu_db_session() as session:
app = session.query(GyomuAppsInfoCdtbl).get(app.application_id)
session.delete(app)
session.commit()
return StatusCode.SUCCEED_STATUS
def __get_task_submission_information_list(self, latest_instance: GyomuTaskInstance) \
-> list[GyomuTaskInstanceSubmitInformation]:
with DbConnectionFactory.get_gyomu_db_session() as session:
return session.query(GyomuTaskInstanceSubmitInformation).filter(
GyomuTaskInstanceSubmitInformation.task_instance_id == latest_instance.id).all()