Your portal into the Jobsquare API.

use Symfony\Contracts\HttpClient\HttpClientInterface;
use Symfony\Component\HttpFoundation\StreamedResponse;

class ApiHandler
{
    private HttpClientInterface $httpClient;
    private string $proxyBaseUrl;
    private string $apiKey;

    public function __construct(HttpClientInterface $httpClient, string $proxyBaseUrl, string $apiKey)
    {
        $this->httpClient = $httpClient;
        $this->proxyBaseUrl = rtrim($proxyBaseUrl, "/");
        $this->apiKey = $apiKey;
    }

    public function makeApiRequest(string $endpoint, string $method, array $data = null, bool $isBinary = false): array
    {
        $url = $this->proxyBaseUrl . "/" . ltrim($endpoint, "/");

        $options = [
            "headers" => [
                "Accept" => $isBinary ? "*/*" : "application/json",
                "Connection" => "keep-alive",
                "key" => $this->apiKey,
            ],
            "http_version" => "1.1",
        ];

        if ($data) {
            if ($method === "PUT" && $endpoint === "resume") {
                $options["body"] = http_build_query($data);
            } else {
                $options["json"] = $data;
            }
        }

        $response = $this->httpClient->request($method, $url, $options);
        $statusCode = $response->getStatusCode();
        $content = $response->getContent(false);
        $decoded = json_decode($content, true);

        if (json_last_error() === JSON_ERROR_NONE && is_array($decoded)) {
            return $decoded;
        }

        return [
            "success" => false,
            "message" => "Non-JSON response (HTTP $statusCode): " . substr($content, 0, 300),
            "raw" => $content,
        ];
    }

    public function downloadResumeDirectly(string $applicationResume): StreamedResponse
    {
        $url = $this->proxyBaseUrl . "/download-resume";

        $options = [
            "headers" => [
                "Accept" => "*/*",
                "Content-Type" => "application/json",
                "key" => $this->apiKey,
            ],
            "json" => ["applicationResume" => $applicationResume],
            "buffer" => false,
        ];

        $response = $this->httpClient->request("POST", $url, $options);

        return new StreamedResponse(function () use ($response) {
            foreach ($this->httpClient->stream($response) as $chunk) {
                echo $chunk->getContent();
                flush();
            }
        }, $response->getStatusCode(), $response->getHeaders(false));
    }
}

services:
  App\Service\ApiHandler:
    arguments:
      $httpClient: "@http_client"
      $proxyBaseUrl: "%env(JOBSQUARE_BASE_URL)%"
      $apiKey: "%env(JOBSQUARE_API_KEY)%"

import os
import requests

BASE_URL = os.getenv("JOBSQUARE_BASE_URL")
API_KEY = os.getenv("JOBSQUARE_API_KEY")

def make_api_request(endpoint, method="GET", data=None, is_binary=False):
    url = BASE_URL.rstrip("/") + "/" + endpoint.lstrip("/")
    headers = {
        "Accept": "*/*" if is_binary else "application/json",
        "key": API_KEY,
        "Connection": "keep-alive",
    }
    kwargs = {"headers": headers, "timeout": 20}
    if data is not None:
        kwargs["json"] = data
    if is_binary:
        kwargs["stream"] = True

    resp = requests.request(method, url, **kwargs)
    if is_binary:
        return resp.iter_content(chunk_size=8192)
    return resp.json()

def download_resume(application_resume):
    url = BASE_URL.rstrip("/") + "/download-resume"
    headers = {
        "Accept": "*/*",
        "Content-Type": "application/json",
        "key": API_KEY,
    }
    resp = requests.post(
        url,
        json={"applicationResume": application_resume},
        headers=headers,
        stream=True,
        timeout=20,
    )
    return resp.iter_content(chunk_size=8192)

class JobsquareHelper
{
    private ApiHandler $apiHandler;
    private MappingConfigurationRepository $mappingConfigRepo;

    public function __construct(ApiHandler $apiHandler, MappingConfigurationRepository $mappingConfigRepo)
    {
        $this->apiHandler = $apiHandler;
        $this->mappingConfigRepo = $mappingConfigRepo;
    }

    public function getContracts(): array
    {
        try {
            $response = $this->apiHandler->makeApiRequest("contracts", "GET");
            return $response["contracts"] ?? [];
        } catch (\Throwable $e) {
            return [];
        }
    }

    public function getValues(string $valueKey): array
    {
        try {
            $response = $this->apiHandler->makeApiRequest("values", "POST", ["value" => $valueKey]);
            return $response["function_result"] ?? [];
        } catch (\Throwable $e) {
            return [];
        }
    }

    public function mapField(?object $entity, string $type)
    {
        if (!$entity) {
            return $this->getDefaultValueForType($type);
        }

        $localId = $entity->getId();
        $mappings = $this->mappingConfigRepo->findBy(["entityType" => $type]);

        if (empty($mappings)) {
            return $this->getDefaultValueForType($type);
        }

        foreach ($mappings as $mapping) {
            $sourceCriteria = $mapping->getSourceCriteria();
            $targetCriteria = $mapping->getTargetCriteria();

            $targetArray = is_string($targetCriteria) ? json_decode($targetCriteria, true) : $targetCriteria;

            foreach ($targetArray as $target) {
                if (isset($target["id"]) && $target["id"] == $localId) {
                    $sourceArray = is_string($sourceCriteria) ? json_decode($sourceCriteria, true) : $sourceCriteria;
                    return $sourceArray["id"];
                }
            }
        }

        return $this->getDefaultValueForType($type);
    }

    private function getDefaultValueForType(string $type): string
    {
        $defaults = [
            "JobCategory" => "1046",
            "EmploymentType" => "1047",
            "id_Job_Experience" => "1045",
            "id_Job_Niveaudtude" => "1048",
            "id_Job_Rmunrationpropose" => "1049",
            "id_Job_Langue" => "1050",
            "id_Job_Genre" => "1023",
            "WorkType" => "2215",
        ];

        return $defaults[$type] ?? "";
    }
}

import json
from api_handler import make_api_request

def get_contracts():
    try:
        res = make_api_request("contracts", "GET")
        return res.get("contracts", [])
    except Exception:
        return []

def get_values(value_key: str):
    try:
        res = make_api_request("values", "POST", {"value": value_key})
        return res.get("function_result", [])
    except Exception:
        return []

def map_field(mapping_config: dict, local_id: int, type_: str) -> str:
    if not local_id:
        return get_default_value_for_type(type_)

    mappings = mapping_config.get(type_, [])
    if not mappings:
        return get_default_value_for_type(type_)

    for m in mappings:
        source_criteria = m.get("sourceCriteria")
        target_criteria = m.get("targetCriteria")

        target_array = (
            json.loads(target_criteria)
            if isinstance(target_criteria, str)
            else target_criteria
        ) or []

        for target in target_array:
            if isinstance(target, dict) and target.get("id") == local_id:
                source_array = (
                    json.loads(source_criteria)
                    if isinstance(source_criteria, str)
                    else source_criteria
                ) or {}
                return str(source_array.get("id", get_default_value_for_type(type_)))

    return get_default_value_for_type(type_)

def get_default_value_for_type(type_: str) -> str:
    defaults = {
        "JobCategory": "1046",
        "EmploymentType": "1047",
        "id_Job_Experience": "1045",
        "id_Job_Niveaudtude": "1048",
        "id_Job_Rmunrationpropose": "1049",
        "id_Job_Langue": "1050",
        "id_Job_Genre": "1023",
        "WorkType": "2215",
    }
    return defaults.get(type_, "")

class MappingService
{
    private ApiHandler $apiHandler;
    private EntityManagerInterface $entityManager;

    private const API_FIELDS = [
        "Category" => "Category",
        "EducationLevel" => "Education Level",
        "ContractType" => "Contract Type",
        "Experience" => "Experience",
        "Language" => "Language",
        "Gender" => "Gender",
        "Location" => "Location",
		"WorkType" => "WorkType"
    ];

    private const TARGET_CLASS_MAP = [
        "Category" => \App\Entity\Category::class,
        "EducationLevel" => \App\Entity\Education::class,
        "ContractType" => \App\Entity\ContractType::class,
        "Experience" => \App\Entity\Experience::class,
        "Language" => \App\Entity\Language::class,
        "Gender" => \App\Entity\Gender::class,
        "Location" => \App\Entity\Region::class,
		"WorkType" => \App\Entity\Region::class,
    ];

    public function __construct(ApiHandler $apiHandler, EntityManagerInterface $entityManager)
    {
        $this->apiHandler = $apiHandler;
        $this->entityManager = $entityManager;
    }

    public function processMappings(array $formData): array
    {
        $mappings = [];

        foreach ($formData as $field => $fieldMappings) {
            if (!isset(self::API_FIELDS[$field])) {
                continue;
            }

            ["values" => $apiValues, "ids" => $apiIdMap] = $this->fetchApiValues($field);

            foreach ($fieldMappings as $apiIndex => $localIds) {
                $apiValue = $apiValues[$apiIndex] ?? null;
                if (!$apiValue) {
                    continue;
                }

                $sourceCriteria = [
                    "id" => $apiIdMap[$apiValue] ?? null,
                    "value" => $apiValue,
                ];

                $localIdsArray = is_array($localIds) ? $localIds : [$localIds];
                $targetCriteria = $this->resolveLocalEntities($field, $localIdsArray);

                if (!empty($targetCriteria)) {
                    $mappings[] = [
                        "entityType" => $field,
                        "sourceCriteria" => $sourceCriteria,
                        "targetCriteria" => $targetCriteria,
                        "targetEntityClass" => self::TARGET_CLASS_MAP[$field] ?? "UnknownClass",
                    ];
                }
            }
        }

        return $mappings;
    }

    private function fetchApiValues(string $field): array
    {
        $response = $this->apiHandler->makeApiRequest("values", "GET", ["value" => $field]);

        if (!empty($response["success"]) && !empty($response["function_result"])) {
            $items = $response["function_result"];
            $first = $items[0];
            $valueKey = isset($first["value"]) ? "value" : "name";

            $values = array_map(fn ($item) => $item[$valueKey] ?? $item["name"], $items);
            $ids = [];
            foreach ($items as $item) {
                $key = $item[$valueKey] ?? $item["name"];
                $ids[$key] = $item["sid"] ?? null;
            }

            return ["values" => $values, "ids" => $ids];
        }

        return ["values" => [], "ids" => []];
    }

    private function resolveLocalEntities(string $field, array $localIds): array
    {
        $class = self::TARGET_CLASS_MAP[$field] ?? null;
        if (!$class) {
            return [];
        }

        $repo = $this->entityManager->getRepository($class);
        $entities = $repo->findBy(["id" => $localIds]);

        $result = [];
        foreach ($entities as $entity) {
            $result[] = [
                "id" => $entity->getId(),
                "value" => (string) $entity,
            ];
        }

        return $result;
    }
}

from typing import Dict, List, Any, Tuple

from api_handler import make_api_request

API_FIELDS: Dict[str, str] = {
    "Category": "Category",
    "EducationLevel": "Education Level",
    "ContractType": "Contract Type",
    "Experience": "Experience",
    "Language": "Language",
    "Gender": "Gender",
    "Location": "Location",
	"WorkType": "WorkType"
}

TARGET_CLASS_MAP: Dict[str, str] = {
    "Category": "app.models.Category",
    "EducationLevel": "app.models.Education",
    "ContractType": "app.models.ContractType",
    "Experience": "app.models.Experience",
    "Language": "app.models.Language",
    "Gender": "app.models.Gender",
    "Location": "app.models.Region",
	"WorkType": "app.models.WorkType"
}


async def process_mappings(form_data: Dict[str, Any]) -> List[Dict[str, Any]]:
    mappings: List[Dict[str, Any]] = []

    for field, field_mappings in form_data.items():
        if field not in API_FIELDS:
            continue

        api_values, api_ids = await fetch_api_values(field)

        for api_index, local_ids in field_mappings.items():
            api_index_int = int(api_index)
            if api_index_int >= len(api_values):
                continue

            api_value = api_values[api_index_int]
            source_criteria = {
                "id": api_ids.get(api_value),
                "value": api_value,
            }

            local_ids_list = local_ids if isinstance(local_ids, list) else [local_ids]
            target_criteria = await resolve_local_entities(field, local_ids_list)

            if target_criteria:
                mappings.append(
                    {
                        "entityType": field,
                        "sourceCriteria": source_criteria,
                        "targetCriteria": target_criteria,
                        "targetEntityClass": TARGET_CLASS_MAP.get(field, "UnknownClass"),
                    }
                )

    return mappings


async def fetch_api_values(field: str) -> Tuple[List[str], Dict[str, Any]]:
    try:
        response = await make_api_request("values", "GET", {"value": field})
        data = response.get("raw", {})
        items = data.get("function_result", [])

        if not items:
            return [], {}

        first = items[0]
        value_key = "value" if "value" in first else "name"

        values = [item.get(value_key) or item.get("name") for item in items]
        ids: Dict[str, Any] = {}
        for item in items:
            key = item.get(value_key) or item.get("name")
            ids[key] = item.get("sid")

        return values, ids
    except Exception:
        return [], {}


async def resolve_local_entities(field: str, local_ids: List[Any]) -> List[Dict[str, Any]]:
    local_options = await get_local_options(field)

    result: List[Dict[str, Any]] = []
    for id_ in local_ids:
        entity = next((opt for opt in local_options if opt.get("id") == id_), None)
        if entity:
            result.append(
                {
                    "id": entity.get("id"),
                    "value": entity.get("name"),
                }
            )

    return result


async def get_local_options(field: str) -> List[Dict[str, Any]]:
    return []


async def load_existing_mappings() -> List[Dict[str, Any]]:
    return []


async def save_mappings(mappings: List[Dict[str, Any]]) -> None:
    print(f"Saving {len(mappings)} mappings")


async def clear_mappings() -> None:
    print("Clearing all mappings")

public function newJob(Request $request, EntityManagerInterface $em)
{
    $form = $this->createForm(JobFormType::class, null, [
        "allow_extra_fields" => true,
    ]);
    $form->handleRequest($request);

    if ($form->isSubmitted() && $form->isValid()) {
        /** @var Job $job */
        $job = $form->getData();

        $addToApi = $request->request->get("switch") === "private"
            || $request->request->get("switch") === "1";

        $selectedContract = $request->request->get("contract");
        $email = $request->request->get("email");
        $web = $request->request->get("web");
        $vacant = $request->request->get("vacant");
        $etude = $request->request->get("netude");
        $money = $request->request->get("nmoney");
        $langue = (array) $request->request->get("nlangue", []);
        $genre = $request->request->get("nGenre");

        $postulerMethod = $request->request->get("postuler-name");
        $emailValue = $postulerMethod === "email-postuler" ? $email : "contact@artusmaroc.ma";
        $webValue = $postulerMethod === "web-postuler" ? $web : "";

        $enterpriseName = "Entreprise name";
        $description = $job->getDescription() ?? "";
        $requirements = $job->getResume() ?? "";

        $defaultKeywords = array_filter(array_map("trim", explode(" ", "$enterpriseName $description $requirements")));
        $idJobMotsCls = implode(",", array_slice($defaultKeywords, 0, 5));

        if ($addToApi) {
            if (!$selectedContract) {
                $this->addFlash("error", "Please select a contract type.");
                return $this->redirectToRoute("app_admin_jobs");
            }

            $mappedData = [
                "contract_id" => $selectedContract,
                "id_Job_Vacancies" => $vacant ?? 0,
                "Title" => $job->getTitle(),
                "JobCategory" => $this->mapField($job->getSecteur(), "JobCategory") ?? "",
                "EmploymentType" => $this->mapField($job->getTypecontrat(), "EmploymentType") ?? "",
                "JobDescription" => $job->getDescription(),
                "JobRequirements" => $job->getResume(),
                "id_Job_Experience" => $this->mapField($job->getExperience(), "id_Job_Experience") ?? "",
                "id_Job_Niveaudtude" => $etude ?: null,
                "id_Job_Rmunrationpropose" => $money ?: null,
                "id_Job_Langue" => $langue ? implode(",", $langue) : null,
                "WorkType" => $workMode ? implode(",", $workMode) : null,
                "Location_ville" => $job->getVille() ?? "",
                "Location_State" => $job->getGov()->getName(),
                "Location_gouvernorat" => $this->mapField($job->getGov(), "Location_State"),
                "GooglePlace" => "Maroc",
                "email" => $emailValue,
                "url" => $webValue,
                "id_Job_MotsCls" => $idJobMotsCls,
            ];

            $apiJobData = $this->apiHandler->makeApiRequest("jobs/addJob", "POST", $mappedData);

            if (!empty($apiJobData["function_result"]["id"])) {
                $job->setIsPostedApi(true);
                $job->setApiJobId($apiJobData["function_result"]["id"]);
            }
        }

        $em->persist($job);
        $em->flush();
    }
}

from typing import Dict, Any

from api_handler import make_api_request


async def create_job(request) -> Dict[str, Any]:
    body = await request.json()
    job = await load_local_job(body)

    mapped_data = {
        "contract_id": job.get("contract_id"),
        "id_Job_Vacancies": job.get("vacancies", 0),
        "Title": job.get("title"),
        "JobCategory": job.get("jobCategoryId"),
        "EmploymentType": job.get("employmentTypeId"),
        "JobDescription": job.get("description"),
        "JobRequirements": job.get("requirements"),
        "id_Job_Experience": job.get("experienceId"),
        "id_Job_Niveaudtude": job.get("educationId"),
        "id_Job_Rmunrationpropose": job.get("salaryRangeId"),
        "id_Job_Langue": ",".join(job.get("languageIds", [])),
        "WorkType": ",".join(job.get("workModeIds", [])),
        "Location_ville": job.get("cityId"),
        "Location_State": job.get("stateName"),
        "Location_gouvernorat": job.get("stateId"),
        "GooglePlace": job.get("country", "Maroc"),
        "email": job.get("email"),
        "url": job.get("url"),
        "id_Job_MotsCls": job.get("keywords"),
    }

    response = await make_api_request("jobs/addJob", "POST", mapped_data)
    data = response.get("raw", {}).get("function_result", {})
    api_job_id = data.get("id")

    if api_job_id:
        await mark_job_as_posted(job["id"], api_job_id)

    return {"success": True, "apiJobId": api_job_id}


async def load_local_job(payload: Dict[str, Any]) -> Dict[str, Any]:
    return payload


async def mark_job_as_posted(job_id: int, api_job_id: Any) -> None:
    pass

/**
 * @Route("a/admin/jobs", name="app_admin_jobs")
 */
public function jobs(Request $request, JobRepository $jobRepository)
{
    $myJobsResponse = $this->apiHandler->makeApiRequest("jobs/my-jobs", "GET");
    $jobs = $jobRepository->findAll();
    $jobStatuses = [];

    $myJobs = $myJobsResponse["function_result"] ?? [];

    foreach ($jobs as $job) {
        $status = "désactivé";

        if ($job->getIsPostedApi()) {
            foreach ($myJobs as $data) {
                if ($job->getApiJobId() === ($data["id"] ?? null)) {
                    if (($data["active"] ?? null) === 1) {
                        $status = "activé";
                    } elseif (($data["active"] ?? null) === 2) {
                        $status = "posté, en attente d'acceptation";
                    } elseif (($data["active"] ?? null) === 0) {
                        $status = "posté, caché";
                    }
                }
            }
        } else {
            $status = "non posté";
        }

        $jobStatuses[$job->getId()] = $status;
    }

    return $this->render("admin/job/listing.html.twig", [
        "jobs" => $jobs,
        "jobStatuses" => $jobStatuses,
    ]);
}

from typing import Dict, Any, List

from api_handler import make_api_request


async def list_jobs_with_status(request) -> Dict[str, Any]:
    api_response = await make_api_request("jobs/my-jobs", "GET")
    api_jobs: List[Dict[str, Any]] = api_response.get("raw", {}).get("function_result", [])

    local_jobs = await load_local_jobs()
    job_statuses: Dict[int, str] = {}

    for job in local_jobs:
        status = "désactivé"

        if job.get("isPostedApi"):
            match = next((j for j in api_jobs if j.get("id") == job.get("apiJobId")), None)
            if match:
                active = match.get("active")
                if active == 1:
                    status = "activé"
                elif active == 2:
                    status = "posté, en attente d'acceptation"
                elif active == 0:
                    status = "posté, caché"
        else:
            status = "non posté"

        job_statuses[job["id"]] = status

    return {"jobs": local_jobs, "jobStatuses": job_statuses}


async def load_local_jobs() -> List[Dict[str, Any]]:
    return []

class JobApiService
{
    private const REQUIRED_FIELDS = [
        "JobCategory",
        "EmploymentType",
        "id_Job_Experience",
        "Location_State",
        "id_Job_Niveaudtude",
        "id_Job_Rmunrationpropose",
        "id_Job_Langue",
        "Location_ville",
        "id_Job_Genre",
        "WorkType",
        "id_Job_Vacancies",
    ];

    private ApiHandler $apiHandler;

    public function __construct(ApiHandler $apiHandler)
    {
        $this->apiHandler = $apiHandler;
    }

    private function validateJobPayload(array $payload): void
    {
        $missing = [];

        foreach (self::REQUIRED_FIELDS as $field) {
            $value = $payload[$field] ?? null;
            if ($value === null || (is_string($value) && trim($value) === "")) {
                $missing[] = $field;
            }
        }

        if (!empty($missing)) {
            throw new \RuntimeException("Required fields missing or empty: " . implode(", ", $missing));
        }
    }

    public function addJob(array $payload): array
    {
        $this->validateJobPayload($payload);

        return $this->apiHandler->makeApiRequest("jobs/addJob", "POST", $payload);
    }

    public function updateJob(string $listingSid, array $changes): array
    {
        $body = array_merge(["listing_sid" => $listingSid], $changes);

        return $this->apiHandler->makeApiRequest("update-listings", "PUT", $body);
    }

    public function deleteJob(string $listingSid): array
    {
        $body = ["listing_sid" => $listingSid];

        return $this->apiHandler->makeApiRequest("jobs/deleteJob", "PUT", $body);
    }
}

from typing import Dict, Any, List

from api_handler import make_api_request

REQUIRED_FIELDS: List[str] = [
    "JobCategory",
    "EmploymentType",
    "id_Job_Experience",
    "Location_State",
    "id_Job_Niveaudtude",
    "id_Job_Rmunrationpropose",
    "id_Job_Langue",
    "Location_ville",
    "id_Job_Genre",
    "WorkType",
    "id_Job_Vacancies",
]


def validate_job_payload(payload: Dict[str, Any]) -> None:
    missing: List[str] = []
    for field in REQUIRED_FIELDS:
        value = payload.get(field)
        if value is None or (isinstance(value, str) and value.strip() == ""):
            missing.append(field)
    if missing:
        raise RuntimeError("Required fields missing or empty: " + ", ".join(missing))


async def add_job(payload: Dict[str, Any]) -> Dict[str, Any]:
    validate_job_payload(payload)
    response = await make_api_request("jobs/addJob", "POST", payload)
    return response


async def update_job(listing_sid: str, changes: Dict[str, Any]) -> Dict[str, Any]:
    body: Dict[str, Any] = {"listing_sid": listing_sid}
    body.update(changes)
    response = await make_api_request("update-listings", "PUT", body)
    return response


async def delete_job(listing_sid: str) -> Dict[str, Any]:
    body = {"listing_sid": listing_sid}
    response = await make_api_request("jobs/deleteJob", "PUT", body)
    return response

class ApplicationApiService
{
    private ApiHandler $apiHandler;

    public function __construct(ApiHandler $apiHandler)
    {
        $this->apiHandler = $apiHandler;
    }

    public function getApplicationsForJob(string $listingId): array
    {
        $body = ["listing_id" => $listingId];
        return $this->apiHandler->makeApiRequest("applications", "GET", $body);
    }

    public function updateStatus(string $appId, string $status): array
    {
        $body = [
            "status" => $status,
            "app_id" => $appId,
        ];

        return $this->apiHandler->makeApiRequest("applications/updateStatus", "PUT", $body);
    }

    public function downloadResume(string $applicationResume): \Symfony\Component\HttpFoundation\StreamedResponse
    {
        return $this->apiHandler->downloadResumeDirectly($applicationResume);
    }
}

from typing import Dict, Any, List

from api_handler import make_api_request, download_resume


async def get_applications_for_job(listing_id: str) -> List[Dict[str, Any]]:
    response = await make_api_request("applications", "GET", {"listing_id": listing_id})
    return response.get("raw", {}).get("function_result", [])


async def update_application_status(app_id: str, status: str) -> Dict[str, Any]:
    body = {"status": status, "app_id": app_id}
    response = await make_api_request("applications/updateStatus", "PUT", body)
    return response


def stream_resume(application_resume: str):
    return download_resume(application_resume)