Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Kode
<a name="actions-code"></a>

Tindakan kode di Quick Automate memungkinkan Anda menerapkan logika khusus menggunakan blok kode Python, melampaui apa yang didukung tindakan otomatisasi standar. Mereka sangat cocok untuk transformasi dan perhitungan data yang kompleks, dan berjalan dalam lingkungan Python terbatas untuk menjaga keamanan.

**Dua Jenis Tindakan Kode:**
+ **Ekspresi Baris Tunggal:** Operasi satu baris cepat yang memodifikasi variabel tanpa mengembalikan nilai
+ **Blok Kode Kustom:** Fungsi Multi-line Python untuk logika kompleks dengan parameter dan nilai pengembalian

**Kapan menggunakan tindakan kode:**

Gunakan blok kode saat Anda perlu:
+ Lakukan transformasi data kompleks yang tidak tersedia dalam tindakan standar
+ Menerapkan logika atau perhitungan bisnis khusus
+ Memproses atau memanipulasi struktur data (daftar, kamus, JSON)
+ Bekerja dengan tanggal, waktu, dan zona waktu dengan cara khusus
+ Parse atau format string dengan pola yang kompleks
+ Optimalkan kinerja otomatisasi dengan mengkonsolidasikan beberapa tindakan ke dalam satu blok kode

**Kapan tidak menggunakan tindakan kode:**

Hindari pemblokiran kode saat:
+ Tindakan otomatisasi standar sudah ada untuk kasus penggunaan Anda
+ Operasi ini cukup sederhana untuk tindakan bawaan
+ Anda perlu berinteraksi dengan API eksternal (gunakan integrasi REST API sebagai gantinya)
+ Anda perlu mengakses sistem file atau database (menggunakan integrasi yang sesuai)

**Cara Mengakses tindakan kode:**

Blok kode tersedia melalui beberapa antarmuka:
+ **Panel Tindakan (Disarankan):**
  + Buka otomatisasi Anda di pembuat otomatisasi
  + Klik pada Panel Tindakan di sisi kanan
  + Temukan “Blok Kode Kustom” di bawah bagian Tindakan Kode
  + Seret dan jatuhkan blok kode ke dalam alur kerja otomatisasi Anda
+ **Membangun dengan Asisten:**
  + Tersedia selama pembuatan paket saat asisten menentukan kode kustom diperlukan
  + Asisten secara otomatis menyarankan blok kode untuk operasi yang kompleks
  + Anda dapat meminta blok kode dengan menjelaskan kebutuhan logika kustom Anda

**Tindakan yang tersedia:**

## Ekspresi Baris Tunggal
<a name="single-line-expressions"></a>

Ekspresi Baris Tunggal mengeksekusi pernyataan Python satu baris yang melakukan operasi tanpa mengembalikan nilai. Mereka ideal untuk modifikasi cepat ke variabel yang ada seperti menambahkan ke daftar, memperbarui kamus, atau melakukan perhitungan sederhana yang mengubah status.

**Properti:**
+ Expression (required): Ekspresi Python untuk mengeksekusi (misalnya, “my\_list.append ('item baru')”)

**Contoh:**
+ **Menambahkan ke daftar**

  ```
  my_list.append("1")
  my_list.append(new_item)
  ```
+ **Menghapus Item Daftar**

  ```
  task_list.remove(completed_task)
  ```

## Blok Kode Kustom
<a name="custom-code-block"></a>

Blok Kode Kustom adalah fungsi Python multi-baris yang menjalankan logika kompleks, menerima parameter, dan mengembalikan nilai. Mereka adalah opsi fallback ketika tindakan otomatisasi standar dan Ekspresi Garis Tunggal tidak cukup untuk kebutuhan Anda.

**Properti:**
+ **Judul Fungsi (wajib)**: Pengidentifikasi nama untuk blok kode (misalnya, "Calculate\_Total“)
+ **Fungsi (wajib):** Blok kode Python yang berisi logika kustom Anda.
  + Langkah 1: Tentukan Parameter
    + Klik tombol “Edit” untuk membuka editor kode
    + Di panel Parameter, klik “Tambah” untuk membuat parameter baru
    + Masukkan nama parameter yang cocok dengan variabel otomatisasi Anda
    + Parameter tersedia sebagai argumen fungsi
  + Langkah 2: Tulis Kode Python Anda
+ **Nilai Pengembalian (opsional):** Nama variabel untuk menyimpan output fungsi
  + Ikuti struktur blok kode yang diperlukan (lihat di bawah)
  + Menerapkan logika kustom Anda dalam fungsi
  + Gunakan hanya pustaka yang disetujui dan fungsi bawaan
  + Sertakan pernyataan pengembalian jika Anda perlu mengeluarkan data

**Struktur Blok Kode**

Semua blok kode harus mengikuti format khusus ini:

```
@code_block()
def your_function_name(parameter1, parameter2, parameter3):
-------------------------------------------------------------------------------------
    """
    Optional: Add a docstring describing what your function does
    """
    # Your custom logic here
    result = parameter1 + parameter2 + parameter3

    return result
```

**Built-in Fungsi dan Impor Python**

Semua fungsi bawaan Python standar tersedia tanpa impor (len, str, int, dll.)

**Perpustakaan Standar yang Disetujui (Keamanan Dibatasi)**

Blok kode HANYA dapat mengimpor pustaka standar ini:
+ `base64`- Base64 encoding/decoding
+ `datetime`- Tanggal dan waktu operasi
+ `json`- Penguraian dan generasi JSON
+ `math`- Fungsi matematika
+ `re`- Ekspresi reguler
+ `zoneinfo`- Penanganan zona waktu

**catatan**  
Tidak dapat mengimpor pustaka standar selain yang tercantum di atas.
Tidak dapat menginstal atau mengimpor pustaka pihak ketiga. `pip install`tidak didukung dalam blok kode.

**Batasan**
+ Lingkungan Python terbatas dengan akses perpustakaan terbatas. Lingkungan eksekusi didasarkan pada RestrictedPython, subset dari Python 3.10.
+ Blok kode tidak dapat memanggil blok atau tindakan kode lain

**Praktik Terbaik**
+ Jaga agar blok kode tetap sederhana dan fokus
+ Gunakan nama fungsi deskriptif
+ Selalu lebih suka tindakan yang dibuat sebelumnya bila tersedia
+ Uji blok kode Anda secara menyeluruh karena opsi debugging terfokus terbatas)

**Contoh Kasus Penggunaan**
+ Operasi matematika (Hitung properti lingkaran - radius sebagai parameter

  ```
  def function
  (radius):
  
      return {
          "radius": radius,
          "diameter": 2 * radius,
          "circumference": round(2 * math.pi * radius, 2),
          "area": round(math.pi * radius ** 2, 2)
      }
  ```
+ Mendapatkan saat ini date/time

  ```
  def function
  ():
  
      now = datetime.datetime.now()
  
      return {
          "current_date": now.strftime("%Y-%m-%d"),
          "current_time": now.strftime("%H:%M:%S"),
          "formatted": now.strftime("%B %d, %Y at %I:%M %p"),
          "iso_format": now.isoformat(),
          "timestamp": now.timestamp()
      }
  ```
+ Menghitung perbedaan tanggal - Tanggal mulai dan tanggal akhir sebagai parameter

  ```
  def function
  _(start_date_str, end_date_str):
  
  # Parse date strings (format: YYYY-MM-DD)_
      start = datetime.datetime.strptime(start_date_str, "%Y-%m-%d")
      end = datetime.datetime.strptime(end_date_str, "%Y-%m-%d")
  
      _# Calculate difference_
      difference = end - start
      return {
          "days": difference.days,
          "weeks": difference.days // 7,
          "start": start_date_str,
          "end": end_date_str    }
  ```
+ Pencocokan pola dan manipulasi teks menggunakan ekspresi reguler (Memvalidasi alamat email, nomor telepon, dll.)

  ```
  def function
  (email, phone, zip_code):
  
      email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
      phone_pattern = r'^\d{3}-\d{3}-\d{4}$'
      zip_pattern = r'^\d{5}(-\d{4})?$'
  
      return {
          "email_valid": bool(re.match(email_pattern, email)),
          "phone_valid": bool(re.match(phone_pattern, phone)),
          "zip_valid": bool(re.match(zip_pattern, zip_code))
      }
  ```
+ Operasi Daftar (Filter dan Transform List)

  ```
  def function
  (numbers, threshold):
  
      # Filter numbers above threshold and calculate statistics
      filtered = [n for n in numbers if n > threshold]
  
      if filtered:
          return {
              "filtered_numbers": filtered,
              "count": len(filtered),
              "sum": sum(filtered),
              "average": sum(filtered) / len(filtered),
              "min": min(filtered),
              "max": max(filtered)
          }
      else:
          return {
              "filtered_numbers": [],
              "count": 0,
              "message": "No numbers above threshold"
          }
  ```