def to_datastore_entity(
self, process_history: ProcessHistory) -> DatastoreEntity:
doc = DatastoreEntity(exclude_from_indexes=[
"data", "request_headers", "request_body", "response_headers",
"response_body", "error_message"
])
doc.update({
'started_at':
process_history.started_at,
'duration_seconds':
process_history.duration_seconds,
'method':
process_history.method,
'url':
process_history.url,
'data':
json.dumps(process_history.data),
'status_code':
process_history.status_code,
'request_headers':
json.dumps(process_history.request_headers),
'request_body':
process_history.request_body,
'response_headers':
json.dumps(process_history.response_headers),
'response_body':
process_history.response_body,
'error_message':
process_history.error_message,
})
return doc
def to_datastore_entity(self) -> "DatastoreEntity":
doc = DatastoreEntity(
key=self.key,
exclude_from_indexes=self.exclude_from_indexes,
)
doc.update({
"name": self.name,
"created_at": self.created_at,
})
return doc
def from_datastore_entity(cls, doc: DatastoreEntity) -> "TaskDataModel":
return cls(
key=doc.key,
name=doc["name"],
project_key=doc.get("project_key"),
finished_at=cls.convert_optional_datetime(doc.get("finished_at")),
created_at=cls.convert_datetime(doc["created_at"]),
update_at=cls.convert_datetime(
doc.get("updated_at", doc["created_at"])),
)
def create_book():
client = get_client()
entity = DatastoreEntity(client.key('Book', str(uuid.uuid4())))
entity.update({
'states.id': [random.randint(10000, 100000)],
'states.name': [random.randint(10000, 1000000)],
'updated_by': ['python3'],
'created_at': datetime.datetime.utcnow(),
'updated_at': datetime.datetime.utcnow(),
})
client.put(entity)
return entity
def to_datastore_entity(self,
task_process: GumoTaskProcess) -> DatastoreEntity:
entity = DatastoreEntity(key=self._entity_key_mapper.to_datastore_key(
entity_key=task_process.key),
exclude_from_indexes=["payload"])
entity.update({
'relative_uri':
task_process.relative_uri,
'method':
task_process.method,
'payload':
task_process.payload,
'headers':
task_process.headers,
'schedule_time':
task_process.schedule_time,
'created_at':
task_process.created_at,
'updated_at':
task_process.updated_at,
'queue_name':
task_process.queue_name,
'state':
task_process.state.value,
'attempts':
task_process.attempts,
'last_run_at':
task_process.last_run_at,
'run_at':
task_process.run_at,
'locked_at':
task_process.locked_at,
'succeeded_at':
task_process.succeeded_at,
'failed_at':
task_process.failed_at,
'histories': [
self._process_history_mapper.to_datastore_entity(history)
for history in task_process.histories
],
})
return entity
def to_datastore_entity(self, task: GumoTask) -> DatastoreEntity:
doc = DatastoreEntity(
key=self.entity_key_mapper.to_datastore_key(task.key),
exclude_from_indexes=("payload_str",),
)
doc.update({
'relative_uri': task.relative_uri,
'method': task.method,
'payload_str': json.dumps(task.payload),
'headers': json.dumps(task.headers if task.headers else {}),
'schedule_time': task.schedule_time,
'created_at': task.created_at,
'queue_name': task.queue_name,
})
if task.app_engine_routing:
doc.update({
'app_engine_routing.service': task.app_engine_routing.service,
'app_engine_routing.version': task.app_engine_routing.version,
'app_engine_routing.instance': task.app_engine_routing.instance,
})
return doc
def save(self, name: str):
entity = DatastoreEntity(
key=self.datastore_client.key(self.KIND, name))
entity['name'] = name
entity['updated_at'] = datetime.datetime.utcnow()
self.datastore_client.put(entity)
def to_entity(self, doc: DatastoreEntity) -> GumoTask:
key = self.entity_key_mapper.to_entity_key(doc.key)
if 'payload_str' in doc:
payload = json.loads(doc.get('payload_str'))
else:
payload = doc.get('payload', {})
headers = {}
if 'headers' in doc:
headers = json.loads(doc.get('headers'))
routing = TaskAppEngineRouting(
service=doc.get('app_engine_routing.service'),
version=doc.get('app_engine_routing.version'),
instance=doc.get('app_engine_routing.instance'),
)
return GumoTask(
key=key,
relative_uri=doc.get('relative_uri', doc.get('url')),
method=doc.get('method'),
payload=payload,
headers=headers,
schedule_time=self.convert_datetime(doc.get('schedule_time')),
created_at=self.convert_datetime(doc.get('created_at')),
queue_name=doc.get('queue_name'),
app_engine_routing=routing,
)
def to_entity(self, datastore_entity: DatastoreEntity) -> GumoTaskProcess:
key = self._entity_key_mapper.to_entity_key(datastore_entity.key)
return GumoTaskProcess(
key=key,
relative_uri=datastore_entity.get('relative_uri'),
method=datastore_entity.get('method'),
payload=datastore_entity.get('payload'),
headers=datastore_entity.get('headers'),
schedule_time=datastore_entity.get('schedule_time'),
created_at=datastore_entity.get('created_at'),
updated_at=datastore_entity.get('updated_at'),
queue_name=datastore_entity.get('queue_name'),
state=TaskState.get(datastore_entity.get('state')),
attempts=datastore_entity.get('attempts'),
last_run_at=datastore_entity.get('last_run_at'),
run_at=datastore_entity.get('run_at'),
locked_at=datastore_entity.get('locked_at'),
succeeded_at=datastore_entity.get('succeeded_at'),
failed_at=datastore_entity.get('failed_at'),
histories=[
self._process_history_mapper.to_entity(history)
for history in datastore_entity.get('histories')
],
)