Music Cover Generation Callbacks

from flask import Flask, request, jsonify
import requests
import os
from urllib.parse import urlparse

app = Flask(__name__)

@app.route('/suno-cover-callback', methods=['POST'])
def handle_callback():
    data = request.json
    
    code = data.get('code')
    msg = data.get('msg')
    callback_data = data.get('data', {})
    task_id = callback_data.get('taskId')
    images = callback_data.get('images')
    
    print(f"Received cover generation callback: {task_id}, status: {code}, message: {msg}")
    
    if code == 200:
        # Task completed successfully
        print("Cover generation completed")
        
        if images:
            print("Generated cover images:")
            for i, image_url in enumerate(images, 1):
                print(f"Cover {i}: {image_url}")
            
            # Download cover images
            download_images(images, task_id)
            
    else:
        # Task failed
        print(f"Cover generation failed: {msg}")
        
        # Handle failure cases...
    
    # Return 200 status code to confirm callback received
    return jsonify({'status': 'received'}), 200

def download_images(image_urls, task_id):
    """Download cover images"""
    # Create directory
    dir_path = f"covers/{task_id}"
    os.makedirs(dir_path, exist_ok=True)
    
    for i, url in enumerate(image_urls, 1):
        try:
            # Get file extension
            parsed_url = urlparse(url)
            file_ext = os.path.splitext(parsed_url.path)[1] or '.png'
            filename = os.path.join(dir_path, f"cover_{i}{file_ext}")
            
            # Download file
            response = requests.get(url, stream=True)
            if response.status_code == 200:
                with open(filename, 'wb') as f:
                    for chunk in response.iter_content(chunk_size=8192):
                        f.write(chunk)
                print(f"Cover saved: {filename}")
            else:
                print(f"Download failed {url}: HTTP {response.status_code}")
                
        except Exception as e:
            print(f"Download failed {url}: {e}")

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=3000)

/**
 * @param request Callback request
 * @return ResponseEntity
 * @author zj
 * @description Handle Suno Cover generation callback
 * @date 2025/1/15
 **/
@PostMapping("/suno-cover-callback")
@Operation(summary = "Suno Cover generation callback", description = "Receive Cover generation completion notification")
public ResponseEntity<Map<String, String>> handleCoverCallback(
    @RequestBody CoverCallbackRequest request) {
    
    log.info("Received cover generation callback: taskId={}, status={}, message={}", 
        request.getData().getTaskId(), request.getCode(), request.getMsg());
    
    try {
        if (request.getCode() == 200) {
            // Task completed successfully
            log.info("Cover generation completed");
            List<String> images = request.getData().getImages();
            
            if (images != null && !images.isEmpty()) {
                log.info("Generated cover images: {}", images);
                
                // Process cover images
                processCoverImages(request.getData().getTaskId(), images);
            }
            
        } else {
            // Task failed
            log.error("Cover generation failed: {}", request.getMsg());
            
            // Handle failure cases
            handleCoverGenerationFailure(request.getData().getTaskId(), 
                request.getCode(), request.getMsg());
        }
        
        // Update task status
        coverTaskService.updateTaskStatus(request.getData().getTaskId(), 
            request.getCode(), request.getMsg(), request.getData().getImages());
            
    } catch (Exception e) {
        log.error("Failed to process cover generation callback", e);
        return ResponseEntity.status(500)
            .body(Map.of("status", "error", "message", e.getMessage()));
    }
    
    // Return 200 status code to confirm callback received
    return ResponseEntity.ok(Map.of("status", "received"));
}

/**
 * @param taskId Task ID
 * @param imageUrls Image URL list
 * @author zj
 * @description Process cover images
 * @date 2025/1/15
 **/
private void processCoverImages(String taskId, List<String> imageUrls) {
    // Asynchronously download images
    CompletableFuture.runAsync(() -> {
        try {
            downloadCoverImages(taskId, imageUrls);
        } catch (Exception e) {
            log.error("Failed to download cover images: taskId={}", taskId, e);
        }
    });
}

/**
 * @param taskId Task ID
 * @param imageUrls Image URL list
 * @author zj
 * @description Download cover images
 * @date 2025/1/15
 **/
private void downloadCoverImages(String taskId, List<String> imageUrls) {
    String dirPath = "covers/" + taskId;
    File dir = new File(dirPath);
    if (!dir.exists()) {
        dir.mkdirs();
    }
    
    for (int i = 0; i < imageUrls.size(); i++) {
        String url = imageUrls.get(i);
        String filename = dirPath + "/cover_" + (i + 1) + ".png";
        
        try {
            downloadFile(url, filename);
            log.info("Cover saved: {}", filename);
        } catch (Exception e) {
            log.error("Download failed: {}", url, e);
        }
    }
}

@Data
public class CoverCallbackRequest {
    private Integer code;
    private String msg;
    private CoverCallbackData data;
}

@Data
public class CoverCallbackData {
    private String taskId;
    private List<String> images;
}

<?php
header('Content-Type: application/json');

// Get POST data
$input = file_get_contents('php://input');
$data = json_decode($input, true);

$code = $data['code'] ?? null;
$msg = $data['msg'] ?? '';
$callbackData = $data['data'] ?? [];
$taskId = $callbackData['taskId'] ?? '';
$images = $callbackData['images'] ?? null;

error_log("Received cover generation callback: $taskId, status: $code, message: $msg");

if ($code === 200) {
    // Task completed successfully
    error_log("Cover generation completed");
    
    if ($images && is_array($images) && count($images) > 0) {
        error_log("Generated cover images: " . implode(', ', $images));
        
        // Download cover images
        downloadCoverImages($taskId, $images);
    }
    
} else {
    // Task failed
    error_log("Cover generation failed: $msg");
    
    // Handle failure cases...
}

/**
 * Download cover images
 * @param string $taskId Task ID
 * @param array $imageUrls Image URL array
 */
function downloadCoverImages($taskId, $imageUrls) {
    // Create directory
    $dir = "covers/$taskId";
    if (!is_dir($dir)) {
        mkdir($dir, 0777, true);
    }
    
    foreach ($imageUrls as $index => $url) {
        $filename = $dir . "/cover_" . ($index + 1) . ".png";
        
        try {
            $imageContent = file_get_contents($url);
            if ($imageContent !== false) {
                file_put_contents($filename, $imageContent);
                error_log("Cover saved: $filename");
            } else {
                error_log("Download failed: $url");
            }
        } catch (Exception $e) {
            error_log("Download failed $url: " . $e->getMessage());
        }
    }
}

// Return 200 status code to confirm callback received
http_response_code(200);
echo json_encode(['status' => 'received']);
?>