Axelo API

import com.google.firebase.auth.FirebaseAuth

val user = FirebaseAuth.getInstance().currentUser
user?.getIdToken(true)?.addOnSuccessListener { result ->
    val token = result.token
    val request = Request.Builder()
        .url(url)
        .header("Authorization", "Bearer $token")
        .build()
}

import { getAuth } from "firebase/auth";

const token = await getAuth().currentUser.getIdToken();
const res = await fetch(url, {
  headers: { "Authorization": `Bearer ${token}` }
});

fun determineAction(status: OrderStatus, minutesUntilPickup: Int?, isASAP: Boolean, role: UserRole): StornoAction {
    if (status == OrderStatus.CANCELLED || status == OrderStatus.CANCELLATION_REQUESTED) {
        return StornoAction.NotPossible
    }
    return when (role) {
        UserRole.DRIVER -> when (status) {
            OrderStatus.PENDING, OrderStatus.REQUESTED_DRIVER -> StornoAction.NotPossible
            OrderStatus.ACCEPTED -> {
                if (!isASAP && minutesUntilPickup != null && minutesUntilPickup > 60)
                    StornoAction.DirectCancel
                else StornoAction.Form(FormType.F1)
            }
            OrderStatus.DRIVING_TO_PICKUP -> StornoAction.Form(FormType.F2)
            OrderStatus.ARRIVED_AT_PICKUP -> StornoAction.Form(FormType.F3)
            OrderStatus.PICKED_UP, OrderStatus.DRIVING_TO_DELIVERY -> StornoAction.SupportOnly
            else -> StornoAction.NotPossible
        }
        UserRole.CLIENT -> when (status) {
            OrderStatus.PENDING, OrderStatus.REQUESTED_DRIVER -> StornoAction.DirectCancel
            OrderStatus.ACCEPTED -> {
                if (!isASAP && minutesUntilPickup != null && minutesUntilPickup > 60)
                    StornoAction.DirectCancel
                else StornoAction.Form(FormType.F1)
            }
            OrderStatus.DRIVING_TO_PICKUP -> StornoAction.Form(FormType.F2)
            OrderStatus.ARRIVED_AT_PICKUP -> StornoAction.Form(FormType.F3)
            OrderStatus.PICKED_UP, OrderStatus.DRIVING_TO_DELIVERY -> StornoAction.Form(FormType.F5)
            else -> StornoAction.NotPossible
        }
    }
}

function determineAction(status, minutesUntilPickup, isASAP, role) {
  if (["cancelled", "cancellationRequested"].includes(status)) return "notPossible";

  if (role === "driver") {
    switch (status) {
      case "pending": case "requestedDriver": return "notPossible";
      case "accepted":
        return (!isASAP && minutesUntilPickup > 60) ? "directCancel" : "form:F1";
      case "drivingToPickup": return "form:F2";
      case "arrivedAtPickup": return "form:F3";
      case "pickedUp": case "drivingToDelivery": return "supportOnly";
      default: return "notPossible";
    }
  } else {
    switch (status) {
      case "pending": case "requestedDriver": return "directCancel";
      case "accepted":
        return (!isASAP && minutesUntilPickup > 60) ? "directCancel" : "form:F1";
      case "drivingToPickup": return "form:F2";
      case "arrivedAtPickup": return "form:F3";
      case "pickedUp": case "drivingToDelivery": return "form:F5";
      default: return "notPossible";
    }
  }
}

val ref = FirebaseStorage.getInstance().reference
    .child("cancellation_photos/$orderId/$index.jpg")

val baos = ByteArrayOutputStream()
bitmap.compress(Bitmap.CompressFormat.JPEG, 70, baos)
val data = baos.toByteArray()

ref.putBytes(data)
    .addOnSuccessListener {
        ref.downloadUrl.addOnSuccessListener { uri ->
            photoURLs.add(uri.toString())
        }
    }

import { getStorage, ref, uploadBytes, getDownloadURL } from "firebase/storage";

const storage = getStorage();
const storageRef = ref(storage, `cancellation_photos/${orderId}/${index}.jpg`);

const blob = await fetch(imageUri).then(r => r.blob());
await uploadBytes(storageRef, blob, { contentType: "image/jpeg" });
const url = await getDownloadURL(storageRef);
photoURLs.push(url);

let requestBody: [String: Any] = [
    "request": [
        "orderId": order.id,
        "formType": formType.rawValue,
        "reason": selectedReason.label,
        "detailedDescription": description,
        "confirmedTruthfulness": true,
        "confirmedConditions": true,
        "orderNumber": order.deliveryOrderNumber ?? "",
        "requestedBy": userRole == .driver ? "driver" : "client",
        "requestedAt": ISO8601DateFormatter().string(from: Date()),
        "pickupAddress": order.pickupLocation.address,
        "deliveryAddress": order.deliveryLocation.address,
        "vehicleClass": order.vehicleClass.rawValue,
        "price": order.price,
        "photoURLs": uploadedPhotoURLs
    ]
]
var urlRequest = URLRequest(url: URL(string: "https://api.axelo.app/reports/cancellation")!)
urlRequest.httpMethod = "POST"
urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
urlRequest.timeoutInterval = 60
urlRequest.httpBody = try JSONSerialization.data(withJSONObject: requestBody)

let (data, response) = try await URLSession.shared.data(for: urlRequest)
let storageURL = (response as? HTTPURLResponse)?.value(forHTTPHeaderField: "X-Download-URL")

val requestJson = JSONObject().apply {
    put("request", JSONObject().apply {
        put("orderId", order.id)
        put("formType", "F1")
        put("reason", "Vehicle Breakdown")
        put("detailedDescription", "Engine failure on highway A1")
        put("confirmedTruthfulness", true)
        put("confirmedConditions", true)
        put("orderNumber", order.orderNumber)
        put("requestedBy", "driver")
        put("pickupAddress", order.pickupAddress)
        put("deliveryAddress", order.deliveryAddress)
        put("vehicleClass", order.vehicleClass)
        put("price", order.price)
        put("photoURLs", JSONArray(uploadedPhotoURLs))
    })
}
val body = requestJson.toString().toRequestBody("application/json".toMediaType())
val request = Request.Builder()
    .url("https://api.axelo.app/reports/cancellation")
    .post(body)
    .build()

val client = OkHttpClient.Builder()
    .callTimeout(60, TimeUnit.SECONDS)
    .build()
val response = client.newCall(request).execute()
val pdfBytes = response.body?.bytes()
val storageURL = response.header("X-Download-URL")

const res = await fetch("https://api.axelo.app/reports/cancellation", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    request: {
      orderId: "abc123",
      formType: "F1",
      reason: "Vehicle Breakdown",
      detailedDescription: "Engine failure on highway A1 near km 42",
      confirmedTruthfulness: true,
      confirmedConditions: true,
      orderNumber: "AXL-2026-001234",
      requestedBy: "driver",
      pickupAddress: "Musterstr. 1, 1010 Wien",
      deliveryAddress: "Beispielweg 5, 4020 Linz",
      vehicleClass: "pkwCaddy",
      price: 45.90,
      photoURLs: ["https://firebasestorage.googleapis.com/..."]
    }
  })
});
const pdfBlob = await res.blob();
const storageURL = res.headers.get("X-Download-URL");

var request = URLRequest(url: URL(string: "https://api.axelo.app/reports/delivery")!)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let body: [String: Any] = [
    "order": orderDict,
    "clientName": "Max Mustermann",
    "driverName": "Hans Fahrer",
    "userId": Auth.auth().currentUser?.uid ?? ""
]
request.httpBody = try JSONSerialization.data(withJSONObject: body)
let (data, response) = try await URLSession.shared.data(for: request)
// data contains the PDF bytes

val client = OkHttpClient()
val json = JSONObject().apply {
    put("order", orderJson)
    put("clientName", "Max Mustermann")
    put("driverName", "Hans Fahrer")
    put("userId", FirebaseAuth.getInstance().currentUser?.uid)
}
val body = json.toString().toRequestBody("application/json".toMediaType())
val request = Request.Builder()
    .url("https://api.axelo.app/reports/delivery")
    .post(body)
    .build()
val response = client.newCall(request).execute()
val pdfBytes = response.body?.bytes()

const res = await fetch("https://api.axelo.app/reports/delivery", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    order: { id: "abc123", deliveryOrderNumber: "AXL-2026-001",
             status: "delivered", price: 45.90,
             pickupLocation: { address: "Musterstr. 1, 1010 Wien" },
             deliveryLocation: { address: "Beispielweg 5, 4020 Linz" } },
    clientName: "Max Mustermann",
    driverName: "Hans Fahrer",
    userId: "firebase-uid"
  })
});
const pdfBlob = await res.blob();