def root():
task_repository: TaskRepository = injector.get(TaskRepository)
project_repository: ProjectRepository = injector.get(ProjectRepository)
tasks = task_repository.fetch_list()
sorted_tasks = []
for key, tasks in groupby(tasks, key=lambda task: task.project_key):
project = project_repository.fetch(key) if key is not None else key
if project is not None:
project_name = project.name.value
else:
project_name = 'プロジェクト未指定'
grouped_tasks = []
for task in tasks:
grouped_tasks.append(task)
sorted_tasks.append({
'project_name': project_name,
'tasks': grouped_tasks
})
sorted_tasks.sort(key=lambda task: task['project_name'], reverse=True)
return flask.render_template('index.html', sorted_tasks=sorted_tasks)
def get(self):
task_repository: TaskRepository = injector.get(TaskRepository)
project_repository: ProjectRepository = injector.get(ProjectRepository)
tasks = task_repository.fetch_list()
projects = project_repository.fetch_list()
return flask.render_template("todo/tasks.html",
tasks=tasks,
projects=projects)
def run(self):
repository = injector.get(TaskProcessRepository) # type: TaskProcessRepository
execute_service = injector.get(TaskExecuteService) # type: TaskExecuteService
task_processes = repository.fetch_tasks_by_state(state=TaskState.QUEUED)
for task in task_processes:
logger.debug(f'task.key={task.key} is executing')
execute_service.execute(key=task.key)
self.check_stop()
def post(self, task_id):
task_key = TaskKey.build_by_id(task_id=task_id)
task_name: str = flask.request.form.get("new_task_name", "")
service: TaskNameUpdateService = injector.get(TaskNameUpdateService)
service.execute(key=task_key, task_name=task_name)
return flask.redirect("/tasks")
def get_datastore_client(cls) -> DatastoreClient:
if cls._datastore_client is None:
configuration: DatastoreConfiguration = injector.get(
DatastoreConfiguration, scope=singleton)
cls._datastore_client = configuration.client
return cls._datastore_client
class TaskCleanupView(flask.views.MethodView):
_repository = injector.get(TaskProcessRepository) # type: TaskProcessRepository
def get(self):
self._repository.cleanup_finished_tasks()
return flask.jsonify({'cleanup': 'ok'})
def enqueue(
url: str,
method: str = 'POST',
payload: Optional[dict] = None,
headers: Optional[dict] = None,
schedule_time: Optional[datetime.datetime] = None,
in_seconds: Optional[int] = None,
queue_name: Optional[str] = None,
service: Optional[str] = None,
version: Optional[str] = None,
instance: Optional[str] = None,
) -> GumoTask:
enqueue_service = injector.get(
CloudTasksEnqueueService) # type: CloudTasksEnqueueService
return enqueue_service.enqueue(
url=url,
method=method,
payload=payload,
headers=headers,
schedule_time=schedule_time,
in_seconds=in_seconds,
queue_name=queue_name,
service=service,
version=version,
instance=instance,
)
def post(self, task_id):
task_key = TaskKey.build_by_id(task_id=task_id)
project_id: str = flask.request.form.get("project_id", "")
service: TaskProjectUpdateService = injector.get(
TaskProjectUpdateService)
service.execute(key=task_key, project_id=project_id)
return flask.redirect("/tasks")
def _get_id_allocator(self) -> KeyIDAllocator:
try:
import gumo.datastore # noqa: F401 for dependency checks.
except ImportError:
raise RuntimeError(
f'gumo.datastore is not imported. Cloud not use KeyGenerateStyle.INT.'
)
return injector.get(KeyIDAllocator, scope=singleton)
def post(self, task_id):
task_key = TaskKey.build_by_id(task_id=task_id)
finished = flask.request.form.get("finished", "false") == "true"
service: TaskStatusUpdateService = injector.get(
TaskStatusUpdateService)
service.execute(key=task_key, finished=finished)
print(flask.request.path)
return flask.redirect("/")
class TaskSummaryView(flask.views.MethodView):
_repository = injector.get(TaskProcessSummaryRepository) # type: TaskProcessSummaryRepository
def get(self):
summary = self._repository.fetch_summary()
return flask.jsonify({
'summary': summary.to_dict(),
})
class TaskDetailView(flask.views.MethodView):
_repository = injector.get(TaskProcessRepository) # type: TaskProcessRepository
def get(self, key):
task = self._repository.fetch_by_key(
key=EntityKeyFactory().build_from_key_path(key)
)
return flask.jsonify(TaskProcessJSONEncoder(task).to_json())
class TaskRemoveView(flask.views.MethodView):
_service = injector.get(TaskMarkAsFailedService) # type: TaskMarkAsFailedService
def get(self, key):
task = self._service.execute(
key=EntityKeyFactory().build_from_key_path(key)
)
return flask.jsonify(TaskProcessJSONEncoder(task).to_json())
class QueueDetailUI(flask.views.MethodView):
_repository = injector.get(
TaskProcessRepository) # type: TaskProcessRepository
def get(self, queue_name):
tasks = self._repository.fetch_tasks(queue_name=queue_name, limit=100)
return flask.render_template('detail.html',
queue_name=queue_name,
tasks=tasks)
class TasksEmulatorEnqueue(flask.views.MethodView):
_task_process_create_service = injector.get(TaskProcessBulkCreateService) # type: TaskProcessBulkCreateService
def get(self):
result = self._task_process_create_service.execute()
return flask.jsonify(result)
def post(self):
result = self._task_process_create_service.execute()
return flask.jsonify(result)
def test_build_credential_with_google_application_credentials(self):
self.prepare_credential()
assert 'GOOGLE_APPLICATION_CREDENTIALS' in os.environ
assert os.path.exists(os.environ['GOOGLE_APPLICATION_CREDENTIALS'])
manager = injector.get(GoogleOAuthCredentialManager) # type: GoogleOAuthCredentialManager
cred = manager.build_credentials()
assert isinstance(cred, Credentials)
assert cred.signer_email.index('@') > 0
assert cred.signer_email.index('gserviceaccount.com') > 0
def get_google_id_token_credentials(
target_audience: str,
with_refresh: bool = True,
token_uri: Optional[str] = None,
) -> Tuple[IDTokenCredentials, Request]:
return injector.get(GoogleOAuthCredentialManager,
scope=singleton).build_id_token_credentials(
target_audience=target_audience,
with_refresh=with_refresh,
token_uri=token_uri,
)
class QueueUI(flask.views.MethodView):
_repository = injector.get(
TaskProcessSummaryRepository) # type: TaskProcessSummaryRepository
def get(self):
summary = self._repository.fetch_summary()
return flask.render_template(
'index.html',
summary=summary.to_dict(),
)
class TaskProcessesView(flask.views.MethodView):
_repository = injector.get(TaskProcessRepository) # type: TaskProcessRepository
def get(self):
task_processes = self._repository.fetch_tasks()
return flask.jsonify({
'tasks': [
TaskProcessJSONEncoder(task_process=task_process).to_json()
for task_process in task_processes
]
})
class QueuedTasksView(flask.views.MethodView):
_repository = injector.get(TaskProcessRepository) # type: TaskProcessRepository
def get(self):
task_processes = self._repository.fetch_tasks_by_state(state=TaskState.QUEUED)
return flask.jsonify({
'tasks': [
TaskProcessJSONEncoder(task_process).to_json()
for task_process in task_processes
]
})
class TasksView(flask.views.MethodView):
_repository = injector.get(TaskRepository) # type: TaskRepository
def get(self):
tasks = self._repository.fetch_tasks(limit=100)
return flask.jsonify({
'results': [TaskJSONEncoder(task).to_json() for task in tasks]
})
def post(self):
return 'ok'
def test_build_id_token_credential_with_google_application_credentials(self):
self.prepare_credential()
assert 'GOOGLE_APPLICATION_CREDENTIALS' in os.environ
assert os.path.exists(os.environ['GOOGLE_APPLICATION_CREDENTIALS'])
target_audience = os.environ.get(
'TEST_TARGET_AUDIENCE',
'204100934405-b9gjp2hnbtq12r9s4i460mmrsjl1jvg4.apps.googleusercontent.com'
)
manager = injector.get(GoogleOAuthCredentialManager) # type: GoogleOAuthCredentialManager
id_token_credential, request = manager.build_id_token_credentials(
target_audience=target_audience
)
assert isinstance(id_token_credential, IDTokenCredentials)
assert isinstance(request, Request)
assert id_token_credential.signer_email.index('@') > 0
assert id_token_credential.signer_email.index('gserviceaccount.com') > 0
assert id_token_credential.service_account_email.index('gserviceaccount.com') > 0
def build_allocator(self) -> DatastoreKeyIDAllocator:
return injector.get(DatastoreKeyIDAllocator)
def get_config() -> DatastoreConfiguration:
return injector.get(DatastoreConfiguration, scope=singleton)
def get_config() -> TaskConfiguration:
return injector.get(TaskConfiguration, scope=singleton)
def get_client():
return injector.get(DatastoreConfiguration).client
def get_config() -> GumoConfiguration:
return injector.get(GumoConfiguration)
def run(self):
service = injector.get(TaskProcessBulkCreateService) # type: TaskProcessBulkCreateService
service.execute()
def entity_key_mapper(self) -> EntityKeyMapper:
if self._entity_key_mapper is None:
self._entity_key_mapper: EntityKeyMapper = injector.get(
EntityKeyMapper)
return self._entity_key_mapper
def datastore_transaction():
datastore_client: DatastoreClient = injector.get(
DatastoreConfiguration).client
with datastore_client.transaction():
yield
