Tips Custom Odoo dengan mindset "Techno-Functional"

Bismillah,
Assalamu'alaikum Warohmatullah Wabarokatuh,

Di artikel kali ini, insyaAllah saya akan memberikan sedikit tips bagaimana cara custom odoo dengan mindset seorang Techno-Functional
Techno-Functional adalah seseorang yang memiliki kemampuan ganda (multi skill) dari sisi fungsional dan technical.

kemampuan fungsional contohnya :
- Mampu berinteraksi dengan user terkait proses bisnis
- Memahami proses bisnis dan kebutuhan user
- Melakukan testing dengan berbagai kasus dan melakukan UAT (User Acceptance Test)
- Membuat dokumen requirement user
- Membuat dokumentasi
- Melakukan konfigurasi terkait penggunaan sistem

kemampuan technical contohnya :
- Menulis code
- Bugs fixing
- Testing atas code yang dibuat

Seperti yang kita tahu bahwa, Odoo adalah aplikasi ERP yang siap digunakan, tapi pada implementasinya akan ada penyesuaian dengan user yang akan menggunakan aplikasi Odoo ini.

Ketika ada permintaan dari user untuk menamambahkan suatu fitur, langkah yang dilakukan diantaranya :

1. Cek terlebih dahulu apakah fitur tersebut sudah tersedia di Odoo atau belum

Hal ini bisa diketahui dari kemampuan functional kita atau seberapa jauh pengalaman kita dalam implementasi odoo, setelah kita mencari tahu dengan mencoba langsung atau googling tapi tidak menemukannya, minimal kita bertanya terlebih dahulu kepada yang lebih senior, jangan langsung custom apa yang diinginkan oleh user

2. Jika fitur yang diminta tidak ada, coba tawarkan solusi yang lain yang tersedia

Odoo merupakan aplikasi yang sudah best practice, fitur-fiturnya sudah mengakomodir kebutuhan proses bisnis secara umum. Jadi, jangan terburu-buru untuk kita custom.
Misalnya user meminta adanya fitur giro atau check, dimana di odoo secara eksplisit tidak ada fitur tersebut, dengan kita memahami fungsi fitur tersebut dan membandingkan dengan proses yang ada di Odoo kita bisa menggunakan fitur Customer Payment atau Vendor Payment yang secara fungsi mirip dengan konsep giro atau check.
Hal ini akan menghemat waktu dan tenaga kita untuk meminimalisir proses custom.

3. Jika harus custom, jangan mudah membuat object baru

Misalnya dalam perusahaan travel umroh ada proses pendaftaran, dimana proses pendaftaran itu mirip dengan proses penjualan odoo, maka bisa kita gunakan fitur sales order, sedangkan untuk atribut yang tidak ada di odoo bisa kita tambahkan sebagai field baru atau elemen yang lain. Hal ini akan meminimalisir terjadinya banyak custom dan keluar dari flow proses odoo.

4. Sering mengecek code original odoo, bisa jadi ada object, field, function yang bisa kita gunakan untuk meminimalisir custom

Misalnya dari fitur product pricelist, dalam membuat pricelist dengan tipe formula terdapat field Rounding Method atau pembulatan, dimana pembulatan yang ada hanya dengan format HALF-UP (dibulatkan keatas jika setengah keatas), sedangkan user meminta agar pricelist dibulatkan ke bawah walaupun nilainya diatas setengah dari nilai pembulatannya. Hal ini akan beresiko jika langsung kita custom tanpa memperdulikan efek samping ke yang lain, jadi solusinya kita cek apakah didalam code original odoo terdapat fungsi yang bisa kita gunakan. Jika dicek ternyata kita cukup menambahkan parameter tipe pembulatannya saja yaitu UP, DOWN atau HALF-UP saja di code fungsi pembulatannya.

class PricelistItem(models.Model):
    _inherit = "product.pricelist.item"

    rounding_method = fields.Selection([('UP','UP'),('DOWN','DOWN'),('HALF-UP','HALF-UP')], string="Rounding Type", default="HALF-UP")
    
    @api.depends_context('lang')
    @api.depends('compute_price', 'price_discount', 'price_surcharge', 'base', 'price_round')
    def _compute_rule_tip(self):
        base_selection_vals = {elem[0]: elem[1] for elem in self._fields['base']._description_selection(self.env)}
        self.rule_tip = False
        for item in self:
            if item.compute_price != 'formula':
                continue
            base_amount = 100
            discount_factor = (100 - item.price_discount) / 100
            discounted_price = base_amount * discount_factor
            if item.price_round:
                # Tambah Rounding Method
                discounted_price = tools.float_round(discounted_price, precision_rounding=item.price_round, rounding_method=item.rounding_method)
            surcharge = tools.format_amount(item.env, item.price_surcharge, item.currency_id)
            item.rule_tip = _(
                "%(base)s with a %(discount)s %% discount and %(surcharge)s extra fee\n"
                "Example: %(amount)s * %(discount_charge)s + %(price_surcharge)s → %(total_amount)s",
                base=base_selection_vals[item.base],
                discount=item.price_discount,
                surcharge=surcharge,
                amount=tools.format_amount(item.env, 100, item.currency_id),
                discount_charge=discount_factor,
                price_surcharge=surcharge,
                total_amount=tools.format_amount(
                    item.env, discounted_price + item.price_surcharge, item.currency_id),
            )

    def _compute_price(self, product, quantity, uom, date, currency=None):
        """Compute the unit price of a product in the context of a pricelist application.

        :param product: recordset of product (product.product/product.template)
        :param float qty: quantity of products requested (in given uom)
        :param uom: unit of measure (uom.uom record)
        :param datetime date: date to use for price computation and currency conversions
        :param currency: pricelist currency (for the specific case where self is empty)

        :returns: price according to pricelist rule, expressed in pricelist currency
        :rtype: float
        """
        product.ensure_one()
        uom.ensure_one()

        currency = currency or self.currency_id
        currency.ensure_one()

        #  specific values are specified according to product UoM
        # and must be multiplied according to the factor between uoms
        product_uom = product.uom_id
        if product_uom != uom:
            convert = lambda p: product_uom._compute_price(p, uom)
        else:
            convert = lambda p: p

        if self.compute_price == 'fixed':
            price = convert(self.fixed_price)
        elif self.compute_price == 'percentage':
            base_price = self._compute_base_price(product, quantity, uom, date, currency)
            price = (base_price - (base_price * (self.percent_price / 100))) or 0.0
        elif self.compute_price == 'formula':
            base_price = self._compute_base_price(product, quantity, uom, date, currency)
            # complete formula
            price_limit = base_price
            price = (base_price - (base_price * (self.price_discount / 100))) or 0.0
            # Tambah Rounding Method
            if self.price_round:
                price = tools.float_round(price, precision_rounding=self.price_round, rounding_method=self.rounding_method)

            if self.price_surcharge:
                price += convert(self.price_surcharge)

            if self.price_min_margin:
                price = max(price, price_limit + convert(self.price_min_margin))

            if self.price_max_margin:
                price = min(price, price_limit + convert(self.price_max_margin))
        else:  # empty self, or extended pricelist price computation logic
            price = self._compute_base_price(product, quantity, uom, date, currency)

        return price

Terima kasih, semoga bermanfaat.

Kahfi

Wassalamu'alaikum Warohmatullah Wabarokatuh

Penggunaan Stable Diffusion di Odoo 16