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

watchmen_collector_kernel/service/task_housekeeping.py

@@ -0,0 +1,61 @@
+from datetime import date, datetime, timedelta
+from logging import getLogger
+from threading import Thread
+from typing import List
+
+from time import sleep
+
+from watchmen_collector_kernel.storage import get_competitive_lock_service
+from watchmen_collector_kernel.model import CompetitiveLock
+
+
+class CleanTask:
+
+	def __init__(self):
+		self.lock_service = get_competitive_lock_service()
+		self.processed_date = []
+		self.cleanTaskInterval = 3600
+
+	def run(self):
+		try:
+			while True:
+				self.clean_task()
+				sleep(self.cleanTaskInterval)
+		except Exception as e:
+			getLogger(__name__).error(e, exc_info=True, stack_info=True)
+			sleep(30)
+			self.restart()
+
+	def clean_task(self):
+		query_datetime = datetime.now()
+		delta = timedelta(
+			hours=query_datetime.hour,
+			minutes=query_datetime.minute,
+			seconds=query_datetime.second,
+			microseconds=query_datetime.microsecond)
+		query_date = query_datetime.date() - delta
+		if self.is_processed(query_date):
+			return "Done"
+		else:
+			tasks = self.get_task_list(query_date)
+			for task in tasks:
+				self.lock_service.delete_by_id(task.lockId)
+			self.processed_date.append(query_date.strftime('%Y-%m-%d'))
+
+	def get_task_list(self, clean_date) -> List[CompetitiveLock]:
+		return self.lock_service.find_completed_task(clean_date)
+
+	def is_processed(self, query_date: date) -> bool:
+		date_str = query_date.strftime('%Y-%m-%d')
+		if date_str in self.processed_date:
+			return True
+		else:
+			return False
+
+	def restart(self):
+		Thread(target=CleanTask.run, args=(self,), daemon=True).start()
+
+
+def init_task_housekeeping():
+	clean_task = CleanTask()
+	Thread(target=CleanTask.run, args=(clean_task,), daemon=True).start()

watchmen_collector_kernel/service/task_service.py

@@ -0,0 +1,72 @@
+from logging import getLogger
+from traceback import format_exc
+from typing import Callable, Dict, Optional, List
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.model import ScheduledTask, TaskStatus
+from watchmen_collector_kernel.model.scheduled_task import Dependence
+from watchmen_collector_kernel.storage import get_scheduled_task_service
+from watchmen_model.common import ScheduledTaskId
+from watchmen_storage import TransactionalStorageSPI, SnowflakeGenerator
+from watchmen_utilities import ArrayHelper
+
+logger = getLogger(__name__)
+
+
+class TaskService:
+
+	def __init__(self,
+	             storage: TransactionalStorageSPI,
+	             snowflake_generator: SnowflakeGenerator,
+	             principal_service: PrincipalService
+	             ):
+		self.storage = storage
+		self.snowflake_generator = snowflake_generator
+		self.principal_service = principal_service
+		self.scheduled_task_service = get_scheduled_task_service(self.storage,
+		                                                         self.snowflake_generator,
+		                                                         self.principal_service)
+
+	# noinspection PyMethodMayBeStatic
+	def consume_task(self, task: ScheduledTask, executed: Callable[[str, Dict, str], None]) -> ScheduledTask:
+		try:
+			executed(task.topicCode, task.content, task.tenantId)
+			task.status = int(TaskStatus.SUCCESS)
+			return self.scheduled_task_service.update_task(task)
+		except Exception as e:
+			logger.error(e, exc_info=True, stack_info=True)
+			task.status = int(TaskStatus.FAILED)
+			task.result = format_exc()
+			return self.scheduled_task_service.update_task(task)
+
+	def is_dependencies_finished(self, task: ScheduledTask) -> bool:
+		return ArrayHelper(task.parentTaskId).every(self.is_parent_task_finished) \
+		       and self.is_dependence_finished(task.dependOn, task.tenantId)
+
+	def is_parent_task_finished(self, task_id: ScheduledTaskId) -> bool:
+		existed_task = self.scheduled_task_service.find_task_by_id(task_id)
+		return self.is_finished(existed_task)
+
+	# noinspection PyMethodMayBeStatic
+	def is_finished(self, task: ScheduledTask) -> bool:
+		if task.status == TaskStatus.SUCCESS or task.status == TaskStatus.FAILED:
+			return True
+		else:
+			return False
+
+	def is_dependence_finished(self, depend_on: Optional[List[Dependence]], tenant_id: str) -> bool:
+		if ArrayHelper(depend_on).every(lambda dependence: self.is_dependent_task_finished(dependence, tenant_id)):
+			return True
+		else:
+			return False
+
+	def is_dependent_task_finished(self, dependence: Dependence, tenant_id: str) -> bool:
+		return self.scheduled_task_service.is_dependent_task_finished(dependence.modelName,
+		                                                              dependence.objectId,
+		                                                              tenant_id)
+
+
+def get_task_service(storage: TransactionalStorageSPI,
+                     snowflake_generator: SnowflakeGenerator,
+                     principal_service: PrincipalService) -> TaskService:
+	return TaskService(storage, snowflake_generator, principal_service)

watchmen_collector_kernel/service/trigger_collector.py

@@ -0,0 +1,147 @@
+from typing import Callable, List
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.model import TriggerEvent, CollectorModelConfig, TriggerModel, TriggerTable, \
+	CollectorTableConfig
+
+from watchmen_collector_kernel.storage import TriggerModelService, TriggerTableService, TriggerEventService, \
+	get_trigger_model_service, get_collector_model_config_service, get_trigger_table_service, \
+	CollectorTableConfigService, get_collector_table_config_service
+from watchmen_meta.common import TupleService
+from watchmen_model.common import Storable
+
+from watchmen_rest.util import validate_tenant_id
+
+
+# noinspection SpellCheckingInspection
+def redress_storable_id(tuple_service: TupleService,
+                        a_tuple: Storable) -> None:
+	tuple_id = tuple_service.get_storable_id(a_tuple)
+	if tuple_service.is_storable_id_faked(tuple_id):
+		tuple_service.redress_storable_id(a_tuple)
+
+
+def new_trigger_model(model_name: str, event_trigger_id: str) -> TriggerModel:
+	return TriggerModel(
+		modelName=model_name,
+		is_finished=False,
+		eventTriggerId=event_trigger_id
+	)
+
+
+def get_trigger_model(event_trigger: TriggerEvent, model_config: CollectorModelConfig) -> TriggerModel:
+	return new_trigger_model(model_config.modelName, event_trigger.eventTriggerId)
+
+
+def save_trigger_model(trigger_model_service: TriggerModelService,
+                       trigger_model: TriggerModel,
+                       principal_service: PrincipalService) -> TriggerModel:
+	validate_tenant_id(trigger_model, principal_service)
+	redress_storable_id(trigger_model_service, trigger_model)
+	# noinspection PyTypeChecker
+	return trigger_model_service.create(trigger_model)
+
+
+def get_trigger_model_action(trigger_event_service: TriggerEventService,
+                             trigger_event: TriggerEvent) -> Callable[[CollectorModelConfig], TriggerModel]:
+	def create_trigger_model_action(model_config: CollectorModelConfig) -> TriggerModel:
+		trigger_model = get_trigger_model(trigger_event, model_config)
+		trigger_model_service = get_trigger_model_service(trigger_event_service.storage,
+		                                                  trigger_event_service.snowflakeGenerator,
+		                                                  trigger_event_service.principalService)
+		return save_trigger_model(trigger_model_service,
+		                          trigger_model,
+		                          trigger_event_service.principalService)
+
+	return create_trigger_model_action
+
+
+def new_trigger_table(table_name: str,
+                      model_name: str,
+                      model_trigger_id: str,
+                      event_trigger_id: str) -> TriggerTable:
+	return TriggerTable(
+		tableName=table_name,
+		dataCount=0,
+		modelName=model_name,
+		isExtracted=False,
+		modelTriggerId=model_trigger_id,
+		eventTriggerId=event_trigger_id
+	)
+
+
+def get_trigger_table(model_trigger: TriggerModel, table_config: CollectorTableConfig) -> TriggerTable:
+	return new_trigger_table(table_config.tableName,
+	                         table_config.modelName,
+	                         model_trigger.modelTriggerId,
+	                         model_trigger.eventTriggerId)
+
+
+def save_trigger_table(trigger_table_service: TriggerTableService,
+                       trigger_table: TriggerTable,
+                       principal_service: PrincipalService) -> None:
+	validate_tenant_id(trigger_table, principal_service)
+	redress_storable_id(trigger_table_service, trigger_table)
+	trigger_table_service.create(trigger_table)
+
+
+def get_trigger_table_action(trigger_model_service: TriggerModelService,
+                             trigger_model: TriggerModel) -> Callable[[CollectorTableConfig], TriggerTable]:
+	def create_trigger_table_action(table_config: CollectorTableConfig) -> TriggerTable:
+		trigger_table = get_trigger_table(trigger_model, table_config)
+		trigger_table_service = get_trigger_table_service(trigger_model_service.storage,
+		                                                  trigger_model_service.snowflakeGenerator,
+		                                                  trigger_model_service.principalService)
+		# noinspection PyTypeChecker
+		return save_trigger_table(trigger_table_service,
+		                          trigger_table,
+		                          trigger_table_service.principalService)
+
+	return create_trigger_table_action
+
+
+def get_table_configs_by_model(collector_table_config_service: CollectorTableConfigService,
+                               model_config: CollectorModelConfig) -> List[CollectorTableConfig]:
+	return collector_table_config_service.find_by_model_name(model_config.modelName)
+
+
+def trigger_collector(trigger_event_service: TriggerEventService,
+                      trigger_event: TriggerEvent,
+                      principal_service: PrincipalService, ) -> TriggerEvent:
+	trigger_event_service.begin_transaction()
+	try:
+		# noinspection PyTypeChecker
+		trigger_event = trigger_event_service.create(trigger_event)
+		model_config_service = get_collector_model_config_service(trigger_event_service.storage,
+		                                                          trigger_event_service.snowflakeGenerator,
+		                                                          trigger_event_service.principalService)
+		model_configs = model_config_service.find_by_tenant(principal_service.get_tenant_id())
+		# noinspection PyTypeChecker
+		trigger_model_action = get_trigger_model_action(trigger_event_service, trigger_event)
+		trigger_model_service = get_trigger_model_service(trigger_event_service.storage,
+		                                                  trigger_event_service.snowflakeGenerator,
+		                                                  trigger_event_service.principalService)
+		# noinspection PyTypeChecker
+		table_config_service = get_collector_table_config_service(trigger_event_service.storage,
+		                                                          trigger_event_service.snowflakeGenerator,
+		                                                          trigger_event_service.principalService)
+		for model_config in model_configs:
+			trigger_model = trigger_model_action(model_config)
+			trigger_table_action = get_trigger_table_action(trigger_model_service, trigger_model)
+			table_configs = get_table_configs_by_model(table_config_service, model_config)
+			for table_config in table_configs:
+				trigger_table_action(table_config)
+
+		trigger_event_service.commit_transaction()
+	except Exception as e:
+		trigger_event_service.rollback_transaction()
+		raise e
+
+	# noinspection PyTypeChecker
+	return trigger_event
+
+
+def get_trigger_collector() -> Callable[[TriggerEventService,
+                                         TriggerEvent,
+                                         PrincipalService], TriggerEvent]:
+	return trigger_collector

watchmen_collector_kernel/storage/__init__.py

@@ -0,0 +1,17 @@
+from .competitive_lock_service import get_competitive_lock_service, CompetitiveLockService
+from .scheduled_task_service import get_scheduled_task_service, ScheduledTaskService
+
+
+from .collector_model_config_service import get_collector_model_config_service, CollectorModelConfigService
+from .collector_table_config_service import get_collector_table_config_service, CollectorTableConfigService
+
+
+from .trigger_event_service import get_trigger_event_service, TriggerEventService
+from .trigger_model_service import get_trigger_model_service, TriggerModelService
+from .trigger_table_service import get_trigger_table_service, TriggerTableService
+from .change_data_record_service import get_change_data_record_service, ChangeDataRecordService
+from .change_data_json_service import get_change_data_json_service, ChangeDataJsonService
+
+
+
+

watchmen_collector_kernel/storage/change_data_json_service.py

@@ -0,0 +1,171 @@
+from typing import List, Dict, Any, Optional
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.common import IS_POSTED, CHANGE_JSON_ID, TENANT_ID, MODEL_TRIGGER_ID
+from watchmen_collector_kernel.model import ChangeDataJson
+from watchmen_meta.common import TupleService, TupleShaper
+from watchmen_meta.common.storage_service import StorableId
+from watchmen_model.common import Storable, ChangeJsonId
+from watchmen_storage import EntityName, EntityRow, EntityShaper, TransactionalStorageSPI, SnowflakeGenerator, \
+	ColumnNameLiteral, EntityCriteriaExpression, EntityStraightValuesFinder, EntityStraightColumn, EntitySortColumn, \
+	EntitySortMethod
+
+
+class ChangeDataJsonShaper(EntityShaper):
+	def serialize(self, entity: ChangeDataJson) -> EntityRow:
+		return TupleShaper.serialize_tenant_based(entity,
+		                                          {
+			                                          'change_json_id': entity.changeJsonId,
+			                                          'resource_id': entity.resourceId,
+			                                          'model_name': entity.modelName,
+			                                          'object_id': entity.objectId,
+			                                          'table_name': entity.tableName,
+			                                          'data_id': entity.dataId,
+			                                          'content': entity.content,
+			                                          'depend_on': entity.dependOn,
+			                                          'is_posted': entity.isPosted,
+			                                          'task_id': entity.taskId,
+			                                          'table_trigger_id': entity.tableTriggerId,
+			                                          'model_trigger_id': entity.modelTriggerId,
+			                                          'event_trigger_id': entity.eventTriggerId
+		                                          })
+
+	def deserialize(self, row: EntityRow) -> ChangeDataJson:
+		# noinspection PyTypeChecker
+		return TupleShaper.deserialize_tenant_based(row,
+		                                            ChangeDataJson(
+			                                            changeJsonId=row.get('change_json_id'),
+			                                            resourceId=row.get('resource_id'),
+			                                            modelName=row.get('model_name'),
+			                                            objectId=row.get('object_id'),
+			                                            tableName=row.get('table_name'),
+			                                            dataId=row.get('data_id'),
+			                                            content=row.get('content'),
+			                                            dependOn=row.get('depend_on'),
+			                                            isPosted=row.get('is_posted'),
+			                                            taskId=row.get('task_id'),
+			                                            tableTriggerId=row.get('table_trigger_id'),
+			                                            modelTriggerId=row.get('model_trigger_id'),
+			                                            eventTriggerId=row.get('event_trigger_id')
+		                                            ))
+
+
+CHANGE_DATA_JSON_TABLE = 'change_data_json'
+CHANGE_DATA_JSON_ENTITY_SHAPER = ChangeDataJsonShaper()
+
+
+class ChangeDataJsonService(TupleService):
+
+	def should_record_operation(self) -> bool:
+		return False
+
+	def get_entity_name(self) -> EntityName:
+		return CHANGE_DATA_JSON_TABLE
+
+	def get_entity_shaper(self) -> EntityShaper:
+		return CHANGE_DATA_JSON_ENTITY_SHAPER
+
+	# noinspection SpellCheckingInspection
+	def get_storable_id_column_name(self) -> EntityName:
+		return 'change_json_id'
+
+	def get_storable_id(self, storable: ChangeDataJson) -> StorableId:
+		# noinspection PyTypeChecker
+		return storable.changeJsonId
+
+	# noinspection SpellCheckingInspection
+	def set_storable_id(self, storable: ChangeDataJson, storable_id: ChangeJsonId) -> Storable:
+		storable.changeRecordId = storable_id
+		return storable
+
+	def update_change_data_json(self, storable: ChangeDataJson) -> ChangeDataJson:
+		self.begin_transaction()
+		try:
+			self.update(storable)
+			self.commit_transaction()
+			return storable
+		except Exception as e:
+			self.rollback_transaction()
+			raise e
+
+	def find_not_posted_json(self, model_trigger_id: int) -> List[Dict[str, Any]]:
+		self.begin_transaction()
+		try:
+			return self.storage.find_straight_values(EntityStraightValuesFinder(
+				name=self.get_entity_name(),
+				shaper=self.get_entity_shaper(),
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=IS_POSTED), right=False),
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=MODEL_TRIGGER_ID), right=model_trigger_id)
+				],
+				straightColumns=[EntityStraightColumn(columnName=CHANGE_JSON_ID),
+				                 EntityStraightColumn(columnName=TENANT_ID)]
+			))
+		finally:
+			self.close_transaction()
+
+	def find_json_by_id(self, change_json_id: str) -> ChangeDataJson:
+		self.begin_transaction()
+		try:
+			# noinspection PyTypeChecker
+			return self.find_by_id(change_json_id)
+		finally:
+			self.close_transaction()
+
+	def find_id_by_resource_id(self, resource_id: str) -> Optional[ChangeDataJson]:
+		try:
+			self.storage.connect()
+			return self.storage.find_one(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='resource_id'), right=resource_id)
+				]
+			))
+		finally:
+			self.storage.close()
+
+	def find_by_object_id(self, model_name: str, object_id: str, model_trigger_id: int) -> List:
+		try:
+			self.storage.connect()
+			return self.storage.find(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='model_trigger_id'), right=model_trigger_id)
+				],
+				sort=[EntitySortColumn(name='sequence', method=EntitySortMethod.ASC)]
+			))
+		finally:
+			self.storage.close()
+
+	def is_event_finished(self, event_trigger_id: int) -> bool:
+		self.begin_transaction()
+		try:
+			# noinspection PyTypeChecker
+			return self.storage.count(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='event_trigger_id'), right=event_trigger_id),
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=IS_POSTED), right=False)
+				]
+			)) == 0
+		finally:
+			self.close_transaction()
+
+	def is_model_finished(self, model_trigger_id: int) -> bool:
+		self.begin_transaction()
+		try:
+			# noinspection PyTypeChecker
+			return self.storage.count(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='model_trigger_id'), right=model_trigger_id),
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=IS_POSTED), right=False)
+				]
+			)) == 0
+		finally:
+			self.close_transaction()
+
+
+def get_change_data_json_service(storage: TransactionalStorageSPI,
+                                 snowflake_generator: SnowflakeGenerator,
+                                 principal_service: PrincipalService
+                                 ) -> ChangeDataJsonService:
+	return ChangeDataJsonService(storage, snowflake_generator, principal_service)

watchmen_collector_kernel/storage/change_data_record_service.py

@@ -0,0 +1,185 @@
+from typing import List, Optional, Dict
+
+from watchmen_auth import PrincipalService
+from watchmen_collector_kernel.common import CHANGE_RECORD_ID, TENANT_ID, IS_MERGED
+from watchmen_collector_kernel.model import ChangeDataRecord
+from watchmen_meta.common import TupleService, TupleShaper
+from watchmen_meta.common.storage_service import StorableId
+from watchmen_model.common import Storable, ChangeRecordId
+from watchmen_storage import EntityName, EntityRow, EntityShaper, TransactionalStorageSPI, SnowflakeGenerator, \
+	EntityCriteriaExpression, ColumnNameLiteral, EntityStraightValuesFinder, EntityStraightColumn, EntityColumnType
+from watchmen_utilities import ArrayHelper
+
+
+class ChangeDataRecordShaper(EntityShaper):
+	def serialize(self, entity: ChangeDataRecord) -> EntityRow:
+		return TupleShaper.serialize_tenant_based(entity,
+		                                          {
+			                                          'change_record_id': entity.changeRecordId,
+			                                          'model_name': entity.modelName,
+			                                          'table_name': entity.tableName,
+			                                          'data_id': entity.dataId,
+			                                          'root_table_name': entity.rootTableName,
+			                                          'root_data_id': entity.rootDataId,
+			                                          'is_merged': entity.isMerged,
+			                                          'result': entity.result,
+			                                          'table_trigger_id': entity.tableTriggerId,
+			                                          'model_trigger_id': entity.modelTriggerId,
+			                                          'event_trigger_id': entity.eventTriggerId
+		                                          })
+
+	def deserialize(self, row: EntityRow) -> ChangeDataRecord:
+		# noinspection PyTypeChecker
+		return TupleShaper.deserialize_tenant_based(row,
+		                                            ChangeDataRecord(
+			                                            changeRecordId=row.get('change_record_id'),
+			                                            modelName=row.get('model_name'),
+			                                            tableName=row.get('table_name'),
+			                                            dataId=row.get('data_id'),
+			                                            rootTableName=row.get('root_table_name'),
+			                                            rootDataId=row.get('root_data_id'),
+			                                            isMerged=row.get('is_merged'),
+			                                            result=row.get('result'),
+			                                            tableTriggerId=row.get('table_trigger_id'),
+			                                            modelTriggerId=row.get('model_trigger_id'),
+			                                            eventTriggerId=row.get('event_trigger_id')
+		                                            ))
+
+
+CHANGE_DATA_RECORD_TABLE = 'change_data_record'
+CHANGE_DATA_RECORD_ENTITY_SHAPER = ChangeDataRecordShaper()
+
+
+class ChangeDataRecordService(TupleService):
+
+	def should_record_operation(self) -> bool:
+		return False
+
+	def get_entity_name(self) -> EntityName:
+		return CHANGE_DATA_RECORD_TABLE
+
+	def get_entity_shaper(self) -> EntityShaper:
+		return CHANGE_DATA_RECORD_ENTITY_SHAPER
+
+	# noinspection SpellCheckingInspection
+	def get_storable_id_column_name(self) -> EntityName:
+		return 'change_record_id'
+
+	# noinspection SpellCheckingInspection
+	def get_storable_id(self, storable: ChangeDataRecord) -> StorableId:
+		# noinspection PyTypeChecker
+		return storable.changeRecordId
+
+	# noinspection SpellCheckingInspection
+	def set_storable_id(self, storable: ChangeDataRecord, storable_id: ChangeRecordId) -> Storable:
+		storable.changeRecordId = storable_id
+		return storable
+
+	def create_change_record(self, record: ChangeDataRecord) -> None:
+		self.begin_transaction()
+		try:
+			self.create(record)
+			self.commit_transaction()
+		except Exception as e:
+			self.rollback_transaction()
+			raise e
+
+	def update_change_record(self, record: ChangeDataRecord) -> Optional[ChangeDataRecord]:
+		self.begin_transaction()
+		try:
+			result = self.update(record)
+			self.commit_transaction()
+			# noinspection PyTypeChecker
+			return result
+		except Exception as e:
+			self.rollback_transaction()
+			raise e
+
+	def find_unmerged_records(self) -> List:
+		self.begin_transaction()
+		try:
+			return self.storage.find_straight_values(EntityStraightValuesFinder(
+				name=self.get_entity_name(),
+				shaper=self.get_entity_shaper(),
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=IS_MERGED), right=False)
+				],
+				straightColumns=[EntityStraightColumn(columnName=CHANGE_RECORD_ID),
+				                 EntityStraightColumn(columnName=TENANT_ID)]
+			))
+		finally:
+			self.close_transaction()
+
+	def count_unmerged_records(self) -> int:
+		self.begin_transaction()
+		try:
+			# noinspection PyTypeChecker
+			return self.storage.count(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=IS_MERGED), right=False)
+				]
+			))
+		finally:
+			self.close_transaction()
+
+	def find_change_record_by_id(self, change_record_id: ChangeRecordId) -> ChangeDataRecord:
+		self.begin_transaction()
+		try:
+			# noinspection PyTypeChecker
+			return self.find_by_id(change_record_id)
+		finally:
+			self.close_transaction()
+
+	def find_existed_records(self, table_trigger_id: int) -> List[Dict]:
+		self.begin_transaction()
+		try:
+			# noinspection PyTypeChecker
+			result = self.storage.find_straight_values(
+				EntityStraightValuesFinder(
+					name=self.get_entity_name(),
+					shaper=self.get_entity_shaper(),
+					criteria=[
+						EntityCriteriaExpression(left=ColumnNameLiteral(columnName='table_trigger_id'),
+						                         right=table_trigger_id)
+					],
+					straightColumns=[EntityStraightColumn(columnName='data_id', columnType=EntityColumnType.JSON)]
+					)
+				)
+			return ArrayHelper(result).map(lambda x: x.get('data_id')).to_list()
+		finally:
+			self.close_transaction()
+
+	def is_event_finished(self, event_trigger_id: int) -> bool:
+		self.begin_transaction()
+		try:
+			# noinspection PyTypeChecker
+			return self.storage.count(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='event_trigger_id'),
+					                         right=event_trigger_id),
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=IS_MERGED), right=False)
+				]
+			)) == 0
+		finally:
+			self.close_transaction()
+
+	def is_model_finished(self, model_trigger_id: int) -> bool:
+		self.begin_transaction()
+		try:
+			# noinspection PyTypeChecker
+			return self.storage.count(self.get_entity_finder(
+				criteria=[
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName='model_trigger_id'),
+					                         right=model_trigger_id),
+					EntityCriteriaExpression(left=ColumnNameLiteral(columnName=IS_MERGED), right=False)
+				]
+			)) == 0
+		finally:
+			self.close_transaction()
+
+
+def get_change_data_record_service(storage: TransactionalStorageSPI,
+                                   snowflake_generator: SnowflakeGenerator,
+                                   principal_service: PrincipalService
+                                   ) -> ChangeDataRecordService:
+	return ChangeDataRecordService(storage, snowflake_generator, principal_service)