Operation Name the Party

From Soyjak Wiki, the free ensoyclopedia
Jump to navigationJump to search
Operation Name the Party was a Sharty neutralraid.
You can update the page to reflect this.
Reason(s): Initial attempts to spam the site were successful but the Facebook posting failed.
You shall use the King's English.
Operation Name the Party
Date28 August 2025
Location
yourparty.uk/ourname#
Result Neutralraid, possible failraid
Belligerents
soyjak.party Jeremy Corbyn's party
Commanders and leaders
Soyteens Jeremy Corbyn
Units involved

/soy/
/raid/
Python codeGODs

Java codeGODs		 Jannies
Casualties and losses
Several hours of time Jeremy Corbyn and jannies clean out meme names

Operation Name the Party was a raid that started on August 28, 2025.[1][2] It was on both /soy/ and /raid/. It revolved around a UK political party led by Jeremy Corbyn choosing to decide their new name through an online poll.

Most ‘teens submitted the name "Soyjak Party", though other options are Jezbollah, National Socialist Party, National Socialist British Workers Party, BRAP (Black n Red Antifascist Party), Gem Party, Soycialist Party, Deform UK, the Islamic Communist Party, and others.

'teens have created a botnet that can spam the poll website with sharty-focused answers. (You) can help by adapting the scripts on Undertroon Memories Rape (there are already two in Python and Java). The site has Cloudflare so we can't just mindlessly spam it but if we use Selenium or Playwright we may be able to bypass it.

A 'teen found the Facebook API key: "1168954500254617". You WILL try to gem up the page by making HTTP requests with the key (another 'teen created an example program in the thread showing how). It was later attempted to run the program which failed likely because the public API key was reported, which is a fail however goes to show how poor security these fags have.

Copypasta[edit | edit source]

Soyjaks, originally born as an internet meme, have grown into a recognizable political subculture that often embodies an ironic critique of modern consumerism and mass culture. By exaggerating expressions of enthusiasm for corporate products, the imagery satirizes blind consumer loyalty and highlights how capitalist systems condition people to define identity through consumption. In this sense, soyjaks serve as a fitting symbol for a socialist-progressist movement, as they underscore the absurdity of consumer-driven values while pointing toward the need for collective awareness and systemic change. Their widespread use across online spaces also makes them a uniquely grassroots cultural phenomenon, capable of channeling youthful energy into critiques of commodification and the alienation it produces under capitalism.

Python script[edit | edit source]

Requires selenium and undetected_chromedriver, install using pip. 

#!/usr/bin/env python3

import asyncio
import time
import random
from asyncio import AbstractEventLoop, Task
from collections import OrderedDict
from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
from typing import List, Optional, Tuple, Union

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.remote.webelement import WebElement
from undetected_chromedriver import Chrome


@dataclass
class FormData:
    """
    @brief Data class to hold form submission data
    @details Contains all the necessary information for a single form submission
    """
    name: str
    email: str
    code: str
    party_name: str
    description: str


FIRST_NAMES: List[str] = [
    "Jay", "Jim", "Roy", "Axel", "Billy", "Charlie", "Jax", "Gina", "Paul", "Ringo", 
    "Ally", "Nicky", "Cam", "Ari", "Trudie", "Cal", "Carl", "Lady", "Lauren", "Ichabod", 
    "Arthur", "Ashley", "Drake", "Kim", "Julio", "Lorraine", "Floyd", "Janet", "Lydia", 
    "Charles", "Pedro", "Bradley"
]
TARGET_URL: str = "https://embed-1113427.secondstreetapp.com/embed/bfdf7409-7a40-463d-8e8b-ea95bb3c2aa9/"

FIRST_LETTERS: str = "ABCDEFGHIJKLMNOPRSTUWYZ" 
SECOND_LETTERS: str = "ABCDEFGHJKLMNOPQRSTUVWXY"
LAST_LETTERS_OUTWARD: str = "ABEHMNPRVWXY" 
INWARD_LETTERS: str = "ABDEFGHJLNPQRSTUWXYZ"
PATTERNS: List[str] = ["A9", "A9A", "A99", "AA9", "AA9A", "AA99"]

PARTY_NAME: str = "Soyjak Party"
DESCRIPTION: str = (
    "Soyjaks, originally born as an internet meme, have grown into a recognizable political "
    "subculture that often embodies an ironic critique of modern consumerism and mass culture. "
    "By exaggerating expressions of enthusiasm for corporate products, the imagery satirizes blind "
    "consumer loyalty and highlights how capitalist systems condition people to define identity "
    "through consumption. In this sense, soyjaks serve as a fitting symbol for a socialist-progressist "
    "movement, as they underscore the absurdity of consumer-driven values while pointing toward the "
    "need for collective awareness and systemic change. Their widespread use across online spaces "
    "also makes them a uniquely grassroots cultural phenomenon, capable of channeling youthful "
    "energy into critiques of commodification and the alienation it produces under capitalism."
)

POSTAL_ZONES: Tuple[str, ...] = (
    'AB', 'AL', 'B', 'BA', 'BB', 'BD', 'BH', 'BL', 'BN', 'BR',
    'BS', 'BT', 'CA', 'CB', 'CF', 'CH', 'CM', 'CO', 'CR', 'CT',
    'CV', 'CW', 'DA', 'DD', 'DE', 'DG', 'DH', 'DL', 'DN', 'DT',
    'DY', 'E', 'EC', 'EH', 'EN', 'EX', 'FK', 'FY', 'G', 'GL',
    'GY', 'GU', 'HA', 'HD', 'HG', 'HP', 'HR', 'HS', 'HU', 'HX',
    'IG', 'IM', 'IP', 'IV', 'JE', 'KA', 'KT', 'KW', 'KY', 'L',
    'LA', 'LD', 'LE', 'LL', 'LN', 'LS', 'LU', 'M', 'ME', 'MK',
    'ML', 'N', 'NE', 'NG', 'NN', 'NP', 'NR', 'NW', 'OL', 'OX',
    'PA', 'PE', 'PH', 'PL', 'PO', 'PR', 'RG', 'RH', 'RM', 'S',
    'SA', 'SE', 'SG', 'SK', 'SL', 'SM', 'SN', 'SO', 'SP', 'SR',
    'SS', 'ST', 'SW', 'SY', 'TA', 'TD', 'TF', 'TN', 'TQ', 'TR',
    'TS', 'TW', 'UB', 'W', 'WA', 'WC', 'WD', 'WF', 'WN', 'WR',
    'WS', 'WV', 'YO', 'ZE'
)

POSTAL_ZONES_ONE_CHAR: List[str] = [z for z in POSTAL_ZONES if len(z) == 1]
POSTAL_ZONES_TWO_CHARS: List[str] = [z for z in POSTAL_ZONES if len(z) == 2]

POSTCODE_FORMATS: Tuple[str, ...] = (
    'AN NEE',
    'ANN NEE',
    'PN NEE',
    'PNN NEE',
    'ANC NEE',
    'PND NEE',
)

POSTCODE_SETS: OrderedDict[str, Union[str, List[str]]] = OrderedDict((
    (' ', ' '),
    ('N', [str(i) for i in range(10)]),
    ('A', POSTAL_ZONES_ONE_CHAR),
    ('B', 'ABCDEFGHKLMNOPQRSTUVWXY'),
    ('C', 'ABCDEFGHJKSTUW'),
    ('D', 'ABEHMNPRVWXY'),
    ('E', 'ABDEFGHJLNPQRSTUWXYZ'),
    ('P', POSTAL_ZONES_TWO_CHARS),
))

def generate_postal_code() -> str:
    """
    @brief Generates a random UK postal code
    @return A randomly generated postal code string in UK format
    @details Creates a postal code following UK postal code patterns with proper letter distributions
    """
    pattern: str = random.choice(POSTCODE_FORMATS)
    postcode: str = ''
    for placeholder in pattern:
        elem: Optional[Union[str, List[str]]] = POSTCODE_SETS.get(placeholder)
        if isinstance(elem, List):
            postcode += random.choice(elem)
        else:
            postcode += random.choice(list(elem))
    return postcode


def generate_form_data() -> FormData:
    """
    @brief Generates random form data for submission
    @return FormData object containing randomized form fields
    @details Creates a complete set of form data including name, email, postal code, and description
    """
    name: str = random.choice(FIRST_NAMES)
    email: str = f"{random.choice(FIRST_NAMES)}{random.randint(1, 10000)}@gmail.com"
    code: str = generate_postal_code()
    
    return FormData(name, email, code, PARTY_NAME, DESCRIPTION)


def run_selenium_task(thread_id: int) -> bool:
    """
    @brief Executes the Selenium automation task
    @param thread_id Unique identifier for this execution thread
    @return True if the task completed successfully, False otherwise
    @details Creates a Chrome WebDriver instance and automates form submission on the target website
    """
    driver: Optional[Chrome] = None
    
    try:
        form_data: FormData = generate_form_data()
        
        options: ChromeOptions = ChromeOptions()
        # options.add_argument("--headless=new")  # Uncomment for headless mode
        options.add_argument("--disable-blink-features=AutomationControlled")  
        options.add_argument("--start-maximized")

        driver = Chrome(options = options, use_subprocess = True)

        driver.get(TARGET_URL)

        wait: WebDriverWait = WebDriverWait(driver, 20)

        name_field: WebElement = wait.until(EC.element_to_be_clickable((By.ID, "ember7")))
        name_field.send_keys(form_data.name)

        email_field: WebElement = wait.until(EC.element_to_be_clickable((By.ID, "ember10")))
        email_field.send_keys(form_data.email)

        code_field: WebElement = wait.until(EC.element_to_be_clickable((By.ID, "ember15")))
        code_field.send_keys(form_data.code)

        party_name_field: WebElement = wait.until(EC.element_to_be_clickable((By.ID, "ember18")))
        party_name_field.send_keys(form_data.party_name)

        description_field: WebElement = wait.until(EC.element_to_be_clickable((By.ID, "ember21")))
        description_field.send_keys(form_data.description)

        submit_button: WebElement = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, "button.ssButtonContinue")))
        submit_button.click()

        time.sleep(10)
        
        print(f"Thread {thread_id}: Form submitted successfully")
        return True

    except Exception as e:
        print(f"Thread {thread_id}: Error during form submission - {e}")
        return False
    
    finally:
        if driver:
            try:
                driver.quit()
            except Exception as e:
                print(f"Thread {thread_id}: Error closing driver - {e}")


async def submit_form_async(thread_id: int) -> bool:
    """
    @brief Asynchronously submits a form using Selenium WebDriver
    @param thread_id Unique identifier for the thread/process
    @return True if submission was successful, False otherwise
    @details Runs the form submission in a separate thread using asyncio's thread pool executor
    """
    loop: AbstractEventLoop = asyncio.get_event_loop()
    
    with ThreadPoolExecutor() as executor:
        try:
            result: bool = await loop.run_in_executor(executor, run_selenium_task, thread_id)
            return result
        except Exception as e:
            print(f"Thread {thread_id} failed with error: {e}")
            return False

async def run_multiple_submissions(num_submissions: int = 3) -> List[bool]:
    """
    @brief Runs multiple form submissions concurrently using async
    @param num_submissions Number of concurrent form submissions to execute
    @return List of boolean results indicating success/failure of each submission
    @details Creates multiple async tasks to submit forms concurrently with random delays
    """
    tasks: List[Task] = []
    
    for i in range(num_submissions):
        if i > 0:
            delay: float = random.uniform(2, 5)
            await asyncio.sleep(delay)
        
        task: asyncio.Task = asyncio.create_task(submit_form_async(i))
        tasks.append(task)
    
    results: List[bool] = await asyncio.gather(*tasks, return_exceptions=True)
    
    processed_results: List[bool] = []
    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Task {i} failed with exception: {result}")
            processed_results.append(False)
        else:
            processed_results.append(result)
    
    return processed_results


async def main() -> None:
    """
    @brief Main async function that orchestrates the form submission process
    @details Runs multiple concurrent form submissions and reports the results
    """
    print("Starting automated form submissions...")
    num_submissions: int = 3
    
    results: List[bool] = await run_multiple_submissions(num_submissions)
    
    successful: int = sum(results)
    total: int = len(results)
    
    print(f"Submission completed: {successful}/{total} successful")
    print("Form submission process finished")


if __name__ == "__main__":
    asyncio.run(main())

Java version[edit | edit source]

Requires selenium-java, any version will do, you can get it off the Maven repository here. 

package party.soyjak.soy;

import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.MalformedURLException;
import java.time.Duration;
import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;

/**
 * @brief Main class for automated form submission
 * @details Handles concurrent form submissions using Selenium WebDriver
 */
public class ApeParty {
    
    /**
     * @brief Data class to hold form submission data
     * @details Contains all the necessary information for a single form submission
     */
    public static record FormData(String name, String email, String code, String partyName, String description) {}
    
    private static final List<String> FIRST_NAMES = Arrays.asList(
        "Jay", "Jim", "Roy", "Axel", "Billy", "Charlie", "Jax", "Gina", "Paul", "Ringo", 
        "Ally", "Nicky", "Cam", "Ari", "Trudie", "Cal", "Carl", "Lady", "Lauren", "Ichabod", 
        "Arthur", "Ashley", "Drake", "Kim", "Julio", "Lorraine", "Floyd", "Janet", "Lydia", 
        "Charles", "Pedro", "Bradley"
    );
    
    private static final URL TARGET_URL;

    static {
        try {
            TARGET_URL = new URI("https://embed-1113427.secondstreetapp.com/embed/bfdf7409-7a40-463d-8e8b-ea95bb3c2aa9/").toURL();
        } catch (MalformedURLException e) {
            throw new RuntimeException("Invalid target URL", e);
        } catch (URISyntaxException e) {
            throw new RuntimeException("Invalid URI syntax", e);
        }
    }
    
    private static final String FIRST_LETTERS = "ABCDEFGHIJKLMNOPRSTUWYZ";
    private static final String SECOND_LETTERS = "ABCDEFGHJKLMNOPQRSTUVWXY";
    private static final String LAST_LETTERS_OUTWARD = "ABEHMNPRVWXY";
    private static final String INWARD_LETTERS = "ABDEFGHJLNPQRSTUWXYZ";
    private static final List<String> PATTERNS = Arrays.asList("A9", "A9A", "A99", "AA9", "AA9A", "AA99");
    
    private static final String PARTY_NAME = "Soyjak Party";
    private static final String DESCRIPTION = """
        Soyjaks, originally born as an internet meme, have grown into a recognizable political subculture 
        that often embodies an ironic critique of modern consumerism and mass culture. By exaggerating 
        expressions of enthusiasm for corporate products, the imagery satirizes blind consumer loyalty and 
        highlights how capitalist systems condition people to define identity through consumption. In this 
        sense, soyjaks serve as a fitting symbol for a socialist-progressist movement, as they underscore the 
        absurdity of consumer-driven values while pointing toward the need for collective awareness and systemic 
        change. Their widespread use across online spaces also makes them a uniquely grassroots cultural phenomenon, 
        capable of channeling youthful energy into critiques of commodification and the alienation it produces under capitalism.
    """;

    
    private static final List<String> POSTAL_ZONES = Arrays.asList(
        "AB", "AL", "B", "BA", "BB", "BD", "BH", "BL", "BN", "BR",
        "BS", "BT", "CA", "CB", "CF", "CH", "CM", "CO", "CR", "CT",
        "CV", "CW", "DA", "DD", "DE", "DG", "DH", "DL", "DN", "DT",
        "DY", "E", "EC", "EH", "EN", "EX", "FK", "FY", "G", "GL",
        "GY", "GU", "HA", "HD", "HG", "HP", "HR", "HS", "HU", "HX",
        "IG", "IM", "IP", "IV", "JE", "KA", "KT", "KW", "KY", "L",
        "LA", "LD", "LE", "LL", "LN", "LS", "LU", "M", "ME", "MK",
        "ML", "N", "NE", "NG", "NN", "NP", "NR", "NW", "OL", "OX",
        "PA", "PE", "PH", "PL", "PO", "PR", "RG", "RH", "RM", "S",
        "SA", "SE", "SG", "SK", "SL", "SM", "SN", "SO", "SP", "SR",
        "SS", "ST", "SW", "SY", "TA", "TD", "TF", "TN", "TQ", "TR",
        "TS", "TW", "UB", "W", "WA", "WC", "WD", "WF", "WN", "WR",
        "WS", "WV", "YO", "ZE"
    );
    
    private static final List<String> POSTAL_ZONES_ONE_CHAR = POSTAL_ZONES.stream()
        .filter(z -> z.length() == 1)
        .collect(Collectors.toList());
        
    private static final List<String> POSTAL_ZONES_TWO_CHARS = POSTAL_ZONES.stream()
        .filter(z -> z.length() == 2)
        .collect(Collectors.toList());
    
    private static final Random random = new Random();
    
    /**
     * @brief Generates a random UK postal code
     * @return A randomly generated postal code string in UK format
     * @details Creates a postal code following UK postal code patterns with proper letter distributions
     */
    public static String generatePostalCode() {
        String pattern = PATTERNS.get(random.nextInt(PATTERNS.size()));
        StringBuilder outward = new StringBuilder();
        
        for (int i = 0; i < pattern.length(); ++i) {
            char ch = pattern.charAt(i);
            if (ch == 'A') {
                if (i == 0) {
                    outward.append(FIRST_LETTERS.charAt(random.nextInt(FIRST_LETTERS.length())));
                } else if (i == 1 && pattern.length() > 2) {
                    outward.append(SECOND_LETTERS.charAt(random.nextInt(SECOND_LETTERS.length())));
                } else {
                    outward.append(LAST_LETTERS_OUTWARD.charAt(random.nextInt(LAST_LETTERS_OUTWARD.length())));
                }
            } else {
                if (pattern.startsWith("AA") && i == 2 && pattern.endsWith("A")) {
                    outward.append(random.nextInt(10));
                } else {
                    outward.append(random.nextInt(10));
                }
            }
        }
        
        String inward = String.format("%d%c%c", 
            random.nextInt(10),
            INWARD_LETTERS.charAt(random.nextInt(INWARD_LETTERS.length())),
            INWARD_LETTERS.charAt(random.nextInt(INWARD_LETTERS.length()))
        );
        
        return String.format("%s %s", outward.toString(), inward);
    }
    
    /**
     * @brief Generates random form data for submission
     * @return FormData object containing randomized form fields
     * @details Creates a complete set of form data including name, email, postal code, and description
     */
    public static FormData generateFormData() {
        String name = FIRST_NAMES.get(random.nextInt(FIRST_NAMES.size()));
        String email = String.format("%s%d@gmail.com", 
            FIRST_NAMES.get(random.nextInt(FIRST_NAMES.size())),
            random.nextInt(10000) + 1
        );
        String code = generatePostalCode();
        
        return new FormData(name, email, code, PARTY_NAME, DESCRIPTION);
    }
    
    /**
     * @brief Validates a URL for proper format and accessibility
     * @param url The URL to validate
     * @return true if the URL is valid, false otherwise
     * @details Checks if the URL has proper format and uses HTTPS protocol
     */
    public static boolean validateUrl(URL url) {
        if (url == null) {
            return false;
        }
        
        String protocol = url.getProtocol();
        String host = url.getHost();
        
        return "https".equals(protocol) && host != null && !host.isEmpty();
    }
    
    /**
     * @brief Executes the Selenium automation task
     * @param threadId Unique identifier for this execution thread
     * @return true if the task completed successfully, false otherwise
     * @details Creates a Chrome WebDriver instance and automates form submission on the target website
     */
    public static boolean runSeleniumTask(int threadId) {
        WebDriver driver = null;
        
        try {
            WebDriverManager.chromedriver().setup();
            
            if (!validateUrl(TARGET_URL)) {
                System.err.printf("Thread %d: Invalid target URL%n", threadId);
                return false;
            }
            
            FormData formData = generateFormData();
            ChromeOptions options = new ChromeOptions();
            // options.addArguments("--headless"); // Uncomment for headless mode
            options.addArguments("--disable-blink-features=AutomationControlled");
            options.addArguments("--start-maximized");
            options.addArguments(String.format("--user-data-dir=/tmp/chrome_profile_%d", threadId));
            
            driver = new ChromeDriver(options);
            driver.get(TARGET_URL.toString());
            
            WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(20));

            WebElement nameField = wait.until(ExpectedConditions.elementToBeClickable(By.id("ember7")));
            nameField.sendKeys(formData.getName());
            
            WebElement emailField = wait.until(ExpectedConditions.elementToBeClickable(By.id("ember10")));
            emailField.sendKeys(formData.getEmail());
            
            WebElement codeField = wait.until(ExpectedConditions.elementToBeClickable(By.id("ember15")));
            codeField.sendKeys(formData.getCode());
            
            WebElement partyNameField = wait.until(ExpectedConditions.elementToBeClickable(By.id("ember18")));
            partyNameField.sendKeys(formData.getPartyName());
            
            WebElement descriptionField = wait.until(ExpectedConditions.elementToBeClickable(By.id("ember21")));
            descriptionField.sendKeys(formData.getDescription());
            
            WebElement submitButton = wait.until(ExpectedConditions.elementToBeClickable(By.cssSelector("button.ssButtonContinue")));
            submitButton.click();
            
            Thread.sleep(10000);
            
            System.out.printf("Thread %d: Form submitted successfully%n", threadId);
            return true;
            
        } catch (Exception e) {
            System.err.printf("Thread %d: Error during form submission - %s%n", threadId, e.getMessage());
            return false;
        } finally {
            if (driver != null) {
                try {
                    driver.quit();
                } catch (Exception e) {
                    System.err.printf("Thread %d: Error closing driver - %s%n", threadId, e.getMessage());
                }
            }
        }
    }
    
    /**
     * @brief Runs multiple form submissions concurrently using thread pool
     * @param numSubmissions Number of concurrent form submissions to execute
     * @return List of boolean results indicating success/failure of each submission
     * @details Creates multiple threads to submit forms concurrently with random delays
     */
    public static List<Boolean> runMultipleSubmissions(int numSubmissions) {
        ExecutorService executor = Executors.newFixedThreadPool(numSubmissions);
        List<Future<Boolean>> futures = new ArrayList<>();
        
        try {
            for (int i = 0; i < numSubmissions; ++i) {
                final int threadId = i;
                
                if (i > 0) {
                    try {
                        Thread.sleep((long) (random.nextDouble() * 3000 + 2000));
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
                
                Future<Boolean> future = executor.submit(() -> runSeleniumTask(threadId));
                futures.add(future);
            }
            
            List<Boolean> results = new ArrayList<>();
            for (int i = 0; i < futures.size(); ++i) {
                try {
                    results.add(futures.get(i).get());
                } catch (Exception e) {
                    System.err.printf("Task %d failed with exception: %s%n", i, e.getMessage());
                    results.add(false);
                }
            }
            
            return results;
            
        } finally {
            executor.shutdown();
            try {
                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                    executor.shutdownNow();
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
    }
    
    /**
     * @brief Main method that orchestrates the form submission process
     * @param args Command line arguments
     * @details Runs multiple concurrent form submissions and reports the results
     */
    public static void main(String[] args) {
        System.out.println("Starting automated form submissions...");
        System.out.printf("Target URL: %s%n", TARGET_URL.toString());
        System.out.printf("URL validation: %s%n", (validateUrl(TARGET_URL) ? "PASSED" : "FAILED"));
        
        int numSubmissions = 3;
        
        List<Boolean> results = runMultipleSubmissions(numSubmissions);
        
        long successful = results.stream().mapToLong(b -> b ? 1 : 0).sum();
        int total = results.size();
        
        System.out.printf("Submission completed: %d/%d successful%n", successful, total);
        System.out.println("Form submission process finished");
    }
}

Facebook page posting[edit | edit source]

Requires jakarta.json, any version will do, you can get it off the Maven repository here. 

package party.soyjak.soy;

import java.io.IOException;
import java.io.StringWriter;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

import jakarta.json.Json;
import jakarta.json.JsonObject;
import jakarta.json.JsonWriter;

/**
 * @brief Facebook Graph API client for posting messages to a page
 * @details Handles HTTP requests to Facebook's Graph API for automated posting
 */
public class ApeFacebookPage {
    private static final String ACCESS_TOKEN = "1168954500254617";
    private static final String PAGE_ID = "765531996644181";
    private static final String DEFAULT_MESSAGE = "vote for soyjak party 卐";
    private static final URL GRAPH_API_URL;
    
    static {
        try {
            GRAPH_API_URL = new URI(String.format("https://graph.facebook.com/%s/feed", PAGE_ID)).toURL();
        } catch (URISyntaxException | MalformedURLException e) {
            throw new RuntimeException("Invalid Graph API URL configuration", e);
        }
    }
    
    /**
     * @brief Creates a JSON payload for the Facebook post
     * @param message The message to post
     * @param accessToken The Facebook access token
     * @return JsonObject containing the payload
     */
    private static JsonObject createPostPayload(String message, String accessToken) {
        return Json.createObjectBuilder()
                .add("message", message)
                .add("access_token", accessToken)
                .build();
    }
    
    /**
     * @brief Converts JsonObject to JSON string
     * @param jsonObject The JsonObject to convert
     * @return JSON string representation
     */
    private static String jsonToString(JsonObject jsonObject) {
        StringWriter writer = new StringWriter();
        try (JsonWriter jsonWriter = Json.createWriter(writer)) {
            jsonWriter.writeObject(jsonObject);
        }
        return writer.toString();
    }
    
    /**
     * @brief Posts a message to Facebook page using Graph API
     * @param message The message to post
     * @return true if successful, false otherwise
     */
    private static boolean postToFacebook(String message) {
        try {
            // Create JSON payload
            JsonObject payload = createPostPayload(message, ACCESS_TOKEN);
            String jsonBody = jsonToString(payload);
            
            HttpClient client = HttpClient.newHttpClient();
            HttpRequest request = HttpRequest.newBuilder()
                    .uri(GRAPH_API_URL)
                    .header("Content-Type", "application/json")
                    .header("User-Agent", "ApeParty/1.0")
                    .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                    .build();
            
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            
            System.out.printf("Response Code: %d%n", response.statusCode());
            System.out.printf("Response Body: %s%n", response.body());
            
            return response.statusCode() >= 200 && response.statusCode() < 300;
            
        } catch (IOException e) {
            System.err.printf("IO Error during request: %s%n", e.getMessage());
            return false;
        } catch (InterruptedException e) {
            System.err.printf("Request was interrupted: %s%n", e.getMessage());
            Thread.currentThread().interrupt();
            return false;
        } catch (Exception e) {
            System.err.printf("Unexpected error: %s%n", e.getMessage());
            return false;
        }
    }
    
    /**
     * @brief Main method to execute Facebook posting
     * @param args Command line arguments (optional message)
     */
    public static void main(String[] args) {
        System.out.println("'book 'em maker");
        System.out.printf("Target URL: %s%n", GRAPH_API_URL.toString());
        System.out.printf("Target Page ID: %s%n", PAGE_ID);
        
        String message = (args.length > 0) ? args[0] : DEFAULT_MESSAGE;
        System.out.printf("Message to post: %s%n", message);
        
        if (ACCESS_TOKEN == null || ACCESS_TOKEN.trim().isEmpty()) {
            System.err.println("ERROR: Access token is missing or empty");
            System.exit(1);
        }
        
        if (PAGE_ID == null || PAGE_ID.trim().isEmpty()) {
            System.err.println("ERROR: Page ID is missing or empty");
            System.exit(1);
        }
        
        System.out.println("Attempting to post to Facebook...");
        
        boolean success = postToFacebook(message);
        
        if (success) {
            System.out.println("✓ Successfully 'emmed up Facebook page!");
        } else {
            System.err.println("✗ Failed to 'em up Facebook page");
            System.exit(1);
        }
        
        System.out.println("Process completed");
    }
}

See also[edit | edit source]

Citations

  1. ↑ https://archive.ph/cWBd3
  2. ↑ https://megalodon.jp/2025-0830-0801-01/https://www.soyjak.st:443/soy/thread/12880513.html
Operation Name the Party is part of a series on
Trolling and Raids
Visit the Soyfare portal for more.

Do we even know, who is this Snarky Snappy person or website?

Operations [-+]
Targets [-+]
Techniques [-+]
Types of raids [-+]
Trolling groups [-+]

Anonymous ♦ CIA ♦ GNAA ♦ KKK ♦ Kiwi Farms ♦ NSS ♦ rDrama ♦ soyjak.party

Retrieved from "https://soyjakwiki.org/index.php?title=Operation_Name_the_Party&oldid=261068"