ตารางเวลาการโอน

ตารางเวลาการโอนช่วยให้คุณสามารถอัตโนมัติการชำระเงินปกติ การประมวลผลเงินเดือน และการชำระเงินให้ผู้ขายอย่างสมบูรณ์ คู่มือนี้อธิบายวิธีการสร้างตารางเวลา ตั้งค่ารูปแบบการทำซ้ำ และจัดการเพย์เอาต์อัตโนมัติ

ภาพรวม

ตารางเวลาการโอนช่วยให้คุณสามารถ:

• การชำระเงินเป็นระยะ: เพย์เอาต์รายวัน รายสัปดาห์ รายเดือน
• ตารางเวลาที่ยืดหยุ่น: รองรับรูปแบบโดยเฉพาะ
• การประมวลผลอัตโนมัติ: ไม่ต้องใช้การดำเนินการด้วยตนเอง
• การควบคุมแบบเต็ม: หยุดพักชั่วคราว ทำให้กลับมาใช้งาน ยกเลิกตารางเวลา
• การจัดการข้อผิดพลาด: รับการแจ้งเตือนสำหรับการโอนตามกำหนดเวลาที่ล้มเหลว
• การตรวจสอบ: ติดตามการทำงานตามกำหนดเวลาแบบเรียลไทม์

การสร้างตารางเวลา

ตารางเวลาเงินเดือนรายเดือน

const omise = require('omise')({
  secretKey: 'skey_test_123456789'
});

async function createMonthlyPayrollSchedule(recipientId, monthlyAmount) {
  const schedule = await omise.schedules.create({
    every: 1,
    period: 'month',
    recipient: recipientId,
    transfer: {
      amount: monthlyAmount
    },
    metadata: {
      type: 'monthly_salary',
      purpose: 'Employee compensation'
    }
  });

  console.log('Schedule created:', schedule.id);
  console.log('Next scheduled:', schedule.next_occurrence);
  console.log('Recipient:', schedule.recipient);

  return schedule;
}

// ตัวอย่างการใช้งาน: สร้างตารางเวลาเงินเดือนรายเดือน
createMonthlyPayrollSchedule('recp_test_123456', 5000000); // 50,000 THB

ตารางเวลาการชำระเงินรายสัปดาห์

async function createWeeklyPayoutSchedule(recipientId, weeklyAmount, dayOfWeek = 'monday') {
  const schedule = await omise.schedules.create({
    every: 1,
    period: 'week',
    weekdays: [dayOfWeek],
    recipient: recipientId,
    transfer: {
      amount: weeklyAmount
    },
    metadata: {
      type: 'weekly_vendor_payment',
      vendor_id: 'VENDOR-001'
    }
  });

  return schedule;
}

ตารางเวลาการชำระเงินสองสัปดาห์

async function createBiWeeklySchedule(recipientId, biWeeklyAmount, startDate) {
  const schedule = await omise.schedules.create({
    every: 2,
    period: 'week',
    start_date: startDate,
    recipient: recipientId,
    transfer: {
      amount: biWeeklyAmount
    },
    metadata: {
      type: 'bi_weekly_payment'
    }
  });

  return schedule;
}

การจัดการตารางเวลา

รับรายละเอียดตารางเวลา

async function getScheduleDetails(scheduleId) {
  const schedule = await omise.schedules.retrieve(scheduleId);

  console.log('Schedule ID:', schedule.id);
  console.log('Status:', schedule.status);
  console.log('Recipient:', schedule.recipient);
  console.log('Amount:', schedule.transfer.amount / 100, 'THB');
  console.log('Period:', schedule.every, schedule.period);
  console.log('Next occurrence:', schedule.next_occurrence);

  return schedule;
}

รายชื่อตารางเวลาทั้งหมด

async function listAllSchedules(status = 'active') {
  const schedules = await omise.schedules.list({
    status: status,
    limit: 100
  });

  schedules.data.forEach(schedule => {
    console.log(`${schedule.id}: ${schedule.transfer.amount / 100} THB - ${schedule.status}`);
  });

  return schedules;
}

อัปเดตตารางเวลา

async function updateScheduleAmount(scheduleId, newAmount) {
  const schedule = await omise.schedules.update(scheduleId, {
    transfer: {
      amount: newAmount
    }
  });

  console.log('Schedule updated:', schedule.id);
  console.log('New amount:', schedule.transfer.amount / 100, 'THB');

  return schedule;
}

หยุดพักชั่วคราว/ทำให้กลับมาใช้งานตารางเวลา

async function pauseSchedule(scheduleId) {
  const schedule = await omise.schedules.update(scheduleId, {
    status: 'paused'
  });

  console.log('Schedule paused:', schedule.id);
  return schedule;
}

async function resumeSchedule(scheduleId) {
  const schedule = await omise.schedules.update(scheduleId, {
    status: 'active'
  });

  console.log('Schedule resumed:', schedule.id);
  return schedule;
}

ยกเลิกตารางเวลา

async function cancelSchedule(scheduleId) {
  const schedule = await omise.schedules.destroy(scheduleId);

  console.log('Schedule cancelled:', schedule.id);
  return schedule;
}

ตัวอย่างกรณีการใช้งานทั่วไป

ตารางเวลาการประมวลผลเงินเดือน

class PayrollScheduleManager:
    def __init__(self, omise_client):
        self.omise = omise_client

    def create_payroll_schedules(self, employees):
        """สร้างตารางเวลาเงินเดือนสำหรับพนักงานหลายคน"""
        schedules = []

        for employee in employees:
            try:
                schedule = self.omise.schedules.create(
                    every=1,
                    period='month',
                    recipient=employee['recipient_id'],
                    transfer={
                        'amount': employee['monthly_salary']
                    },
                    metadata={
                        'type': 'monthly_payroll',
                        'employee_id': employee['employee_id'],
                        'employee_name': employee['name'],
                        'department': employee['department']
                    }
                )

                schedules.append({
                    'employee_id': employee['employee_id'],
                    'employee_name': employee['name'],
                    'schedule_id': schedule.id,
                    'status': 'created'
                })

                print(f"✓ Created schedule for {employee['name']}")

            except Exception as e:
                schedules.append({
                    'employee_id': employee['employee_id'],
                    'employee_name': employee['name'],
                    'error': str(e),
                    'status': 'failed'
                })
                print(f"✗ Failed for {employee['name']}: {str(e)}")

        return schedules

    def pause_all_schedules(self, department):
        """หยุดพักชั่วคราวตารางเวลาทั้งหมดในแผนก"""
        schedules = self.omise.schedules.list(limit=100)
        paused = []

        for schedule in schedules.data:
            if schedule.metadata.get('department') == department:
                try:
                    self.omise.schedules.update(schedule.id, status='paused')
                    paused.append(schedule.id)
                except Exception as e:
                    print(f"Failed to pause {schedule.id}: {str(e)}")

        print(f"Paused {len(paused)} schedules")
        return paused

    def resume_paused_schedules(self, department):
        """ทำให้กลับมาใช้งานตารางเวลาที่หยุดพักชั่วคราวในแผนก"""
        schedules = self.omise.schedules.list(
            status='paused',
            limit=100
        )
        resumed = []

        for schedule in schedules.data:
            if schedule.metadata.get('department') == department:
                try:
                    self.omise.schedules.update(schedule.id, status='active')
                    resumed.append(schedule.id)
                except Exception as e:
                    print(f"Failed to resume {schedule.id}: {str(e)}")

        return resumed

ตารางเวลาการชำระเงินให้ผู้ขาย

class VendorPaymentScheduleManager {
  constructor(omise) {
    this.omise = omise;
  }

  async createWeeklyVendorPayments(vendors) {
    const schedules = [];

    for (const vendor of vendors) {
      try {
        const schedule = await this.omise.schedules.create({
          every: 1,
          period: 'week',
          weekdays: ['friday'], // ชำระเงินทุกวันศุกร์
          recipient: vendor.recipientId,
          transfer: {
            amount: vendor.weeklyAmount
          },
          metadata: {
            type: 'vendor_payment',
            vendor_id: vendor.vendorId,
            vendor_name: vendor.name,
            category: vendor.category
          }
        });

        schedules.push({
          vendorId: vendor.vendorId,
          scheduleId: schedule.id,
          status: 'active'
        });

        console.log(`✓ Created weekly schedule for ${vendor.name}`);
      } catch (error) {
        console.error(`✗ Failed for ${vendor.name}: ${error.message}`);
        schedules.push({
          vendorId: vendor.vendorId,
          error: error.message,
          status: 'failed'
        });
      }
    }

    return schedules;
  }

  async adjustVendorPayment(scheduleId, newAmount) {
    const schedule = await this.omise.schedules.update(scheduleId, {
      transfer: { amount: newAmount }
    });

    console.log(`Updated schedule ${scheduleId} to ${newAmount / 100} THB`);
    return schedule;
  }

  async suspendVendor(scheduleId, reason) {
    const schedule = await this.omise.schedules.update(scheduleId, {
      status: 'paused'
    });

    // บันทึกบันทึกเพื่อการบันทึก
    console.log(`Suspended schedule ${scheduleId}: ${reason}`);
    return schedule;
  }
}

การตรวจสอบการทำงานตามกำหนดเวลา

ติดตามการทำงานตามกำหนดเวลา

async function trackScheduleExecutions(scheduleId) {
  const executions = await omise.schedule_transfers.list({
    schedule: scheduleId,
    limit: 50,
    order: 'reverse_chronological'
  });

  console.log(`Schedule ${scheduleId} executions:`);

  executions.data.forEach(execution => {
    console.log(`
      Transfer ID: ${execution.transfer.id}
      Amount: ${execution.transfer.amount / 100} THB
      Status: ${execution.transfer.status}
      Created: ${execution.created}
    `);
  });

  return executions;
}

สถิติการทำงานตามกำหนดเวลา

class ScheduleAnalytics:
    def __init__(self, omise_client):
        self.omise = omise_client

    def get_schedule_stats(self, schedule_id, months=12):
        """รับสถิติการทำงานตามกำหนดเวลา"""
        executions = self.omise.schedule_transfers.list(
            schedule=schedule_id,
            limit=100
        )

        stats = {
            'total_executions': len(executions.data),
            'successful': 0,
            'failed': 0,
            'total_amount_transferred': 0,
            'total_fees': 0,
            'average_transfer': 0
        }

        for execution in executions.data:
            transfer = execution.transfer

            if transfer.paid or transfer.sent:
                stats['successful'] += 1
                stats['total_amount_transferred'] += transfer.amount
                stats['total_fees'] += transfer.fee
            else:
                stats['failed'] += 1

        if stats['successful'] > 0:
            stats['average_transfer'] = (
                stats['total_amount_transferred'] / stats['successful']
            )

        return stats

    def get_scheduled_vs_actual(self, schedule_id):
        """เปรียบเทียบจำนวนที่คาดว่าจะเป็นตามตารางเวลาและจำนวนที่เป็นจริงที่ส่ง"""
        schedule = self.omise.schedules.retrieve(schedule_id)
        executions = self.omise.schedule_transfers.list(
            schedule=schedule_id,
            limit=100
        )

        total_scheduled = len(executions.data) * schedule.transfer.amount
        total_transferred = sum(
            e.transfer.amount for e in executions.data
            if e.transfer.paid or e.transfer.sent
        )

        return {
            'scheduled_amount': total_scheduled,
            'transferred_amount': total_transferred,
            'difference': total_scheduled - total_transferred,
            'execution_rate': (
                total_transferred / total_scheduled * 100
                if total_scheduled > 0 else 0
            )
        }

วิธีปฏิบัติที่ดีที่สุด

1. ตรวจสอบก่อนสร้างตารางเวลา

async function createValidatedSchedule(recipientId, amount, frequency) {
  // ยืนยันผู้รับ
  const recipient = await omise.recipients.retrieve(recipientId);
  if (!recipient.active || !recipient.verified) {
    throw new Error('Recipient is not active or verified');
  }

  // ยืนยันจำนวน
  if (amount < 2000) { // จำนวนต่ำสุด 20 THB
    throw new Error('Amount below minimum');
  }

  // สร้างตารางเวลา
  const schedule = await omise.schedules.create({
    every: frequency.every,
    period: frequency.period,
    recipient: recipientId,
    transfer: { amount }
  });

  return schedule;
}

2. ตรวจสอบความล้มเหลวของตารางเวลา

def monitor_schedule_failures(schedule_id, notification_email):
    """ตรวจสอบความล้มเหลวของตารางเวลาและส่งการแจ้งเตือน"""

    executions = omise.ScheduleTransfer.list(
        schedule=schedule_id,
        limit=100
    )

    failures = [
        e for e in executions.data
        if e.transfer.failure_code
    ]

    if failures:
        # ส่งการแจ้งเตือน
        send_alert_email(
            to=notification_email,
            subject=f"Schedule {schedule_id} has failures",
            body=f"{len(failures)} transfers failed"
        )

        # บันทึกลงใน log
        for failure in failures:
            print(f"Failed transfer: {failure.transfer.id}")
            print(f"Reason: {failure.transfer.failure_message}")

    return failures

คำถามที่พบบ่อย

ความถี่ตารางเวลาขั้นต่ำคือเท่าไหร่?

ความถี่รายวันเป็นความถี่ต่ำสุด หากคุณต้องการการโอนบ่อยครั้งขึ้น คุณจะต้องสร้างการโอนด้วยตนเองแทน

ตารางเวลาจะทำงานตรงเวลาหรือไม่?

ตารางเวลาจะทำงานตอนเวลาอ้างอิงในวันถัดไป (UTC) ด้วยเวลาท้องถิ่นของธนาคาร เงินอาจใช้เวลามากขึ้นไปถึงบัญชี

จำนวนตารางเวลาสูงสุดคือเท่าไหร่?

ไม่มีข้อจำกัดทางเทคนิคสำหรับจำนวนตารางเวลาต่อบัญชี แต่ไม่แนะนำให้จัดการตารางเวลาที่ทำงานพร้อมกันจำนวนมาก

ตารางเวลาจะลองใหม่โดยอัตโนมัติหลังการล้มเหลวหรือไม่?

ไม่ การโอนตามกำหนดเวลาที่ล้มเหลวจะไม่ลองใหม่โดยอัตโนมัติ ความล้มเหลวจะถูกบันทึก และคุณจะได้รับการแจ้งเตือนผ่าน Webhook

ฉันสามารถแก้ไขตารางเวลาขณะที่กำลังทำงาน?

ใช่ คุณสามารถแก้ไขจำนวนหรือข้อมูลเมตาในตารางเวลาได้โดยไม่ต้องหยุดพักชั่วคราว

ฉันสามารถเปลี่ยนเวลาการทำงานตามกำหนดเวลาได้หรือไม่?

คุณไม่สามารถเปลี่ยนเวลาการทำงานโดยตรงได้ คุณจะต้องสร้างตารางเวลาใหม่พร้อมวันเริ่มต้นแตกต่างกัน

ทรัพยากรที่เกี่ยวข้อง

• การสร้างการโอน - สร้างการโอนเดี่ยวด้วยตนเอง
• การจัดการผู้รับ - ตั้งค่าผู้รับ
• Webhook - การแจ้งเตือนตารางเวลา
• การจัดการยอดคงเหลือ - ตรวจสอบยอดคงเหลือ