363 lines
14 KiB
Python
Executable File
363 lines
14 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 = jumlah commit per task. Total = 8 jam.
|
|
Contoh: Task A 3 commit + Task B 1 commit → A=6h, B=2h.
|
|
"""
|
|
|
|
import json
|
|
import re
|
|
import subprocess
|
|
import urllib.request
|
|
import urllib.error
|
|
import argparse
|
|
from datetime import date, timedelta
|
|
from collections import defaultdict
|
|
from decimal import Decimal, ROUND_HALF_UP
|
|
|
|
BASE_URL = "https://odoo.minipc.sismedika.biz.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", "project": "IBL"},
|
|
{"path": "/Users/fajrihardhitamurti/REPO_GITEA_KD", "project": "Support Kedungdoro"},
|
|
{"path": "/Users/fajrihardhitamurti/REPO_GITLAB_PRAMITA/bisone", "project": "Support Pramita"},
|
|
]
|
|
|
|
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(session_id: str, code: str, project_id: int) -> tuple[int, str] | None:
|
|
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 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]:
|
|
until = (date.fromisoformat(today) + timedelta(days=1)).isoformat()
|
|
cmd = [
|
|
"git", "-C", repo_path, "log",
|
|
f"--author={author}",
|
|
f"--after={today}",
|
|
f"--before={until}",
|
|
"--format=%h|%ad|%s",
|
|
"--date=short",
|
|
]
|
|
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:
|
|
commits.append({"hash": parts[0], "date": parts[1], "message": parts[2]})
|
|
return commits
|
|
|
|
|
|
# ── Pro-rata ──────────────────────────────────────────────────────────────────
|
|
|
|
def distribute_hours(weights: list[int], total: float = 8.0) -> list[float]:
|
|
"""
|
|
Distribusi jam pro-rata berdasarkan bobot (jumlah commit).
|
|
Adjustment di entry terakhir supaya sum persis = total.
|
|
"""
|
|
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")
|
|
args = parser.parse_args()
|
|
|
|
print(f"Tanggal : {args.date}")
|
|
print(f"Author : {args.author}")
|
|
print(f"Mode : {'DRY RUN' if args.dry_run else 'UPLOAD'}")
|
|
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"],
|
|
"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), value = list of commit descriptions & count
|
|
groups = defaultdict(lambda: {"descriptions": [], "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 project {c['project']} ({c['hash']})")
|
|
continue
|
|
|
|
task_id, task_name = task
|
|
key = (task_id, c["project_id"])
|
|
groups[key]["descriptions"].append(c["description"])
|
|
groups[key]["count"] += 1
|
|
groups[key]["project_id"] = c["project_id"]
|
|
groups[key]["project"] = c["project"]
|
|
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 jam
|
|
keys = list(groups.keys())
|
|
weights = [groups[k]["count"] for k in keys]
|
|
hours = distribute_hours(weights, total=float(TOTAL_HOURS))
|
|
|
|
# 4. Tampilkan preview
|
|
print(f"\n{'─' * 65}")
|
|
print(f" {'PROJECT':<20} {'TASK':<10} {'JAM':>5} {'COMMIT':>6} DESKRIPSI")
|
|
print(f"{'─' * 65}")
|
|
|
|
entries = []
|
|
for key, h in zip(keys, hours):
|
|
g = groups[key]
|
|
desc = g["descriptions"][0] if len(g["descriptions"]) == 1 else \
|
|
"; ".join(dict.fromkeys(g["descriptions"])) # deduplicate, preserve order
|
|
print(f" {g['project']:<20} {str(g['task_id']):<10} {h:>5.2f} {g['count']:>6}x {desc[:35]}")
|
|
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"{'─' * 65}")
|
|
print(f" {'TOTAL':<20} {'':<10} {sum(hours):>5.2f} {sum(weights):>6}x")
|
|
|
|
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
|
|
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()
|