watchmen-collector-kernel 16.4.6__py3-none-any.whl → 16.4.8__py3-none-any.whl

watchmen_collector_kernel/storage/collector_model_config_service.py

@@ -0,0 +1,107 @@
+from typing import Optional, List
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.model import CollectorModelConfig
+from watchmen_meta.common import TupleService, TupleShaper
+from watchmen_meta.common.storage_service import StorableId
+from watchmen_model.common import Storable, TenantId, CollectorModelConfigId
+from watchmen_storage import EntityName, EntityRow, EntityShaper, TransactionalStorageSPI, SnowflakeGenerator, \
+	EntityCriteriaExpression, ColumnNameLiteral
+
+
+class CollectorModelConfigShaper(EntityShaper):
+	def serialize(self, config: CollectorModelConfig) -> EntityRow:
+		return TupleShaper.serialize_tenant_based(config, {
+			'model_id': config.modelId,
+			'model_name': config.modelName,
+			'depend_on': config.dependOn,
+			'raw_topic_code': config.rawTopicCode,
+			'is_paralleled': config.isParalleled
+		})
+
+	def deserialize(self, row: EntityRow) -> CollectorModelConfig:
+		# noinspection PyTypeChecker
+		return TupleShaper.deserialize_tenant_based(row, CollectorModelConfig(
+			modelId=row.get('model_id'),
+			modelName=row.get('model_name'),
+			dependOn=row.get('depend_on'),
+			rawTopicCode=row.get('raw_topic_code'),
+			isParalleled=row.get('is_paralleled')
+		))
+
+
+COLLECTOR_MODEL_CONFIG_ENTITY_NAME = 'collector_model_config'
+COLLECTOR_MODEL_CONFIG_ENTITY_SHAPER = CollectorModelConfigShaper()
+
+
+class CollectorModelConfigService(TupleService):
+	def should_record_operation(self) -> bool:
+		return False
+
+	def get_entity_name(self) -> EntityName:
+		return COLLECTOR_MODEL_CONFIG_ENTITY_NAME
+
+	def get_entity_shaper(self) -> EntityShaper:
+		return COLLECTOR_MODEL_CONFIG_ENTITY_SHAPER
+
+	# noinspection SpellCheckingInspection
+	def get_storable_id_column_name(self) -> EntityName:
+		return "model_id"
+
+	def get_storable_id(self, storable: CollectorModelConfig) -> StorableId:
+		return storable.modelId
+
+	# noinspection SpellCheckingInspection
+	def set_storable_id(self, storable: CollectorModelConfig, storable_id: CollectorModelConfigId) -> Storable:
+		storable.modelId = storable_id
+		return storable
+
+	def create_model_config(self, model_config: CollectorModelConfig) -> CollectorModelConfig:
+		try:
+			self.storage.connect()
+			# noinspection PyTypeChecker
+			return self.create(model_config)
+		finally:
+			self.storage.close()
+
+	def update_model_config(self, model_config: CollectorModelConfig) -> CollectorModelConfig:
+		try:
+			self.storage.connect()
+			# noinspection PyTypeChecker
+			return self.update(model_config)
+		finally:
+			self.storage.close()
+
+	def find_by_model_id(self, model_id: str) -> Optional[CollectorModelConfig]:
+		self.begin_transaction()
+		try:
+			return self.storage.find_one(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='model_id'), right=model_id)]
+			))
+		finally:
+			self.close_transaction()
+
+	def find_by_tenant(self, tenant_id: TenantId) -> Optional[List[CollectorModelConfig]]:
+		# noinspection PyTypeChecker
+		return self.storage.find(self.get_entity_finder(
+			criteria=[
+				EntityCriteriaExpression(left=ColumnNameLiteral(columnName='tenant_id'), right=tenant_id)]
+		))
+
+	def find_by_name(self, model_name: str) -> Optional[CollectorModelConfig]:
+		self.begin_transaction()
+		try:
+			return self.storage.find_one(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='model_name'), right=model_name)]
+			))
+		finally:
+			self.close_transaction()
+
+
+def get_collector_model_config_service(storage: TransactionalStorageSPI,
+                                       snowflake_generator: SnowflakeGenerator,
+                                       principal_service: PrincipalService
+                                       ) -> CollectorModelConfigService:
+	return CollectorModelConfigService(storage, snowflake_generator, principal_service)

watchmen_collector_kernel/storage/collector_table_config_service.py

@@ -0,0 +1,168 @@
+from typing import Optional, List
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.model import CollectorTableConfig
+from watchmen_meta.common import TupleService, TupleShaper
+from watchmen_meta.common.storage_service import StorableId
+from watchmen_model.common import Storable
+from watchmen_storage import EntityName, EntityRow, EntityShaper, TransactionalStorageSPI, SnowflakeGenerator, \
+	EntityCriteriaExpression, ColumnNameLiteral
+from watchmen_utilities import ArrayHelper
+
+
+class CollectorTableConfigShaper(EntityShaper):
+	def serialize(self, config: CollectorTableConfig) -> EntityRow:
+		return TupleShaper.serialize_tenant_based(config, {
+			'config_id': config.configId,
+			'name': config.name,
+			'table_name': config.tableName,
+			'primary_key': config.primaryKey,
+			'object_key': config.objectKey,
+			'model_name': config.modelName,
+			'parent_name': config.parentName,
+			'join_keys': ArrayHelper(config.joinKeys).map(lambda x: x.to_dict()).to_list(),
+			'depend_on': ArrayHelper(config.dependOn).map(lambda x: x.to_dict()).to_list(),
+			'conditions': ArrayHelper(config.conditions).map(lambda x: x.to_dict()).to_list(),
+			'label': config.label,
+			'audit_column': config.auditColumn,
+			'data_source_id': config.dataSourceId,
+			'is_list': config.isList,
+			'triggered': config.triggered
+		})
+
+	def deserialize(self, row: EntityRow) -> CollectorTableConfig:
+		# noinspection PyTypeChecker
+		return TupleShaper.deserialize_tenant_based(row, CollectorTableConfig(
+			configId=row.get('config_id'),
+			name=row.get('name'),
+			tableName=row.get('table_name'),
+			primaryKey=row.get('primary_key'),
+			objectKey=row.get('object_key'),
+			modelName=row.get('model_name'),
+			parentName=row.get('parent_name'),
+			joinKeys=row.get('join_keys'),
+			dependOn=row.get('depend_on'),
+			conditions=row.get('conditions'),
+			label=row.get('label'),
+			auditColumn=row.get('audit_column'),
+			dataSourceId=row.get('data_source_id'),
+			isList=row.get('is_list'),
+			triggered=row.get('triggered')
+		))
+
+
+COLLECTOR_TABLE_CONFIG_ENTITY_NAME = 'collector_table_config'
+COLLECTOR_TABLE_CONFIG_ENTITY_SHAPER = CollectorTableConfigShaper()
+
+
+class CollectorTableConfigService(TupleService):
+	def should_record_operation(self) -> bool:
+		return False
+
+	def get_entity_name(self) -> EntityName:
+		return COLLECTOR_TABLE_CONFIG_ENTITY_NAME
+
+	def get_entity_shaper(self) -> EntityShaper:
+		return COLLECTOR_TABLE_CONFIG_ENTITY_SHAPER
+
+	# noinspection SpellCheckingInspection
+	def get_storable_id_column_name(self) -> EntityName:
+		return "config_id"
+
+	def get_storable_id(self, storable: CollectorTableConfig) -> StorableId:
+		return storable.configId
+
+	# noinspection SpellCheckingInspection
+	def set_storable_id(self, storable: CollectorTableConfig, storable_id: StorableId) -> Storable:
+		storable.configId = storable_id
+		return storable
+
+	# noinspection PyTypeChecker
+	def create_config(self, config: CollectorTableConfig) -> CollectorTableConfig:
+		self.begin_transaction()
+		try:
+			config = self.create(config)
+			self.commit_transaction()
+			return config
+		except Exception as e:
+			self.rollback_transaction()
+			raise e
+
+	# noinspection PyTypeChecker
+	def update_config(self, config: CollectorTableConfig) -> CollectorTableConfig:
+		self.begin_transaction()
+		try:
+			config = self.update(config)
+			self.commit_transaction()
+			return config
+		except Exception as e:
+			self.rollback_transaction()
+			raise e
+
+	def find_config_by_id(self, config_id: str) -> Optional[CollectorTableConfig]:
+		self.begin_transaction()
+		try:
+			return self.find_by_id(config_id)
+		finally:
+			self.close_transaction()
+
+	def find_by_table_name(self, table_name: str) -> Optional[CollectorTableConfig]:
+		try:
+			self.storage.connect()
+			# noinspection PyTypeChecker
+			return self.storage.find_one(
+				self.get_entity_finder(
+					criteria=[
+						EntityCriteriaExpression(left=ColumnNameLiteral(columnName='table_name'),
+						                         right=table_name)
+					]
+				)
+			)
+		finally:
+			self.storage.close()
+
+	def find_by_name(self, name: str) -> Optional[CollectorTableConfig]:
+		try:
+			self.storage.connect()
+			# noinspection PyTypeChecker
+			return self.storage.find_one(
+				self.get_entity_finder(
+					criteria=[
+						EntityCriteriaExpression(left=ColumnNameLiteral(columnName='name'),
+						                         right=name)
+					]
+				)
+			)
+		finally:
+			self.storage.close()
+
+	def find_by_parent_name(self, parent_name: str) -> Optional[List[CollectorTableConfig]]:
+		try:
+			self.storage.connect()
+			# noinspection PyTypeChecker
+			return self.storage.find(
+				self.get_entity_finder(
+					criteria=[
+						EntityCriteriaExpression(left=ColumnNameLiteral(columnName='parent_name'),
+						                         right=parent_name)
+					]
+				)
+			)
+		finally:
+			self.storage.close()
+
+	def find_by_model_name(self,
+	                       model_name: str) -> Optional[List[CollectorTableConfig]]:
+		# noinspection PyTypeChecker
+		return self.storage.find(self.get_entity_finder(
+			criteria=[
+				EntityCriteriaExpression(left=ColumnNameLiteral(columnName='tenant_id'), right=self.principalService.get_tenant_id()),
+				EntityCriteriaExpression(left=ColumnNameLiteral(columnName='model_name'), right=model_name)]
+		))
+
+
+def get_collector_table_config_service(storage: TransactionalStorageSPI,
+                                       snowflake_generator: SnowflakeGenerator,
+                                       principal_service: PrincipalService
+                                       ) -> CollectorTableConfigService:
+	return CollectorTableConfigService(storage, snowflake_generator, principal_service)

watchmen_collector_kernel/storage/competitive_lock_service.py

@@ -0,0 +1,83 @@
+from datetime import datetime
+from typing import List
+
+from watchmen_collector_kernel.model import CompetitiveLock
+from watchmen_meta.common import ask_meta_storage, EntityService
+from watchmen_meta.common.storage_service import StorableId
+from watchmen_model.common import CompetitiveLockId, Storable
+from watchmen_storage import ColumnNameLiteral, Entity, EntityCriteriaExpression, EntityCriteriaOperator, \
+	EntityName, EntityRow, EntityShaper, TransactionalStorageSPI
+
+
+class CompetitiveLockShaper(EntityShaper):
+	def serialize(self, entity: CompetitiveLock) -> EntityRow:
+		return {
+			'lock_id': entity.lockId,
+			'resource_id': entity.resourceId,
+			'registered_at': entity.registeredAt,
+			'tenant_id': entity.tenantId
+		}
+
+	def deserialize(self, row: EntityRow) -> CompetitiveLock:
+		return CompetitiveLock(
+			lockId=row.get('lock_id'),
+			resourceId=row.get('resource_id'),
+			registeredAt=row.get('registered_at'),
+			tenantId=row.get('tenant_id')
+		)
+
+
+COMPETITIVE_LOCK_TABLE = 'competitive_lock'
+COMPETITIVE_LOCK_ENTITY_SHAPER = CompetitiveLockShaper()
+
+
+class CompetitiveLockService(EntityService):
+
+	def __init__(self, storage: TransactionalStorageSPI):
+		super().__init__(storage)
+
+	def get_entity_name(self) -> EntityName:
+		return COMPETITIVE_LOCK_TABLE
+
+	def get_entity_shaper(self) -> EntityShaper:
+		return COMPETITIVE_LOCK_ENTITY_SHAPER
+
+	def get_storable_id_column_name(self) -> EntityName:
+		return 'lock_id'
+
+	def get_storable_id(self, storable: CompetitiveLock) -> StorableId:
+		return storable.lockId
+
+	def set_storable_id(
+			self, storable: CompetitiveLock, storable_id: CompetitiveLockId) -> Storable:
+		storable.lockId = storable_id
+		return storable
+
+	def insert_one(self, lock: CompetitiveLock):
+		try:
+			self.storage.connect()
+			self.storage.insert_one(lock, self.get_entity_helper())
+		finally:
+			self.storage.close()
+
+	def delete_by_id(self, lock_id: CompetitiveLockId):
+		try:
+			self.storage.connect()
+			self.storage.delete_by_id(lock_id, self.get_entity_id_helper())
+		finally:
+			self.storage.close()
+
+	def find_overtime_lock(self, query_time: datetime) -> List:
+		try:
+			self.storage.connect()
+			return self.storage.find(self.get_entity_finder(criteria=[
+				EntityCriteriaExpression(
+					left=ColumnNameLiteral(columnName='registered_at'),
+					operator=EntityCriteriaOperator.LESS_THAN, right=query_time)
+			]))
+		finally:
+			self.storage.close()
+
+
+def get_competitive_lock_service(storage: TransactionalStorageSPI) -> CompetitiveLockService:
+	return CompetitiveLockService(storage)

watchmen_collector_kernel/storage/scheduled_task_service.py

@@ -0,0 +1,155 @@
+from typing import Optional, List, Any, Dict
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.model import ScheduledTask
+from watchmen_meta.common import TupleService, TupleShaper
+from watchmen_meta.common.storage_service import StorableId
+from watchmen_model.common import Storable, ScheduledTaskId
+from watchmen_storage import EntityName, EntityRow, EntityShaper, TransactionalStorageSPI, \
+	EntityCriteriaExpression, ColumnNameLiteral, SnowflakeGenerator, EntitySortColumn, EntitySortMethod, \
+	EntityCriteriaJoint, EntityCriteriaJointConjunction, EntityStraightValuesFinder, EntityStraightColumn, \
+	EntityCriteriaOperator
+
+
+class ScheduledTaskShaper(EntityShaper):
+	def serialize(self, entity: ScheduledTask) -> EntityRow:
+		return TupleShaper.serialize_tenant_based(entity, {
+			'task_id': entity.taskId,
+			'resource_id': entity.resourceId,
+			'topic_code': entity.topicCode,
+			'content': entity.content,
+			'model_name': entity.modelName,
+			'object_id': entity.objectId,
+			'depend_on': entity.dependOn,
+			'parent_task_id': entity.parentTaskId,
+			'tenant_id': entity.tenantId,
+			'status': entity.status,
+			'result': entity.result
+		})
+
+	def deserialize(self, row: EntityRow) -> ScheduledTask:
+		# noinspection PyTypeChecker
+		return TupleShaper.deserialize_tenant_based(row, ScheduledTask(
+			taskId=row.get('task_id'),
+			resourceId=row.get('resource_id'),
+			topicCode=row.get('topic_code'),
+			content=row.get('content'),
+			modelName=row.get('model_name'),
+			objectId=row.get('object_id'),
+			dependOn=row.get('depend_on'),
+			parentTaskId=row.get('parent_task_id'),
+			tenantId=row.get('tenant_id'),
+			status=row.get('status'),
+			result=row.get('result')
+		))
+
+
+SCHEDULED_TASK_TABLE = 'scheduled_task'
+SCHEDULED_TASK_ENTITY_SHAPER = ScheduledTaskShaper()
+
+
+class ScheduledTaskService(TupleService):
+
+	def should_record_operation(self) -> bool:
+		return False
+
+	def get_entity_name(self) -> EntityName:
+		return SCHEDULED_TASK_TABLE
+
+	def get_entity_shaper(self) -> EntityShaper:
+		return SCHEDULED_TASK_ENTITY_SHAPER
+
+	def get_storable_id_column_name(self) -> EntityName:
+		return 'task_id'
+
+	def get_storable_id(self, storable: ScheduledTask) -> StorableId:
+		return storable.taskId
+
+	def set_storable_id(
+			self, storable: ScheduledTask, storable_id: ScheduledTaskId) -> Storable:
+		storable.taskId = storable_id
+		return storable
+
+	def create_task(self, task: ScheduledTask) -> ScheduledTask:
+		self.begin_transaction()
+		try:
+			task = self.create(task)
+			self.commit_transaction()
+			# noinspection PyTypeChecker
+			return task
+		except Exception as e:
+			self.rollback_transaction()
+			raise e
+
+	def update_task(self, task: ScheduledTask) -> ScheduledTask:
+		self.begin_transaction()
+		try:
+			task = self.update(task)
+			self.commit_transaction()
+			# noinspection PyTypeChecker
+			return task
+		except Exception as e:
+			self.rollback_transaction()
+			raise e
+
+	def find_task_by_id(self, task_id: ScheduledTaskId) -> Optional[ScheduledTask]:
+		self.begin_transaction()
+		try:
+			return self.find_by_id(task_id)
+		finally:
+			self.close_transaction()
+
+	def find_unfinished_tasks(self) -> List[Dict[str, Any]]:
+		self.begin_transaction()
+		try:
+			return self.storage.find_straight_values(EntityStraightValuesFinder(
+				name=self.get_entity_name(),
+				criteria=[EntityCriteriaJoint(
+					children=[
+						EntityCriteriaExpression(
+							left=ColumnNameLiteral(columnName='status'), right=0)
+					]
+				)],
+				straightColumns=[EntityStraightColumn(columnName='task_id'),
+				                 EntityStraightColumn(columnName='resource_id'),
+				                 EntityStraightColumn(columnName='tenant_id')],
+				sort=[EntitySortColumn(name='resource_id', method=EntitySortMethod.ASC)]
+			))
+		finally:
+			self.close_transaction()
+
+	def find_by_resource_id(self, resource_id: str) -> List[Dict[str, Any]]:
+		self.begin_transaction()
+		try:
+			return self.storage.find_straight_values(EntityStraightValuesFinder(
+				name=self.get_entity_name(),
+				criteria=[EntityCriteriaExpression(left=ColumnNameLiteral(columnName='resource_id'), right=resource_id)],
+				straightColumns=['task_id', 'resource_id', 'tenant_id']
+			))
+		finally:
+			self.close_transaction()
+
+	def is_dependent_task_finished(self, model_name: str, object_id: str, tenant_id: str) -> bool:
+		self.begin_transaction()
+		try:
+			# noinspection PyTypeChecker
+			return self.storage.count(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='model_name'),
+					                         right=model_name),
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='object_id'),
+					                         right=object_id),
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='status'),
+					                         right=0),
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='tenant_id'),
+					                         right=tenant_id)
+				]
+			)) == 0
+		finally:
+			self.close_transaction()
+
+def get_scheduled_task_service(storage: TransactionalStorageSPI,
+                               snowflake_generator: SnowflakeGenerator,
+                               principal_service: PrincipalService
+                               ) -> ScheduledTaskService:
+	return ScheduledTaskService(storage, snowflake_generator, principal_service)

watchmen_collector_kernel/storage/trigger_event_service.py

@@ -0,0 +1,86 @@
+from typing import List, Dict, Any
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.model import TriggerEvent
+from watchmen_meta.common import TupleShaper, TupleService
+from watchmen_meta.common.storage_service import StorableId
+from watchmen_model.common import Storable, EventTriggerId
+from watchmen_storage import EntityName, EntityRow, EntityShaper, TransactionalStorageSPI, SnowflakeGenerator, \
+	EntityStraightValuesFinder, EntityCriteriaExpression, ColumnNameLiteral, \
+	EntityStraightColumn, EntitySortColumn, EntitySortMethod
+
+
+class TriggerEventShaper(EntityShaper):
+
+	def serialize(self, entity: TriggerEvent) -> EntityRow:
+		return TupleShaper.serialize_tenant_based(entity, {
+			'event_trigger_id': entity.eventTriggerId,
+			'start_time': entity.startTime,
+			'end_time': entity.endTime,
+			'is_finished': entity.isFinished
+		})
+
+	def deserialize(self, row: EntityRow) -> TriggerEvent:
+		# noinspection PyTypeChecker
+		return TupleShaper.deserialize_tenant_based(row, TriggerEvent(
+			eventTriggerId=row.get('event_trigger_id'),
+			startTime=row.get('start_time'),
+			endTime=row.get('end_time'),
+			isFinished=row.get('is_finished')
+		))
+
+
+TRIGGER_EVENT_TABLE = 'trigger_event'
+TRIGGER_EVENT_ENTITY_SHAPER = TriggerEventShaper()
+
+
+class TriggerEventService(TupleService):
+
+	def should_record_operation(self) -> bool:
+		return False
+
+	def get_entity_name(self) -> EntityName:
+		return TRIGGER_EVENT_TABLE
+
+	def get_entity_shaper(self) -> EntityShaper:
+		return TRIGGER_EVENT_ENTITY_SHAPER
+
+	def get_storable_id_column_name(self) -> EntityName:
+		return 'event_trigger_id'
+
+	def get_storable_id(self, storable: TriggerEvent) -> StorableId:
+		# noinspection PyTypeChecker
+		return storable.eventTriggerId
+
+	def set_storable_id(
+			self, storable: TriggerEvent, storable_id: EventTriggerId) -> Storable:
+		storable.eventTriggerId = storable_id
+		return storable
+
+	def find_event_by_id(self, event_trigger_id: EventTriggerId) -> TriggerEvent:
+		try:
+			self.storage.connect()
+			# noinspection PyTypeChecker
+			return self.storage.find_by_id(event_trigger_id, self.get_entity_id_helper())
+		finally:
+			self.storage.close()
+
+	def find_unfinished_events(self) -> List[Dict[str, Any]]:
+		self.begin_transaction()
+		try:
+			return self.storage.find_straight_values(EntityStraightValuesFinder(
+				name=self.get_entity_name(),
+				criteria=[EntityCriteriaExpression(left=ColumnNameLiteral(columnName='is_finished'), right=False)],
+				straightColumns=[EntityStraightColumn(columnName=self.get_storable_id_column_name()),
+				                 EntityStraightColumn(columnName='tenant_id')],
+				sort=[EntitySortColumn(name=self.get_storable_id_column_name(), method=EntitySortMethod.ASC)]
+			))
+		finally:
+			self.close_transaction()
+
+
+def get_trigger_event_service(storage: TransactionalStorageSPI,
+                              snowflake_generator: SnowflakeGenerator,
+                              principal_service: PrincipalService
+                              ) -> TriggerEventService:
+	return TriggerEventService(storage, snowflake_generator, principal_service)

watchmen_collector_kernel/storage/trigger_model_service.py

@@ -0,0 +1,96 @@
+from typing import Optional, List
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.common import IS_FINISHED, TENANT_ID
+from watchmen_collector_kernel.model import TriggerModel
+from watchmen_meta.common import TupleShaper, TupleService
+from watchmen_meta.common.storage_service import StorableId
+from watchmen_model.common import Storable, ModelTriggerId
+from watchmen_storage import EntityName, EntityRow, EntityShaper, TransactionalStorageSPI, SnowflakeGenerator, \
+	EntityCriteriaExpression, ColumnNameLiteral
+
+
+class TriggerModelShaper(EntityShaper):
+
+	def serialize(self, entity: TriggerModel) -> EntityRow:
+		return TupleShaper.serialize_tenant_based(entity, {
+			'model_trigger_id': entity.modelTriggerId,
+			'model_name': entity.modelName,
+			'is_finished': entity.isFinished,
+			'event_trigger_id': entity.eventTriggerId
+		})
+
+	def deserialize(self, row: EntityRow) -> TriggerModel:
+		# noinspection PyTypeChecker
+		return TupleShaper.deserialize_tenant_based(row, TriggerModel(
+			modelTriggerId=row.get('model_trigger_id'),
+			modelName=row.get('model_name'),
+			isFinished=row.get('is_finished'),
+			eventTriggerId=row.get('event_trigger_id')
+		))
+
+
+TRIGGER_MODEL_TABLE = 'trigger_model'
+TRIGGER_MODEL_ENTITY_SHAPER = TriggerModelShaper()
+
+
+class TriggerModelService(TupleService):
+
+	def should_record_operation(self) -> bool:
+		return False
+
+	def get_entity_name(self) -> EntityName:
+		return TRIGGER_MODEL_TABLE
+
+	def get_entity_shaper(self) -> EntityShaper:
+		return TRIGGER_MODEL_ENTITY_SHAPER
+
+	def get_storable_id_column_name(self) -> EntityName:
+		return 'model_trigger_id'
+
+	def get_storable_id(self, storable: TriggerModel) -> StorableId:
+		# noinspection PyTypeChecker
+		return storable.modelTriggerId
+
+	def set_storable_id(
+			self, storable: TriggerModel, storable_id: ModelTriggerId) -> Storable:
+		storable.modelTriggerId = storable_id
+		return storable
+
+	def find_trigger_by_id(self, trigger_id: int) -> Optional[TriggerModel]:
+		self.begin_transaction()
+		try:
+			return self.find_by_id(trigger_id)
+		finally:
+			self.close_transaction()
+
+	def is_finished(self, event_trigger_id: str) -> bool:
+		self.begin_transaction()
+		try:
+			return self.storage.count(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=IS_FINISHED), right=False),
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='event_trigger_id'), right=event_trigger_id)
+				]
+			)) == 0
+		finally:
+			self.close_transaction()
+
+	def find_by_event_trigger_id(self, event_trigger_id: int) -> List[TriggerModel]:
+		self.begin_transaction()
+		try:
+			# noinspection PyTypeChecker
+			return self.storage.find(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='event_trigger_id'), right=event_trigger_id)
+				]
+			))
+		finally:
+			self.close_transaction()
+
+
+def get_trigger_model_service(storage: TransactionalStorageSPI,
+                              snowflake_generator: SnowflakeGenerator,
+                              principal_service: PrincipalService
+                              ) -> TriggerModelService:
+	return TriggerModelService(storage, snowflake_generator, principal_service)