API Documentation

<?php
/**
 * WordPress-compatible REST API for Auto Content
 * Route: /wp-json/wp/v2/posts (POST), /wp-json/wp/v2/categories (GET)
 */

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

// ========== BASIC AUTH ==========
function verifyAuth() {
    $auth = $_SERVER['HTTP_AUTHORIZATION'] ?? $_SERVER['REDIRECT_HTTP_AUTHORIZATION'] ?? '';
    if (!preg_match('/Basic\s+(.+)/i', $auth, $matches)) {
        return false;
    }
    $credentials = base64_decode($matches[1]);
    list($username, $password) = explode(':', $credentials, 2);

    // TODO: Verify against your user database
    // Example: return User::where('username', $username)->verifyPassword($password);
    return $username === 'your_username' && $password === 'your_app_password';
}

if (!verifyAuth()) {
    http_response_code(401);
    die(json_encode(['code' => 'unauthorized', 'message' => 'Invalid credentials']));
}

// ========== ROUTING ==========
$method = $_SERVER['REQUEST_METHOD'];
$path = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

// GET /wp-json/wp/v2/categories
if ($method === 'GET' && preg_match('#/wp-json/wp/v2/categories#', $path)) {
    // TODO: Fetch from your database
    $categories = [
        ['id' => 1, 'name' => 'Technology', 'slug' => 'technology'],
        ['id' => 2, 'name' => 'News', 'slug' => 'news'],
        ['id' => 3, 'name' => 'Crypto', 'slug' => 'crypto'],
    ];
    echo json_encode($categories);
    exit;
}

// POST /wp-json/wp/v2/posts
if ($method === 'POST' && preg_match('#/wp-json/wp/v2/posts#', $path)) {
    $input = json_decode(file_get_contents('php://input'), true);

    $title = $input['title'] ?? '';
    $content = $input['content'] ?? '';
    $excerpt = $input['excerpt'] ?? '';
    $status = $input['status'] ?? 'draft';
    $categories = $input['categories'] ?? [];
    $featuredMedia = $input['featured_media'] ?? null;

    // TODO: Save to your database
    // $post = Post::create([...]);
    // $postId = $post->id;
    $postId = rand(1000, 9999); // Demo ID

    http_response_code(201);
    echo json_encode([
        'id' => $postId,
        'link' => 'https://yoursite.com/posts/' . $postId,
        'status' => $status,
        'title' => ['rendered' => $title]
    ]);
    exit;
}

// POST /wp-json/wp/v2/media (Optional - for featured images)
if ($method === 'POST' && preg_match('#/wp-json/wp/v2/media#', $path)) {
    $filename = 'upload_' . time() . '.jpg';
    $imageData = file_get_contents('php://input');

    // TODO: Save image to your storage
    // file_put_contents('/uploads/' . $filename, $imageData);
    $mediaId = rand(1000, 9999);

    http_response_code(201);
    echo json_encode([
        'id' => $mediaId,
        'source_url' => 'https://yoursite.com/uploads/' . $filename
    ]);
    exit;
}

http_response_code(404);
echo json_encode(['code' => 'not_found', 'message' => 'Endpoint not found']);

const express = require('express');
const app = express();

app.use(express.json());
app.use(express.raw({ type: 'image/*', limit: '10mb' }));

// ========== BASIC AUTH MIDDLEWARE ==========
const basicAuth = (req, res, next) => {
    const auth = req.headers.authorization || '';
    if (!auth.startsWith('Basic ')) {
        return res.status(401).json({ code: 'unauthorized', message: 'No credentials' });
    }

    const credentials = Buffer.from(auth.slice(6), 'base64').toString();
    const [username, password] = credentials.split(':');

    // TODO: Verify against your database
    if (username !== 'your_username' || password !== 'your_app_password') {
        return res.status(401).json({ code: 'unauthorized', message: 'Invalid credentials' });
    }

    req.user = username;
    next();
};

// ========== ENDPOINTS ==========

// GET /wp-json/wp/v2/categories
app.get('/wp-json/wp/v2/categories', basicAuth, async (req, res) => {
    // TODO: Fetch from your database
    const categories = [
        { id: 1, name: 'Technology', slug: 'technology' },
        { id: 2, name: 'News', slug: 'news' },
        { id: 3, name: 'Crypto', slug: 'crypto' },
    ];
    res.json(categories);
});

// POST /wp-json/wp/v2/posts
app.post('/wp-json/wp/v2/posts', basicAuth, async (req, res) => {
    const { title, content, excerpt, status, categories, featured_media } = req.body;

    // TODO: Save to your database
    // const post = await Post.create({ title, content, status, ... });
    const postId = Math.floor(Math.random() * 9000) + 1000; // Demo ID

    res.status(201).json({
        id: postId,
        link: `https://yoursite.com/posts/${postId}`,
        status: status || 'draft',
        title: { rendered: title }
    });
});

// POST /wp-json/wp/v2/media (Optional)
app.post('/wp-json/wp/v2/media', basicAuth, async (req, res) => {
    const filename = `upload_${Date.now()}.jpg`;
    const imageBuffer = req.body;

    // TODO: Save to your storage (S3, local, etc.)
    // await fs.writeFile(`./uploads/${filename}`, imageBuffer);
    const mediaId = Math.floor(Math.random() * 9000) + 1000;

    res.status(201).json({
        id: mediaId,
        source_url: `https://yoursite.com/uploads/${filename}`
    });
});

app.listen(3000, () => console.log('API running on port 3000'));

from flask import Flask, request, jsonify
import base64
import random
import time

app = Flask(__name__)

# ========== BASIC AUTH ==========
def verify_auth():
    auth = request.headers.get('Authorization', '')
    if not auth.startswith('Basic '):
        return None

    try:
        credentials = base64.b64decode(auth[6:]).decode('utf-8')
        username, password = credentials.split(':', 1)

        # TODO: Verify against your database
        if username == 'your_username' and password == 'your_app_password':
            return username
    except:
        pass
    return None

def require_auth(f):
    def wrapper(*args, **kwargs):
        if not verify_auth():
            return jsonify({'code': 'unauthorized', 'message': 'Invalid credentials'}), 401
        return f(*args, **kwargs)
    wrapper.__name__ = f.__name__
    return wrapper

# ========== ENDPOINTS ==========

# GET /wp-json/wp/v2/categories
@app.route('/wp-json/wp/v2/categories', methods=['GET'])
@require_auth
def get_categories():
    # TODO: Fetch from your database
    categories = [
        {'id': 1, 'name': 'Technology', 'slug': 'technology'},
        {'id': 2, 'name': 'News', 'slug': 'news'},
        {'id': 3, 'name': 'Crypto', 'slug': 'crypto'},
    ]
    return jsonify(categories)

# POST /wp-json/wp/v2/posts
@app.route('/wp-json/wp/v2/posts', methods=['POST'])
@require_auth
def create_post():
    data = request.json

    title = data.get('title', '')
    content = data.get('content', '')
    excerpt = data.get('excerpt', '')
    status = data.get('status', 'draft')
    categories = data.get('categories', [])
    featured_media = data.get('featured_media')

    # TODO: Save to your database
    # post = Post.create(title=title, content=content, ...)
    post_id = random.randint(1000, 9999)  # Demo ID

    return jsonify({
        'id': post_id,
        'link': f'https://yoursite.com/posts/{post_id}',
        'status': status,
        'title': {'rendered': title}
    }), 201

# POST /wp-json/wp/v2/media (Optional)
@app.route('/wp-json/wp/v2/media', methods=['POST'])
@require_auth
def upload_media():
    filename = f'upload_{int(time.time())}.jpg'
    image_data = request.data

    # TODO: Save to your storage
    # with open(f'./uploads/{filename}', 'wb') as f:
    #     f.write(image_data)
    media_id = random.randint(1000, 9999)

    return jsonify({
        'id': media_id,
        'source_url': f'https://yoursite.com/uploads/{filename}'
    }), 201

if __name__ == '__main__':
    app.run(port=3000, debug=True)

package main

import (
    "encoding/base64"
    "encoding/json"
    "fmt"
    "math/rand"
    "net/http"
    "strings"
    "time"
)

// ========== BASIC AUTH MIDDLEWARE ==========
func basicAuth(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        auth := r.Header.Get("Authorization")
        if !strings.HasPrefix(auth, "Basic ") {
            http.Error(w, `{"code":"unauthorized","message":"No credentials"}`, 401)
            return
        }

        decoded, err := base64.StdEncoding.DecodeString(auth[6:])
        if err != nil {
            http.Error(w, `{"code":"unauthorized","message":"Invalid encoding"}`, 401)
            return
        }

        parts := strings.SplitN(string(decoded), ":", 2)
        if len(parts) != 2 {
            http.Error(w, `{"code":"unauthorized","message":"Invalid format"}`, 401)
            return
        }

        // TODO: Verify against your database
        if parts[0] != "your_username" || parts[1] != "your_app_password" {
            http.Error(w, `{"code":"unauthorized","message":"Invalid credentials"}`, 401)
            return
        }

        next(w, r)
    }
}

// ========== HANDLERS ==========

func getCategories(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    // TODO: Fetch from your database
    categories := []map[string]interface{}{
        {"id": 1, "name": "Technology", "slug": "technology"},
        {"id": 2, "name": "News", "slug": "news"},
        {"id": 3, "name": "Crypto", "slug": "crypto"},
    }
    json.NewEncoder(w).Encode(categories)
}

func createPost(w http.ResponseWriter, r *http.Request) {
    var input map[string]interface{}
    json.NewDecoder(r.Body).Decode(&input)

    // TODO: Save to your database
    postID := rand.Intn(9000) + 1000

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(201)
    json.NewEncoder(w).Encode(map[string]interface{}{
        "id":     postID,
        "link":   fmt.Sprintf("https://yoursite.com/posts/%d", postID),
        "status": input["status"],
        "title":  map[string]interface{}{"rendered": input["title"]},
    })
}

func uploadMedia(w http.ResponseWriter, r *http.Request) {
    filename := fmt.Sprintf("upload_%d.jpg", time.Now().Unix())
    // TODO: Save r.Body to your storage
    mediaID := rand.Intn(9000) + 1000

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(201)
    json.NewEncoder(w).Encode(map[string]interface{}{
        "id":         mediaID,
        "source_url": fmt.Sprintf("https://yoursite.com/uploads/%s", filename),
    })
}

func main() {
    rand.Seed(time.Now().UnixNano())

    http.HandleFunc("/wp-json/wp/v2/categories", basicAuth(getCategories))
    http.HandleFunc("/wp-json/wp/v2/posts", basicAuth(createPost))
    http.HandleFunc("/wp-json/wp/v2/media", basicAuth(uploadMedia))

    fmt.Println("Server running on :3000")
    http.ListenAndServe(":3000", nil)
}

require 'sinatra'
require 'json'
require 'base64'
require 'securerandom'

set :port, 3000

# ========== BASIC AUTH ==========
def verify_auth
  auth = request.env['HTTP_AUTHORIZATION'] || ''
  return nil unless auth.start_with?('Basic ')

  begin
    credentials = Base64.decode64(auth[6..])
    username, password = credentials.split(':', 2)

    # TODO: Verify against your database
    return username if username == 'your_username' && password == 'your_app_password'
  rescue
    nil
  end
  nil
end

before do
  content_type :json

  unless verify_auth
    halt 401, { code: 'unauthorized', message: 'Invalid credentials' }.to_json
  end
end

# ========== ENDPOINTS ==========

# GET /wp-json/wp/v2/categories
get '/wp-json/wp/v2/categories' do
  # TODO: Fetch from your database
  categories = [
    { id: 1, name: 'Technology', slug: 'technology' },
    { id: 2, name: 'News', slug: 'news' },
    { id: 3, name: 'Crypto', slug: 'crypto' }
  ]
  categories.to_json
end

# POST /wp-json/wp/v2/posts
post '/wp-json/wp/v2/posts' do
  data = JSON.parse(request.body.read)

  # TODO: Save to your database
  post_id = rand(1000..9999)

  status 201
  {
    id: post_id,
    link: "https://yoursite.com/posts/#{post_id}",
    status: data['status'] || 'draft',
    title: { rendered: data['title'] }
  }.to_json
end

# POST /wp-json/wp/v2/media
post '/wp-json/wp/v2/media' do
  filename = "upload_#{Time.now.to_i}.jpg"
  # image_data = request.body.read
  # TODO: Save to your storage

  media_id = rand(1000..9999)

  status 201
  {
    id: media_id,
    source_url: "https://yoursite.com/uploads/#{filename}"
  }.to_json
end

using Microsoft.AspNetCore.Mvc;
using System.Text;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// ========== BASIC AUTH MIDDLEWARE ==========
bool VerifyAuth(HttpContext context)
{
    var auth = context.Request.Headers["Authorization"].FirstOrDefault() ?? "";
    if (!auth.StartsWith("Basic ")) return false;

    try
    {
        var credentials = Encoding.UTF8.GetString(Convert.FromBase64String(auth[6..]));
        var parts = credentials.Split(':', 2);
        // TODO: Verify against your database
        return parts[0] == "your_username" && parts[1] == "your_app_password";
    }
    catch { return false; }
}

// ========== ENDPOINTS ==========

// GET /wp-json/wp/v2/categories
app.MapGet("/wp-json/wp/v2/categories", (HttpContext context) =>
{
    if (!VerifyAuth(context))
        return Results.Json(new { code = "unauthorized", message = "Invalid credentials" }, statusCode: 401);

    // TODO: Fetch from your database
    var categories = new[]
    {
        new { id = 1, name = "Technology", slug = "technology" },
        new { id = 2, name = "News", slug = "news" },
        new { id = 3, name = "Crypto", slug = "crypto" }
    };
    return Results.Json(categories);
});

// POST /wp-json/wp/v2/posts
app.MapPost("/wp-json/wp/v2/posts", async (HttpContext context) =>
{
    if (!VerifyAuth(context))
        return Results.Json(new { code = "unauthorized", message = "Invalid credentials" }, statusCode: 401);

    var data = await context.Request.ReadFromJsonAsync<PostRequest>();

    // TODO: Save to your database
    var postId = Random.Shared.Next(1000, 9999);

    return Results.Json(new
    {
        id = postId,
        link = $"https://yoursite.com/posts/{postId}",
        status = data?.Status ?? "draft",
        title = new { rendered = data?.Title }
    }, statusCode: 201);
});

// POST /wp-json/wp/v2/media
app.MapPost("/wp-json/wp/v2/media", async (HttpContext context) =>
{
    if (!VerifyAuth(context))
        return Results.Json(new { code = "unauthorized", message = "Invalid credentials" }, statusCode: 401);

    var filename = $"upload_{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}.jpg";
    // var imageData = await context.Request.Body...
    // TODO: Save to your storage

    var mediaId = Random.Shared.Next(1000, 9999);

    return Results.Json(new
    {
        id = mediaId,
        source_url = $"https://yoursite.com/uploads/{filename}"
    }, statusCode: 201);
});

app.Run("http://localhost:3000");

record PostRequest(string? Title, string? Content, string? Excerpt, string? Status, int[]? Categories);

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.*;
import org.springframework.web.bind.annotation.*;
import java.util.*;

@SpringBootApplication
@RestController
public class WpApiApplication {

    public static void main(String[] args) {
        SpringApplication.run(WpApiApplication.class, args);
    }

    // ========== BASIC AUTH ==========
    private boolean verifyAuth(String authHeader) {
        if (authHeader == null || !authHeader.startsWith("Basic ")) {
            return false;
        }
        try {
            String credentials = new String(Base64.getDecoder().decode(authHeader.substring(6)));
            String[] parts = credentials.split(":", 2);
            // TODO: Verify against your database
            return parts[0].equals("your_username") && parts[1].equals("your_app_password");
        } catch (Exception e) {
            return false;
        }
    }

    // ========== ENDPOINTS ==========

    // GET /wp-json/wp/v2/categories
    @GetMapping("/wp-json/wp/v2/categories")
    public ResponseEntity<?> getCategories(@RequestHeader("Authorization") String auth) {
        if (!verifyAuth(auth)) {
            return ResponseEntity.status(401)
                .body(Map.of("code", "unauthorized", "message", "Invalid credentials"));
        }

        // TODO: Fetch from your database
        List<Map<String, Object>> categories = List.of(
            Map.of("id", 1, "name", "Technology", "slug", "technology"),
            Map.of("id", 2, "name", "News", "slug", "news"),
            Map.of("id", 3, "name", "Crypto", "slug", "crypto")
        );
        return ResponseEntity.ok(categories);
    }

    // POST /wp-json/wp/v2/posts
    @PostMapping("/wp-json/wp/v2/posts")
    public ResponseEntity<?> createPost(
            @RequestHeader("Authorization") String auth,
            @RequestBody Map<String, Object> body) {

        if (!verifyAuth(auth)) {
            return ResponseEntity.status(401)
                .body(Map.of("code", "unauthorized", "message", "Invalid credentials"));
        }

        // TODO: Save to your database
        int postId = new Random().nextInt(9000) + 1000;

        return ResponseEntity.status(201).body(Map.of(
            "id", postId,
            "link", "https://yoursite.com/posts/" + postId,
            "status", body.getOrDefault("status", "draft"),
            "title", Map.of("rendered", body.get("title"))
        ));
    }

    // POST /wp-json/wp/v2/media
    @PostMapping("/wp-json/wp/v2/media")
    public ResponseEntity<?> uploadMedia(
            @RequestHeader("Authorization") String auth,
            @RequestBody byte[] imageData) {

        if (!verifyAuth(auth)) {
            return ResponseEntity.status(401)
                .body(Map.of("code", "unauthorized", "message", "Invalid credentials"));
        }

        String filename = "upload_" + System.currentTimeMillis() / 1000 + ".jpg";
        // TODO: Save imageData to your storage

        int mediaId = new Random().nextInt(9000) + 1000;

        return ResponseEntity.status(201).body(Map.of(
            "id", mediaId,
            "source_url", "https://yoursite.com/uploads/" + filename
        ));
    }
}