454 lines
17 KiB
Python
Executable File
454 lines
17 KiB
Python
Executable File
#!/usr/bin/env python3
|
||
"""
|
||
Ambil semua commit hari ini dari semua repo, distribusikan 8 jam pro-rata,
|
||
lalu upload ke Odoo timesheet.
|
||
|
||
Pro-rata: bobot = time span per task (last commit - first commit).
|
||
Single commit mendapat minimum 30 menit.
|
||
Contoh: Task A span 2 jam + Task B span 1.5 jam + Task C 1 commit →
|
||
bobot: 120 + 90 + 30 = 240 menit
|
||
Task A = 8 × 120/240 = 4.00h, Task B = 3.00h, Task C = 1.00h
|
||
"""
|
||
|
||
import json
|
||
import re
|
||
import subprocess
|
||
import urllib.request
|
||
import urllib.error
|
||
import argparse
|
||
from datetime import date, datetime, timedelta
|
||
from collections import defaultdict
|
||
from decimal import Decimal, ROUND_HALF_UP
|
||
|
||
BASE_URL = "https://odoo.aplikasi.web.id"
|
||
TOTAL_HOURS = 8
|
||
|
||
PROJECT_MAP = {
|
||
"CPONE": 123,
|
||
"IBL": 186,
|
||
"Support Pramita": 70,
|
||
"SAS": 92,
|
||
"Support Kedungdoro": 77,
|
||
}
|
||
|
||
REPOS = [
|
||
{"path": "/Users/fajrihardhitamurti/REPO_CPONE/BE_CPONE", "project": "CPONE"},
|
||
{"path": "/Users/fajrihardhitamurti/REPO_CPONE/FE_CPONE", "project": "CPONE"},
|
||
{"path": "/Users/fajrihardhitamurti/REPO_CPONE_DASHBOARD", "project": "CPONE"},
|
||
{"path": "/Users/fajrihardhitamurti/REPO_GITEA_IBL/BE_IBL", "project": "IBL"},
|
||
{"path": "/Users/fajrihardhitamurti/REPO_GITEA_IBL/FE_IBL", "project": "IBL"},
|
||
{"path": "/Users/fajrihardhitamurti/REPO_GITEA_KD", "project": "Support Kedungdoro"},
|
||
{"path": "/Users/fajrihardhitamurti/REPO_GITLAB_PRAMITA/bisone", "project": "Support Pramita"},
|
||
{"path": "/Users/fajrihardhitamurti/SAS_TASK", "project": "SAS"},
|
||
]
|
||
|
||
COMMIT_RE = re.compile(r"^([A-Z0-9]+)\s*-\s*(.+)$")
|
||
|
||
|
||
# ── HTTP ──────────────────────────────────────────────────────────────────────
|
||
|
||
def build_headers(session_id: str) -> dict:
|
||
return {
|
||
"accept": "*/*",
|
||
"content-type": "application/json",
|
||
"origin": BASE_URL,
|
||
"referer": f"{BASE_URL}/web",
|
||
"user-agent": "Mozilla/5.0",
|
||
"cookie": f"frontend_lang=en_US; cids=1; session_id={session_id}; tz=Asia/Jakarta",
|
||
}
|
||
|
||
|
||
def odoo_call(session_id: str, endpoint: str, payload: dict) -> dict:
|
||
url = f"{BASE_URL}{endpoint}"
|
||
body = json.dumps(payload).encode("utf-8")
|
||
req = urllib.request.Request(url, data=body, headers=build_headers(session_id), method="POST")
|
||
try:
|
||
with urllib.request.urlopen(req) as resp:
|
||
response = json.loads(resp.read().decode("utf-8"))
|
||
except urllib.error.HTTPError as e:
|
||
raise RuntimeError(f"HTTP {e.code}: {e.read().decode()}") from e
|
||
if "error" in response:
|
||
err = response["error"]
|
||
raise RuntimeError(f"Odoo error: {err.get('message')}")
|
||
return response
|
||
|
||
|
||
# ── Odoo helpers ──────────────────────────────────────────────────────────────
|
||
|
||
def check_session(session_id: str) -> bool:
|
||
"""Return True jika session masih valid, False jika expired."""
|
||
payload = {"jsonrpc": "2.0", "method": "call", "id": 1, "params": {}}
|
||
url = f"{BASE_URL}/web/session/get_session_info"
|
||
body = json.dumps(payload).encode("utf-8")
|
||
req = urllib.request.Request(url, data=body, headers=build_headers(session_id), method="POST")
|
||
try:
|
||
with urllib.request.urlopen(req) as resp:
|
||
response = json.loads(resp.read().decode("utf-8"))
|
||
uid = response.get("result", {}).get("uid")
|
||
return bool(uid)
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def notify_session_expired():
|
||
import os
|
||
os.system(
|
||
'osascript -e \'display notification '
|
||
'"Session Odoo expired. Buka run_daily.sh dan ganti SESSION_ID." '
|
||
'with title "⚠️ Timesheet Gagal" '
|
||
'subtitle "Session ID perlu diperbarui" '
|
||
'sound name "Basso"\''
|
||
)
|
||
print("SESSION EXPIRED — update SESSION_ID di run_daily.sh")
|
||
|
||
|
||
def search_task_in_project(session_id: str, code: str, project_id: int) -> tuple[int, str] | None:
|
||
"""Cari task di satu project spesifik."""
|
||
payload = {
|
||
"id": 1, "jsonrpc": "2.0", "method": "call",
|
||
"params": {
|
||
"model": "project.task", "method": "name_search", "args": [],
|
||
"kwargs": {
|
||
"name": f"[{code}]", "operator": "ilike",
|
||
"args": [
|
||
"&", "&", "&",
|
||
["company_id", "=", 1],
|
||
["project_id.allow_timesheets", "=", True],
|
||
["stage_id.fold", "=", False],
|
||
["project_id", "=", project_id],
|
||
],
|
||
"limit": 1,
|
||
"context": {
|
||
"lang": "en_US", "tz": "Asia/Jakarta", "uid": 41,
|
||
"allowed_company_ids": [1], "is_timesheet": 1,
|
||
"default_project_id": project_id,
|
||
},
|
||
},
|
||
},
|
||
}
|
||
result = odoo_call(session_id, "/web/dataset/call_kw/project.task/name_search", payload)
|
||
items = result.get("result", [])
|
||
return tuple(items[0]) if items else None
|
||
|
||
|
||
def search_task(session_id: str, code: str, project_id: int) -> tuple[int, str, int] | None:
|
||
"""
|
||
Cari task mulai dari project default repo.
|
||
Kalau tidak ketemu, fallback cari di semua project lain.
|
||
Return (task_id, task_name, actual_project_id).
|
||
"""
|
||
result = search_task_in_project(session_id, code, project_id)
|
||
if result:
|
||
return result[0], result[1], project_id
|
||
|
||
for name, pid in PROJECT_MAP.items():
|
||
if pid == project_id:
|
||
continue
|
||
result = search_task_in_project(session_id, code, pid)
|
||
if result:
|
||
return result[0], result[1], pid
|
||
|
||
return None
|
||
|
||
|
||
def upload_timesheet(session_id: str, entry: dict, user_id: int) -> int:
|
||
payload = {
|
||
"id": 1, "jsonrpc": "2.0", "method": "call",
|
||
"params": {
|
||
"model": "account.analytic.line", "method": "create",
|
||
"args": [entry],
|
||
"kwargs": {
|
||
"context": {
|
||
"lang": "en_US", "tz": "Asia/Jakarta", "uid": user_id,
|
||
"allowed_company_ids": [1], "is_timesheet": 1,
|
||
}
|
||
},
|
||
},
|
||
}
|
||
result = odoo_call(session_id, "/web/dataset/call_kw/account.analytic.line/create", payload)
|
||
return result.get("result")
|
||
|
||
|
||
# ── Git ───────────────────────────────────────────────────────────────────────
|
||
|
||
def get_commits_today(repo_path: str, author: str, today: str) -> list[dict]:
|
||
cmd = [
|
||
"git", "-C", repo_path, "log",
|
||
f"--author={author}",
|
||
f"--since={today} 00:00:00",
|
||
f"--until={today} 23:59:59",
|
||
"--format=%h|%ad|%s",
|
||
"--date=format:%Y-%m-%d %H:%M",
|
||
]
|
||
try:
|
||
out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL, text=True)
|
||
except subprocess.CalledProcessError:
|
||
return []
|
||
commits = []
|
||
for line in out.strip().splitlines():
|
||
if not line:
|
||
continue
|
||
parts = line.split("|", 2)
|
||
if len(parts) == 3:
|
||
dt = datetime.strptime(parts[1], "%Y-%m-%d %H:%M")
|
||
commits.append({
|
||
"hash": parts[0],
|
||
"date": dt.strftime("%Y-%m-%d"),
|
||
"time": dt.strftime("%H:%M"),
|
||
"dt": dt,
|
||
"message": parts[2],
|
||
})
|
||
return commits
|
||
|
||
|
||
# ── Pro-rata ──────────────────────────────────────────────────────────────────
|
||
|
||
SINGLE_COMMIT_MINUTES = 30 # bobot minimum untuk task dengan 1 commit
|
||
WORK_START_HOUR = 8 # jam mulai kerja
|
||
|
||
|
||
def span_minutes(timestamps: list[datetime], extend_to_work_start: bool = False) -> int:
|
||
"""
|
||
Menit dari start sampai commit terakhir. Minimum 30 menit.
|
||
Jika extend_to_work_start=True, start dihitung dari jam 08:00
|
||
(berlaku untuk task yang punya commit paling awal di hari itu).
|
||
"""
|
||
first = min(timestamps)
|
||
last = max(timestamps)
|
||
|
||
if extend_to_work_start:
|
||
start = first.replace(hour=WORK_START_HOUR, minute=0, second=0, microsecond=0)
|
||
else:
|
||
start = first
|
||
|
||
return max(
|
||
int((last - start).total_seconds() / 60),
|
||
SINGLE_COMMIT_MINUTES,
|
||
)
|
||
|
||
|
||
def distribute_hours(weights: list[int], total: float = 8.0) -> list[float]:
|
||
"""Pro-rata berdasarkan bobot (menit span). Sum = total. Adjustment di entry terakhir."""
|
||
total_weight = sum(weights)
|
||
raw = [Decimal(str(total)) * Decimal(w) / Decimal(total_weight) for w in weights]
|
||
rounded = [float(r.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)) for r in raw]
|
||
diff = round(total - sum(rounded), 2)
|
||
rounded[-1] = round(rounded[-1] + diff, 2)
|
||
return rounded
|
||
|
||
|
||
# ── Main ──────────────────────────────────────────────────────────────────────
|
||
|
||
def main():
|
||
today = date.today().isoformat()
|
||
|
||
parser = argparse.ArgumentParser(description="Daily timesheet: commit → Odoo (8 jam pro-rata)")
|
||
parser.add_argument("--session-id", required=True, help="session_id cookie Odoo")
|
||
parser.add_argument("--author", required=True, help="Git author filter, e.g. 'fajri'")
|
||
parser.add_argument("--user-id", required=True, type=int, help="ID user Odoo")
|
||
parser.add_argument("--employee-id", required=True, type=int, help="ID employee Odoo")
|
||
parser.add_argument("--date", default=today, help=f"Tanggal YYYY-MM-DD (default: {today})")
|
||
parser.add_argument("--dry-run", action="store_true", help="Preview saja, tidak upload")
|
||
parser.add_argument("--save-pending", action="store_true", help="Simpan ke pending.json + notifikasi macOS")
|
||
parser.add_argument("--yes", action="store_true", help="Skip konfirmasi, langsung upload")
|
||
args = parser.parse_args()
|
||
|
||
print(f"Tanggal : {args.date}")
|
||
print(f"Author : {args.author}")
|
||
if args.dry_run:
|
||
mode = "DRY RUN"
|
||
elif args.save_pending:
|
||
mode = "SAVE PENDING"
|
||
else:
|
||
mode = "UPLOAD"
|
||
print(f"Mode : {mode}")
|
||
print("=" * 65)
|
||
|
||
# Cek session sebelum mulai
|
||
if not check_session(args.session_id):
|
||
notify_session_expired()
|
||
return
|
||
|
||
# 1. Kumpulkan semua commit hari ini dari semua repo
|
||
raw_commits = []
|
||
for repo in REPOS:
|
||
commits = get_commits_today(repo["path"], args.author, args.date)
|
||
repo_name = repo["path"].split("/")[-1]
|
||
for c in commits:
|
||
m = COMMIT_RE.match(c["message"])
|
||
if m:
|
||
raw_commits.append({
|
||
"code": m.group(1),
|
||
"description": m.group(2),
|
||
"date": c["date"],
|
||
"time": c["time"],
|
||
"dt": c["dt"],
|
||
"hash": c["hash"],
|
||
"repo": repo_name,
|
||
"project": repo["project"],
|
||
"project_id": PROJECT_MAP[repo["project"]],
|
||
})
|
||
else:
|
||
print(f" SKIP {c['hash']} ({repo_name}): {c['message']}")
|
||
|
||
if not raw_commits:
|
||
print("\nTidak ada commit dengan format TASKCODE - deskripsi hari ini.")
|
||
return
|
||
|
||
# 2. Cari task_id di Odoo, group by (task_id, project_id)
|
||
print(f"\nMencari task di Odoo untuk {len(raw_commits)} commit...\n")
|
||
|
||
task_cache = {} # (code, project_id) → (task_id, task_name) | None
|
||
|
||
# Group: key = (task_id, project_id)
|
||
groups = defaultdict(lambda: {
|
||
"descriptions": [], "timestamps": [], "count": 0,
|
||
"project_id": None, "project": None, "task_name": None, "date": None,
|
||
})
|
||
|
||
not_found = []
|
||
for c in raw_commits:
|
||
cache_key = (c["code"], c["project_id"])
|
||
if cache_key not in task_cache:
|
||
task_cache[cache_key] = search_task(args.session_id, c["code"], c["project_id"])
|
||
|
||
task = task_cache[cache_key]
|
||
if not task:
|
||
not_found.append(c)
|
||
print(f" NOT FOUND [{c['code']}] di semua project ({c['hash']})")
|
||
continue
|
||
|
||
task_id, task_name, actual_project_id = task
|
||
if actual_project_id != c["project_id"]:
|
||
actual_name = next(k for k, v in PROJECT_MAP.items() if v == actual_project_id)
|
||
print(f" FALLBACK [{c['code']}] tidak ada di {c['project']}, ditemukan di {actual_name}")
|
||
key = (task_id, actual_project_id)
|
||
groups[key]["descriptions"].append(c["description"])
|
||
groups[key]["timestamps"].append(c["dt"])
|
||
groups[key]["count"] += 1
|
||
groups[key]["project_id"] = actual_project_id
|
||
groups[key]["project"] = next(k for k, v in PROJECT_MAP.items() if v == actual_project_id)
|
||
groups[key]["task_id"] = task_id
|
||
groups[key]["task_name"] = task_name
|
||
groups[key]["date"] = c["date"]
|
||
|
||
if not groups:
|
||
print("\nTidak ada task yang ditemukan di Odoo.")
|
||
return
|
||
|
||
# 3. Hitung pro-rata berdasarkan time span
|
||
keys = list(groups.keys())
|
||
|
||
# Task yang punya commit paling awal di hari itu → spannya dihitung dari 08:00
|
||
global_first_dt = min(min(groups[k]["timestamps"]) for k in keys)
|
||
first_task_key = next(
|
||
k for k in keys if global_first_dt in groups[k]["timestamps"]
|
||
)
|
||
|
||
spans = [
|
||
span_minutes(groups[k]["timestamps"], extend_to_work_start=(k == first_task_key))
|
||
for k in keys
|
||
]
|
||
hours = distribute_hours(spans, total=float(TOTAL_HOURS))
|
||
|
||
# 4. Tampilkan preview
|
||
print(f"\n{'─' * 78}")
|
||
print(f" {'PROJECT':<20} {'TASK':<10} {'WAKTU':<15} {'SPAN':>6} {'JAM':>5} DESKRIPSI")
|
||
print(f"{'─' * 78}")
|
||
|
||
entries = []
|
||
for key, h, span in zip(keys, hours, spans):
|
||
g = groups[key]
|
||
ts = sorted(g["timestamps"])
|
||
is_first = (key == first_task_key)
|
||
|
||
if is_first:
|
||
start_label = f"08:00→{ts[-1].strftime('%H:%M')}"
|
||
elif len(ts) == 1:
|
||
start_label = ts[0].strftime("%H:%M") + " (1x)"
|
||
else:
|
||
start_label = f"{ts[0].strftime('%H:%M')}–{ts[-1].strftime('%H:%M')}"
|
||
|
||
span_label = f"{span}m{'↑' if is_first else ''}" if span > SINGLE_COMMIT_MINUTES else "30m*"
|
||
desc = "; ".join(dict.fromkeys(g["descriptions"]))
|
||
print(f" {g['project']:<20} {str(g['task_id']):<10} {start_label:<15} {span_label:>6} {h:>5.2f} {desc[:28]}")
|
||
entries.append({
|
||
"odoo": {
|
||
"name": desc,
|
||
"date": g["date"],
|
||
"unit_amount": h,
|
||
"user_id": args.user_id,
|
||
"employee_id": args.employee_id,
|
||
"task_id": g["task_id"],
|
||
"project_id": g["project_id"],
|
||
},
|
||
"display": g,
|
||
})
|
||
|
||
print(f"{'─' * 78}")
|
||
total_span = sum(spans)
|
||
print(f" {'TOTAL':<20} {'':<10} {'':<15} {total_span:>5}m {sum(hours):>5.2f}")
|
||
print(f" ↑ span dihitung dari 08:00 | * single commit → minimum {SINGLE_COMMIT_MINUTES} menit")
|
||
|
||
if not_found:
|
||
print(f"\n {len(not_found)} commit diabaikan (task tidak ditemukan di Odoo)")
|
||
|
||
if args.dry_run:
|
||
print("\n[DRY RUN] Tidak ada yang diupload.")
|
||
return
|
||
|
||
# 5. Simpan pending.json + notifikasi macOS
|
||
if args.save_pending:
|
||
import os
|
||
pending_path = os.path.join(
|
||
os.path.dirname(os.path.abspath(__file__)),
|
||
f"pending_{args.date}.json"
|
||
)
|
||
pending = {
|
||
"date": args.date,
|
||
"user_id": args.user_id,
|
||
"employee_id": args.employee_id,
|
||
"entries": [e["odoo"] for e in entries],
|
||
}
|
||
with open(pending_path, "w") as f:
|
||
json.dump(pending, f, indent=2)
|
||
|
||
summary = ", ".join(
|
||
f"{e['odoo']['unit_amount']}h {e['display']['project']}"
|
||
for e in entries
|
||
)
|
||
msg = f"{len(entries)} entry siap ({summary})"
|
||
os.system(
|
||
f'osascript -e \'display notification "{msg}" '
|
||
f'with title "Timesheet {args.date}" '
|
||
f'subtitle "Jalankan: python3 upload_pending.py --session-id XXX"\''
|
||
)
|
||
print(f"\nPending disimpan: {pending_path}")
|
||
print("Notifikasi macOS dikirim.")
|
||
return
|
||
|
||
# 6. Konfirmasi & upload
|
||
if not args.yes:
|
||
confirm = input(f"\nUpload {len(entries)} timesheet entry? (y/N): ").strip().lower()
|
||
if confirm != "y":
|
||
print("Dibatalkan.")
|
||
return
|
||
|
||
print()
|
||
ok, fail = 0, 0
|
||
for e in entries:
|
||
try:
|
||
new_id = upload_timesheet(args.session_id, e["odoo"], args.user_id)
|
||
g = e["display"]
|
||
print(f" OK ID {new_id:<8} {g['project']:<20} {e['odoo']['unit_amount']}h {e['odoo']['name'][:40]}")
|
||
ok += 1
|
||
except RuntimeError as ex:
|
||
print(f" ERR {e['odoo']['name'][:40]} → {ex}")
|
||
fail += 1
|
||
|
||
print(f"\nSelesai: {ok} sukses, {fail} gagal.")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|