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

909 lines
20 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

---
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.