import 'package:http/http.dart' as http;
import 'dart:convert';

class DsiApiService {
  static const String baseUrl = "https://fake-api.devsecit.com/1.0.0/wb/";
  
  static Future call({required String method, required String table, Map? data}) async {
    final token = base64.encode(utf8.encode("PgcQqi8ZGmlnYwd50JKo74_secure_token_2024"));
    final ts = base64.encode(utf8.encode((DateTime.now().millisecondsSinceEpoch ~/ 1000).toString()));

    try {
      final res = await http.post(Uri.parse(baseUrl), body: {
        'token': token, 'timestmp': ts, 'method': method, 'table': table, ...?data
      });
      return json.decode(res.body);
    } catch (e) { throw e; }
  }
}

'use server'

export async function dsiRequest(method: string, table: string, data: any = {}) {
  const token = Buffer.from("PgcQqi8ZGmlnYwd50JKo74_secure_token_2024").toString('base64');
  const ts = Buffer.from(Math.floor(Date.now() / 1000).toString()).toString('base64');

  const res = await fetch("https://fake-api.devsecit.com/1.0.0/wb/", {
    method: 'POST',
    body: new URLSearchParams({ token, timestmp: ts, method, table, ...data })
  });
  return res.json();
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Collections.Generic;

public class DsiClient {
    private static readonly HttpClient client = new HttpClient();
    private const string BaseUrl = "https://fake-api.devsecit.com/1.0.0/wb/";
    private const string AppToken = "PgcQqi8ZGmlnYwd50JKo74_secure_token_2024";

    public async Task CallApi(string method, string table, Dictionary extraData = null) {
        var token = Convert.ToBase64String(Encoding.UTF8.GetBytes(AppToken));
        var ts = Convert.ToBase64String(Encoding.UTF8.GetBytes(DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString()));

        var payload = new Dictionary {
            { "token", token },
            { "timestmp", ts },
            { "method", method },
            { "table", table }
        };

        if (extraData != null) foreach (var kv in extraData) payload[kv.Key] = kv.Value;

        var content = new FormUrlEncodedContent(payload);
        client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YOUR_SECRET");

        var response = await client.PostAsync(BaseUrl, content);
        return await response.Content.ReadAsStringAsync();
    }
}

import android.util.Base64;
import okhttp3.*;
import java.io.IOException;

public class DsiApiService {
    private static final String BASE_URL = "https://fake-api.devsecit.com/1.0.0/wb/";
    private final OkHttpClient client = new OkHttpClient();

    public void call(String method, String table, FormBody extraParams, Callback callback) {
        String token = Base64.encodeToString("PgcQqi8ZGmlnYwd50JKo74_secure_token_2024".getBytes(), Base64.NO_WRAP);
        String ts = Base64.encodeToString(String.valueOf(System.currentTimeMillis() / 1000).getBytes(), Base64.NO_WRAP);

        FormBody.Builder bodyBuilder = new FormBody.Builder()
            .add("token", token)
            .add("timestmp", ts)
            .add("method", method)
            .add("table", table);

        // Add extra params if needed logic here...

        Request request = new Request.Builder()
            .url(BASE_URL)
            .addHeader("Authorization", "Bearer YOUR_SECRET")
            .post(bodyBuilder.build())
            .build();

        client.newCall(request).enqueue(callback);
    }
}

import io.ktor.client.*
import io.ktor.client.request.*
import io.ktor.client.request.forms.*
import io.ktor.http.*
import java.util.Base64

class DsiRepository(private val client: HttpClient) {
    private val baseUrl = "https://fake-api.devsecit.com/1.0.0/wb/"
    private val appToken = "PgcQqi8ZGmlnYwd50JKo74_secure_token_2024"

    suspend fun fetchData(method: String, table: String, where: String): String {
        val token = Base64.getEncoder().encodeToString(appToken.toByteArray())
        val ts = Base64.getEncoder().encodeToString((System.currentTimeMillis() / 1000).toString().toByteArray())

        return client.post(baseUrl) {
            header(HttpHeaders.Authorization, "Bearer YOUR_SECRET")
            setBody(FormDataContent(Parameters.build {
                append("token", token)
                append("timestmp", ts)
                append("method", method)
                append("table", table)
                append("where", where)
            }))
        }
    }
}

import { Buffer } from 'buffer';

export const dsiRequest = async (method, table, data = {}) => {
  const token = Buffer.from("PgcQqi8ZGmlnYwd50JKo74_secure_token_2024").toString('base64');
  const ts = Buffer.from(Math.floor(Date.now() / 1000).toString()).toString('base64');

  const body = new URLSearchParams({
    token,
    timestmp: ts,
    method,
    table,
    ...data
  }).toString();

  const response = await fetch("https://fake-api.devsecit.com/1.0.0/wb/", {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_SECRET',
      'Content-Type': 'application/x-www-form-urlencoded'
    },
    body
  });

  return await response.json();
};