API Documentation

// Get one steps function
const getOneSteps = async (filters = {}) => {
  try {
    const token = localStorage.getItem('api_token');
    
    if (!token) {
      throw new Error('No authentication token found');
    }

    // Build query string from filters
    const queryParams = new URLSearchParams();
    Object.keys(filters).forEach(key => {
      if (filters[key] !== null && filters[key] !== undefined) {
        queryParams.append(key, filters[key]);
      }
    });

    const url = `http://service.ssumethods.com/api/one-steps${queryParams.toString() ? '?' + queryParams.toString() : ''}`;

    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Accept': 'application/json'
      }
    });

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

    const data = await response.json();
    console.log('One steps retrieved:', data);
    return data;
  } catch (error) {
    console.error('Error fetching one steps:', error);
    throw error;
  }
};

// Usage examples
getOneSteps()
  .then(result => {
    console.log(`Found ${result.data.transfers.length} transfers`);
    console.log(`Total amount: ${result.data.summary.total_amount}`);
  });

// With account filters
getOneSteps({
  from_account: 'ACC001',
  min_amount: 100,
  limit: 20
}).then(result => {
  console.log('Filtered transfers:', result.data.transfers);
});

// With date range
getOneSteps({
  date_from: '2024-01-01',
  date_to: '2024-01-31',
  limit: 50
}).then(result => {
  console.log('Date filtered transfers:', result.data.transfers);
});

// Pagination helper
const loadTransfersPage = async (page, filters = {}) => {
  try {
    const result = await getOneSteps({ ...filters, page, limit: 25 });
    return {
      transfers: result.data.transfers,
      hasNext: result.data.pagination.has_next,
      totalPages: result.data.pagination.total_pages,
      summary: result.data.summary
    };
  } catch (error) {
    console.error('Failed to load page:', error);
    throw error;
  }
};

import requests
from typing import Dict, Any, Optional
from datetime import datetime

class OneStepsAPI:
    def __init__(self, base_url: str, token: str):
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {token}',
            'Accept': 'application/json'
        })
    
    def get_one_steps(self, **filters) -> Dict[str, Any]:
        """Get one steps with optional filters"""
        try:
            # Remove None values from filters
            params = {k: v for k, v in filters.items() if v is not None}
            
            response = self.session.get(
                f'{self.base_url}/api/one-steps',
                params=params,
                timeout=30
            )
            response.raise_for_status()
            
            return response.json()
        
        except requests.exceptions.RequestException as e:
            print(f"API error: {e}")
            raise
    
    def get_transfers_by_account(self, 
                               from_account: Optional[str] = None,
                               to_account: Optional[str] = None,
                               min_amount: Optional[float] = None,
                               max_amount: Optional[float] = None) -> Dict[str, Any]:
        """Get transfers filtered by account and amount"""
        filters = {
            'from_account': from_account,
            'to_account': to_account,
            'min_amount': min_amount,
            'max_amount': max_amount
        }
        return self.get_one_steps(**filters)
    
    def get_transfers_by_date_range(self, 
                                  date_from: str,
                                  date_to: str,
                                  limit: int = 50) -> Dict[str, Any]:
        """Get transfers within a date range"""
        filters = {
            'date_from': date_from,
            'date_to': date_to,
            'limit': limit
        }
        return self.get_one_steps(**filters)
    
    def get_paginated_transfers(self, page: int = 1, limit: int = 50, **filters) -> Dict[str, Any]:
        """Get paginated transfers"""
        filters.update({'page': page, 'limit': limit})
        return self.get_one_steps(**filters)

# Usage example
try:
    api = OneStepsAPI('http://service.ssumethods.com', 'your_access_token_here')
    
    # Get all one steps
    all_transfers = api.get_one_steps()
    print(f"Found {len(all_transfers['data']['transfers'])} transfers")
    print(f"Total amount: {all_transfers['data']['summary']['total_amount']}")
    
    # Get transfers by account
    account_transfers = api.get_transfers_by_account(
        from_account='ACC001',
        min_amount=100.0
    )
    
    for transfer in account_transfers['data']['transfers']:
        print(f"From: {transfer['from_account']} To: {transfer['to_account']}")
        print(f"Amount: {transfer['amount']} Date: {transfer['date']}")
        print("---")
    
    # Get transfers by date range
    date_transfers = api.get_transfers_by_date_range(
        date_from='2024-01-01',
        date_to='2024-01-31',
        limit=20
    )
    
    print(f"Transfers in date range: {len(date_transfers['data']['transfers'])}")
    
    # Pagination example
    page = 1
    while True:
        result = api.get_paginated_transfers(page=page, limit=10)
        transfers = result['data']['transfers']
        
        if not transfers:
            break
            
        print(f"Page {page}: {len(transfers)} transfers")
        
        if not result['data']['pagination']['has_next']:
            break
            
        page += 1

except Exception as e:
    print(f"Error: {e}")

<?php

class OneStepsAPI {
    private $baseUrl;
    private $token;
    
    public function __construct($baseUrl, $token) {
        $this->baseUrl = rtrim($baseUrl, '/');
        $this->token = $token;
    }
    
    public function getOneSteps($filters = []) {
        $url = $this->baseUrl . '/api/one-steps';
        
        if (!empty($filters)) {
            $url .= '?' . http_build_query($filters);
        }
        
        return $this->makeRequest($url);
    }
    
    public function getTransfersByAccount($fromAccount = null, $toAccount = null, 
                                        $minAmount = null, $maxAmount = null) {
        $filters = array_filter([
            'from_account' => $fromAccount,
            'to_account' => $toAccount,
            'min_amount' => $minAmount,
            'max_amount' => $maxAmount
        ], function($value) { return $value !== null; });
        
        return $this->getOneSteps($filters);
    }
    
    public function getTransfersByDateRange($dateFrom, $dateTo, $limit = 50) {
        $filters = [
            'date_from' => $dateFrom,
            'date_to' => $dateTo,
            'limit' => $limit
        ];
        
        return $this->getOneSteps($filters);
    }
    
    public function getPaginatedTransfers($page = 1, $limit = 50, $filters = []) {
        $filters['page'] = $page;
        $filters['limit'] = $limit;
        return $this->getOneSteps($filters);
    }
    
    private function makeRequest($url) {
        $headers = [
            'Authorization: Bearer ' . $this->token,
            'Accept: application/json'
        ];
        
        $ch = curl_init();
        curl_setopt_array($ch, [
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => $headers,
            CURLOPT_TIMEOUT => 30,
            CURLOPT_SSL_VERIFYPEER => false
        ]);
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $error = curl_error($ch);
        curl_close($ch);
        
        if ($error) {
            throw new Exception("cURL Error: " . $error);
        }
        
        $decodedResponse = json_decode($response, true);
        
        if ($httpCode >= 400) {
            $message = isset($decodedResponse['message']) ? $decodedResponse['message'] : 'Unknown error';
            throw new Exception("HTTP Error $httpCode: " . $message);
        }
        
        return $decodedResponse;
    }
}

// Usage example
try {
    $api = new OneStepsAPI('http://service.ssumethods.com', 'your_access_token_here');
    
    // Get all transfers
    $allTransfers = $api->getOneSteps();
    echo "Found " . count($allTransfers['data']['transfers']) . " transfers\n";
    echo "Total amount: " . $allTransfers['data']['summary']['total_amount'] . "\n";
    
    // Get transfers by account
    $accountTransfers = $api->getTransfersByAccount(
        $fromAccount = 'ACC001',
        $toAccount = null,
        $minAmount = 100.0,
        $maxAmount = null
    );
    
    foreach ($accountTransfers['data']['transfers'] as $transfer) {
        echo "From: " . $transfer['from_account'] . " To: " . $transfer['to_account'] . "\n";
        echo "Amount: " . $transfer['amount'] . " Date: " . $transfer['date'] . "\n";
        echo "---\n";
    }
    
    // Get transfers by date range
    $dateTransfers = $api->getTransfersByDateRange('2024-01-01', '2024-01-31', 20);
    echo "Transfers in date range: " . count($dateTransfers['data']['transfers']) . "\n";
    
    // Pagination example
    $page = 1;
    while (true) {
        $result = $api->getPaginatedTransfers($page, 10);
        $transfers = $result['data']['transfers'];
        
        if (empty($transfers)) {
            break;
        }
        
        echo "Page $page: " . count($transfers) . " transfers\n";
        
        if (!$result['data']['pagination']['has_next']) {
            break;
        }
        
        $page++;
    }
    
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

?>

import java.io.IOException;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;

public class OneStepsAPI {
    private final String baseUrl;
    private final String token;
    private final HttpClient httpClient;
    private final ObjectMapper objectMapper;
    
    public OneStepsAPI(String baseUrl, String token) {
        this.baseUrl = baseUrl.replaceAll("/$", "");
        this.token = token;
        this.httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
        this.objectMapper = new ObjectMapper();
    }
    
    public JsonNode getOneSteps() throws IOException, InterruptedException {
        return getOneSteps(new HashMap<>());
    }
    
    public JsonNode getOneSteps(Map<String, Object> filters) throws IOException, InterruptedException {
        String url = this.baseUrl + "/api/one-steps";
        
        if (!filters.isEmpty()) {
            String queryString = filters.entrySet().stream()
                .filter(entry -> entry.getValue() != null)
                .map(entry -> URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8) + "=" +
                            URLEncoder.encode(entry.getValue().toString(), StandardCharsets.UTF_8))
                .collect(Collectors.joining("&"));
            url += "?" + queryString;
        }
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer " + this.token)
            .header("Accept", "application/json")
            .GET()
            .timeout(Duration.ofSeconds(30))
            .build();
        
        HttpResponse<String> response = httpClient.send(
            request, 
            HttpResponse.BodyHandlers.ofString()
        );
        
        if (response.statusCode() != 200) {
            throw new RuntimeException("Request failed with HTTP " + response.statusCode() + 
                                     ": " + response.body());
        }
        
        return objectMapper.readTree(response.body());
    }
    
    public JsonNode getTransfersByAccount(String fromAccount, String toAccount, 
                                        Double minAmount, Double maxAmount) 
                                        throws IOException, InterruptedException {
        Map<String, Object> filters = new HashMap<>();
        if (fromAccount != null) filters.put("from_account", fromAccount);
        if (toAccount != null) filters.put("to_account", toAccount);
        if (minAmount != null) filters.put("min_amount", minAmount);
        if (maxAmount != null) filters.put("max_amount", maxAmount);
        
        return getOneSteps(filters);
    }
    
    public JsonNode getTransfersByDateRange(String dateFrom, String dateTo, int limit) 
                                          throws IOException, InterruptedException {
        Map<String, Object> filters = new HashMap<>();
        filters.put("date_from", dateFrom);
        filters.put("date_to", dateTo);
        filters.put("limit", limit);
        
        return getOneSteps(filters);
    }
    
    public JsonNode getPaginatedTransfers(int page, int limit) throws IOException, InterruptedException {
        Map<String, Object> filters = new HashMap<>();
        filters.put("page", page);
        filters.put("limit", limit);
        
        return getOneSteps(filters);
    }
    
    public static void main(String[] args) {
        try {
            OneStepsAPI api = new OneStepsAPI(
                "http://service.ssumethods.com", 
                "your_access_token_here"
            );
            
            // Get all transfers
            JsonNode allTransfers = api.getOneSteps();
            JsonNode transfers = allTransfers.get("data").get("transfers");
            JsonNode summary = allTransfers.get("data").get("summary");
            
            System.out.println("Found " + transfers.size() + " transfers");
            System.out.println("Total amount: " + summary.get("total_amount").asDouble());
            
            // Get transfers by account
            JsonNode accountTransfers = api.getTransfersByAccount("ACC001", null, 100.0, null);
            JsonNode filteredTransfers = accountTransfers.get("data").get("transfers");
            
            for (JsonNode transfer : filteredTransfers) {
                System.out.println("From: " + transfer.get("from_account").asText() + 
                                 " To: " + transfer.get("to_account").asText());
                System.out.println("Amount: " + transfer.get("amount").asDouble() + 
                                 " Date: " + transfer.get("date").asText());
                System.out.println("---");
            }
            
            // Get transfers by date range
            JsonNode dateTransfers = api.getTransfersByDateRange("2024-01-01", "2024-01-31", 20);
            JsonNode dateFilteredTransfers = dateTransfers.get("data").get("transfers");
            System.out.println("Transfers in date range: " + dateFilteredTransfers.size());
            
            // Pagination example
            int page = 1;
            while (true) {
                JsonNode result = api.getPaginatedTransfers(page, 10);
                JsonNode pageTransfers = result.get("data").get("transfers");
                
                if (pageTransfers.size() == 0) {
                    break;
                }
                
                System.out.println("Page " + page + ": " + pageTransfers.size() + " transfers");
                
                if (!result.get("data").get("pagination").get("has_next").asBoolean()) {
                    break;
                }
                
                page++;
            }
            
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strings"
    "time"
)

type OneStepsAPI struct {
    BaseURL string
    Token   string
    Client  *http.Client
}

type Transfer struct {
    ID            string  `json:"id"`
    FromAccount   string  `json:"from_account"`
    ToAccount     string  `json:"to_account"`
    Amount        float64 `json:"amount"`
    Date          string  `json:"date"`
    Description   string  `json:"description"`
    TransactionID string  `json:"transaction_id"`
    Timestamp     string  `json:"timestamp"`
}

type OneStepsResponse struct {
    Success bool `json:"success"`
    Message string `json:"message"`
    Data    struct {
        Transfers []Transfer `json:"transfers"`
        Pagination struct {
            CurrentPage  int  `json:"current_page"`
            PerPage      int  `json:"per_page"`
            Total        int  `json:"total"`
            TotalPages   int  `json:"total_pages"`
            HasNext      bool `json:"has_next"`
            HasPrevious  bool `json:"has_previous"`
        } `json:"pagination"`
        Summary struct {
            TotalTransfers   int     `json:"total_transfers"`
            TotalAmount      float64 `json:"total_amount"`
            UniqueSenders    int     `json:"unique_senders"`
            UniqueReceivers  int     `json:"unique_receivers"`
            DateRange        struct {
                Start string `json:"start"`
                End   string `json:"end"`
            } `json:"date_range"`
            AverageAmount   float64 `json:"average_amount"`
            LargestTransfer float64 `json:"largest_transfer"`
            SmallestTransfer float64 `json:"smallest_transfer"`
        } `json:"summary"`
    } `json:"data"`
}

func NewOneStepsAPI(baseURL, token string) *OneStepsAPI {
    return &OneStepsAPI{
        BaseURL: strings.TrimSuffix(baseURL, "/"),
        Token:   token,
        Client: &http.Client{
            Timeout: 30 * time.Second,
        },
    }
}

func (api *OneStepsAPI) GetOneSteps(filters map[string]interface{}) (*OneStepsResponse, error) {
    baseURL := api.BaseURL + "/api/one-steps"
    
    // Build query parameters
    if len(filters) > 0 {
        params := url.Values{}
        for key, value := range filters {
            if value != nil {
                params.Add(key, fmt.Sprintf("%v", value))
            }
        }
        baseURL += "?" + params.Encode()
    }
    
    req, err := http.NewRequest("GET", baseURL, nil)
    if err != nil {
        return nil, fmt.Errorf("creating request: %w", err)
    }
    
    req.Header.Set("Authorization", "Bearer "+api.Token)
    req.Header.Set("Accept", "application/json")
    
    resp, err := api.Client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("making request: %w", err)
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("reading response: %w", err)
    }
    
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("request failed with status %d: %s", resp.StatusCode, string(body))
    }
    
    var oneStepsResp OneStepsResponse
    if err := json.Unmarshal(body, &oneStepsResp); err != nil {
        return nil, fmt.Errorf("parsing response: %w", err)
    }
    
    return &oneStepsResp, nil
}

func (api *OneStepsAPI) GetTransfersByAccount(fromAccount, toAccount *string, minAmount, maxAmount *float64) (*OneStepsResponse, error) {
    filters := make(map[string]interface{})
    if fromAccount != nil {
        filters["from_account"] = *fromAccount
    }
    if toAccount != nil {
        filters["to_account"] = *toAccount
    }
    if minAmount != nil {
        filters["min_amount"] = *minAmount
    }
    if maxAmount != nil {
        filters["max_amount"] = *maxAmount
    }
    
    return api.GetOneSteps(filters)
}

func (api *OneStepsAPI) GetTransfersByDateRange(dateFrom, dateTo string, limit int) (*OneStepsResponse, error) {
    filters := map[string]interface{}{
        "date_from": dateFrom,
        "date_to":   dateTo,
        "limit":     limit,
    }
    
    return api.GetOneSteps(filters)
}

func (api *OneStepsAPI) GetPaginatedTransfers(page, limit int, filters map[string]interface{}) (*OneStepsResponse, error) {
    if filters == nil {
        filters = make(map[string]interface{})
    }
    filters["page"] = page
    filters["limit"] = limit
    return api.GetOneSteps(filters)
}

func main() {
    api := NewOneStepsAPI("http://service.ssumethods.com", "your_access_token_here")
    
    // Get all transfers
    allTransfers, err := api.GetOneSteps(nil)
    if err != nil {
        fmt.Printf("Error getting transfers: %v\n", err)
        return
    }
    
    fmt.Printf("Found %d transfers\n", len(allTransfers.Data.Transfers))
    fmt.Printf("Total amount: %.2f\n", allTransfers.Data.Summary.TotalAmount)
    
    // Get transfers by account
    fromAccount := "ACC001"
    minAmount := 100.0
    accountTransfers, err := api.GetTransfersByAccount(&fromAccount, nil, &minAmount, nil)
    if err != nil {
        fmt.Printf("Error getting account transfers: %v\n", err)
        return
    }
    
    for _, transfer := range accountTransfers.Data.Transfers {
        fmt.Printf("From: %s To: %s\n", transfer.FromAccount, transfer.ToAccount)
        fmt.Printf("Amount: %.2f Date: %s\n", transfer.Amount, transfer.Date)
        fmt.Println("---")
    }
    
    // Get transfers by date range
    dateTransfers, err := api.GetTransfersByDateRange("2024-01-01", "2024-01-31", 20)
    if err != nil {
        fmt.Printf("Error getting date transfers: %v\n", err)
        return
    }
    
    fmt.Printf("Transfers in date range: %d\n", len(dateTransfers.Data.Transfers))
    
    // Pagination example
    page := 1
    for {
        result, err := api.GetPaginatedTransfers(page, 10, nil)
        if err != nil {
            fmt.Printf("Error getting page %d: %v\n", page, err)
            break
        }
        
        if len(result.Data.Transfers) == 0 {
            break
        }
        
        fmt.Printf("Page %d: %d transfers\n", page, len(result.Data.Transfers))
        
        if !result.Data.Pagination.HasNext {
            break
        }
        
        page++
    }
}