158 lines
6.7 KiB
Python
158 lines
6.7 KiB
Python
from decouple import config
|
|
from chalicelib.utils import helper
|
|
from chalicelib.utils.TimeUTC import TimeUTC
|
|
from chalicelib.utils import pg_client
|
|
from chalicelib.core import integrations_manager, integration_base_issue
|
|
import json
|
|
|
|
|
|
async def __get_saved_data(project_id, session_id, issue_id, tool):
|
|
async with pg_client.cursor() as cur:
|
|
query = cur.mogrify(f"""\
|
|
SELECT *
|
|
FROM public.assigned_sessions
|
|
WHERE
|
|
session_id = %(session_id)s
|
|
AND issue_id = %(issue_id)s
|
|
AND provider = %(provider)s;\
|
|
""",
|
|
{"session_id": session_id, "issue_id": issue_id, "provider": tool.lower()})
|
|
await cur.execute(
|
|
query
|
|
)
|
|
return helper.dict_to_camel_case(await cur.fetchone())
|
|
|
|
|
|
async def create_new_assignment(tenant_id, project_id, session_id, creator_id, assignee, description, title, issue_type,
|
|
integration_project_id):
|
|
error, integration = await integrations_manager.get_integration(tenant_id=tenant_id, user_id=creator_id)
|
|
if error is not None:
|
|
return error
|
|
|
|
i = await integration.get()
|
|
|
|
if i is None:
|
|
return {"errors": [f"integration not found"]}
|
|
link = config("SITE_URL") + f"/{project_id}/session/{session_id}"
|
|
description += f"\n> {link}"
|
|
try:
|
|
issue = await integration.issue_handler.create_new_assignment(title=title, assignee=assignee, description=description,
|
|
issue_type=issue_type,
|
|
integration_project_id=integration_project_id)
|
|
except integration_base_issue.RequestException as e:
|
|
return integration_base_issue.proxy_issues_handler(e)
|
|
if issue is None or "id" not in issue:
|
|
return {"errors": ["something went wrong while creating the issue"]}
|
|
async with pg_client.cursor() as cur:
|
|
query = cur.mogrify("""\
|
|
INSERT INTO public.assigned_sessions(session_id, issue_id, created_by, provider,provider_data)
|
|
VALUES (%(session_id)s, %(issue_id)s, %(creator_id)s, %(provider)s,%(provider_data)s);\
|
|
""",
|
|
{"session_id": session_id, "creator_id": creator_id,
|
|
"issue_id": issue["id"], "provider": integration.provider.lower(),
|
|
"provider_data": json.dumps({"integrationProjectId": integration_project_id})})
|
|
await cur.execute(
|
|
query
|
|
)
|
|
issue["provider"] = integration.provider.lower()
|
|
return issue
|
|
|
|
|
|
async def get_all(project_id, user_id):
|
|
available_integrations = await integrations_manager.get_available_integrations(user_id=user_id)
|
|
no_integration = not any(available_integrations.values())
|
|
if no_integration:
|
|
return []
|
|
all_integrations = all(available_integrations.values())
|
|
extra_query = ["sessions.project_id = %(project_id)s"]
|
|
if not all_integrations:
|
|
extra_query.append("provider IN %(providers)s")
|
|
with pg_client.cursor() as cur:
|
|
query = cur.mogrify(f"""\
|
|
SELECT assigned_sessions.*
|
|
FROM public.assigned_sessions
|
|
INNER JOIN public.sessions USING (session_id)
|
|
WHERE {" AND ".join(extra_query)};\
|
|
""",
|
|
{"project_id": project_id,
|
|
"providers": tuple(d for d in available_integrations if available_integrations[d])})
|
|
await cur.execute(
|
|
query
|
|
)
|
|
assignments = helper.list_to_camel_case(await cur.fetchall())
|
|
for a in assignments:
|
|
a["createdAt"] = TimeUTC.datetime_to_timestamp(a["createdAt"])
|
|
return assignments
|
|
|
|
|
|
async def get_by_session(tenant_id, user_id, project_id, session_id):
|
|
available_integrations = await integrations_manager.get_available_integrations(user_id=user_id)
|
|
if not any(available_integrations.values()):
|
|
return []
|
|
extra_query = ["session_id = %(session_id)s", "provider IN %(providers)s"]
|
|
with pg_client.cursor() as cur:
|
|
query = cur.mogrify(f"""\
|
|
SELECT *
|
|
FROM public.assigned_sessions
|
|
WHERE {" AND ".join(extra_query)};""",
|
|
{"session_id": session_id,
|
|
"providers": tuple([k for k in available_integrations if available_integrations[k]])})
|
|
await cur.execute(
|
|
query
|
|
)
|
|
results = await cur.fetchall()
|
|
issues = {}
|
|
for i in results:
|
|
if i["provider"] not in issues.keys():
|
|
issues[i["provider"]] = []
|
|
|
|
issues[i["provider"]].append({"integrationProjectId": i["provider_data"]["integrationProjectId"],
|
|
"id": i["issue_id"]})
|
|
results = []
|
|
for tool in issues.keys():
|
|
error, integration = await integrations_manager.get_integration(tool=tool, tenant_id=tenant_id, user_id=user_id)
|
|
if error is not None:
|
|
return error
|
|
|
|
i = await integration.get()
|
|
if i is None:
|
|
print("integration not found")
|
|
continue
|
|
|
|
r = await integration.issue_handler.get_by_ids(saved_issues=issues[tool])
|
|
for i in r["issues"]:
|
|
i["provider"] = tool
|
|
results += r["issues"]
|
|
return results
|
|
|
|
|
|
async def get(tenant_id, user_id, project_id, session_id, assignment_id):
|
|
error, integration = await integrations_manager.get_integration(tenant_id=tenant_id, user_id=user_id)
|
|
if error is not None:
|
|
return error
|
|
l = await __get_saved_data(project_id, session_id, assignment_id, tool=integration.provider)
|
|
if l is None:
|
|
return {"errors": ["issue not found"]}
|
|
i = await integration.get()
|
|
if i is None:
|
|
return {"errors": ["integration not found"]}
|
|
r = await integration.issue_handler.get(integration_project_id=l["providerData"]["integrationProjectId"],
|
|
assignment_id=assignment_id)
|
|
|
|
r["provider"] = integration.provider.lower()
|
|
return r
|
|
|
|
|
|
async def comment(tenant_id, user_id, project_id, session_id, assignment_id, message):
|
|
error, integration = await integrations_manager.get_integration(tenant_id=tenant_id, user_id=user_id)
|
|
if error is not None:
|
|
return error
|
|
i = await integration.get()
|
|
|
|
if i is None:
|
|
return {"errors": [f"integration not found"]}
|
|
l = await __get_saved_data(project_id, session_id, assignment_id, tool=integration.provider)
|
|
|
|
return await integration.issue_handler.comment(integration_project_id=l["providerData"]["integrationProjectId"],
|
|
assignment_id=assignment_id,
|
|
comment=message)
|