Doc_chelvyn/Easset Mac/Duplikat Nomor Inventaris/Server Action Audit & Perba...

909 lines
20 KiB
Markdown
Raw Normal View History

---
proyek: e-Asset Patra Jasa
modul: pj_easset
kategori: Duplikat Nomor Inventaris
urutan-baca: 3 dari 3 — alat
tanggal: 2026-09-04
status: SA-1 siap pakai · SA-2 & SA-3 hasilnya AMAN · SA-4 menunggu keputusan cetak ulang label
tags:
- easset
- server-action
- runbook
- duplikat-nomor-inventaris
---
> Index: [[Easset — Index]] · Kasus: **Duplikat Nomor Inventaris** (3 dari 3 — alat)
> Laporan: [[Bug Report Duplikat Nomor Inventaris pada Data Aset]] ·
> Data hasil SA-1: [[Daftar Duplikat Nomor Inventaris — DB master3]]
**Tanggal dibuat:** 04 September 2026
**Project:** e-Asset Patra Jasa (`pj_easset`)
**Terkait:** [[Bug Report Duplikat Nomor Inventaris pada Data Aset]] (bug report) · [[Daftar Duplikat Nomor Inventaris — DB master3]] (data hasil SA-1)
**Status pemakaian:** SA-1 siap dipakai kapan saja · **SA-2 & SA-3 sudah dijalankan, hasilnya AMAN** · **SA-4 menunggu keputusan soal cetak ulang label**
> **Catatan 04 Sep 2026 (sesudah data diperiksa).** SA-2 dan SA-3 dibuat untuk membuktikan dua dugaan yang **ternyata tidak terbukti**: konfigurasi sequence per Jenis Aset sudah benar, dan pemecahan counter per tahun memang disengaja. Penyebab sebenarnya adalah **counter yang tertinggal jauh di belakang data** karena nomor dari impor tidak pernah memajukannya. Keduanya tetap berguna sebagai pemeriksaan berkala, tapi bukan lagi alat diagnosis utama untuk kasus ini. Prasyarat SA-4 soal "generator masih rusak" **sudah terpenuhi** — perbaikan generator sudah masuk di Rilis 1.
---
## Kegunaan Dokumen Ini
Kumpulan kode Server Action yang dijalankan **langsung dari UI Odoo**, tanpa akses psql maupun CLI ke server production. Dipakai untuk:
1. **Mendata** duplikat Nomor Inventaris yang sudah terlanjur ada (SA-1)
2. **Membuktikan** dugaan root cause pada konfigurasi master data (SA-2, SA-3)
3. **Membersihkan** duplikat setelah keputusan bisnis turun dan kode diperbaiki (SA-4)
Tiga yang pertama **read-only** — aman dijalankan di production kapan pun, termasuk saat jam kerja. Yang keempat **mengubah data** dan punya prasyarat ketat.
---
## Cara Membuat Server Action di UI
1. Aktifkan **Developer Mode**: **Pengaturan → Umum → Developer Tools → Activate the developer mode**
2. Buka **Pengaturan → Teknis → Tindakan → Tindakan Server** (*Settings → Technical → Actions → Server Actions*)
3. Klik **Baru**, lalu isi:
- **Nama Tindakan** — sesuai judul tiap SA di bawah
- **Model** — sesuai keterangan tiap SA
- **Jenis Tindakan** — **Jalankan Kode Python** (*Execute Python Code*)
4. Tempel kode ke kolom **Kode Python**
5. **Simpan**, lalu klik tombol **Jalankan** (*Run*) di kanan atas form
Untuk memunculkannya di menu roda gigi ⚙️ pada tampilan list, isi juga field **Available in the Actions menu** (`binding_model_id`) dengan model yang sama. Opsional — tombol **Jalankan** di form sudah cukup untuk pemakaian sesekali.
---
## Catatan Penting: Batasan Kode Server Action
Server Action dieksekusi lewat `safe_eval`, **bukan** Python biasa. Variabel yang tersedia hanya yang terdaftar di `odoo/addons/base/models/ir_actions.py:925-937`:
| Tersedia | Keterangan |
|---|---|
| `env` | Environment aktif |
| `model` | Model yang dipilih di field **Model** |
| `record` / `records` | Record aktif — `None` bila dijalankan dari tombol Run |
| `UserError` | Satu-satunya exception yang tersedia |
| `log(message, level)` | Menulis ke tabel `ir_logging` |
| `_logger` | Logger ke file log server |
| `datetime`, `time`, `dateutil`, `timezone` | Wrapper aman |
| `Command`, `float_compare`, `b64encode`, `b64decode` | Helper |
| `uid`, `user` | User yang menjalankan |
**Yang TIDAK tersedia** dan sering bikin error:
- ❌ `fields` — jadi `fields.Date.today()` **gagal**. Pakai `datetime.date.today()`
- ❌ `_` (fungsi terjemahan) — tulis string apa adanya
- ❌ `ValidationError`, `AccessError` — hanya `UserError` yang ada
- ❌ `import` apa pun
Cara menampilkan hasil ke layar: **`raise UserError("...")`**. Terdengar seperti error, tetapi inilah cara baku Odoo menampilkan teks laporan dari Server Action ke dialog UI. Karena `raise` membatalkan transaksi, ini justru **menjamin action read-only tidak meninggalkan perubahan apa pun**.
---
## SA-1 — Audit Duplikat Nomor Inventaris
> **Model:** `maintenance.equipment` (Peralatan / Aset)
> **Sifat:** 🟢 Read-only — aman dijalankan di production
> **Hasil:** membuka tampilan list berisi seluruh record yang nomornya kembar, sudah dikelompokkan per nomor
Menjawab pertanyaan: **berapa banyak duplikatnya, dan record mana saja?** Angka inilah yang menentukan besarnya pekerjaan pembersihan bila Opsi A yang dipilih PM.
```python
# Pengelompokan dijalankan di database lewat satu query read_group, bukan
# ditarik ke Python lalu dihitung manual. Pola ini sama dengan yang dipakai
# Dashboard Aset di controllers/maintenance/asset_dashboard.py:96.
#
# active_test=False supaya aset yang sudah diarsipkan ikut terhitung —
# duplikat tetap duplikat meski salah satu record sudah di-arsip.
groups = env['maintenance.equipment'].with_context(active_test=False).read_group(
domain=[('number', 'not in', [False, ''])],
fields=['number'],
groupby=['number'],
lazy=False,
)
duplicate_groups = [g for g in groups if g.get('__count', 0) > 1]
dup_numbers = [g['number'] for g in duplicate_groups]
if not dup_numbers:
raise UserError(
"HASIL AUDIT: BERSIH\n\n"
"Tidak ditemukan duplikat Nomor Inventaris.\n"
"Total nomor unik terdaftar: %s" % len(groups)
)
total_records = sum(g['__count'] for g in duplicate_groups)
worst = sorted(duplicate_groups, key=lambda g: g['__count'], reverse=True)[:10]
# Ringkasan ditulis ke ir_logging supaya ada jejak audit kapan dan oleh siapa
# pengecekan ini dijalankan.
log(
"Audit duplikat nomor inventaris: %s nomor kembar, %s record terdampak"
% (len(dup_numbers), total_records),
level="warning",
)
action = {
'type': 'ir.actions.act_window',
'name': 'Duplikat Nomor Inventaris — %s nomor / %s record' % (len(dup_numbers), total_records),
'res_model': 'maintenance.equipment',
'view_mode': 'list,form',
'domain': [('number', 'in', dup_numbers)],
'context': {'active_test': False, 'group_by': 'number'},
'target': 'current',
}
```
**Cara membaca hasilnya:** tampilan list terbuka dalam keadaan sudah ter-*group by* Nomor Inventaris. Setiap grup dengan jumlah lebih dari 1 adalah satu kasus duplikat. Judul jendela memuat totalnya.
Bila ingin ringkasan berupa teks saja tanpa membuka list, ganti blok `action = {...}` di atas dengan:
```python
lines = ['%s → %s record' % (g['number'], g['__count']) for g in worst]
raise UserError(
"HASIL AUDIT DUPLIKAT NOMOR INVENTARIS\n\n"
"Nomor kembar : %s\n"
"Record terdampak: %s\n\n"
"10 duplikat terbanyak:\n%s"
% (len(dup_numbers), total_records, "\n".join(lines))
)
```
---
## SA-2 — Audit Konfigurasi Jenis Aset vs Sequence
> **Model:** `maintenance.equipment.category` (Jenis Aset)
> **Sifat:** 🟢 Read-only — aman dijalankan di production
> **Hasil:** dialog berisi daftar Subklasifikasi yang berisiko menghasilkan nomor kembar
Ini **pembuktian otomatis atas Error 2** di bug report. Menggantikan Langkah Verifikasi 1–2 yang tadinya harus dikerjakan manual lewat *Group By*.
Yang dicari: Subklasifikasi yang dipakai oleh **lebih dari satu Jenis Aset**, dan Jenis Aset tersebut memakai **sequence yang berbeda-beda**. Kombinasi itulah yang dijamin menghasilkan nomor identik.
```python
rows = env['maintenance.equipment.category'].with_context(active_test=False).search_read(
domain=[('is_license', '=', False)],
fields=['name', 'maintenance_subclassification_id', 'sequence_id'],
)
# Pengelompokan pakai dict — bukan loop bersarang, dan tanpa query di dalamnya.
by_subclass = {}
for row in rows:
subclass = row['maintenance_subclassification_id']
if not subclass:
continue
entry = by_subclass.setdefault(subclass[0], {'name': subclass[1], 'categories': []})
entry['categories'].append(row)
risky = []
tanpa_sequence = []
jml_tanpa_sequence = 0
for subclass_id, entry in by_subclass.items():
categories = entry['categories']
# Jenis Aset TANPA sequence tidak pernah menghasilkan nomor sama sekali,
# jadi tidak mungkin menabrak siapa pun. Itu masalah lain — asetnya tidak
# dapat Nomor Inventaris — dan dilaporkan terpisah, bukan sebagai risiko
# duplikat. Menghitungnya sebagai "counter berbeda" hanya melahirkan
# peringatan palsu.
kosong = []
bersequence = []
for c in categories:
if c['sequence_id']:
bersequence.append(c)
else:
kosong.append(c['name'])
if kosong:
jml_tanpa_sequence += len(kosong)
tanpa_sequence.append('%s → %s' % (entry['name'], ", ".join(kosong)))
if len(bersequence) < 2:
continue
sequence_ids = set()
detail = []
for c in bersequence:
sequence_ids.add(c['sequence_id'][0])
detail.append(' - %s [sequence: %s]' % (c['name'], c['sequence_id'][1]))
if len(sequence_ids) < 2:
continue
risky.append('%s → %s Jenis Aset, %s sequence berbeda\n%s' % (
entry['name'], len(bersequence), len(sequence_ids), "\n".join(detail),
))
bagian = []
if risky:
bagian.append(
"RISIKO DUPLIKAT DITEMUKAN\n\n"
"%s Subklasifikasi di bawah ini dipakai oleh beberapa Jenis Aset dengan "
"sequence TERPISAH. Tiap sequence menghitung sendiri dari 1, sementara "
"prefix nomor hanya mengambil kode Subklasifikasi — sehingga nomor yang "
"dihasilkan dijamin kembar.\n\n%s" % (len(risky), "\n\n".join(risky))
)
else:
bagian.append(
"RISIKO DUPLIKAT: TIDAK ADA\n\n"
"Seluruh Jenis Aset di bawah satu Subklasifikasi memakai sequence yang "
"sama. Konfigurasi sudah benar."
)
if tanpa_sequence:
bagian.append(
"CATATAN TERPISAH — BUKAN RISIKO DUPLIKAT\n\n"
"%s Jenis Aset belum punya sequence. Aset di bawahnya tidak akan "
"mendapat Nomor Inventaris sama sekali (nomornya kosong), tetapi juga "
"tidak bisa menabrak nomor milik aset lain.\n\n%s"
% (jml_tanpa_sequence, "\n".join(tanpa_sequence))
)
raise UserError("\n\n".join(bagian))
```
**Cara membaca hasilnya:**
- **"AMAN"** → Error 2 gugur sebagai penyebab. Tersangka bergeser ke SA-3 atau ke jalur import.
- **"DITEMUKAN RISIKO"** → Error 2 terbukti. Daftar yang muncul adalah Subklasifikasi yang wajib dibereskan konfigurasinya, bukan sekadar datanya.
---
## SA-3 — Audit Date Range pada Sequence
> **Model:** `maintenance.equipment.category` (Jenis Aset)
> **Sifat:** 🟢 Read-only — aman dijalankan di production
> **Hasil:** dialog berisi daftar sequence yang counter-nya me-reset per rentang tanggal
Pembuktian **Error 3**. Sequence dengan **Use Date Range** aktif akan memulai hitungan dari 1 lagi di tiap rentang tanggal, padahal unsur tahun tidak pernah muncul di nomor akhir. Faktor ini bisa memicu duplikat **walaupun tiap Jenis Aset sudah punya Subklasifikasi sendiri**.
```python
rows = env['maintenance.equipment.category'].with_context(active_test=False).search_read(
domain=[('sequence_id', '!=', False), ('is_license', '=', False)],
fields=['name', 'sequence_id'],
)
if not rows:
raise UserError("Tidak ada Jenis Aset yang punya sequence. Periksa konfigurasi master data.")
sequence_ids = list({row['sequence_id'][0] for row in rows})
# ir.sequence perlu sudo() — user biasa umumnya tidak punya akses baca ke model
# teknis ini.
dated = env['ir.sequence'].sudo().search_read(
domain=[('id', 'in', sequence_ids), ('use_date_range', '=', True)],
fields=['name', 'prefix', 'padding'],
)
if not dated:
raise UserError(
"AMAN\n\n"
"Dari %s sequence yang dipakai Jenis Aset, tidak ada satu pun yang "
"mengaktifkan Use Date Range." % len(sequence_ids)
)
# Use Date Range HANYA berbahaya kalau tahun tidak ikut muncul di nomor akhir.
# Bila prefix memuat %(year)s atau %(range_year)s, counter yang me-reset tiap
# tahun justru BENAR dan disengaja: A-2023-0001 dan A-2024-0001 adalah dua
# nomor yang berbeda. Memvonis semua date range sebagai masalah hanya
# menghasilkan alarm palsu.
berisiko = []
aman = []
for d in dated:
prefix = d['prefix'] or ''
baris = '%s [prefix: %s]' % (d['name'], prefix or '(kosong)')
if '%(year)s' in prefix or '%(range_year)s' in prefix:
aman.append(baris)
else:
berisiko.append(baris)
if not berisiko:
raise UserError(
"AMAN\n\n"
"%s sequence memakai Use Date Range, dan SELURUHNYA memuat unsur tahun "
"pada prefix. Counter yang me-reset tiap tahun memang disengaja dan "
"tidak menghasilkan duplikat.\n\n%s" % (len(aman), "\n".join(aman))
)
raise UserError(
"RISIKO DUPLIKAT DITEMUKAN\n\n"
"%s sequence di bawah ini memakai Use Date Range TANPA unsur tahun pada "
"prefix. Counter me-reset tiap rentang tanggal sementara nomor akhirnya "
"tidak membedakan tahun, sehingga nomor yang sama terulang antar "
"periode.\n\n%s\n\nSequence yang sudah benar (tahun ikut di prefix): %s"
% (len(berisiko), "\n".join(berisiko), len(aman))
)
```
---
## SA-4 — Penomoran Ulang Duplikat
> **Model:** `maintenance.equipment` (Peralatan / Aset)
> **Sifat:** 🔴 **MENGUBAH DATA** — jangan dijalankan sebelum prasyarat terpenuhi
> **Hasil:** laporan pemetaan nomor lama → nomor baru
### ⛔ Prasyarat wajib — penuhi semuanya sebelum menjalankan
1. **PM sudah memutuskan Opsi A** (Nomor Inventaris wajib unik). Bila yang dipilih Opsi B, action ini **tidak relevan** dan tidak boleh dijalankan.
2. ~~**Akar masalahnya sudah diperbaiki lebih dulu di kode.**~~ ✅ **Sudah terpenuhi.** `_generate_equipment_number()` kini memeriksa tabrakan dan memajukan counter yang tertinggal sebelum mengembalikan nomor, jadi nomor pengganti yang dihasilkan SA-4 dijamin bebas bentrok. Sudah diuji: impor 30 aset lintas tahun menghasilkan 30 nomor unik tanpa satu pun bentrok dengan data lama.
3. **`pg_dump` database sudah diambil** dan sudah diverifikasi bisa di-restore.
4. **Dijalankan di staging lebih dulu** memakai salinan data production.
5. **Sudah dijalankan dalam mode `DRY_RUN = True`**, dan hasil pemetaannya sudah dibaca serta disetujui.
### Konsekuensi di lapangan
Nomor Inventaris tercetak pada QR barcode dan label fisik aset (`snk_maintenance_equipment.py:531-550`). Setiap nomor yang berubah **menuntut pencetakan dan penempelan ulang label di lapangan**. Laporan keluaran action ini adalah daftar kerja tim lapangan — simpan hasilnya.
### Kode
```python
# ═══════════════════════════════════════════════════════════════════
# UBAH KE False HANYA SETELAH SELURUH PRASYARAT DI ATAS TERPENUHI
# dan hasil dry-run sudah diperiksa serta disetujui.
# ═══════════════════════════════════════════════════════════════════
DRY_RUN = True
Equipment = env['maintenance.equipment'].with_context(active_test=False)
groups = Equipment.read_group(
domain=[('number', 'not in', [False, ''])],
fields=['number'],
groupby=['number'],
lazy=False,
)
dup_numbers = [g['number'] for g in groups if g.get('__count', 0) > 1]
if not dup_numbers:
raise UserError("Tidak ada duplikat Nomor Inventaris. Tidak ada yang perlu dikerjakan.")
# order='number, id' memastikan record TERTUA (id terkecil) berada di urutan
# pertama tiap kelompok — record itulah yang nomornya dipertahankan.
duplicates = Equipment.search([('number', 'in', dup_numbers)], order='number, id')
by_number = {}
for rec in duplicates:
by_number.setdefault(rec.number, []).append(rec)
# Diratakan pakai extend, bukan loop bersarang: yang dipertahankan adalah
# elemen pertama, sisanya masuk antrean penomoran ulang.
to_renumber = []
for number, recs in by_number.items():
to_renumber.extend(recs[1:])
report = []
skipped = []
changed = 0
for rec in to_renumber:
old_number = rec.number
new_number = rec._generate_equipment_number()
if not new_number:
skipped.append('%s (id %s) — sequence Jenis Aset atau Subklasifikasi belum lengkap' % (old_number, rec.id))
continue
report.append('%s → %s [id %s] %s' % (old_number, new_number, rec.id, rec.display_name or ''))
if not DRY_RUN:
# write per record memang tidak bisa dijadikan bulk: tiap record
# menerima nilai yang BERBEDA, dan next_by_id() sendiri menulis ke
# ir.sequence tiap kali dipanggil.
# safe_eval memblokir STORE_ATTR, jadi `rec.number = x` DITOLAK di
# server action. Nilainya harus ditulis lewat write().
rec.with_context(skip_validation_check=True).write({'number': new_number})
# Barcode wajib dibuat ulang, isinya adalah nomor inventaris.
rec.generate_barcode()
changed += 1
if not DRY_RUN:
log("Penomoran ulang duplikat nomor inventaris: %s record diubah oleh %s" % (changed, user.name), level="warning")
header = "MODE UJI COBA (DRY RUN) — TIDAK ADA DATA YANG DIUBAH" if DRY_RUN else "DATA TELAH DIUBAH — %s record" % changed
body = "\n".join(report) if report else "(tidak ada)"
skip_body = ("\n\nDILEWATI (master data belum lengkap):\n" + "\n".join(skipped)) if skipped else ""
message = (
"%s\n\n"
"Nomor kembar : %s\n"
"Record dipertahankan: %s (tertua per nomor)\n"
"Record dinomori ulang: %s\n\n"
"PEMETAAN NOMOR LAMA → NOMOR BARU\n"
"(salin daftar ini — jadi acuan cetak ulang label di lapangan)\n\n%s%s"
% (header, len(dup_numbers), len(by_number), len(report), body, skip_body)
)
if DRY_RUN:
# raise membatalkan transaksi — inilah yang menjamin dry-run benar-benar
# tidak meninggalkan perubahan apa pun di database.
raise UserError(message)
raise UserError(message)
```
### Kenapa baris terakhir tetap `raise` walau bukan dry-run
`raise UserError` **membatalkan transaksi**, termasuk perubahan yang baru saja ditulis. Jadi pada kode di atas, versi `DRY_RUN = False` pun **belum benar-benar menyimpan** — ini disengaja sebagai lapisan pengaman terakhir.
Ketika benar-benar siap mengeksekusi, ganti dua baris penutup itu menjadi:
```python
action = {
'type': 'ir.actions.client',
'tag': 'display_notification',
'params': {
'title': 'Penomoran ulang selesai',
'message': '%s record telah dinomori ulang. Periksa log untuk pemetaan lengkap.' % changed,
'type': 'success',
'sticky': True,
},
}
```
Sebelum menggantinya, **simpan dulu keluaran dry-run** — pemetaan nomor lama → nomor baru tidak akan bisa direkonstruksi setelah data berubah.
---
## Urutan Pemakaian yang Disarankan
| Tahap | Action | Tujuan | Kapan |
|---|---|---|---|
| 1 | **SA-1** | Mengukur besaran duplikat | ✅ Sudah — hasilnya 48 nomor / 96 record |
| 2 | **SA-2** | Membuktikan Error 2 | ✅ Sudah — hasilnya AMAN, dugaan gugur |
| 3 | **SA-3** | Membuktikan Error 3 | ✅ Sudah — hasilnya AMAN, dugaan gugur |
| 4 | — | **Perbaikan generator + validasi impor** | ✅ Sudah — Rilis 1, teruji di DB dev |
| 5 | — | **Rilis 1 naik ke production** | Menunggu — aman kapan saja |
| 6 | **SA-4** dry-run | Menyusun rencana penomoran ulang | Setelah Rilis 1 naik, di staging |
| 7 | — | **Persetujuan cetak ulang 48 label** | Menunggu keputusan tim lapangan |
| 8 | **SA-4** eksekusi | Pembersihan data | Setelah dry-run disetujui + `pg_dump` diambil |
| 9 | — | **Unique index (Rilis 2)** | Setelah data bersih |
Tahap 1–3 tidak perlu menunggu siapa pun. Justru hasilnya yang membuat keputusan di tahap 4 punya dasar angka.
---
## Catatan Tambahan
- **Server Action bersifat sementara, bukan pengganti perbaikan kode.** SA-4 hanya membereskan data yang sudah rusak. Selama `_generate_equipment_number()` belum diperbaiki, duplikat baru akan terus bermunculan. Perbaikan permanen tetap harus masuk ke repository lengkap dengan migration script — naikkan `version` di `__manifest__.py`, buat `migrations/<version>/pre-migrate.py` yang idempotent.
- **Jangan menyimpan SA-4 dalam keadaan `DRY_RUN = False`.** Setelah selesai dipakai, kembalikan ke `True` atau hapus server action-nya, agar tidak ada yang menjalankannya tanpa sengaja lewat menu roda gigi.
- **SA-1 s/d SA-3 layak dijadwalkan berkala.** Setelah perbaikan naik ke production, jalankan SA-1 sesekali untuk memastikan tidak ada duplikat baru yang lolos.
- **Seluruh action di sini memakai ORM, bukan SQL mentah**, sehingga cache, hak akses, dan constraint Odoo tetap dihormati — sesuai standar yang berlaku di project ini.