Untitled

def process_orders_continuously(self, check_interval=30):
        """Memproses pesanan secara berkelanjutan"""
        # Track pesanan yang sudah diproses di batch ini untuk mencegah duplikasi
        processed_ids_this_batch = set()
        
        while True:
            try:
                # Selalu refresh koneksi database untuk mendapatkan data terbaru
                if not self.conn or not self.conn.is_connected():
                    logger.info("Koneksi database terputus, mencoba menghubungkan kembali...")
                    self.connect_database()
                
                # Reset tracking ID yang diproses untuk batch baru
                processed_ids_this_batch.clear()
                
                # Dapatkan pesanan yang pending
                orders = self.get_pending_orders()
                
                if orders:
                    logger.info(f"Mulai memproses batch dengan {len(orders)} pesanan")
                    
                    # Grup pesanan berdasarkan created_at untuk memastikan semua diproses
                    orders_by_timestamp = {}
                    for order in orders:
                        ts = str(order['created_at'])
                        if ts not in orders_by_timestamp:
                            orders_by_timestamp[ts] = []
                        orders_by_timestamp[ts].append(order)
                    
                    # Proses timestamp dari yang terlama
                    for ts in sorted(orders_by_timestamp.keys()):
                        orders_same_ts = orders_by_timestamp[ts]
                        
                        # Log informasi timestamp
                        if len(orders_same_ts) > 1:
                            order_ids = [o['id'] for o in orders_same_ts]
                            logger.info(f"Memproses {len(orders_same_ts)} pesanan dengan timestamp sama ({ts}): {order_ids}")
                        
                        # Proses pesanan dalam grup timestamp ini berdasarkan ID
                        sorted_orders = sorted(orders_same_ts, key=lambda x: x['id'])
                        
                        for order in sorted_orders:
                            order_id = order['id']
                            
                            # Skip jika sudah diproses di batch ini
                            if order_id in processed_ids_this_batch:
                                logger.info(f"Pesanan #{order_id} sudah diproses di batch ini, melewati...")
                                continue
                            
                            logger.info(f"Memproses pesanan #{order_id} (created: {order['created_at']})")
                            
                            success = self.process_order(order)
                            if success:
                                self.processed_count += 1
                                logger.info(f"Pesanan #{order_id} berhasil diproses (total: {self.processed_count})")
                                # Tandai sebagai sudah diproses
                                processed_ids_this_batch.add(order_id)
                            else:
                                logger.warning(f"Pesanan #{order_id} gagal diproses")
                            
                            time.sleep(1)  # Jeda antar pesanan
                    
                    logger.info(f"Selesai memproses batch, total {len(processed_ids_this_batch)} pesanan berhasil diproses")
                else:
                    logger.info(f"Tidak ada pesanan pending, menunggu {check_interval} detik...")
                    # Refresh koneksi database saat tidak ada orderan
                    self.connect_database()
                
                # Tunggu interval waktu yang ditentukan
                time.sleep(check_interval)
                
                # Refresh koneksi database setelah interval waktu
                logger.info("Me-refresh koneksi database untuk siklus baru...")
                self.connect_database()
                
            except KeyboardInterrupt:
                logger.info("Bot dihentikan oleh pengguna")
                break
            except Exception as e:
                logger.error(f"Error dalam loop pemrosesan pesanan: {e}")
                time.sleep(check_interval)