Push Notifications
for Automation

const axios = require('axios');

async function sendNotification(token, message, options = {}) {
  const url = `https://webhooknotify.com/webhook/${token}`;

  const payload = {
    message,
    title: options.title || null,
    priority: options.priority || 'normal'
  };

  try {
    const response = await axios.post(url, payload);
    return { success: true, data: response.data };
  } catch (error) {
    return { success: false, error: error.message };
  }
}

// Usage
const TOKEN = 'your-webhook-token-here';

// Simple notification
await sendNotification(TOKEN, 'Build completed!');

// With options
await sendNotification(TOKEN, 'CPU usage critical', {
  title: 'Server Alert',
  priority: 'high'
});

use reqwest;
use serde::Serialize;

#[derive(Serialize)]
struct Notification {
    message: String,
    title: Option<String>,
    priority: Option<String>,
}

async fn send_notification(
    token: &str,
    message: &str,
    title: Option<&str>,
) -> Result<(), Box<dyn std::error::Error>> {
    let url = format!("https://webhooknotify.com/webhook/{}", token);

    let notification = Notification {
        message: message.to_string(),
        title: title.map(|s| s.to_string()),
        priority: Some("normal".to_string()),
    };

    let client = reqwest::Client::new();
    client.post(&url).json(¬ification).send().await?;

    Ok(())
}

// Usage
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let token = "your-webhook-token-here";

    send_notification(token, "Build completed!", None).await?;
    send_notification(token, "CPU at 95%", Some("Server Alert")).await?;

    Ok(())
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

type Notification struct {
    Message  string `json:"message"`
    Title    string `json:"title,omitempty"`
    Priority string `json:"priority,omitempty"`
}

func sendNotification(token, message, title string) error {
    url := fmt.Sprintf("https://webhooknotify.com/webhook/%s", token)

    notification := Notification{
        Message:  message,
        Title:    title,
        Priority: "normal",
    }

    jsonData, _ := json.Marshal(notification)
    resp, err := http.Post(url, "application/json", bytes.NewBuffer(jsonData))
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    return nil
}

func main() {
    token := "your-webhook-token-here"

    sendNotification(token, "Build completed!", "")
    sendNotification(token, "CPU at 95%", "Server Alert")
}

import java.net.URI;
import java.net.http.*;
import com.google.gson.*;

public class WebhookNotifyExample {

    public static void sendNotification(
        String token,
        String message,
        String title
    ) throws Exception {
        String url = "https://webhooknotify.com/webhook/" + token;

        JsonObject payload = new JsonObject();
        payload.addProperty("message", message);
        payload.addProperty("title", title);
        payload.addProperty("priority", "normal");

        String jsonPayload = new Gson().toJson(payload);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build();

        client.send(request, HttpResponse.BodyHandlers.ofString());
    }

    public static void main(String[] args) throws Exception {
        String token = "your-webhook-token-here";

        sendNotification(token, "Build completed!", null);
        sendNotification(token, "CPU at 95%", "Server Alert");
    }
}