GET /open-api/v1/forms/{formId}/responses

# 첫 페이지 조회 (기본값)
curl -X GET "https://api.walla.my/open-api/v1/forms/form_abc/responses" \
  -H "X-WALLA-API-KEY: your_api_key_here" \
  -H "Content-Type: application/json"

# 사용자 지정 제한으로 특정 페이지 조회
curl -X GET "https://api.walla.my/open-api/v1/forms/form_abc/responses?page=2&limit=50" \
  -H "X-WALLA-API-KEY: your_api_key_here" \
  -H "Content-Type: application/json"

{
  "success": true,
  "data": {
    "responses": [
      {
        "responseId": "response_123",
        "customerKey": "customer_001",
        "submittedAt": "2024-01-15T14:30:00Z",
        "question_1": "Very satisfied",
        "question_2": 5,
        "question_3": ["Feature A", "Feature B"],
        "question_4": "Great product!"
      },
      {
        "responseId": "response_456",
        "customerKey": "customer_002",
        "submittedAt": "2024-01-15T15:45:00Z",
        "question_1": "Satisfied",
        "question_2": 4,
        "question_3": ["Feature A"],
        "question_4": "Good experience"
      }
    ],
    "pagination": {
      "page": 1,
      "limit": 20,
      "totalCount": 150,
      "totalPages": 8
    }
  }
}

GET /open-api/v1/forms/{formId}/responses/{responseId}

curl -X GET "https://api.walla.my/open-api/v1/forms/form_abc/responses/response_123" \
  -H "X-WALLA-API-KEY: your_api_key_here" \
  -H "Content-Type: application/json"

{
  "success": true,
  "data": {
    "responseId": "response_123",
    "formId": "form_abc",
    "teamId": "team_456",
    "workspaceId": "workspace_789",
    "response": {
      "question_1": "Very satisfied",
      "question_2": 5,
      "question_3": ["Feature A", "Feature B"],
      "question_4": "Great product!",
      "email": "john@example.com",
      "name": "John Doe"
    },
    "submittedAt": "2024-01-15T14:30:00Z",
    "customerKey": "customer_001",
    "startedAt": "2024-01-15T14:25:00Z"
  }
}

{
  "questions": [
    { "id": "satisfaction", "type": "rating", "label": "How satisfied are you?" },
    { "id": "feedback", "type": "text", "label": "Additional comments" },
    { "id": "features", "type": "multiple_choice", "label": "Which features do you use?" }
  ]
}

{
  "responseId": "response_123",
  "satisfaction": 5,
  "feedback": "Excellent service!",
  "features": ["Feature A", "Feature C"],
  "submittedAt": "2024-01-15T14:30:00Z"
}

const timeToComplete = new Date(response.submittedAt) - new Date(response.startedAt);
const minutes = timeToComplete / 1000 / 60;
console.log(`Completed in ${minutes.toFixed(2)} minutes`);

interface PaginationParams {
  page?: number;
  limit?: number;
}

interface ResponseData {
  responseId: string;
  customerKey: string | null;
  submittedAt: string;
  [key: string]: any; // Dynamic form fields
}

interface PaginatedResponse {
  responses: ResponseData[];
  pagination: {
    page: number;
    limit: number;
    totalCount: number;
    totalPages: number;
  };
}

class WallaResponsesAPI {
  constructor(private apiKey: string) {}

  async getResponses(
    formId: string,
    params: PaginationParams = {}
  ): Promise<PaginatedResponse> {
    const { page = 1, limit = 20 } = params;
    const url = new URL(
      `https://api.walla.my/open-api/v1/forms/${formId}/responses`
    );
    url.searchParams.set('page', page.toString());
    url.searchParams.set('limit', limit.toString());

    const response = await fetch(url.toString(), {
      method: 'GET',
      headers: {
        'X-WALLA-API-KEY': this.apiKey,
        'Content-Type': 'application/json'
      }
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    return data.data;
  }

  async getResponseById(formId: string, responseId: string) {
    const response = await fetch(
      `https://api.walla.my/open-api/v1/forms/${formId}/responses/${responseId}`,
      {
        method: 'GET',
        headers: {
          'X-WALLA-API-KEY': this.apiKey,
          'Content-Type': 'application/json'
        }
      }
    );

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    return data.data;
  }

  async getAllResponses(formId: string): Promise<ResponseData[]> {
    const allResponses: ResponseData[] = [];
    let page = 1;
    let hasMore = true;

    while (hasMore) {
      const data = await this.getResponses(formId, { page, limit: 100 });
      allResponses.push(...data.responses);
      hasMore = page < data.pagination.totalPages;
      page++;
    }

    return allResponses;
  }

  async exportToCSV(formId: string): Promise<string> {
    const responses = await this.getAllResponses(formId);

    if (responses.length === 0) {
      return '';
    }

    // Get all unique keys from responses
    const keys = Array.from(
      new Set(responses.flatMap(r => Object.keys(r)))
    );

    // Create CSV header
    const csv = [
      keys.join(','),
      ...responses.map(response =>
        keys.map(key => {
          const value = response[key];
          if (Array.isArray(value)) {
            return `"${value.join(', ')}"`;
          }
          return typeof value === 'string' && value.includes(',')
            ? `"${value}"`
            : value;
        }).join(',')
      )
    ].join('\n');

    return csv;
  }
}

// Usage
const api = new WallaResponsesAPI(process.env.WALLA_API_KEY!);

// Get paginated responses
const page1 = await api.getResponses('form_abc', { page: 1, limit: 50 });
console.log(`Total responses: ${page1.pagination.totalCount}`);

// Get specific response
const response = await api.getResponseById('form_abc', 'response_123');
console.log(response);

// Export all responses to CSV
const csv = await api.exportToCSV('form_abc');

import requests
import csv
import io
from typing import List, Dict, Any, Optional

class WallaResponsesAPI:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.walla.my/open-api/v1"
        self.headers = {
            "X-WALLA-API-KEY": api_key,
            "Content-Type": "application/json"
        }

    def get_responses(
        self,
        form_id: str,
        page: int = 1,
        limit: int = 20
    ) -> Dict[str, Any]:
        """Get paginated form responses"""
        url = f"{self.base_url}/forms/{form_id}/responses"
        params = {"page": page, "limit": limit}

        response = requests.get(url, headers=self.headers, params=params)
        response.raise_for_status()
        return response.json()["data"]

    def get_response_by_id(
        self,
        form_id: str,
        response_id: str
    ) -> Dict[str, Any]:
        """Get specific response details"""
        url = f"{self.base_url}/forms/{form_id}/responses/{response_id}"
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()["data"]

    def get_all_responses(self, form_id: str) -> List[Dict[str, Any]]:
        """Get all responses by paginating through all pages"""
        all_responses = []
        page = 1

        while True:
            data = self.get_responses(form_id, page=page, limit=100)
            all_responses.extend(data["responses"])

            if page >= data["pagination"]["totalPages"]:
                break

            page += 1

        return all_responses

    def export_to_csv(self, form_id: str, filename: str) -> None:
        """Export all responses to CSV file"""
        responses = self.get_all_responses(form_id)

        if not responses:
            print("No responses to export")
            return

        # Get all unique keys
        keys = set()
        for response in responses:
            keys.update(response.keys())

        # Write CSV
        with open(filename, 'w', newline='', encoding='utf-8') as f:
            writer = csv.DictWriter(f, fieldnames=sorted(keys))
            writer.writeheader()
            writer.writerows(responses)

        print(f"Exported {len(responses)} responses to {filename}")

    def get_response_statistics(self, form_id: str) -> Dict[str, Any]:
        """Calculate basic statistics for form responses"""
        responses = self.get_all_responses(form_id)

        if not responses:
            return {"total": 0}

        # Calculate completion time statistics
        completion_times = []
        for resp in responses:
            detail = self.get_response_by_id(form_id, resp["responseId"])
            if detail["submittedAt"] and detail["startedAt"]:
                from datetime import datetime
                started = datetime.fromisoformat(
                    detail["startedAt"].replace('Z', '+00:00')
                )
                submitted = datetime.fromisoformat(
                    detail["submittedAt"].replace('Z', '+00:00')
                )
                completion_times.append(
                    (submitted - started).total_seconds() / 60
                )

        stats = {
            "total": len(responses),
            "with_customer_key": sum(
                1 for r in responses if r.get("customerKey")
            ),
            "average_completion_time_minutes": (
                sum(completion_times) / len(completion_times)
                if completion_times else None
            )
        }

        return stats

# Usage
api = WallaResponsesAPI(os.getenv("WALLA_API_KEY"))

# Get responses
data = api.get_responses("form_abc", page=1, limit=50)
print(f"Total responses: {data['pagination']['totalCount']}")

# Get all responses
all_responses = api.get_all_responses("form_abc")

# Export to CSV
api.export_to_csv("form_abc", "responses.csv")

# Get statistics
stats = api.get_response_statistics("form_abc")
print(f"Statistics: {stats}")

// 응답 내보내기 및 분석
const responses = await api.getAllResponses('form_abc');

// 평균 평점 계산
const ratings = responses
  .map(r => r.rating)
  .filter(r => typeof r === 'number');
const avgRating = ratings.reduce((a, b) => a + b, 0) / ratings.length;

// 고객 세그먼트별 그룹화
const bySegment = responses.reduce((acc, response) => {
  const segment = response.segment || 'unknown';
  acc[segment] = acc[segment] || [];
  acc[segment].push(response);
  return acc;
}, {});

// 새로운 응답 폴링
let lastCheck = new Date();

setInterval(async () => {
  const data = await api.getResponses('form_abc', { page: 1, limit: 10 });
  const newResponses = data.responses.filter(r =>
    new Date(r.submittedAt) > lastCheck
  );

  if (newResponses.length > 0) {
    console.log(`${newResponses.length} new responses!`);
    // 새로운 응답 처리
  }

  lastCheck = new Date();
}, 60000); // 매분마다 확인

# 분석 플랫폼으로 응답 전송
import analytics

responses = api.get_all_responses("form_abc")

for response in responses:
    analytics.track(
        user_id=response.get("customerKey"),
        event="Survey Completed",
        properties={
            "form_id": "form_abc",
            "rating": response.get("rating"),
            "submitted_at": response["submittedAt"]
        }
    )