PTC Data API
PTC 원장 데이터 서버
이 서버는 `PTC(2023-2026.02).xlsx`를 읽어 요약, 프로젝트 집계, 계정 집계, 거래 미리보기를 JSON API로 제공합니다.
메인 화면은 http://localhost:8000/PTC 에서 확인할 수 있습니다.
현재 적재 건수
{count:,}
원본 파일 기준 전체 거래 행 수
메인 화면
localhost:8000/PTC
사용자가 보는 메인 대시보드
헬스체크
/api/health
서버 상태와 row count 확인
요약
/api/summary
건수, 기간, 공급가액, 누락값
주요 API
GET/api/health
API 서버가 정상 동작하는지와 적재 건수를 반환합니다.
GET/api/summary
건수, 입금/출금, 공급가액, 부가세, 기간, 누락값 요약을 반환합니다.
GET/api/top-accounts
계정코드별 상위 집계를 반환합니다.
GET/api/top-projects
프로젝트별 상위 집계를 반환합니다.
GET/api/project-mismatches
프로젝트코드 대비 프로젝트명/구분 불일치를 반환합니다.
GET/api/transactions?limit=30
원본 거래 미리보기를 반환합니다.
필터 예시
/api/summary?project_type=시공
/api/top-accounts?in_out=출금
/api/transactions?keyword=여비교통비&limit=20
"""
self._send_html(200, html)
return
if parsed.path == "/api/health":
count = conn.execute("select count(*) as count from ptc_transactions").fetchone()["count"]
self._send(200, {"ok": True, "row_count": count})
return
if parsed.path == "/api/project-master-options":
self._send(
200,
{
"project_type_options": PROJECT_TYPE_OPTIONS,
"method_family_options": METHOD_FAMILY_OPTIONS,
"method_options": METHOD_OPTIONS,
"method_family_map": METHOD_FAMILY_MAP,
"account_master": ACCOUNT_MASTER,
"allowed_account_codes_by_project_type": {
key: sorted(value) for key, value in ALLOWED_ACCOUNT_CODES_BY_PROJECT_TYPE.items()
},
},
)
return
if parsed.path == "/api/summary":
summary = query_summary(conn, params)
self._send(200, summary)
return
if parsed.path == "/api/project-types":
rows = conn.execute(
"select distinct project_type from ptc_transactions where coalesce(project_type,'') <> '' order by project_type"
).fetchall()
self._send(200, {"items": [row["project_type"] for row in rows]})
return
if parsed.path == "/api/projects":
keyword = params.get("keyword", [""])[0].strip().lower()
project_type = params.get("project_type", ["전체"])[0]
clauses = ["coalesce(project_code, '') <> ''"]
values = []
if keyword:
like = f"%{keyword}%"
clauses.append(
"""
(
lower(coalesce(project_code, '')) like ?
or lower(coalesce(project_name, '')) like ?
or lower(coalesce(project_type, '')) like ?
)
"""
)
values.extend([like, like, like])
if project_type and project_type != "전체":
clauses.append("project_type = ?")
values.append(project_type)
where = " where " + " and ".join(clauses)
rows = conn.execute(
f"""
select
project_code,
max(project_name) as project_name,
max(project_type) as project_type,
count(*) as txn_count,
coalesce(sum(supply_amount), 0) as supply_sum,
min(transaction_date) as min_date,
max(transaction_date) as max_date
from ptc_transactions
{where}
group by project_code
order by supply_sum desc, project_code
""",
values,
).fetchall()
items = rows_to_dicts(rows)
for item in items:
master = fetch_project_master(conn, item["project_code"])
item["project_type"] = resolve_project_type(
item["project_code"],
item["project_type"],
master.get("project_type") if master else "",
)
if master:
item["project_name"] = master.get("project_name") or item["project_name"]
item["construction_family"] = resolve_construction_family(
master.get("construction_method"),
master.get("construction_family"),
)
item["construction_method"] = master.get("construction_method") or ""
item["note"] = master.get("note") or ""
else:
item["construction_family"] = ""
item["construction_method"] = ""
item["note"] = ""
self._send(200, {"items": items})
return
if parsed.path == "/api/vendors":
keyword = params.get("keyword", [""])[0].strip().lower()
clauses = ["coalesce(vendor_name, '') <> ''"]
values: list[str] = []
if keyword:
clauses.append(
"""
(
lower(coalesce(vendor_name, '')) like ?
or lower(coalesce(account_code_final, '')) like ?
or lower(coalesce(account_name_final, '')) like ?
)
"""
)
like = f"%{keyword}%"
values.extend([like, like, like])
where = f"where {' and '.join(clauses)}"
rows = conn.execute(
f"""
select
vendor_name,
count(*) as txn_count,
coalesce(sum(supply_amount), 0) as supply_sum,
min(transaction_date) as min_date,
max(transaction_date) as max_date
from ptc_transactions
{where}
group by vendor_name
order by supply_sum desc, vendor_name
""",
values,
).fetchall()
self._send(200, {"items": rows_to_dicts(rows)})
return
if parsed.path == "/api/accounts":
keyword = params.get("keyword", [""])[0].strip().lower()
clauses = ["coalesce(account_code_final, '') <> ''"]
values: list[str] = []
if keyword:
clauses.append(
"""
(
lower(coalesce(account_code_final, '')) like ?
or lower(coalesce(account_name_final, '')) like ?
or lower(coalesce(vendor_name, '')) like ?
)
"""
)
like = f"%{keyword}%"
values.extend([like, like, like])
where = f"where {' and '.join(clauses)}"
rows = conn.execute(
f"""
select
account_code_final as account_code,
account_name_final as account_name,
count(*) as txn_count,
coalesce(sum(supply_amount), 0) as supply_sum,
min(transaction_date) as min_date,
max(transaction_date) as max_date
from ptc_transactions
{where}
group by account_code_final, account_name_final
order by cast(account_code_final as integer) asc, account_code_final asc
""",
values,
).fetchall()
self._send(200, {"items": rows_to_dicts(rows)})
return
if parsed.path == "/api/account-detail":
account_code = params.get("account_code", [""])[0].strip()
project_code = params.get("project_code", [""])[0].strip()
if not account_code:
self._send(400, {"ok": False, "message": "account_code is required"})
return
detail_clauses = ["account_code_final = ?"]
detail_values: list[str] = [account_code]
if project_code:
detail_clauses.append("project_code = ?")
detail_values.append(project_code)
detail_where = " where " + " and ".join(detail_clauses)
summary = conn.execute(
f"""
select
account_code_final as account_code,
account_name_final as account_name,
count(*) as txn_count,
sum(case when in_out = '입금' then 1 else 0 end) as income_count,
sum(case when in_out = '출금' then 1 else 0 end) as expense_count,
coalesce(sum(case when in_out = '입금' then supply_amount else 0 end), 0) as income_supply_sum,
coalesce(sum(case when in_out = '출금' then supply_amount else 0 end), 0) as expense_supply_sum,
coalesce(sum(supply_amount), 0) as supply_sum,
min(transaction_date) as min_date,
max(transaction_date) as max_date
from ptc_transactions
{detail_where}
group by account_code_final, account_name_final
""",
detail_values,
).fetchone()
project_rows = conn.execute(
"""
select
project_code,
max(project_name) as project_name,
count(*) as txn_count,
sum(case when in_out = '입금' then 1 else 0 end) as income_count,
sum(case when in_out = '출금' then 1 else 0 end) as expense_count,
coalesce(sum(case when in_out = '입금' then supply_amount else 0 end), 0) as income_supply_sum,
coalesce(sum(case when in_out = '출금' then supply_amount else 0 end), 0) as expense_supply_sum,
coalesce(sum(supply_amount), 0) as supply_sum
from ptc_transactions
where account_code_final = ?
group by project_code
order by supply_sum desc, project_code
limit 30
""",
(account_code,),
).fetchall()
vendor_rows = conn.execute(
f"""
select
vendor_name,
count(*) as txn_count,
sum(case when in_out = '입금' then 1 else 0 end) as income_count,
sum(case when in_out = '출금' then 1 else 0 end) as expense_count,
coalesce(sum(case when in_out = '입금' then supply_amount else 0 end), 0) as income_supply_sum,
coalesce(sum(case when in_out = '출금' then supply_amount else 0 end), 0) as expense_supply_sum,
coalesce(sum(supply_amount), 0) as supply_sum
from ptc_transactions
{detail_where}
group by vendor_name
order by supply_sum desc, vendor_name
limit 30
""",
detail_values,
).fetchall()
transaction_rows = conn.execute(
f"""
select
source_row_no,
transaction_date,
in_out,
project_code,
project_name,
vendor_name,
department_name,
description,
supply_amount
from ptc_transactions
{detail_where}
order by transaction_date desc, source_row_no desc
limit 100
""",
detail_values,
).fetchall()
self._send(
200,
{
"summary": dict(summary) if summary else None,
"projects": rows_to_dicts(project_rows),
"vendors": rows_to_dicts(vendor_rows),
"transactions": rows_to_dicts(transaction_rows),
},
)
return
if parsed.path == "/api/vendor-detail":
vendor_name = params.get("vendor_name", [""])[0].strip()
project_code = params.get("project_code", [""])[0].strip()
account_code = params.get("account_code", [""])[0].strip()
if not vendor_name:
self._send(400, {"ok": False, "message": "vendor_name is required"})
return
detail_clauses = ["vendor_name = ?"]
detail_values: list[str] = [vendor_name]
if project_code:
detail_clauses.append("project_code = ?")
detail_values.append(project_code)
if account_code:
detail_clauses.append("account_code_final = ?")
detail_values.append(account_code)
detail_where = " where " + " and ".join(detail_clauses)
summary = conn.execute(
"""
select
vendor_name,
count(*) as txn_count,
sum(case when in_out = '입금' then 1 else 0 end) as income_count,
sum(case when in_out = '출금' then 1 else 0 end) as expense_count,
coalesce(sum(case when in_out = '입금' then supply_amount else 0 end), 0) as income_supply_sum,
coalesce(sum(case when in_out = '출금' then supply_amount else 0 end), 0) as expense_supply_sum,
coalesce(sum(supply_amount), 0) as supply_sum,
min(transaction_date) as min_date,
max(transaction_date) as max_date
from ptc_transactions
where vendor_name = ?
group by vendor_name
""",
(vendor_name,),
).fetchone()
project_rows = conn.execute(
"""
select
project_code,
max(project_name) as project_name,
count(*) as txn_count,
sum(case when in_out = '입금' then 1 else 0 end) as income_count,
sum(case when in_out = '출금' then 1 else 0 end) as expense_count,
coalesce(sum(case when in_out = '입금' then supply_amount else 0 end), 0) as income_supply_sum,
coalesce(sum(case when in_out = '출금' then supply_amount else 0 end), 0) as expense_supply_sum,
coalesce(sum(supply_amount), 0) as supply_sum
from ptc_transactions
where vendor_name = ?
group by project_code
order by supply_sum desc, project_code
limit 20
""",
(vendor_name,),
).fetchall()
account_rows = conn.execute(
f"""
select
account_code_final as account_code,
account_name_final as account_name,
count(*) as txn_count,
sum(case when in_out = '입금' then 1 else 0 end) as income_count,
sum(case when in_out = '출금' then 1 else 0 end) as expense_count,
coalesce(sum(case when in_out = '입금' then supply_amount else 0 end), 0) as income_supply_sum,
coalesce(sum(case when in_out = '출금' then supply_amount else 0 end), 0) as expense_supply_sum,
coalesce(sum(supply_amount), 0) as supply_sum
from ptc_transactions
{detail_where}
group by account_code_final, account_name_final
order by supply_sum desc, account_code_final
limit 30
""",
detail_values,
).fetchall()
transaction_rows = conn.execute(
f"""
select
source_row_no,
transaction_date,
in_out,
project_code,
project_name,
account_code_final as account_code,
account_name_final as account_name,
department_name,
description,
supply_amount
from ptc_transactions
{detail_where}
order by transaction_date desc, source_row_no desc
limit 100
""",
detail_values,
).fetchall()
self._send(
200,
{
"summary": dict(summary) if summary else None,
"projects": rows_to_dicts(project_rows),
"accounts": rows_to_dicts(account_rows),
"transactions": rows_to_dicts(transaction_rows),
},
)
return
if parsed.path == "/api/project-detail":
project_code = params.get("project_code", [""])[0].strip()
if not project_code:
self._send(400, {"ok": False, "message": "project_code is required"})
return
keyword = params.get("keyword", [""])[0]
in_out = params.get("in_out", ["전체"])[0]
where, values = build_project_where(project_code, keyword, in_out)
summary = conn.execute(
f"""
select
project_code,
max(project_name) as project_name,
max(project_type) as project_type,
count(*) as txn_count,
sum(case when in_out = '입금' then 1 else 0 end) as income_count,
sum(case when in_out = '출금' then 1 else 0 end) as expense_count,
coalesce(sum(supply_amount), 0) as supply_sum,
coalesce(sum(vat_amount), 0) as vat_sum,
coalesce(sum(total_amount), 0) as total_sum,
min(transaction_date) as min_date,
max(transaction_date) as max_date
from ptc_transactions
{where}
""",
values,
).fetchone()
account_rows = conn.execute(
f"""
select
account_code_final as code,
account_name_final as name,
count(*) as count,
coalesce(sum(supply_amount), 0) as total
from ptc_transactions
{where}
group by account_code_final, account_name_final
order by total desc
limit 12
""",
values,
).fetchall()
transaction_rows = conn.execute(
f"""
select
source_row_no,
transaction_date,
in_out,
account_code_final as account_code,
account_name_final as account_name,
department_name,
vendor_name,
description,
supply_amount,
vat_amount,
total_amount
from ptc_transactions
{where}
order by transaction_date desc, source_row_no desc
limit 20
""",
values,
).fetchall()
summary_dict = dict(summary) if summary else None
master = fetch_project_master(conn, project_code)
if summary_dict and master:
summary_dict["project_name"] = master.get("project_name") or summary_dict["project_name"]
summary_dict["project_type"] = resolve_project_type(
project_code,
summary_dict["project_type"],
master.get("project_type"),
)
summary_dict["construction_family"] = resolve_construction_family(
master.get("construction_method"),
master.get("construction_family"),
)
summary_dict["construction_method"] = master.get("construction_method") or ""
summary_dict["note"] = master.get("note") or ""
elif summary_dict:
summary_dict["project_type"] = resolve_project_type(project_code, summary_dict["project_type"])
summary_dict["construction_family"] = resolve_construction_family("")
summary_dict["construction_method"] = ""
summary_dict["note"] = ""
account_issues = get_project_account_issues(
conn,
project_code,
summary_dict["project_type"] if summary_dict else "",
)
budget_analysis = build_budget_analysis(conn, project_code, build_account_structure_rows(account_rows))
self._send(
200,
{
"summary": summary_dict,
"project_master": master,
"account_structure": build_account_structure_rows(account_rows),
"budget_analysis": budget_analysis,
"accounts": rows_to_dicts(account_rows),
"account_issues": account_issues,
"transactions": rows_to_dicts(transaction_rows),
},
)
return
if parsed.path == "/api/project-account-issue-detail":
project_code = params.get("project_code", [""])[0].strip()
account_code = params.get("account_code", [""])[0].strip()
if not project_code or not account_code:
self._send(400, {"ok": False, "message": "project_code and account_code are required"})
return
rows = conn.execute(
"""
select
source_row_no,
transaction_date,
in_out,
account_code_final as account_code,
account_name_final as account_name,
department_name,
vendor_name,
description,
supply_amount,
vat_amount,
total_amount
from ptc_transactions
where project_code = ?
and account_code_final = ?
order by transaction_date desc, source_row_no desc
limit 100
""",
(project_code, account_code),
).fetchall()
summary = conn.execute(
"""
select
count(*) as txn_count,
coalesce(sum(supply_amount), 0) as supply_sum,
min(transaction_date) as min_date,
max(transaction_date) as max_date
from ptc_transactions
where project_code = ?
and account_code_final = ?
""",
(project_code, account_code),
).fetchone()
self._send(
200,
{
"project_code": project_code,
"account_code": account_code,
"account_name": resolve_account_name(account_code, rows[0]["account_name"] if rows else ""),
"summary": dict(summary) if summary else None,
"items": rows_to_dicts(rows),
},
)
return
if parsed.path == "/api/top-accounts":
where, values = build_where(params)
rows = conn.execute(
f"""
select
account_code_final as code,
account_name_final as name,
count(*) as count,
coalesce(sum(supply_amount), 0) as total
from ptc_transactions
{where}
group by account_code_final, account_name_final
order by total desc
limit 10
""",
values,
).fetchall()
self._send(200, {"items": rows_to_dicts(rows)})
return
if parsed.path == "/api/top-projects":
where, values = build_where(params)
rows = conn.execute(
f"""
select
coalesce(project_code, '(없음)') as project_code,
coalesce(project_name, '(없음)') as project_name,
coalesce(project_type, '(없음)') as project_type,
count(*) as count,
coalesce(sum(supply_amount), 0) as total
from ptc_transactions
{where}
group by project_code, project_name, project_type
order by total desc
limit 10
""",
values,
).fetchall()
self._send(200, {"items": rows_to_dicts(rows)})
return
if parsed.path == "/api/project-mismatches":
rows = conn.execute(
"""
select project_code, count(distinct project_name) as name_count, count(distinct project_type) as type_count
from ptc_transactions
where coalesce(project_code, '') <> ''
group by project_code
having count(distinct project_name) > 1 or count(distinct project_type) > 1
order by project_code
limit 20
"""
).fetchall()
self._send(200, {"items": rows_to_dicts(rows)})
return
if parsed.path == "/api/transactions":
where, values = build_where(params)
limit = int(params.get("limit", ["30"])[0])
rows = conn.execute(
f"""
select
source_row_no,
transaction_date,
in_out,
account_code_final as account_code,
account_name_final as account_name,
department_name,
vendor_name,
project_code,
project_name,
project_type,
description,
supply_amount,
vat_amount,
total_amount
from ptc_transactions
{where}
order by source_row_no
limit ?
""",
values + [limit],
).fetchall()
self._send(200, {"items": rows_to_dicts(rows)})
return
self._send(404, {"ok": False, "message": "Not found"})
finally:
conn.close()
def main() -> None:
init_db()
server = ThreadingHTTPServer(("0.0.0.0", 4000), Handler)
print("PTC API server listening on http://0.0.0.0:4000")
server.serve_forever()
if __name__ == "__main__":
main()