Symfony Profiler

<?php
namespace App\Controller\Webservice;
use App\Entity\User;
use App\Entity\Slider;
use App\Entity\Client;
use App\Entity\ExceptionAgent;
use App\Entity\EmailAlert;
use App\Entity\DocumentParent;
use App\Entity\Document;
use App\Entity\SupervisionTicket;
use App\Entity\AssetLocation;
use App\Entity\Asset;
use App\Entity\Ticket;
use App\Entity\TicketMessage;
use App\Entity\TicketPicture;
use App\Entity\TicketCategory;
use App\Entity\TicketStatus;
use App\Entity\DocumentTemplate;
use App\Entity\DocumentTemplateGroup;
use App\Entity\DocumentTemplateField;
use App\Entity\DocumentTemplateFieldValue;
use App\Entity\Employee;
use App\Entity\EmployeeTime;
use App\Entity\EmployeeTimeStatus;
use App\Entity\VehicleAssignmentFail;
use App\Entity\VehiclePicture;
use App\Entity\EmployeeAgreement;
use App\Entity\EmployeeStatusLog;
use App\Entity\Help;
use App\Entity\ShiftReportType;
use App\Entity\Location;
use App\Entity\LocationPlace;
use App\Entity\LocationPosition;
use App\Entity\LocationEmployee;
use App\Entity\LocationService;
use App\Entity\SupervisionPicture;
use App\Entity\SanctionPicture;
use App\Entity\SupervisionRoute;
use App\Entity\SupervisionRouteLocation;
use App\Entity\SupervisionRouteEmployee;
use App\Entity\EmployeeShift;
use App\Entity\ShiftEmployee;
use App\Entity\ShiftEmployeePause;
use App\Entity\ShiftEmployeePauseType;
use App\Entity\RequestField;
use App\Entity\RequestParent;
use App\Entity\RequestAnswer;
use App\Entity\RequestStatus;
use App\Entity\RequestType;
use App\Entity\RequestTypeApply;
use App\Entity\RequestFieldValue;
use App\Entity\ReactionType;
use App\Entity\Reaction;
use App\Entity\ReactionMap;
use App\Entity\ReactionPicture;
use App\Entity\Supervision;
use App\Entity\SupervisionEmployee;
use App\Entity\SupervisionFacility;
use App\Entity\Shift;
use App\Entity\ShiftEmployeeLog;
use App\Entity\ShiftReport;
use App\Entity\ShiftEvent;
use App\Entity\ShiftEventPicture;
use App\Entity\SanctionStatus;
use App\Entity\Sanction;
use App\Entity\SyncLog;
use App\Entity\SyncControl;
use App\Entity\SyncControlLog;
use App\Entity\Push;
use App\Entity\PushUser;
use App\Entity\PushKey;
use App\Entity\Project;
use App\Entity\Electronic;
use App\Entity\ElectronicType;
use App\Entity\ElectronicEmployee;
use App\Entity\ElectronicPicture;
use App\Entity\PropertyReport;
use App\Entity\PropertyReportDetail;
use App\Entity\VehiclePanic;
use App\Entity\VehicleTransfer;
use App\Entity\VehicleAssignment;
use App\Entity\VehicleAssignmentFuel;
use App\Entity\VehicleAssignmentPicture;
use App\Entity\VehicleChecklist;
use App\Entity\Refuel;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\JsonResponse;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
use Symfony\Component\HttpKernel\KernelInterface;
use Nzo\UrlEncryptorBundle\Encryptor\Encryptor;
use App\Service\HelperService;
use App\Service\MailHelper;
/**
* @Route("ws")
*/
class WebserviceController extends AbstractController
{
private $environment;
private $passwordEncoder;
private $encryptor;
public function __construct(UserPasswordEncoderInterface $passwordEncoder, KernelInterface $kernel, Encryptor $encryptor, EntityManagerInterface $entityManager)
{
date_default_timezone_set('America/Guatemala');
$this->passwordEncoder = $passwordEncoder;
$this->environment = $kernel->getEnvironment();
$this->encryptor = $encryptor;
$this->entityManager = $entityManager;
}
public function getProjectPaths()
{
$paths = array();
if($this->environment == "prod"){
$paths["public_path"] = 'https://appseguridad.org/public/';
$paths["public_link"] = 'https://appseguridad.org/signature_client/?rid=';
} else {
$paths["public_path"] = 'https://dev2.datoscontinuos.net/1618/symfony5/bts_interno/public/';
$paths["public_link"] = 'https://dev2.datoscontinuos.net/1618/symfony5/bts_interno/public/signature_client/?rid=';
}
return $paths;
}
public function checkCredentials($password, UserInterface $user)
{
return $this->passwordEncoder->isPasswordValid($user, $password);
}
/**
* @Route("/env-check", name="env-check", methods={"GET", "POST"})
*/
public function envCheck(Request $request, EntityManagerInterface $entityManager): Response
{
$paths = $this->getProjectPaths();
return new JsonResponse(array('env' => $this->environment, 'path' => $paths["public_path"]));
}
/**
* @Route("/validate-dpi", name="validate-dpi", methods={"GET", "POST"})
*/
public function validateDpi(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$dpi = $data->identification;
$type = $data->type;
if($type == 'supervisor')
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $dpi,
'employeeStatus' => 1,
'jobPosition' => [2,11,16,5]
]);
if($employeeObj)
{
$data = $this->sessionEmployee($employeeObj);
return new JsonResponse(array('status' => 'success', 'data' => $data, 'message' => 'Bienvenido '.$employeeObj->getName()));
}
} elseif($type == 'patrolman') {
$token = $data->token;
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $dpi,
'employeeStatus' => 1,
'jobPosition' => 3
]);
if($employeeObj)
{
$employeeObj->setToken($token);
$entityManager->persist($employeeObj);
$entityManager->flush();
$data = $this->sessionEmployee($employeeObj);
return new JsonResponse(array('status' => 'success', 'data' => $data, 'message' => 'Bienvenido '.$employeeObj->getName()));
}
} elseif($type == 'electronic') {
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $dpi,
'employeeStatus' => 1,
'jobPosition' => [4,5]
]);
if($employeeObj)
{
$data = $this->sessionEmployee($employeeObj);
return new JsonResponse(array('status' => 'success', 'data' => $data, 'message' => 'Bienvenido '.$employeeObj->getName()));
}
} elseif($type == 'overtime') {
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $dpi,
'employeeStatus' => 1,
'jobPosition' => [2,5,16,22,11]
]);
if($employeeObj)
{
$data = $this->sessionEmployee($employeeObj);
return new JsonResponse(array('status' => 'success', 'data' => $data, 'message' => 'Bienvenido '.$employeeObj->getName()));
}
} elseif($type == 'administrative') {
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $dpi,
'employeeStatus' => 1,
'jobPosition' => [16, 5, 2, 22, 24, 12,13]
]);
if($employeeObj)
{
$data = $this->sessionEmployee($employeeObj);
return new JsonResponse(array('status' => 'success', 'data' => $data, 'message' => 'Bienvenido '.$employeeObj->getName()));
}
} elseif($type == 'vehicle' || $type == 'refueling') {
//TODOS LOS EMPLEADOS PUEDEN USAR ESTE MODULO
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $dpi,
'employeeStatus' => 1
]);
if($employeeObj)
{
$data = $this->sessionEmployee($employeeObj);
return new JsonResponse(array('status' => 'success', 'data' => $data, 'message' => 'Bienvenido '.$employeeObj->getName()));
}
} else {
//Si se trata de agente, ya no habrá restricción de roles. Esto fue aplicado porque indicaron los usuarios
//del app, que la app no "Servia" porque no podian ingresar (Con roles que aca abajo no estaban especificados)
//Este cambio se hizo el 28 de abril del 2025
/*$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $dpi,
'employeeStatus' => 1,
'jobPosition' => [1,11,2,16,7,21,5]
]);*/
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $dpi,
'employeeStatus' => 1
]);
if($employeeObj)
{
//Esto fue comentado el 3 de marzo del 2023, porque ahora ya no se necesita que el empleado tenga turno asignado para poder iniciar sesión
/*$currentShiftObj = $entityManager->getRepository(ShiftEmployee::class)->findOneBy([
'Employee' => $employeeObj->getEmployeeId(),
'is_done' => 0
]);
if($currentShiftObj)
{*/
$data = $this->sessionEmployee($employeeObj);
return new JsonResponse(array('status' => 'success', 'data' => $data, 'message' => 'Bienvenido '.$employeeObj->getName()));
/*} else {
return new JsonResponse(array('status' => 'error', 'message' => 'El empleado no tiene turno asignado'));
}*/
}
}
}
return new JsonResponse(array('status' => 'error', 'message' => 'Identificación Invalida'));
}
public function sessionEmployee($employeeObj, $locationObj = false, $employeeShiftObj = false)
{
$path = $this->getProjectPaths();
if($employeeObj->getAvatarPath())
{
$avatar = $path['public_path'].'uploads/'.$employeeObj->getAvatarPath();
} else {
$avatar = $path['public_path'].'assets/img/empty_user.png';
}
if(!$locationObj)
{
$data = [
'employee_id' => $employeeObj->getEmployeeId(),
'citizen_id' => $employeeObj->getCitizenId(),
'name' => $employeeObj->getName(),
'alias' => $employeeObj->getAlias(),
'position' => $employeeObj->getJobPosition()->getName(),
'position_id' => $employeeObj->getJobPosition()->getJobPositionId(),
'avatar' => $avatar,
'client_name' => '',
'project_name' => '',
'location_id' => '',
'location_name' => '',
'location_polygon_list' => array(),
'location_address' => '',
'shift_employee_id' => '',
'shift_start' => ''
];
} else {
$data = [
'employee_id' => $employeeObj->getEmployeeId(),
'citizen_id' => $employeeObj->getCitizenId(),
'name' => $employeeObj->getName(),
'alias' => $employeeObj->getAlias(),
'position' => $employeeObj->getJobPosition()->getName(),
'position_id' => $employeeObj->getJobPosition()->getJobPositionId(),
'avatar' => $avatar,
'client_name' => $locationObj->getClient()->getName(),
'project_name' => ($locationObj->getProject() ? $locationObj->getProject()->getName() : ''),
'location_id' => $locationObj->getLocationId(),
'location_name' => $locationObj->getName(),
'location_polygon_list' => json_decode($locationObj->getPolygonList(), true),
'location_address' => $locationObj->getAddress(),
'shift_employee_id' => $employeeShiftObj->getShiftEmployeeId(),
'shift_start' => $employeeShiftObj->getOpenedAt(),
'shift_end' => ''
];
}
return $data;
}
/**
* @Route("/return-vehicle", name="return-vehicle", methods={"GET", "POST"})
*/
public function returnVehicle(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$array = [];
$employeeId = $data->eid;
$vaid = $data->vaid;
$currentKm = $data->currentKm;
$vehicleAssignmentObj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy([
'vehicleAssignmentId' => $vaid
]);
if($vehicleAssignmentObj)
{
if($currentKm < $vehicleAssignmentObj->getMileage())
{
return new JsonResponse(array('status' => 'error', 'message' => 'El kilometraje final no puede ser menor al inicial'));
}
$vehicleAssignmentObj->setMileageFinal($currentKm);
$vehicleAssignmentObj->setIsReturned(1);
$vehicleAssignmentObj->setReturnedAt(new \DateTime());
$entityManager->persist($vehicleAssignmentObj);
$entityManager->flush();
$calculated = $currentKm - $vehicleAssignmentObj->getMileage();
if($helperService->externalDb_setOldVehicleAssignmentsAndStatus($vehicleAssignmentObj->getExternalId(), $currentKm, $calculated))
{
return new JsonResponse(array('status' => 'success', 'message' => 'Vehículo entregado correctamente'));
}
return new JsonResponse(array('status' => 'error', 'message' => 'No se pudo entregar el vehiculo en este momento, por favor reporte este mensaje al administrador del sistema: V34421'));
}
}
return new JsonResponse(array('status' => 'error', 'message' => 'No se puede entregar el vehículo en este momento, reporte este código a su administrador: V3442'));
}
/**
* @Route("/remove-form", name="remove-form", methods={"GET", "POST"})
*/
public function removeForm(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeeId = $data->eid;
$parentId = $data->parentId;
$parentObj = $entityManager->getRepository(DocumentParent::class)->findOneBy([
'documentParentId' => $parentId,
]);
if($parentObj)
{
$parentObj->setIsActive(0);
$entityManager->persist($parentObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-my-forms", name="get-my-forms", methods={"GET", "POST"})
*/
public function getMyForms(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeeId = $data->eid;
$templateId = $data->templateId;
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
$templateObj = $entityManager->getRepository(DocumentTemplate::class)->findOneBy([
'documentTemplateId' => $templateId
]);
$parentObj = $entityManager->getRepository(DocumentParent::class)->findBy([
'DocumentTemplate' => $templateId,
'created_by_employee_id' => $employeeId,
'is_active' => 1
]);
$form = [];
foreach($parentObj as $parent)
{
$documentList = $entityManager->getRepository(Document::class)->findBy([
'DocumentParent' => $parentObj
]);
$fields = [];
$main = [];
$num = 0;
foreach($documentList as $item)
{
$fieldObj = $entityManager->getRepository(DocumentTemplateField::class)->findOneBy([
'documentTemplateFieldId' => $item->getDocumentTemplateField()->getDocumentTemplateFieldId()
]);
$fields[] = [
'document_id' => $item->getDocumentId(),
'label' => $item->getLabel(),
'value' => $item->getInputValue(),
'field_id' => $item->getDocumentTemplateField()->getDocumentTemplateFieldId(),
'field_type' => $fieldObj->getFieldType()
];
if($num < 2)
{
$main[] = [
'name' => $item->getLabel(),
'value' => $item->getInputValue()
];
}
$num++;
}
$form[] = [
'parent_id' => $parent->getDocumentParentId(),
'created_at' => $parent->getCreatedAt()->format("Y-m-d"),
'fields' => $fields,
'main' => $main
];
}
return new JsonResponse(array('status' => 'success', 'form' => $form));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-form", name="get-form", methods={"GET", "POST"})
*/
public function getForm(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$array = [];
$employeeId = $data->eid;
$form = $data->form;
//Template ID
if($form == 'vehicle-supervision')
{
$template = [];
$documentTemplateObj = $entityManager->getRepository(DocumentTemplate::class)->findOneBy([
'documentTemplateId' => 1
]);
if($documentTemplateObj)
{
$documentTemplateGroupList = $entityManager->getRepository(DocumentTemplateGroup::class)->findBy([
'DocumentTemplate' => $documentTemplateObj,
'is_active' => 1
]);
foreach($documentTemplateGroupList as $documentTemplateGroup)
{
$documentTemplateFieldList = $entityManager->getRepository(DocumentTemplateField::class)->findBy([
'DocumentTemplateGroup' => $documentTemplateGroup,
'is_active' => 1
]);
$fields = [];
foreach($documentTemplateFieldList as $documentTemplateField)
{
$documentTemplateFieldValueList = $entityManager->getRepository(DocumentTemplateFieldValue::class)->findBy([
'DocumentTemplateField' => $documentTemplateField,
'is_active' => 1
]);
$choices = [];
foreach($documentTemplateFieldValueList as $documentTemplateFieldValue)
{
$choices[] = [
'id' => $documentTemplateFieldValue->getDocumentTemplateFieldValueId(),
'name' => $documentTemplateFieldValue->getValueName()
];
}
$default = '';
if($documentTemplateField->getFieldType() == 'opcion_multiple')
{
$valueObj = $entityManager->getRepository(DocumentTemplateFieldValue::class)->findOneBy([
'DocumentTemplateField' => $documentTemplateField,
'is_active' => 1,
'is_default' => 1
]);
if($valueObj)
{
$default = $valueObj->getDocumentTemplateFieldValueId();
}
} else {
$default = $documentTemplateField->getDefaultValue();
}
$fields[] = [
'template_field_id' => $documentTemplateField->getDocumentTemplateFieldId(),
'name' => $documentTemplateField->getName(),
'field_type' => $documentTemplateField->getFieldType(),
'help_text' => $documentTemplateField->getHelpText(),
'default_value' => $default,
'date_validation' => $documentTemplateField->getDateValidationType(),
'is_required' => $documentTemplateField->getIsRequired(),
'size' => $documentTemplateField->getSize(),
'weight' => $documentTemplateField->getWeight(),
'choices' => $choices
];
}
$template[] = [
'template_id' => $documentTemplateObj->getDocumentTemplateId(),
'name' => $documentTemplateGroup->getName(),
'description' => $documentTemplateGroup->getDescription(),
'fields' => $fields
];
}
}
}
return new JsonResponse(array('status' => 'success', 'template' => $template));
}
return new JsonResponse(array('status' => 'error', 'message' => 'No se puede entregar el vehículo en este momento, reporte este código a su administrador: V3442'));
}
/**
* @Route("/get-current-vehicle", name="get-current-vehicle", methods={"GET", "POST"})
*/
public function getCurrentVehicle(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$array = [];
$employeeId = $data->eid;
$vehicleAssignmentObj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy([
'created_by_employee_id' => $employeeId,
'is_done' => 1,
'is_active' => 1,
'is_returned' => 0
]);
if($vehicleAssignmentObj)
{
$array = [
'vehicle_assignment_id' => $vehicleAssignmentObj->getVehicleAssignmentId(),
'plate_number' => $vehicleAssignmentObj->getPlateNumber(),
'process_end' => $vehicleAssignmentObj->getProcessEnd(),
'external_id' => $vehicleAssignmentObj->getExternalId()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $array));
}
}
/**
* @Route("/get-vehicle-panics", name="get-vehicle-panics", methods={"GET", "POST"})
*/
public function getVehiclePanics(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$array = [];
$employeeId = $data->eid;
$vaid = $data->vaid;
$vehicleAssignmentFailList = $entityManager->getRepository(VehiclePanic::class)->findBy([
'VehicleAssignment' => $vaid
]);
foreach($vehicleAssignmentFailList as $vehicleAssignmentObj)
{
$array[] = [
'vehicle_panic_id' => $vehicleAssignmentObj->getVehiclePanicId(),
'plate_number' => $vehicleAssignmentObj->getPlateNumber(),
'description' => $vehicleAssignmentObj->getDescription(),
'reason' => $vehicleAssignmentObj->getReason(),
'created_at' => $vehicleAssignmentObj->getCreatedAt()->format("Y-m-d H:i:s")
];
}
return new JsonResponse(array('status' => 'success', 'data' => $array));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-vehicle-fails", name="get-vehicle-fails", methods={"GET", "POST"})
*/
public function getVehicleFails(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$array = [];
$employeeId = $data->eid;
$vaid = $data->vaid;
$vehicleAssignmentFailList = $entityManager->getRepository(VehicleAssignmentFail::class)->findBy([
'created_by_employee_id' => $employeeId,
'VehicleAssignment' => $vaid,
'is_active' => 1
]);
foreach($vehicleAssignmentFailList as $vehicleAssignmentObj)
{
$array[] = [
'vehicle_assignment_fail_id' => $vehicleAssignmentObj->getVehicleAssignmentFailId(),
'plate_number' => $vehicleAssignmentObj->getPlateNumber(),
'description' => $vehicleAssignmentObj->getDescription(),
'created_at' => $vehicleAssignmentObj->getCreatedAt()->format("Y-m-d H:i:s")
];
}
return new JsonResponse(array('status' => 'success', 'data' => $array));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/vehicle-assignment-complete", name="vehicle-assignment-complete", methods={"GET", "POST"})
*/
public function vehicleAssignmentComplete(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$comments = $data->comments;
$currentKm = $data->currentKm;
$currentFuel = $data->currentFuel;
$pictures = $data->pictures;
$assignmentId = $data->assignmentId;
$currentLat = $data->currentLat;
$currentLng = $data->currentLng;
$base64OutgoingSignature = $data->outgoingSignature;
$base64IncomingSignature = $data->incomingSignature;
$vehicleAssignmentObj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy([
'vehicleAssignmentId' => $assignmentId
]);
if($vehicleAssignmentObj)
{
// ----------------------------- MILEAGE CHECK ----------------------------
// ------------------------------------------------------------------------
$arrayInfo = $this->getLatestMileage($helperService, $entityManager, $vehicleAssignmentObj->getPlateNumber());
$mileageCheck = $arrayInfo['mileageCheck'];
$checked = $arrayInfo['checked'];
// ------------------------------------------------------------------------
// ----------------------------- MILEAGE CHECK ----------------------------
if($mileageCheck > $currentKm)
{
return new JsonResponse(array('status' => 'checked', 'message' => "El kilometraje actual es menor al último registrado ($mileageCheck) en $checked, por favor verifique y vuelva a intentar"));
}
$outgoingSignature = $this->saveSignature($base64OutgoingSignature);
$incomingSignature = $this->saveSignature($base64IncomingSignature);
$vehicleAssignmentObj->setProcessEnd(date("Y-m-d H:i:s"));
$vehicleAssignmentObj->setMileage($currentKm);
$vehicleAssignmentObj->setFuel($currentFuel);
$vehicleAssignmentObj->setComments($comments);
$vehicleAssignmentObj->setOutgoingSignature($outgoingSignature);
$vehicleAssignmentObj->setIncomingSignature($incomingSignature);
$vehicleAssignmentObj->setLat($currentLat);
$vehicleAssignmentObj->setLng($currentLng);
$vehicleAssignmentObj->setIsDone(1);
$entityManager->persist($vehicleAssignmentObj);
$entityManager->flush();
//return new JsonResponse(array('status' => 'success'));
$step = 0;
$receiverName = $vehicleAssignmentObj->getCreatedByEmployeeId()->getName();
if(true)
{
$step = 1;
$newAssignment = $helperService->externalDb_getVehicleAssignmentsById($vehicleAssignmentObj->getExternalId());
if($newAssignment)
{
$step = 2;
$oldAssignment = $newAssignment['Id_ant'];
$referencedAssignment = $helperService->externalDb_getVehicleAssignmentsById($newAssignment['Id_ant']);
if($referencedAssignment)
{
$step = "3a";
$oldInitial = $referencedAssignment['KmInicial'];
} else {
$step = "3b";
$oldInitial = 0;
}
$oldFinal = $currentKm;
$calculated = $oldFinal - $oldInitial;
if($currentKm < $oldInitial)
{
return new JsonResponse(array('status' => 'error', 'message' => 'El kilometraje actual no puede ser menor al kilometraje inicial del vehículo'));
}
if($helperService->externalDb_setVehicleAssignments($vehicleAssignmentObj->getExternalId(), $currentKm))
{
if($oldAssignment)
{
$step = 4;
$updateOldAssignment = $helperService->externalDb_setOldVehicleAssignments($oldAssignment, $currentKm, $receiverName, $calculated);
if($updateOldAssignment)
{
return new JsonResponse(array('status' => 'success', 'msg'=>"old_assignment"));
}
} else {
return new JsonResponse(array('status' => 'success', 'msg'=>"no_old_assignment"));
}
}
}
}
}
}
$message = "No se puede realizar esta acción en este momento, el proceso se quedo en el paso: ".$step;
return new JsonResponse(array('status' => 'error', 'message' => $message));
}
/**
* @Route("/get-my-push", name="get-my-push", methods={"GET", "POST"})
*/
public function getMyPush(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$pushObj = $entityManager->getRepository(PushUser::class)->findBy([
'user' => $token->id,
],['createdAt' => 'DESC']);
$data = [];
if($pushObj)
{
foreach($pushObj as $item)
{
$pushMain = $entityManager->getRepository(Push::class)->findOneBy([
'pushId' => $item->getPush()->getPushId()
]);
$path = $this->getProjectPaths();
$image = "";
if($pushMain->getImagePath())
{
$image = $path['public_path'].'uploads/'.$pushMain->getImagePath();
}
$data[] = [
'content' => $pushMain->getTextContent(),
'push_type' => $pushMain->getPushType(),
'created_at'=> $pushMain->getCreatedAt()->format("Y-m-d H:i:s"),
'image' => $image
];
}
}
return new JsonResponse(array('status' => 'success', 'data' => $data));
}
return new JsonResponse(array('status' => 'error', 'data' => $data));
}
/**
* @Route("/complete-supervision", name="complete-supervision", methods={"GET", "POST"})
*/
public function completeSupervision(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$supervisorId = $data->eid;
$supervisionId = $data->supervision_id;
$locationId = $data->location_id;
$agents = 0;
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervisionId
]);
if($supervisionObj)
{
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $supervisorId
]);
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $locationId
]);
$cleanEmployees = $entityManager->getRepository(Employee::class)->findBy([
'assignedLocation' => $locationId
]);
foreach($cleanEmployees as $clean)
{
$clean->setAssignedLocation(null);
$clean->setAssignedAt(null);
$clean->setAssignedByEmployeeId(null);
$clean->setAssignedLocationPositionId(null);
$clean->setAssignedSupervisionId(null);
$entityManager->persist($clean);
$entityManager->flush();
}
$supervisionEmployee = $entityManager->getRepository(SupervisionEmployee::class)->findBy([
'Supervision' => $supervisionId
]);
foreach($supervisionEmployee as $item)
{
/// BRIAN ACA NUEVA VALIDACION ARMA
/*$serial_number = $item->getInventoryWeapon();
if( strlen($serial_number)>0 ){
$idEstadoDeFuerza = $item->getEmployee()->getAlias();
$idPuesto = $item->getSupervision()->getLocation()->getIdPuesto();
$weapon_location_is_correct = $helperService->externalDb_validateWeaponAssign($idEstadoDeFuerza,$idPuesto,$serial_number,$item,$supervisorObj);
}*/
/* TERMINA Nueva validación brian */
//PARCHE PARA GUARDAR EL LOCATION_PLACE_ID EN LA SUPERVISION --------------------------------------------
$locationEmployeeObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'Employee' => $item->getEmployee()->getEmployeeId(),
'Location' => $locationId,
'is_active' => 1
]);
if($locationEmployeeObj)
{
//Si existe el registro de location_employee, entonces continuamos
if($locationEmployeeObj->getLocationPlace() && $item->getLocationPlace())
{
//Solo actualizamos si el registro que guardo el supervisor ES diferente al que esta actualmente en location_employee
if($locationEmployeeObj->getLocationPlace()->getLocationPlaceId() != $item->getLocationPlace()->getLocationPlaceId())
{
//Si lo encuentra, entonces vamos a dar de baja el registro, para ingresar uno nuevo
//para que quede la Bitacora
$locationEmployeeObj->setIsActive(0);
$locationEmployeeObj->setUpdatedByEmployeeId($supervisorObj);
$locationEmployeeObj->setUpdatedAt(new \DateTime());
$entityManager->persist($locationEmployeeObj);
$entityManager->flush();
$newLocationPlaceObj = new LocationEmployee();
$newLocationPlaceObj->setEmployee($item->getEmployee());
$newLocationPlaceObj->setLocation($locationObj);
$newLocationPlaceObj->setLocationPlace($item->getLocationPlace());
$newLocationPlaceObj->setLocationPosition($item->getLocationPosition());
$newLocationPlaceObj->setIsActive(1);
$newLocationPlaceObj->setCreatedByEmployeeId($supervisorObj);
$newLocationPlaceObj->setCreatedAt(new \DateTime());
$entityManager->persist($newLocationPlaceObj);
$entityManager->flush();
}
} else {
//Si no hay registro de Location_Place en el location_employee, entonces igual inactivamos el existente
//Y creamos uno nuevo
$locationEmployeeObj->setIsActive(0);
$locationEmployeeObj->setUpdatedByEmployeeId($supervisorObj);
$locationEmployeeObj->setUpdatedAt(new \DateTime());
$entityManager->persist($locationEmployeeObj);
$entityManager->flush();
$newLocationPlaceObj = new LocationEmployee();
$newLocationPlaceObj->setEmployee($item->getEmployee());
$newLocationPlaceObj->setLocation($locationObj);
$newLocationPlaceObj->setLocationPlace($item->getLocationPlace());
$newLocationPlaceObj->setLocationPosition($item->getLocationPosition());
$newLocationPlaceObj->setIsActive(1);
$newLocationPlaceObj->setCreatedByEmployeeId($supervisorObj);
$newLocationPlaceObj->setCreatedAt(new \DateTime());
$entityManager->persist($newLocationPlaceObj);
$entityManager->flush();
}
}
//-----------------------------------------------------------------------------------------------
$agentObjList = $entityManager->getRepository(Employee::class)->findBy([
'employeeId' => $item->getEmployee()->getEmployeeId()
]);
foreach($agentObjList as $agentObj)
{
$agentObj->setAssignedLocation($locationObj);
$agentObj->setAssignedAt(date("Y-m-d H:i:s"));
$agentObj->setAssignedByEmployeeId($supervisorObj);
$agentObj->setAssignedLocationPositionId($item->getLocationPosition());
$agentObj->setAssignedSupervisionId($supervisionObj);
$entityManager->persist($agentObj);
$entityManager->flush();
$agents++;
}
}
$supervisionObj->setClosedAt(date("Y-m-d H:i:s"));
$supervisionObj->setIsCompleted(1);
$entityManager->persist($supervisionObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success', 'employees' => $agents));
}
return new JsonResponse(array('status' => 'error', 'data' => $data));
}
/**
* @Route("/check_supervisor_qr", name="check_supervisor_qr", methods={"GET", "POST"})
*/
public function checkSupervisorQr(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$qr = $data->qr;
$type = $data->type;
$array = explode("_", $qr);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $array[0]
]);
$employeeInfo = [];
if($employeeObj)
{
$locationEmployeeObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'Employee' => $employeeObj->getEmployeeId(),
'is_active' => 1
]);
if($locationEmployeeObj)
{
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id
]);
if($supervisorObj)
{
$supervisionId = 0;
if($type == 'create')
{
$projectObj = null;
if($locationEmployeeObj->getLocation()->getProject())
{
$projectObj = $locationEmployeeObj->getLocation()->getProject();
}
$supervision = new Supervision();
$supervision->setProject($projectObj);
$supervision->setLocation($locationEmployeeObj->getLocation());
$supervision->setIsActive(1);
$supervision->setCreatedAt(new \DateTime());
$supervision->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervision);
$entityManager->flush();
$supervisionId = $supervision->getSupervisionId();
}
if($locationEmployeeObj->getLocation()->getProject())
{
$projectName = $locationEmployeeObj->getLocation()->getProject()->getName();
$projectId = $locationEmployeeObj->getLocation()->getProject()->getProjectId();
} else {
$projectName = '-';
$projectId = '0';
}
$employees = [];
$data = [
'supervision_id' => $supervisionId,
'project_id' => $projectId,
'project_name' => $projectName,
'location_id' => $locationEmployeeObj->getLocation()->getLocationId(),
'location_name' => $locationEmployeeObj->getLocation()->getName(),
'employees' => $employees
];
return new JsonResponse(array('status' => 'success', 'data' => $data));
}
} else {
return new JsonResponse(array('status' => 'error', 'msg' => 'No se encuentra un puesto asignado a este empleado'));
}
} else {
return new JsonResponse(array('status' => 'error', 'msg' => 'No se encuentra el empleado asignado a este QR'));
}
}
return new JsonResponse(array('status' => 'error', 'msg' => 'La solicitud es invalida'));
}
/**
* @Route("/account-selector", name="account-selector", methods={"GET", "POST"})
*/
public function accountSelector(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$requestType = $data->request_type;
$employeeId = $data->employee_id;
$accounts = [];
$userObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
if($userObj)
{
/*$clients = $entityManager->getRepository(Client::class)->findBy([
'isActive' => 1
]);*/
//foreach($clients as $client)
//{
$projects = [];
$projectsObj = $entityManager->getRepository(Project::class)->findBy([
//'client' => $client->getClientId(),
'isActive' => 1
], ['name' => 'ASC']);
foreach($projectsObj as $project)
{
$locations = [];
$locationsObj = $entityManager->getRepository(Location::class)->findBy([
'project' => $project->getProjectId(),
'isActive' => 1
]);
foreach($locationsObj as $location)
{
if($requestType == 'electronic')
{
$checkService = $entityManager->getRepository(LocationService::class)->findOneBy([
'Location' => $location->getLocationId(),
'Service' => 2,
'is_active' => 1
]);
if(!$checkService)
{
continue;
}
}
if($requestType == 'reaction')
{
$checkService = $entityManager->getRepository(LocationService::class)->findOneBy([
'Location' => $location->getLocationId(),
/*'Service' => 1, Por solicitud de Douglas el 8 de junio se quito esta condición */
'is_active' => 1
]);
if(!$checkService)
{
continue;
}
}
$locations[] = [
'location_id' => $location->getLocationId(),
'name' => $location->getName(),
'address' => $location->getAddress()
];
}
$projects[] = [
'project_id' => $project->getProjectId(),
'name' => $project->getName(),
'locations' => $locations
];
}
/*$accounts[] = [
'client_id' => $client->getClientId(),
'name' => $client->getName(),
'projects' => $projects
];*/
$accounts = $projects;
//}
return new JsonResponse(array('status' => 'success', 'accounts' => $accounts));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/reaction-create", name="reaction-create", methods={"GET", "POST"})
*/
public function reactionCreate(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeeId = $data->employeeId;
$reactionId = $data->reactionId;
$timeArrival = $data->timeArrival;
$timeExit = $data->timeExit;
$contact = $data->contact;
$comments = $data->comments;
$base64SignaturePatrolman = $data->signaturePatrolman;
$base64SignatureClient = $data->signatureClient;
$lat = false;
if($data->lat)
{
$lat = $data->lat;
}
$lng = false;
if($data->lng)
{
$lng = $data->lng;
}
if($employeeId && $timeArrival && $contact)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
if($employeeObj)
{
//--------------------------------
$employeeObj->setAppStatus('ACTIVO');
$employeeObj->setAppStatusUpdatedAt(new \DateTime());
$entityManager->persist($employeeObj);
$entityManager->flush();
//Se guarda el registro en el log
$statusLog = new EmployeeStatusLog();
$statusLog->setEmployee($employeeObj);
$statusLog->setNewStatus('ACTIVO');
$statusLog->setCreatedAt(new \DateTime());
$entityManager->persist($statusLog);
$entityManager->flush();
//--------------------------------
$signaturePatrolman = $this->saveSignature($base64SignaturePatrolman);
if($base64SignatureClient)
{
$signatureClient = $this->saveSignature($base64SignatureClient);
}
$latLng = "";
if($lat && $lng)
{
$latLng = $lat.",".$lng;
}
$reactionObj = $entityManager->getRepository(Reaction::class)->findOneBy([
'reactionId' => $reactionId
]);
if($reactionObj)
{
$reactionObj->setTimeArrival($timeArrival);
$reactionObj->setTimeExit(date("H:i"));
$reactionObj->setContact($contact);
$reactionObj->setComments($comments);
$reactionObj->setLatLng($latLng);
$reactionObj->setSignaturePatrolman($signaturePatrolman);
if($base64SignatureClient)
{
$reactionObj->setSignatureClient($signatureClient);
}
$reactionObj->setUpdatedAt(new \DateTime());
$reactionObj->setCreatedByEmployeeId($employeeObj);
$reactionObj->setIsActive(1);
$reactionObj->setIsDone(1);
$entityManager->persist($reactionObj);
$entityManager->flush();
return new JsonResponse(array('status' => 'success', 'data' => $reactionObj->getReactionId()));
}
return new JsonResponse(array('status' => 'invalid'));
}
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-techs", name="get-techs", methods={"GET", "POST"})
*/
public function getTechs(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findBy([
'jobPosition' => 4,
'employeeStatus' => 1
]);
$list = [];
foreach($employeeObj as $item)
{
$list[] = [
'employee_id' => $item->getEmployeeId(),
'name' => $item->getName()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-employees", name="get-employees", methods={"GET", "POST"})
*/
public function getEmployees(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findBy([
'employeeStatus' => 1
], ['name' => 'ASC']);
$list = [];
foreach($employeeObj as $item)
{
$list[] = [
'employee_id' => $item->getEmployeeId(),
'name' => $item->getName()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/external-vehicle-assignments", name="external-vehicle-assignments", methods={"GET", "POST"})
*/
public function externalVehicleAssignments(Request $request, HelperService $helperService, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$list = [];
$employeeId = $data->eid;
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
if($employeeObj)
{
$list = $helperService->externalDb_getVehicleAssignments($employeeObj->getName());
}
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
/**
* @Route("/external-vehicle-confirm-manage", name="external-vehicle-confirm-manage", methods={"GET", "POST"})
*/
public function externalVehicleConfirmManage(Request $request, HelperService $helperService, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$list = [];
$employeeId = $data->eid;
$assignmentId = $data->assignment_id;
$vehicleAssignmentObj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy([
'vehicleAssignmentId' => $assignmentId
]);
if($vehicleAssignmentObj)
{
$checklistArray = $entityManager->getRepository(VehicleChecklist::class)->findBy([
'is_active' => 1
]);
$checklist = [];
foreach($checklistArray as $item)
{
$checklist[] = [
'vehicle_checklist_id' => $item->getVehicleChecklistId(),
'name' => $item->getName(),
'isChecked' => 0
];
}
$pictures = $this->getVehicleFiles($entityManager, $assignmentId);
$list = [
'checklist' => $checklist,
'pictures' => $pictures
];
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/external-vehicle-manage-assignment", name="external-vehicle-manage-assignment", methods={"GET", "POST"})
*/
public function externalVehicleManageAssignments(Request $request, HelperService $helperService, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$list = [];
$employeeId = $data->eid;
$externalId = $data->external_id;
$plate = $data->plate;
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
if($employeeObj)
{
$vehicleAssignmentObj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy([
'created_by_employee_id' => $employeeId,
'plate_number' => $plate,
'external_id' => $externalId
]);
if(!$vehicleAssignmentObj)
{
$vehicleAssignmentObj = new VehicleAssignment();
$vehicleAssignmentObj->setPlateNumber($plate);
$vehicleAssignmentObj->setExternalId($externalId);
$vehicleAssignmentObj->setIsActive(1);
$vehicleAssignmentObj->setIsDone(0);
$vehicleAssignmentObj->setIsReturned(0);
$vehicleAssignmentObj->setProcessStart(date("Y-m-d H:i:s"));
$vehicleAssignmentObj->setCreatedAt(new \DateTime());
$vehicleAssignmentObj->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($vehicleAssignmentObj);
$entityManager->flush();
return new JsonResponse(array('status' => 'success', 'id' => $vehicleAssignmentObj->getVehicleAssignmentId()));
} else {
return new JsonResponse(array('status' => 'exists', 'id' => $vehicleAssignmentObj->getVehicleAssignmentId()));
}
}
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
/**
* @Route("/update-employee-status", name="update-employee-status", methods={"GET", "POST"})
*/
public function updateEmployeeStatus(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeeId = $data->employee_id;
$newStatus = $data->new_status;
$description = $data->description;
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
if($employeeObj)
{
if($newStatus == true)
{
$status = 'ACTIVO';
} else {
$status = 'INACTIVO';
}
$employeeObj->setAppStatus($status);
$employeeObj->setAppStatusDescription($description);
$employeeObj->setAppStatusUpdatedAt(new \DateTime());
$entityManager->persist($employeeObj);
$entityManager->flush();
//Se guarda el registro en el log
$statusLog = new EmployeeStatusLog();
$statusLog->setEmployee($employeeObj);
$statusLog->setNewStatus($status);
if($status == 'INACTIVO')
{
$statusLog->setDescription($description);
}
$statusLog->setCreatedAt(new \DateTime());
$entityManager->persist($statusLog);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-locations", name="get-locations", methods={"GET", "POST"})
*/
public function getLocations(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$clientId = $data->client_id;
if($clientId == 0)
{
$locationList = $entityManager->getRepository(Location::class)->findBy([
'isActive' => 1
],['name' => 'ASC']);
} else {
$locationList = $entityManager->getRepository(Location::class)->findBy([
'client' => $clientId,
'isActive' => 1
],['name' => 'ASC']);
}
$list = [];
foreach($locationList as $item)
{
$placeList = $entityManager->getRepository(LocationPlace::class)->findBy([
'Location' => $item->getLocationId(),
'is_active' => 1
],['name' => 'ASC']);
$places = [];
foreach($placeList as $subitem)
{
$places[] = [
'location_place_id' => $subitem->getLocationPlaceId(),
'name' => $subitem->getName()
];
}
$list[] = [
'location_id' => $item->getLocationId(),
'name' => $item->getName(),
'places' => $places
];
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/property-report-update", name="get-property-report-update", methods={"GET", "POST"})
*/
public function propertyReportUpdate(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$detailId = $data->property_report_detail_id;
$token = $data->token;
$employeeId = $data->employee_id;
$locationId = $data->location_id;
$locationPlaceId = $data->location_place_id;
$comments = $data->comments;
$remove = $data->remove;
$propertyReportDetailObj = $entityManager->getRepository(PropertyReportDetail::class)->findOneBy([
'propertyReportDetailId' => $detailId
]);
if($propertyReportDetailObj)
{
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id
]);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
if($remove == 0)
{
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $locationId
]);
$locationPlaceObj = $entityManager->getRepository(LocationPlace::class)->findOneBy([
'locationPlaceId' => $locationPlaceId
]);
$propertyReportDetailObj->setLocation($locationObj);
$propertyReportDetailObj->setLocationPlace($locationPlaceObj);
$systemComments = "El supervisor ".$supervisorObj->getName()." asigno como REFUERZO a ".$employeeObj->getName()." en el puesto ".$locationObj->getName()." y en la ubicación ".$locationPlaceObj->getName();
} else {
$systemComments = "El supervisor ".$supervisorObj->getName()." QUITO a ".$employeeObj->getName()." como REFUERZO";
$propertyReportDetailObj->setLocation(null);
$propertyReportDetailObj->setLocationPlace(null);
}
$propertyReportDetailObj->setSupervisorComments($comments);
$propertyReportDetailObj->setUpdatedAt(new \DateTime());
$propertyReportDetailObj->setUpdatedBy(null);
$propertyReportDetailObj->setUpdatedByEmployeeId($supervisorObj);
$entityManager->persist($propertyReportDetailObj);
$entityManager->flush();
$helperService->registerPropertyReportLog($propertyReportDetailObj->getPropertyReportDetailId(), $systemComments, $supervisorObj, true);
return new JsonResponse(array('status' => 'success'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-property-reports", name="get-property-reports", methods={"GET", "POST"})
*/
public function getPropertyReports(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$propertyReportList = $entityManager->getRepository(PropertyReport::class)->findBy([
'is_close' => 0,
'is_active' => 1
]);
$list = [];
foreach($propertyReportList as $item)
{
$list[] = [
'property_report_id' => $item->getPropertyReportId(),
'name' => strtoupper($item->getName()),
'comments' => $item->getComments(),
'total_strength' => $item->getTotalStrength(),
'report_date' => $item->getReportDate(),
'client_id' => $item->getClient()->getClientId(),
'client_name' => $item->getClient()->getName(),
'created_at' => $item->getCreatedAt()->format("Y-m-d H:i:s"),
'created_by' => $item->getCreatedBy()->getFirstName()." ".$item->getCreatedBy()->getLastName()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-property-report-detail", name="get-property-report-detail", methods={"GET", "POST"})
*/
public function getPropertyReportDetail(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$propertyReportId = $data->property_report_id;
$list = $entityManager->getRepository(PropertyReportDetail::class)->findBy([
'PropertyReport' => $propertyReportId,
'PropertyReportAction' => 2,
'is_active' => 1
]);
$assigned = [];
$available = [];
foreach($list as $item)
{
//Si el empleado ya esta asignado
if($item->getEmployee())
{
$path = $this->getProjectPaths();
if($item->getEmployee()->getAvatarPath())
{
$avatar = $path['public_path'].'uploads/'.$item->getEmployee()->getAvatarPath();
} else {
$avatar = $path['public_path'].'assets/img/empty_user.png';
}
//Si ya esta como asignado
if($item->getLocation())
{
$search = $item->getEmployee()->getName();
$assigned[] = [
'property_report_detail_id' => $item->getPropertyReportDetailId(),
'property_report_action_id' => $item->getPropertyReportAction()->getPropertyReportActionId(),
'property_report_action_name' => $item->getPropertyReportAction()->getName(),
'property_report_id' => $item->getPropertyReport()->getPropertyReportId(),
'client_id' => $item->getPropertyReport()->getClient()->getClientId(),
'employee_id' => $item->getEmployee()->getEmployeeId(),
'employee_name' => $item->getEmployee()->getName(),
'position' => $item->getEmployee()->getJobPosition()->getName(),
'avatar' => $avatar,
'company_id' => ($item->getCompany() ? $item->getCompany()->getCompanyId() : null),
'company_name' => ($item->getCompany() ? $item->getCompany()->getName() : null),
'location_id' => ($item->getLocation() ? $item->getLocation()->getLocationId() : null),
'location_name' => ($item->getLocation() ? $item->getLocation()->getName() : null),
'location_place_id' => ($item->getLocationPlace() ? $item->getLocationPlace()->getLocationPlaceId() : null),
'location_place_name' => ($item->getLocationPlace() ? $item->getLocationPlace()->getName() : null),
'supervisor_comments' => $item->getSupervisorComments(),
'comments' => $item->getComments(),
'service' => $item->getService(),
'takeover' => $item->getTakeover(),
'assigned_group' => $item->getAssignedGroup(),
'visible' => 1,
'search' => $search
];
} else {
//Si NO tiene asignacion
$search = $item->getEmployee()->getName();
$available[] = [
'property_report_detail_id' => $item->getPropertyReportDetailId(),
'property_report_action_id' => $item->getPropertyReportAction()->getPropertyReportActionId(),
'property_report_action_name' => $item->getPropertyReportAction()->getName(),
'property_report_id' => $item->getPropertyReport()->getPropertyReportId(),
'client_id' => $item->getPropertyReport()->getClient()->getClientId(),
'employee_id' => $item->getEmployee()->getEmployeeId(),
'employee_name' => $item->getEmployee()->getName(),
'position' => $item->getEmployee()->getJobPosition()->getName(),
'avatar' => $avatar,
'company_id' => ($item->getCompany() ? $item->getCompany()->getCompanyId() : null),
'company_name' => ($item->getCompany() ? $item->getCompany()->getName() : null),
'location_id' => null,
'location_name' => null,
'location_place_id' => null,
'location_place_name' => null,
'supervisor_comments' => null,
'comments' => $item->getComments(),
'service' => $item->getService(),
'takeover' => $item->getTakeover(),
'assigned_group' => $item->getAssignedGroup(),
'visible' => 1,
'search' => $search
];
}
}
}
return new JsonResponse(array('status' => 'success', 'available' => $available, 'assigned' => $assigned));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/set-location-place-old", name="ws_set_location_place_old", methods={"GET", "POST"})
*/
public function setLocationPlaceOld(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeeId = $data->employeeId;
$locationId = $data->locationId;
$locationPlaceId = $data->locationPlaceId;
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
$locationEmployeeObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'Location' => $locationId,
'Employee' => $employeeId
]);
if($locationEmployeeObj)
{
//EXISTE la asignacion de location_place???
if($locationEmployeeObj->getLocationPlace())
{
//Si ya existe, solo debe actualizar en caso lo que el supervisor reporta sea DIFERENTE a lo que ya existe
if($locationEmployeeObj->getLocationPlace()->getLocationPlaceId() <> $locationPlaceId)
{
$locationEmployeeObj->setIsActive(0);
$locationEmployeeObj->setUpdatedByEmployeeId($employeeObj);
$locationEmployeeObj->setUpdatedAt(new \DateTime());
$entityManager->persist($locationEmployeeObj);
$entityManager->flush();
$locationPlaceObj = $entityManager->getRepository(LocationPlace::class)->findOneBy([
'locationPlaceId' => $locationPlaceId
]);
$newLocationEmployee = new LocationEmployee();
$newLocationEmployee->setLocation($locationEmployeeObj->getLocation());
$newLocationEmployee->setEmployee($locationEmployeeObj->getEmployee());
$newLocationEmployee->setLocationPosition($locationEmployeeObj->getLocationPosition());
$newLocationEmployee->setLocationPlace($locationPlaceObj);
$newLocationEmployee->setIsActive(1);
$newLocationEmployee->setCreatedByEmployeeId($employeeObj);
$newLocationEmployee->setCreatedAt(new \DateTime());
$entityManager->persist($newLocationEmployee);
$entityManager->flush();
}
} else {
//Si no existe la asignacion de location_place, es poqrue no le han asignado nada asi que igual tenemos que crear nuevo registro para llevar bitacora
$locationEmployeeObj->setIsActive(0);
$locationEmployeeObj->setUpdatedByEmployeeId($employeeObj);
$locationEmployeeObj->setUpdatedAt(new \DateTime());
$entityManager->persist($locationEmployeeObj);
$entityManager->flush();
$locationPlaceObj = $entityManager->getRepository(LocationPlace::class)->findOneBy([
'locationPlaceId' => $locationPlaceId
]);
$newLocationEmployee = new LocationEmployee();
$newLocationEmployee->setLocation($locationEmployeeObj->getLocation());
$newLocationEmployee->setEmployee($locationEmployeeObj->getEmployee());
$newLocationEmployee->setLocationPosition($locationEmployeeObj->getLocationPosition());
$newLocationEmployee->setLocationPlace($locationPlaceObj);
$newLocationEmployee->setIsActive(1);
$newLocationEmployee->setCreatedByEmployeeId($employeeObj);
$newLocationEmployee->setCreatedAt(new \DateTime());
$entityManager->persist($newLocationEmployee);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/set-location-position", name="ws_set_location_position", methods={"GET", "POST"})
*/
public function setLocationPosition(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$supervisor = $data->supervisor;
$supervisionId = $data->supervisionId;
$employeeId = $data->employeeId;
$locationPositionId = $data->locationPositionId;
$locationEmployeeId = $data->locationEmployeeId;
$supervisionEmployeeObj = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
'Supervision' => $supervisionId,
'Employee' => $employeeId
]);
$locationPositionObj = $entityManager->getRepository(LocationPosition::class)->findOneBy([
'locationPositionId' => $locationPositionId
]);
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $supervisor->employee_id
]);
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervisionId
]);
$agentObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
//Esto es por los cambios que se hicieron en conexión con el sistema externo
$locationEmployeeObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'locationEmployeeId' => $locationEmployeeId
]);
if($locationEmployeeObj)
{
$locationPositionObj = $entityManager->getRepository(LocationPosition::class)->findOneBy([
'locationPositionId' => $locationPositionId
]);
$locationEmployeeObj->setLocationPosition($locationPositionObj);
$entityManager->persist($locationEmployeeObj);
$entityManager->flush();
}
if($supervisionEmployeeObj)
{
$supervisionEmployeeObj->setSupervision($supervisionObj);
$supervisionEmployeeObj->setEmployee($agentObj);
$supervisionEmployeeObj->setLocationPosition($locationPositionObj);
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
} else {
$supervisionEmployeeObj = new SupervisionEmployee();
$supervisionEmployeeObj->setSupervision($supervisionObj);
$supervisionEmployeeObj->setEmployee($agentObj);
$supervisionEmployeeObj->setLocationPosition($locationPositionObj);
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedAt(new \DateTime());
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/set-location-place", name="ws_set_location_place", methods={"GET", "POST"})
*/
public function setLocationPlace(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$supervisor = $data->supervisor;
$supervisionId = $data->supervisionId;
$employeeId = $data->employeeId;
$locationPlaceId = $data->locationPlaceId;
$locationEmployeeId = $data->locationEmployeeId;
$supervisionEmployeeObj = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
'Supervision' => $supervisionId,
'Employee' => $employeeId
]);
$locationPlaceObj = $entityManager->getRepository(LocationPlace::class)->findOneBy([
'locationPlaceId' => $locationPlaceId
]);
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $supervisor->employee_id
]);
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervisionId
]);
$agentObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
//Esto es por los cambios que se hicieron en conexión con el sistema externo
$locationEmployeeObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'locationEmployeeId' => $locationEmployeeId
]);
if($locationEmployeeObj)
{
$locationPlaceObj = $entityManager->getRepository(LocationPlace::class)->findOneBy([
'locationPlaceId' => $locationPlaceId
]);
$locationEmployeeObj->setLocationPlace($locationPlaceObj);
$entityManager->persist($locationEmployeeObj);
$entityManager->flush();
}
if($supervisionEmployeeObj)
{
$supervisionEmployeeObj->setSupervision($supervisionObj);
$supervisionEmployeeObj->setEmployee($agentObj);
$supervisionEmployeeObj->setLocationPlace($locationPlaceObj);
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
} else {
$supervisionEmployeeObj = new SupervisionEmployee();
$supervisionEmployeeObj->setSupervision($supervisionObj);
$supervisionEmployeeObj->setEmployee($agentObj);
$supervisionEmployeeObj->setLocationPlace($locationPlaceObj);
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedAt(new \DateTime());
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/electronic-create", name="electronic-create", methods={"GET", "POST"})
*/
public function electronicCreate(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeeId = $data->employeeId;
$clientId = $data->clientId;
$projectId = $data->projectId;
$locationId = $data->locationId;
$electronicId = $data->electronicId;
$timeArrival = $data->timeArrival;
$timeExit = $data->timeExit;
$electronicTypeId = $data->electronicTypeId;
$description = $data->description;
$comments = $data->comments;
$clientComments = $data->clientComments;
$instalationDate = $data->instalationDate;
$survey = $data->survey;
$customClientName = $data->customClientName;
$extraEmployees = ($data->extraEmployees ? $data->extraEmployees : []);
$base64SignatureTech = $data->signatureTech;
$base64SignatureClient = $data->signatureClient;
$lat = false;
if($data->lat)
{
$lat = $data->lat;
}
$lng = false;
if($data->lng)
{
$lng = $data->lng;
}
$electronicObj = $entityManager->getRepository(Electronic::class)->findOneBy([
'electronicId' => $electronicId
]);
//if($employeeId && $timeArrival && $timeExit && $electronicTypeId && $description)
if(true)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
$signatureTech = $this->saveSignature($base64SignatureTech);
$signatureClient = $this->saveSignature($base64SignatureClient);
$electronicObj->setComments($comments);
$electronicObj->setSignatureTech($signatureTech);
$electronicObj->setSignatureClient($signatureClient);
$electronicObj->setTimeExit(date("H:i:s"));
$electronicObj->setStep(3);
$electronicObj->setLatLng($lat.','.$lng);
$electronicObj->setSurveyResult($survey);
$electronicObj->setClientComments($clientComments);
$entityManager->persist($electronicObj);
$entityManager->flush();
//Si NO es de tipo EVALUACION (1) entonces se trata de un cliente existente
/*if($electronicTypeId > 1)
{
$projectObj = $entityManager->getRepository(Project::class)->findOneBy([
'projectId' => $projectId
]);
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $locationId
]);
$clientObj = $entityManager->getRepository(Client::class)->findOneBy([
'clientId' => $locationObj->getClient()
]);
}
$electronicTypeObj = $entityManager->getRepository(ElectronicType::class)->findOneBy([
'electronicTypeId' => $electronicTypeId
]);
if($employeeObj && $electronicTypeObj)
{
$signatureTech = $this->saveSignature($base64SignatureTech);
$signatureClient = $this->saveSignature($base64SignatureClient);
$latLng = "";
if($lat && $lng)
{
$latLng = $lat.",".$lng;
}
$reactionObj = new Electronic();
if($electronicTypeId > 1)
{
$reactionObj->setClient($clientObj);
$reactionObj->setProject($projectObj);
$reactionObj->setLocation($locationObj);
$reactionObj->setIsCustom(0);
} else {
$reactionObj->setCustomClientName($customClientName);
$reactionObj->setIsCustom(1);
}
$reactionObj->setElectronicType($electronicTypeObj);
$reactionObj->setTimeArrival($timeArrival);
$reactionObj->setTimeExit($timeExit);
$reactionObj->setDescription($description);
$reactionObj->setComments($comments);
$reactionObj->setClientComments($clientComments);
$reactionObj->setInstalationDate($instalationDate);
$reactionObj->setSurveyResult($survey);
$reactionObj->setLatLng($latLng);
$reactionObj->setSignatureTech($signatureTech);
$reactionObj->setSignatureClient($signatureClient);
$reactionObj->setCreatedAt(new \DateTime());
$reactionObj->setCreatedByEmployeeId($employeeObj);
$reactionObj->setIsActive(1);
$entityManager->persist($reactionObj);
$entityManager->flush();
if($extraEmployees)
{
foreach($extraEmployees as $extraEmployee)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $extraEmployee->employee_id
]);
if($employeeObj)
{
$electronicEmployeeObj = new ElectronicEmployee();
$electronicEmployeeObj->setEmployee($employeeObj);
$electronicEmployeeObj->setElectronic($reactionObj);
$electronicEmployeeObj->setIsActive(1);
$electronicEmployeeObj->setCreatedAt(new \DateTime());
$entityManager->persist($electronicEmployeeObj);
$entityManager->flush();
}
}
}
return new JsonResponse(array('status' => 'success', 'data' => $reactionObj->getElectronicId()));
}*/
return new JsonResponse(array('status' => 'success', 'data' => $electronicObj->getElectronicId()));
}
}
return new JsonResponse(array('status' => 'error'));
}
public function saveSignature($base64)
{
$ext = "png";
if($base64)
{
$base64 = substr($base64,strrpos($base64, ",")+1);
}
$dir_path = "uploads/sign/";
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$fileName = md5(date("YmdHis")).rand(0,1000).rand(1001,2000).".".$ext;
$new = $dir_path.$fileName;
$paths = $this->getProjectPaths();
$newPath = $paths["public_path"].$new;
$decoded = base64_decode($base64);
file_put_contents($new, $decoded);
return $fileName;
}
/**
* @Route("/get-time-status", name="get-time-status", methods={"GET", "POST"})
*/
public function getTimeStatus(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$employeeTimeStatusList = $entityManager->getRepository(EmployeeTimeStatus::class)->findBy([
'is_active' => 1
]);
$result = [];
foreach($employeeTimeStatusList as $item)
{
$result[] = array(
'status_id' => $item->getEmployeeTimeStatusId(),
'description' => $item->getDescription(),
'status_name' => $item->getName()
);
}
return new JsonResponse(array('status' => 'success', 'data' => $result));
}
}
/**
* @Route("/get-ticket-options", name="get-ticket-options", methods={"GET", "POST"})
*/
public function getTicketOptions(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$employeeTimeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id,
]);
if($employeeTimeObj)
{
$ticketCategoryList = $entityManager->getRepository(TicketCategory::class)->findBy([
'is_active' => 1
]);
$categories = [];
foreach($ticketCategoryList as $item)
{
$categories[] = array(
'category_id' => $item->getTicketCategoryId(),
'description' => $item->getDescription(),
'category_name' => $item->getName()
);
}
$ticketStatusList = $entityManager->getRepository(TicketStatus::class)->findBy([
'is_active' => 1
]);
$statuses = [];
foreach($ticketStatusList as $item)
{
$statuses[] = array(
'status_id' => $item->getTicketStatusId(),
'description' => $item->getDescription(),
'status_name' => $item->getName()
);
}
}
return new JsonResponse(array('status' => 'success', 'categories' => $categories, 'statuses' => $statuses));
}
}
/**
* @Route("/save-chats", name="save-chats", methods={"GET", "POST"})
*/
public function saveChats(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$input = $data->message;
$ticket = $data->ticket;
$employeeTimeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id,
]);
if($employeeTimeObj)
{
$ticketObj = $entityManager->getRepository(Ticket::class)->findOneBy([
'ticketId' => $ticket
]);
$messageObj = new TicketMessage();
$messageObj->setEmployee($employeeTimeObj);
$messageObj->setTicket($ticketObj);
$messageObj->setDescription($input);
$messageObj->setCreatedAt(new \DateTime());
$messageObj->setIsActive(1);
$entityManager->persist($messageObj);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/get-chats", name="get-chats", methods={"GET", "POST"})
*/
public function getChats(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$ticket = $data->ticket;
$employeeTimeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id,
]);
if($employeeTimeObj)
{
$chatList = $entityManager->getRepository(TicketMessage::class)->findBy([
'Ticket' => $ticket
],['created_at' => 'ASC']);
$ticketData = [];
foreach($chatList as $ticket)
{
$ticketData[] = array(
'ticket_message_id' => $ticket->getTicketMessageId(),
'created_by_name' => ($ticket->getCreatedBy() ? $ticket->getCreatedBy()->getFirstName().' '.$ticket->getCreatedBy()->getLastName() : ''),
'comment' => $ticket->getDescription(),
'visible' => 1,
'created_at' => $ticket->getCreatedAt()->format('Y-m-d H:i:s'),
'time_ago' => $this->timeAgo($ticket->getCreatedAt()),
'created_by_employee_name' => ($ticket->getEmployee() ? $ticket->getEmployee()->getName() : '')
);
}
return new JsonResponse(array('status' => 'success', 'chats' => $ticketData));
}
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/get-my-tickets", name="get-my-tickets", methods={"GET", "POST"})
*/
public function getMyTickets(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$employeeTimeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id,
]);
if($employeeTimeObj)
{
$ticketList = $entityManager->getRepository(Ticket::class)->findBy([
'is_active' => 1,
'Employee' => $employeeTimeObj
],['created_at' => 'DESC']);
$ticketData = [];
foreach($ticketList as $ticket)
{
$messagesList = $entityManager->getRepository(TicketMessage::class)->findBy([
'is_active' => 1,
'Employee' => $employeeTimeObj,
'Ticket' => $ticket
]);
$picturesList = $entityManager->getRepository(TicketPicture::class)->findBy([
'Ticket' => $ticket
]);
$ticketData[] = array(
'ticket_id' => $ticket->getTicketId(),
'class' => $ticket->getTicketStatus()->getClass(),
'name' => $ticket->getName(),
'creator' => $ticket->getEmployee()->getName(),
'category_id' => $ticket->getTicketCategory()->getTicketCategoryId(),
'category_name' => $ticket->getTicketCategory()->getName(),
'status_id' => $ticket->getTicketStatus()->getTicketStatusId(),
'status_name' => $ticket->getTicketStatus()->getName(),
'description' => $ticket->getDescription(),
'created_at' => $ticket->getCreatedAt()->format('Y-m-d H:i:s'),
'time_ago' => $this->timeAgo($ticket->getCreatedAt()),
'total_chat' => count($messagesList),
'total_pictures' => count($picturesList)
);
}
//$ticketData = [];
return new JsonResponse(array('status' => 'success', 'tickets' => $ticketData));
}
return new JsonResponse(array('status' => 'error'));
}
}
public function timeAgo(\DateTime $datetime, $full = false): string
{
$now = new \DateTime;
$diff = $now->diff($datetime);
$diff->w = floor($diff->d / 7);
$diff->d -= $diff->w * 7;
$string = [
'y' => 'año',
'm' => 'mes',
'w' => 'semana',
'd' => 'día',
'h' => 'hora',
'i' => 'minuto',
's' => 'segundo',
];
foreach ($string as $k => &$v) {
if ($diff->$k) {
$v = $diff->$k . ' ' . $v . ($diff->$k > 1 ? 's' : '');
} else {
unset($string[$k]);
}
}
if (!$full) $string = array_slice($string, 0, 1);
return $string ? 'Hace ' . implode(', ', $string) : 'Justo ahora';
}
/**
* @Route("/create-ticket", name="create-ticket", methods={"GET", "POST"})
*/
public function createTicket(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$form = $data->form;
$employeeTimeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id,
]);
if($employeeTimeObj)
{
$categoryObj = $entityManager->getRepository(TicketCategory::class)->findOneBy([
'ticketCategoryId' => $form->category
]);
$ticket = new Ticket();
$ticket->setEmployee($employeeTimeObj);
$ticket->setTicketCategory($categoryObj);
$ticket->setTicketStatus($entityManager->getRepository(TicketStatus::class)->findOneBy(['ticketStatusId' => 1]));
$ticket->setName($form->name);
$ticket->setPhone($form->phone);
$ticket->setDescription($form->description);
$ticket->setCreatedAt(new \DateTime());
$ticket->setIsActive(1);
$entityManager->persist($ticket);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/get-record-time", name="get-record-time", methods={"GET", "POST"})
*/
public function getRecordTime(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$employeeTimeObj = $entityManager->getRepository(EmployeeTime::class)->findOneBy([
'Employee' => $token->employee_id,
'year' => date('Y'),
'month' => date('m'),
'day' => date("d"),
'is_active' => 1
], ['employeeTimeId' => 'DESC']);
$result = [
'status_id' => "null",
'status_name' => "null"
];
if($employeeTimeObj)
{
if($employeeTimeObj->getEmployeeTimeStatus())
{
$statusId = $employeeTimeObj->getEmployeeTimeStatus()->getEmployeeTimeStatusId();
$statusName = $employeeTimeObj->getEmployeeTimeStatus()->getName();
$result = [
'status_id' => $statusId,
'status_name' => $statusName
];
}
}
return new JsonResponse(array('status' => 'success', 'data' => $result));
}
}
/**
* @Route("/record-time", name="record-time", methods={"GET", "POST"})
*/
public function recordTime(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$status = $data->status;
//$shift_employee_id = $data->shift_employee_id;
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id
]);
if($employeeObj)
{
$year = date("Y");
$month = date("m");
$day = date("d");
/*$statusId = 0;
if($status == 'open')
{
//2 es igual a "Dia iniciado"
$statusId = 2;
}*/
$statusId = $status;
$employeeTimeStatusObj = $entityManager->getRepository(EmployeeTimeStatus::class)->findOneBy([
'employeeTimeStatusId' => $statusId
]);
if($employeeTimeStatusObj)
{
//Cerramos todo registro anterior con fecha de finalización
$employeeTimeObj = $entityManager->getRepository(EmployeeTime::class)->findOneBy([
'year' => $year,
'month' => $month,
'day' => $day,
'end_at' => null,
'Employee' => $token->employee_id,
'is_active' => 1
]);
if($employeeTimeObj)
{
$employeeTimeObj->setIsActive(0);
$employeeTimeObj->setEndAt(date("Y-m-d H:i:s"));
$entityManager->persist($employeeTimeObj);
$entityManager->flush();
}
//e insertamos uno nuevo a menos que no sea "Dia terminado"
if($statusId > 1)
{
$employeeTime = new EmployeeTime();
$employeeTime->setEmployee($employeeObj);
$employeeTime->setStartAt(date("Y-m-d H:i:s"));
$employeeTime->setYear(date("Y"));
$employeeTime->setMonth(date("m"));
$employeeTime->setDay(date("d"));
$employeeTime->setEmployeeTimeStatus($employeeTimeStatusObj);
$employeeTime->setIsActive(1);
$employeeTime->setCreatedAt(new \DateTime());
$entityManager->persist($employeeTime);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/validate-nit", name="validate-nit", methods={"GET", "POST"})
*/
public function validateNit(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$nit = $data->identification;
$clientObj = $entityManager->getRepository(Client::class)->findOneBy([
'tax_identifier' => $nit
]);
if($clientObj)
{
$data = [
'client_id' => $clientObj->getClientId(),
'name' => $clientObj->getName()
];
return new JsonResponse(array('status' => 'success', 'data' => $data));
}
}
return new JsonResponse(array('status' => 'error', 'message' => 'NIT Invalido'));
}
/**
* @Route("/start-electronics", name="start-electronics", methods={"GET", "POST"})
*/
public function startElectronics(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$electronicId = $data->id;
$electronicObj = $entityManager->getRepository(Electronic::class)->findOneBy([
'electronicId' => $electronicId
]);
if($electronicObj)
{
$electronicObj->setStep(2);
$electronicObj->setTimeArrival(date("H:i:s"));
$entityManager->persist($electronicObj);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/location-search", name="location-search", methods={"GET", "POST"})
*/
public function locationSearch(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$array = [];
$search = $data->search;
//$results = $entityManager->getRepository(Location::class)->searchLocation($search);
$results = $entityManager->getRepository(Location::class)->searchLocationSimple($search);
foreach($results as $location)
{
$name = $location['name'];
/*if(strlen($location["location_place"]) > 0)
{
$name .= " - ".$location['location_place'];
}*/
$array[] = [
'location_id' => $location['location_id'],
'location_place_id' => '',//=> $location['location_place_id'],
'name' => $name
];
}
return new JsonResponse(array('status' => 'success', 'data' => $array));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-reaction-location", name="get-reaction-location", methods={"GET", "POST"})
*/
public function getReactionLocation(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$rid = $data->rid;
$reactionMainObj = $entityManager->getRepository(Reaction::class)->findOneBy([
'reactionId' => $rid
]);
if($reactionMainObj)
{
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $reactionMainObj->getLocation()->getLocationId()
]);
if($locationObj->getLocationType() == 'Movil')
{
$reactionObj = $entityManager->getRepository(ReactionMap::class)->findOneBy([
'Reaction' => $rid
], ['reactionMapId' => 'DESC']);
if($reactionObj)
{
$googleLink = "https://www.google.com/maps?q=loc:".$reactionObj->getLat().",".$reactionObj->getLng();
$wazeLink = "https://www.waze.com/live-map/directions?to=ll.".$reactionObj->getLat().",".$reactionObj->getLng();
return new JsonResponse(array(
'status' => 'success',
'google' => $googleLink,
'wazeLink' => $wazeLink,
'lat' => $reactionObj->getLat(),
'lng' => $reactionObj->getLng(),
'created_at' => $reactionObj->getCreatedAt()->format("Y-m-d H:i:s")
));
}
} else {
$googleLink = "https://www.google.com/maps?q=loc:".$locationObj->getLat().",".$locationObj->getLng();
$wazeLink = "https://www.waze.com/live-map/directions?to=ll.".$locationObj->getLat().",".$locationObj->getLng();
return new JsonResponse(array(
'status' => 'success',
'google' => $googleLink,
'wazeLink' => $wazeLink,
'lat' => $locationObj->getLat(),
'lng' => $locationObj->getLng(),
'created_at' => date("Y-m-d H:i:s")
));
}
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-electronic-types", name="get-electronic-types", methods={"GET", "POST"})
*/
public function getElectronicTypes(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$values = $entityManager->getRepository(ElectronicType::class)->findBy([
'is_active' => 1
]);
$options = [];
foreach($values as $value)
{
$options[] = [
'value' => $value->getElectronicTypeId(),
'name' => $value->getName()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $options));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-my-electronics", name="get-my-electronics", methods={"GET", "POST"})
*/
public function getMyElectronics(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$myElectronics = $entityManager->getRepository(Electronic::class)->findBy([
'is_active' => 1,
'Employee' => $eid
], ['created_at' => 'DESC']);
$array = [];
foreach($myElectronics as $item)
{
if($item->getIsCustom() == 1)
{
$name = $item->getCustomClientName();
$address = "";
} else {
if($item->getLocation())
{
$name = $item->getLocation()->getName();
$address = $item->getLocation()->getAddress();
} else {
$name = "Desconocido";
$address = "";
}
}
$array[] = [
'electronic_id' => $item->getElectronicId(),
'name' => $name,
'address' => $address,
'step' => $item->getStep(),
'type' => $item->getElectronicType()->getName(),
'scheduled_at' => $item->getInstalationDate(),
'created_at' => $item->getCreatedAt()->format("Y-m-d H:i:s"),
'created_by' => $item->getCreatedBy()->getFirstName()." ".$item->getCreatedBy()->getlastName()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $array));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-reaction-types", name="get-reaction-types", methods={"GET", "POST"})
*/
public function getReactionTypes(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$token = $data->token;
$values = $entityManager->getRepository(ReactionType::class)->findBy([
'is_active' => 1
]);
$options = [];
foreach($values as $value)
{
$options[] = [
'value' => $value->getReactionTypeId(),
'name' => $value->getName()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $options));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-fields", name="get-fields", methods={"GET", "POST"})
*/
public function getFields(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$typeId = $data->type_id;
$fields = $entityManager->getRepository(RequestField::class)->findBy([
'requestType' => $typeId,
'isActive' => 1
], ['weight' => 'ASC']);
if($fields)
{
$list = [];
foreach($fields as $field)
{
$values = $entityManager->getRepository(RequestFieldValue::class)->findBy([
'requestField' => $field->getRequestFieldId(),
'isActive' => 1
]);
$options = [];
foreach($values as $value)
{
$options[] = [
'request_field_value_id' => $value->getRequestFieldValueId(),
'value' => $value->getValue(),
'name' => $value->getName()
];
}
$list[] = [
'request_type_id' => $field->getRequestType()->getRequestTypeId(),
'request_field_id' => $field->getRequestFieldId(),
'name' => $field->getName(),
'input_id' => $field->getRequestInput()->getRequestInputId(),
'is_required' => $field->getIsRequired(),
'options' => $options,
'value' => ''
];
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/create-agent-report", name="create-agent-report", methods={"GET", "POST"})
*/
public function createAgentReport(Request $request, MailHelper $mailHelper, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$seid = $data->seid;
$rtid = $data->rtid;
$comments = $data->comments;
$employeeShiftObj = $entityManager->getRepository(ShiftEmployee::class)->findOneBy([
'shiftEmployeeId' => $seid
]);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeShiftObj->getEmployee()->getEmployeeId()
]);
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $employeeShiftObj->getLocation()->getLocationId()
]);
$reportType = $entityManager->getRepository(ShiftReportType::class)->findOneBy([
'shiftReportTypeId' => $rtid
]);
if($employeeShiftObj && $employeeObj && $locationObj && $reportType)
{
$event = new ShiftEvent();
$event->setEmployee($employeeObj);
$event->setLocation($locationObj);
$event->setShiftEmployee($employeeShiftObj);
$event->setShiftReportType($reportType);
$event->setIsEmptyEvent(0);
$event->setIsActive(1);
$event->setIsPanic(0);
$event->setComments($comments);
$event->setCreatedAt(new \DateTime());
$entityManager->persist($event);
$entityManager->flush();
//--------------- ALERTA DE EMAILS ---------------//
$emailAlertObj = $entityManager->getRepository(EmailAlert::class)->findOneBy([
'emailAlertId' => 2
]);
if($emailAlertObj->getEmail())
{
$content = "El agente ".$employeeObj->getName()." ha reportado novedades en su turno.";
$content .= "Ubicación: ".$locationObj->getName()."";
$content .= "Fecha: ".date('Y-m-d H:i:s')."";
$content .= "ID de reporte: #".$event->getShiftEventId()."";
$content .= "Tipo: ".$reportType->getName()."";
$content .= "Comments: ".$comments."";
$mailHelper::sendEmail($emailAlertObj->getEmail(), "Novedades - ".$employeeObj->getName(), $content);
};
//--------------- ALERTA DE EMAILS ---------------//
return new JsonResponse(array('status' => 'success', 'eventId' => $event->getShiftEventId()));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-report-files", name="get-report-files", methods={"GET", "POST"})
*/
public function getReportFilesAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$seid = $data->seid;
$pictures = $this->getReportFiles($entityManager, $seid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-electronic-files", name="get-electronic-files", methods={"GET", "POST"})
*/
public function getElectronicFilesAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$pictures = $this->getElectronicFiles($entityManager, $eid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-ticket-files", name="get-ticket-files", methods={"GET", "POST"})
*/
public function getTicketFilesAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$tid = $data->tid;
$pictures = $this->getTicketFiles($entityManager, $tid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-sanction-files", name="get-sanction-files", methods={"GET", "POST"})
*/
public function getSanctionFilesAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$sid = $data->sid;
$pictures = $this->getSanctionFiles($entityManager, $sid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-reaction-files", name="get-reaction-files", methods={"GET", "POST"})
*/
public function getReactionFilesAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$rid = $data->rid;
$pictures = $this->getReactionFiles($entityManager, $rid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-vassignment-files", name="get-vassignment-files", methods={"GET", "POST"})
*/
public function getVassignmentFilesAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$vaid = $data->vaid;
$type = $data->type;
$pictures = $this->getVehicleAssignmentFiles($entityManager, $vaid, $type);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-electronic-list", name="get-electronic-list", methods={"GET", "POST"})
*/
public function getElectronicList(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$objs = $entityManager->getRepository(Electronic::class)->findBy([
'is_active' => 1,
'created_by_employee_id' => $eid
], ['created_at' => 'DESC'], 3);
$list = [];
foreach($objs as $item)
{
$pictures = $this->getElectronicFiles($entityManager, $item->getElectronicId());
if($item->getClient())
{
$client = $item->getClient()->getName();
$project = $item->getProject()->getName();
$location = $item->getLocation()->getName();
$address = $item->getLocation()->getAddress();
} else {
$client = $item->getCustomClientName();
$project = "";
$location = "";
$address = "";
}
$list[] = [
'electronic_id' => $item->getElectronicId(),
'client' => $client,
'project' => $project,
'location' => $location,
'address' => $address,
'type' => $item->getElectronicType()->getName(),
'created_at' => $item->getCreatedAt()->format("Y-m-d H:i:s"),
'pictures' => $pictures
];
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/remove-agent-from-supervision", name="remove-agent-from-supervision", methods={"GET", "POST"})
*/
public function removeAgentFromSupervision(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeeId = $data->employeeId;
$supervisionId = $data->supervisionId;
$supervisionEmployee = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
"Employee" => $employeeId,
"Supervision" => $supervisionId
]);
if($supervisionEmployee)
{
$entityManager->remove($supervisionEmployee);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/remove-refueling", name="remove-refueling", methods={"GET", "POST"})
*/
public function removeRefueling(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$refuelId = $data->rid;
$refuelObj = $entityManager->getRepository(Refuel::class)->findOneBy([
"refuelId" => $refuelId
]);
if($refuelObj)
{
@unlink("uploads/vehicle/".$refuelObj->getPicturePath());
$entityManager->remove($refuelObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/remove-fail", name="remove-fail", methods={"GET", "POST"})
*/
public function removeFail(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$vaid = $data->vaid;
$vehicleAssignmentFailObj = $entityManager->getRepository(VehicleAssignmentFail::class)->findOneBy([
"vehicleAssignmentFailId" => $vaid
]);
if($vehicleAssignmentFailObj)
{
//@unlink("uploads/vehicle/".$vehicleAssignmentFailObj->getPicturePath());
$vehicleAssignmentFailObj->setIsActive(0);
$entityManager->persist($vehicleAssignmentFailObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-reaction-list", name="get-reaction-list", methods={"GET", "POST"})
*/
public function getReactionList(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$paths = $this->getProjectPaths();
$eid = $data->eid;
$reaction = $entityManager->getRepository(Reaction::class)->getMyReactions($eid);
$list = [];
foreach($reaction as $item)
{
$pictures = $this->getReactionFiles($entityManager, $item['reaction_id']);
$signatureStatus = false;
if($item['signature_client'])
{
$signatureStatus = true;
}
$encrypted = $this->encryptor->encrypt($item['reaction_id']);
$link = $paths['public_link'].$encrypted;
$updatedBy = "";
$updatedByObj = $entityManager->getRepository(User::class)->findOneBy([
'id' => $item['updated_by']
]);
if($updatedByObj)
{
$updatedBy = $updatedByObj->getFirstName()." ".$updatedByObj->getLastName();
}
$list[] = [
'reaction_id' => $item['reaction_id'],
'client' => $item['client'],
'project' => $item['project'],
'location' => $item['location'],
'address' => $item['address'],
'activation' => $item['time_activation'],
'reaction' => $item['reaction'],
'created_at' => $item['created_at'],
'comments' => $item['creator_comments'],
'created_by' => $item['created_by'],
'is_done' => $item['is_done'],
'is_active' => $item['is_active'],
'is_cancel' => $item['is_cancel'],
'updated_at' => $item['updated_at'],
'updated_by' => $updatedBy,
'pictures' => $pictures,
'link' => $link,
'signature_client' => $signatureStatus
];
}
$status = "";
$statusDate = "";
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $eid
]);
$statusRaw = "";
if($employeeObj)
{
$statusRaw = $employeeObj->getAppStatus();
$status = ($employeeObj->getAppStatus() == 'ACTIVO' ? true : false);
if($status)
{
$statusDate = "Disponible desde ".$employeeObj->getAppStatusUpdatedAt()->format("Y-m-d H:i:s");
} else {
$statusDate = "Inactivo desde ".$employeeObj->getAppStatusUpdatedAt()->format("Y-m-d H:i:s");
}
}
return new JsonResponse(array('status' => 'success', 'data' => $list, 'description' => $employeeObj->getAppStatusDescription(), 'appStatus' => $status, 'appStatusDate' => $statusDate, 'appStatusRaw' => $statusRaw));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-shift-info", name="get-shift-info", methods={"GET", "POST"})
*/
public function getShiftInfo(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$path = $this->getProjectPaths();
$eid = $data->eid;
$shiftEmployee = $entityManager->getRepository(ShiftEmployee::class)->findOneBy([
'Employee' => $eid,
'isActive' => 1,
'isDone' => null
], ['createdAt' => 'DESC']);
if($shiftEmployee)
{
$client_name = "";
if($shiftEmployee->getLocation()->getClient())
{
$client_name = $shiftEmployee->getLocation()->getClient()->getName();
}
$project_name = "";
if($shiftEmployee->getLocation()->getProject())
{
$project_name = $shiftEmployee->getLocation()->getProject()->getName();
}
// Check if the employee is on pause
$shiftEmployeePauseObj = $entityManager->getRepository(ShiftEmployeePause::class)->findOneBy([
'ShiftEmployee' => $shiftEmployee,
'ended_at' => null
]);
if($shiftEmployeePauseObj)
{
$paused = true;
} else {
$paused = false;
}
$array = [
"client_name" => $client_name,
"location_address" => $shiftEmployee->getLocation()->getAddress(),
"location_id" => $shiftEmployee->getLocation()->getLocationId(),
"location_name" => $shiftEmployee->getLocation()->getName(),
"project_name" => $project_name,
"shift_employee_id" => $shiftEmployee->getShiftEmployeeId(),
"shift_start" => $shiftEmployee->getOpenedAt(),
"shift_end" => $shiftEmployee->getClosedAt()
];
return new JsonResponse(array('status' => 'success', 'data' => $array));
} else {
return new JsonResponse(array('status' => 'not_found'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-supervisor-routes", name="get-supervisor-routes", methods={"GET", "POST"})
*/
public function getSupervisorRoutesAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$path = $this->getProjectPaths();
$eid = $data->eid;
$employeeMainObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $eid
]);
//SI ES UN SUPERVISOR O COORDINADOR (5) O SUB-COORDINADOR (16), PUEDE VER SOLO LAS RUTAS ASIGNADAS
if($employeeMainObj->getJobPosition()->getJobPositionId() == 2 || $employeeMainObj->getJobPosition()->getJobPositionId() == 5 || $employeeMainObj->getJobPosition()->getJobPositionId() == 16)
{
$routesObj = $entityManager->getRepository(SupervisionRouteEmployee::class)->findBy([
'Employee' => $eid,
'is_active' => 1
]);
$routes = [];
foreach($routesObj as $item)
{
if($item->getSupervisionRoute()->getIsActive() == 0)
{
continue;
}
$routeLocationObj = $entityManager->getRepository(SupervisionRouteLocation::class)->findBy([
'SupervisionRoute' => $item->getSupervisionRoute()->getSupervisionRouteId()
]);
$locations = [];
foreach($routeLocationObj as $subitem)
{
//Si no esta activa la ubicación, entonces ignoramos
if($subitem->getLocation()->getIsActive() == 0)
{
continue;
}
//Obtener el listado de empleados que deberian estar en el TURNO en este momento
$activeShift = $entityManager->getRepository(Shift::class)->getActiveShifts($subitem->getLocation()->getLocationId());
$employees_list = [];
if($activeShift)
{
$shiftEmployees = $entityManager->getRepository(ShiftEmployee::class)->findBy([
'Shift' => $activeShift['shift_id']
]);
foreach($shiftEmployees as $employee)
{
if($employee->getEmployee()->getAvatarPath())
{
$avatar = $path['public_path'].'uploads/'.$employee->getEmployee()->getAvatarPath();
} else {
$avatar = $path['public_path'].'assets/img/empty_user.png';
}
$employees_list[] = [
"shift_id" => $activeShift['shift_id'],
"employee_id" => $employee->getEmployee()->getEmployeeId(),
"citizen_id" => $employee->getEmployee()->getCitizenId(),
"name" => $employee->getEmployee()->getName(),
"alias" => $employee->getEmployee()->getAlias(),
"avatar" => $avatar,
"position" => $employee->getEmployee()->getJobPosition()->getName(),
"location_position" => $employee->getLocationPosition()->getName()
];
}
}
if($subitem->getProject())
{
$projectName = $subitem->getProject()->getName();
$projectId = $subitem->getProject()->getProjectId();
} else {
$projectName = "";
$projectId = "";
}
$search_string = $subitem->getLocation()->getName().", ".$projectName.", ".$subitem->getLocation()->getAddress();
$locationEmployees = $this->getLocationEmployeesList($subitem->getLocation()->getLocationId(), $entityManager);
$arr = [];
$arr[] = ['val' => 'Limpieza en Puesto', 'isChecked' => false];
$arr[] = ['val' => 'Estado de Mobiliario', 'isChecked' => false];
$arr[] = ['val' => 'No cuenta con Procedimiento', 'isChecked' => false];
$arr[] = ['val' => 'No cuenta con Sanitario', 'isChecked' => false];
$arr[] = ['val' => 'No cuenta con Ventilación', 'isChecked' => false];
$facilitySync = [
'facility_status' => "",
'facility_requires_change' => json_encode($arr)
];
$locations[] = [
'location_name' => $subitem->getLocation()->getName(),
'location_address' => $subitem->getLocation()->getAddress(),
'location_id' => $subitem->getLocation()->getLocationId(),
'project_name' => $projectName,
'project_id' => $projectId,
'client_name' => ($subitem->getClient() ? $subitem->getClient()->getName() : ''),
'client_id' => ($subitem->getClient() ? $subitem->getClient()->getClientId() : ''),
'visible' => 1,
'search' => $search_string,
'supervision_route_id' => $item->getSupervisionRoute()->getSupervisionRouteId(),
"route_name" => $item->getSupervisionRoute()->getName(),
'agents' => $employees_list,
//OFFLINE SYNC
'location_employees' => $locationEmployees,
'max_agents' => $subitem->getLocation()->getContractedAgents(),
'facility_sync' => $facilitySync
];
}
$location_count = count($locations);
$routes[] = [
'supervision_route_id' => $item->getSupervisionRoute()->getSupervisionRouteId(),
"route_name" => $item->getSupervisionRoute()->getName(),
'count' => $location_count,
'locations' => $locations
];
}
return new JsonResponse(array('status' => 'success', 'routes' => $routes));
//SI ES UN ESCOLTA, PUEDE VER TODAS LAS UBICACIONES DE UNA VEZ
} else if($employeeMainObj->getJobPosition()->getJobPositionId() == 11) {
$routesList = $entityManager->getRepository(SupervisionRouteLocation::class)->getActiveSupervisionRoutes();
foreach($routesList as $route)
{
$routeObj = $entityManager->getRepository(SupervisionRoute::class)->findOneBy([
'supervisionRouteId' => $route['supervision_route_id']
]);
$locationObj = $entityManager->getRepository(SupervisionRouteLocation::class)->findBy([
'SupervisionRoute' => $routeObj
]);
$locations = [];
foreach($locationObj as $subitem)
{
$search_string = $subitem->getLocation()->getName().", ".($subitem->getLocation()->getProject() ? $subitem->getLocation()->getProject()->getName().", " : '').$subitem->getLocation()->getAddress();
$employees_list = [];
$locationEmployees = $this->getLocationEmployeesList($subitem->getLocation()->getLocationId(), $entityManager);
$arr = [];
$arr[] = ['val' => 'Limpieza en Puesto', 'isChecked' => false];
$arr[] = ['val' => 'Estado de Mobiliario', 'isChecked' => false];
$arr[] = ['val' => 'No cuenta con Procedimiento', 'isChecked' => false];
$arr[] = ['val' => 'No cuenta con Sanitario', 'isChecked' => false];
$arr[] = ['val' => 'No cuenta con Ventilación', 'isChecked' => false];
$facilitySync = [
'facility_status' => "",
'facility_requires_change' => json_encode($arr)
];
$locations[] = [
'location_name' => $subitem->getLocation()->getName(),
'location_address' => $subitem->getLocation()->getAddress(),
'location_id' => $subitem->getLocation()->getLocationId(),
'project_name' => ($subitem->getLocation()->getProject() ? $subitem->getLocation()->getProject()->getName() : ''),
'project_id' => ($subitem->getLocation()->getProject() ? $subitem->getLocation()->getProject()->getProjectId() : ''),
'client_name' => ($subitem->getLocation()->getClient() ? $subitem->getLocation()->getClient()->getName() : ''),
'client_id' => ($subitem->getLocation()->getClient() ? $subitem->getLocation()->getClient()->getClientId() : ''),
'visible' => 1,
'search' => $search_string,
'supervision_route_id' => 0,
"route_name" => $route['name'], //"Todas las Ubicaciones",
'agents' => $employees_list,
//OFFLINE SYNC
'location_employees' => $locationEmployees,
'max_agents' => $subitem->getLocation()->getContractedAgents(),
'facility_sync' => $facilitySync
];
}
$routes[] = [
'supervision_route_id' => 0,
"route_name" => $route['name'],
'count' => count($locations),
'locations' => $locations
];
}
return new JsonResponse(array('status' => 'success', 'routes' => $routes));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/remove-agent", name="remove-agent", methods={"GET", "POST"})
*/
public function removeAgentAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$supervisionId = $data->supervisionId;
$leid = $data->location_employee_id;
$token = $data->token;
$locationEmployeeObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'locationEmployeeId' => $leid,
]);
if($locationEmployeeObj)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id
]);
$locationEmployeeObj->setIsActive(0);
$locationEmployeeObj->setSyncPending(1);
$locationEmployeeObj->setUpdatedAt(new \Datetime());
$locationEmployeeObj->setUpdatedByEmployeeId($employeeObj);
$entityManager->persist($locationEmployeeObj);
$entityManager->flush();
//Unificacion de actividades
$supervisionEmployee = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
"Employee" => $locationEmployeeObj->getEmployee(),
"Supervision" => $supervisionId
]);
if($supervisionEmployee)
{
$entityManager->remove($supervisionEmployee);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/remove-agent-extra", name="remove-agent-extra", methods={"GET", "POST"})
*/
public function removeAgentExtraAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$supervisionId = $data->supervisionId;
$seid = $data->supervision_employee_id;
$token = $data->token;
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervisionId
]);
if($supervisionObj)
{
/*$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id
]);*/
$supervisionEmployee = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
"supervisionEmployeeId" => $seid,
"is_extra" => 1
]);
if($supervisionEmployee)
{
$entityManager->remove($supervisionEmployee);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/check-agent", name="check-agent", methods={"GET", "POST"})
*/
public function checkAgentAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$lid = $data->location_id;
$employee = $data->employee;
$locationEmployeeObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'Employee' => $employee->employee_id,
'is_active' => 1
]);
if($locationEmployeeObj)
{
if($locationEmployeeObj->getLocation()->getLocationId() == $lid)
{
$message = "No se puede asignar al agente porque ya se encuentra asignado en esta ubicación";
return new JsonResponse(array('status' => 'duplicated', 'message' => $message));
}
$locationId = $locationEmployeeObj->getLocation()->getLocationId();
$locationName = $locationEmployeeObj->getLocation()->getName();
$message = "El agente ya se encuentra asignado en otra ubicación ".$locationName." (".$locationId."). Desea darle de baja en la otra ubicación y asignarlo a esta?";
return new JsonResponse(array('status' => 'duplicated', 'message' => $message));
}
}
return new JsonResponse(array('status' => 'success'));
}
// Esta funcion debe estar siempre parecida a la original add-agent
/**
* @Route("/add-agent-extra", name="add-agent-extra", methods={"GET", "POST"})
*/
public function addAgentExtraAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$supervisionData = $data->supervisionData;
$lid = $data->location_id;
$token = $data->token;
$employee = $data->employee;
$type = $data->type;
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervisionData->supervision_id,
]);
if($supervisionObj)
{
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id
]);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employee->employee_id
]);
$locationPositionObj = $entityManager->getRepository(LocationPosition::class)->findOneBy([
'locationPositionId' => 1
]);
$supervisionEmployeeObj = new SupervisionEmployee();
$supervisionEmployeeObj->setSupervision($supervisionObj);
$supervisionEmployeeObj->setEmployee($employeeObj);
$supervisionEmployeeObj->setLocationPosition($locationPositionObj);
$supervisionEmployeeObj->setIsExtra(1);
$supervisionEmployeeObj->setExtraType($type);
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedAt(new \Datetime());
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/add-agent", name="add-agent", methods={"GET", "POST"})
*/
public function addAgentAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$lid = $data->location_id;
$token = $data->token;
$employee = $data->employee;
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $lid,
]);
if($locationObj)
{
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id
]);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employee->employee_id
]);
$locationPositionObj = $entityManager->getRepository(LocationPosition::class)->findOneBy([
'locationPositionId' => 1
]);
//Revison para no duplicar las asignaciones
$locationEmployeeCheckObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'Employee' => $employee->employee_id,
'is_active' => 1
]);
if($locationEmployeeCheckObj)
{
//Si hay una asignación activa, entonces se desactiva y se ordena para su actualización
if($locationEmployeeCheckObj->getLocation()->getLocationId() <> $lid)
{
$locationEmployeeCheckObj->setIsActive(0);
$locationEmployeeCheckObj->setSyncPending(1);
$locationEmployeeCheckObj->setUpdatedAt(new \Datetime());
$locationEmployeeCheckObj->setUpdatedByEmployeeId($supervisorObj);
$entityManager->persist($locationEmployeeCheckObj);
$entityManager->flush();
}
}
$locationEmployeeObj = new LocationEmployee();
$locationEmployeeObj->setLocation($locationObj);
$locationEmployeeObj->setEmployee($employeeObj);
$locationEmployeeObj->setLocationPosition($locationPositionObj);
$locationEmployeeObj->setIsActive(1);
$locationEmployeeObj->setSyncPending(1);
$locationEmployeeObj->setCreatedAt(new \Datetime());
$locationEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($locationEmployeeObj);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-extra-employees", name="get-extra-employees", methods={"GET", "POST"})
*/
public function getExtraEmployees(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$supervision = $data->supervision;
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervision->supervision_id
]);
$supervisionEmployeeList = $entityManager->getRepository(SupervisionEmployee::class)->findBy([
'Supervision' => $supervision->supervision_id,
'is_active' => 1,
'is_extra' => 1
]);
$employees = [];
foreach($supervisionEmployeeList as $item)
{
$path = $this->getProjectPaths();
if($item->getEmployee()->getAvatarPath())
{
$avatar = $path['public_path'].'uploads/'.$item->getEmployee()->getAvatarPath();
} else {
$avatar = $path['public_path'].'assets/img/empty_user.png';
}
$location_position = "";
if($item->getLocationPosition())
{
$location_position = $item->getLocationPosition()->getName();
}
$employees[] = [
'supervision_employee_id' => $item->getSupervisionEmployeeId(),
'employee_id' => $item->getEmployee()->getEmployeeId(),
'citizen_id' => $item->getEmployee()->getCitizenId(),
'name' => ucwords($item->getEmployee()->getName()),
'alias' => $item->getEmployee()->getAlias(),
'avatar' => $avatar,
'position' => $item->getEmployee()->getJobPosition()->getName(),
'type' => ucwords($item->getExtraType()),
'location_position' => $location_position,
'created_at' => $item->getCreatedAt()->format('Y-m-d H:i:s')
];
}
return new JsonResponse(array('status' => 'success', 'employees' => $employees));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-employees-sync", name="get-employees-sync", methods={"GET", "POST"})
*/
public function getEmployeesSync(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeesList = $entityManager->getRepository(Employee::class)->findBy([
'employeeStatus' => 1,
'jobPosition' => 1
]);
$employees = [];
foreach($employeesList as $item)
{
$employeesLocationObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'is_active' => 1,
'Employee' => $item->getEmployeeId()
]);
$locationName = "";
$locationId = "";
$locationEmployeeId = "";
if($employeesLocationObj)
{
$locationName = $employeesLocationObj->getLocation()->getName();
$locationId = $employeesLocationObj->getLocation()->getLocationId();
$locationEmploeyeId = $employeesLocationObj->getLocationEmployeeId();
}
/*$path = $this->getProjectPaths();
if($item->getAvatarPath())
{
$avatar = $path['public_path'].'uploads/'.$item->getAvatarPath();
} else {
$avatar = $path['public_path'].'assets/img/empty_user.png';
}*/
$employees[] = [
'employee_id' => $item->getEmployeeId(),
'citizen_id' => $item->getCitizenId(),
'name' => ucwords($item->getName()),
'alias' => $item->getAlias(),
//'avatar' => $avatar,
'position' => $item->getJobPosition()->getName(),
'created_at' => $item->getCreatedAt()->format('Y-m-d H:i:s'),
'assigned_location' => $locationName,
'assigned_location_id' => $locationId,
'assigned_location_employee_id' => $locationEmployeeId
];
}
return new JsonResponse(array('status' => 'success', 'employees' => $employees));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-location-employees", name="get-location-employees", methods={"GET", "POST"})
*/
public function getLocationEmployees(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$location_id = $data->location_id;
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $location_id
]);
$employees = $this->getLocationEmployeesList($location_id, $entityManager);
return new JsonResponse(array('status' => 'success', 'employees' => $employees, 'max_agents' => $locationObj->getContractedAgents()));
}
return new JsonResponse(array('status' => 'error'));
}
public function getLocationEmployeesList($location_id, $entityManager)
{
$locationEmployeeList = $entityManager->getRepository(LocationEmployee::class)->findBy([
'Location' => $location_id,
'is_active' => 1
]);
$employees = [];
foreach($locationEmployeeList as $item)
{
$path = $this->getProjectPaths();
if($item->getEmployee()->getAvatarPath())
{
$avatar = $path['public_path'].'uploads/'.$item->getEmployee()->getAvatarPath();
} else {
$avatar = $path['public_path'].'assets/img/empty_user.png';
}
$location_position = "";
if($item->getLocationPosition())
{
$location_position = $item->getLocationPosition()->getName();
}
$employees[] = [
'location_employee_id' => $item->getLocationEmployeeId(),
'employee_id' => $item->getEmployee()->getEmployeeId(),
'citizen_id' => $item->getEmployee()->getCitizenId(),
'name' => ucwords($item->getEmployee()->getName()),
'alias' => $item->getEmployee()->getAlias(),
'avatar' => $avatar,
'position' => $item->getEmployee()->getJobPosition()->getName(),
'location_position' => $location_position,
'created_at' => $item->getCreatedAt()->format('Y-m-d H:i:s')
];
}
return $employees;
}
/**
* @Route("/get-supervision-files", name="get-supervision-files", methods={"GET", "POST"})
*/
public function getSupervisionFilesAction(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$supervision_id = $data->supervision_id;
$comment_type = $data->comment_type;
$pictures = $this->getSupervisionFiles($entityManager, $supervision_id, $comment_type);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error'));
}
public function getSupervisionFiles($entityManager, $supervisionId, $type)
{
$path = $this->getProjectPaths();
$array = [];
$pictures = $entityManager->getRepository(SupervisionPicture::class)->findBy([
"Supervision" => $supervisionId,
"picture_type" => $type
]);
foreach($pictures as $picture)
{
$picturePath = $path['public_path']."uploads/reports/s_".$supervisionId."/".$picture->getPicturePath();
$array[] = array(
'picture_id' => $picture->getSupervisionPictureId(),
'picture_path' => $picturePath
);
}
return $array;
}
/**
* @Route("/get-vehicle-fuel", name="get-vehicle-fuel", methods={"GET", "POST"})
*/
public function getVehicleFuel(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$array = [];
$aid = $data->aid;
$list = $entityManager->getRepository(VehicleAssignmentFuel::class)->findBy([
'VehicleAssignment' => $aid
]);
$total = 0;
foreach($list as $item)
{
$total = $total + $item->getQuantity();
$array[] = [
"quantity" => $item->getQuantity(),
"id" => $item->getVehicleAssignmentFuelId(),
"created_at" => $item->getCreatedAt()->format("Y-m-d H:i:s")
];
}
return new JsonResponse(array('status' => 'success', 'data' => $array, 'total' => $total));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-agent-report-types", name="get-agent-report-types", methods={"GET", "POST"})
*/
public function getReportTypes(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$objs = $entityManager->getRepository(ShiftReportType::class)->findBy([
'is_active' => 1
]);
if($objs)
{
$list = [];
foreach($objs as $item)
{
$list[] = [
"name" => $item->getName(),
"id" => $item->getShiftReportTypeId()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-request-list", name="get-request-list", methods={"GET", "POST"})
*/
public function getRequestList(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$objs = $entityManager->getRepository(RequestParent::class)->findBy([
'is_active' => 1,
'Employee' => $eid
], ['created_at' => 'DESC']);
if($objs)
{
$list = [];
foreach($objs as $item)
{
$color = 'primary';
if($item->getRequestStatus()->getRequestStatusId() == 1)
{
$color = 'primary';
} else if($item->getRequestStatus()->getRequestStatusId() == 2)
{
$color = 'success';
} else if($item->getRequestStatus()->getRequestStatusId() == 3)
{
$color = 'danger';
}
$list[] = [
"request_parent_id" => $item->getRequestParentId(),
"request_type" => $item->getRequestType()->getName(),
"request_status" => $item->getRequestStatus()->getName(),
"comments" => $item->getComments(),
"color" => $color,
"created_at" => $item->getCreatedAt()->format("Y-m-d H:i:s")
];
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/agent-request-submit", name="ws_agent_request_submit", methods={"GET", "POST"})
*/
public function agentRequestSubmit(Request $request, MailHelper $mailHelper, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$fields = $data->fields;
$rtid = $data->request_type_id;
$requestTypeObj = $entityManager->getRepository(RequestType::class)->findOneBy([
'requestTypeId' => $rtid
]);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $eid
]);
$requestStatusObj = $entityManager->getRepository(RequestStatus::class)->findOneBy([
'requestStatusId' => 1
]);
//Si ya envio una solicitud igual y esta aún se encuentra pendiente, entonces se le debe indicar que no puede enviar otra
$checkRequest = $entityManager->getRepository(RequestParent::class)->findOneBy([
'requestType' => $rtid,
'Employee' => $eid,
'requestStatus' => 1,
'is_active' => 1
]);
if($checkRequest)
{
return new JsonResponse(array('status' => 'error', 'message' => "Ya tienes una solicitud pendiente de este tipo, no puedes enviar otra mientras la primera siga en proceso"));
}
$parent = new RequestParent();
$parent->setRequestType($requestTypeObj);
$parent->setEmployee($employeeObj);
$parent->setRequestStatus($requestStatusObj);
$parent->setRequestedFrom('bts_interno');
$parent->setIsActive(1);
$parent->setCreatedAt(new \DateTime());
$entityManager->persist($parent);
$entityManager->flush();
if($parent)
{
$content = "El agente ".$employeeObj->getName()." ha realizado una solicitud.";
$content .= "Fecha: ".date('Y-m-d H:i:s')."";
$content .= "ID de solicitud: #".$parent->getRequestParentId()."";
$content .= "Tipo: ".$requestTypeObj->getName()."";
foreach($fields as $item)
{
$requestFieldObj = $entityManager->getRepository(RequestField::class)->findOneBy([
'requestFieldId' => $item->request_field_id
]);
$answer = new RequestAnswer();
$answer->setRequestParent($parent);
$answer->setRequestType($requestTypeObj);
$answer->setEmployee($employeeObj);
$answer->setRequestField($requestFieldObj);
$value = "";
if($item->input_id == 4)
{
$requestFieldValueObj = $entityManager->getRepository(RequestFieldValue::class)->findOneBy([
'requestFieldValueId' => $item->value
]);
$answer->setRequestFieldValue($requestFieldValueObj);
$answer->setValue($requestFieldValueObj->getValue());
$value = $requestFieldValueObj->getValue();
} else {
$answer->setValue($item->value);
$value = $item->value;
}
$content .= "".$requestFieldObj->getName().": ".$value."";
$answer->setRequestedFrom("bts_interno");
$answer->setEmployee($employeeObj);
$entityManager->persist($answer);
$entityManager->flush();
}
//--------------- ALERTA DE EMAILS ---------------//
$emailAlertObj = $entityManager->getRepository(EmailAlert::class)->findOneBy([
'emailAlertId' => 3
]);
if($emailAlertObj->getEmail())
{
$mailHelper::sendEmail($emailAlertObj->getEmail(), "Solicitud de agente: - ".$employeeObj->getName(), $content);
};
//--------------- ALERTA DE EMAILS ---------------//
return new JsonResponse(array('status' => 'success', 'request_parent_id' => $parent->getRequestParentId()));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/delete-report-file", name="/ws/delete-report-file"), methods={"GET", "POST"})
*/
public function deleteReportFileAction(Request $request, EntityManagerInterface $entityManager) {
$pictures = [];
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$fid = $data->fid;
$seid = $data->seid;
$picture = $entityManager->getRepository(ShiftEventPicture::class)->findOneBy(array("shiftEventPictureId" => $fid));
@unlink("uploads/reports/".$seid."/".$picture->getPicturePath());
$entityManager->remove($picture);
$entityManager->flush();
$pictures = $this->getReportFiles($entityManager, $seid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error' ));
}
/**
* @Route("/delete-sanction-file", name="/ws/delete-sanction-file"), methods={"GET", "POST"})
*/
public function deleteSanctionFileAction(Request $request, EntityManagerInterface $entityManager) {
$pictures = [];
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$fid = $data->fid;
$sid = $data->sid;
$picture = $entityManager->getRepository(SanctionPicture::class)->findOneBy(array("sanctionPictureId" => $fid));
@unlink("uploads/sanctions/".$sid."/".$picture->getPicturePath());
$entityManager->remove($picture);
$entityManager->flush();
$pictures = $this->getSanctionFiles($entityManager, $sid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error' ));
}
/**
* @Route("/delete-reaction-file", name="/ws/delete-reaction-file"), methods={"GET", "POST"})
*/
public function deleteReactionFileAction(Request $request, EntityManagerInterface $entityManager) {
$pictures = [];
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$fid = $data->fid;
$rid = $data->rid;
$picture = $entityManager->getRepository(ReactionPicture::class)->findOneBy(array("reactionPictureId" => $fid));
@unlink("uploads/reactions/".$rid."/".$picture->getPicturePath());
$entityManager->remove($picture);
$entityManager->flush();
$pictures = $this->getReactionFiles($entityManager, $rid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error' ));
}
/**
* @Route("/delete-vassignment-file", name="/ws/delete-vassignment-file"), methods={"GET", "POST"})
*/
public function deleteVassignmentFileAction(Request $request, EntityManagerInterface $entityManager) {
$pictures = [];
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$fid = $data->fid;
$vaid = $data->vaid;
$type = $data->type;
$picture = $entityManager->getRepository(VehiclePicture::class)->findOneBy(array("vehiclePictureId" => $fid));
if($picture)
{
@unlink("uploads/vehicle/".$picture->getPicturePath());
$entityManager->remove($picture);
$entityManager->flush();
$pictures = $this->getVehicleAssignmentFiles($entityManager, $vaid, $type);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
}
return new JsonResponse(array('status' => 'error' ));
}
/**
* @Route("/delete-electronic-file", name="/ws/delete-electronic-file"), methods={"GET", "POST"})
*/
public function deleteElectronicFileAction(Request $request, EntityManagerInterface $entityManager) {
$pictures = [];
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$fid = $data->fid;
$eid = $data->eid;
$picture = $entityManager->getRepository(ElectronicPicture::class)->findOneBy(array("electronicPictureId" => $fid));
@unlink("uploads/electronic/".$eid."/".$picture->getPicturePath());
$entityManager->remove($picture);
$entityManager->flush();
$pictures = $this->getElectronicFiles($entityManager, $eid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error' ));
}
/**
* @Route("/delete-ticket-file", name="/ws/delete-ticket-file"), methods={"GET", "POST"})
*/
public function deleteTicketFileAction(Request $request, EntityManagerInterface $entityManager) {
$pictures = [];
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$fid = $data->fid;
$tid = $data->tid;
$picture = $entityManager->getRepository(TicketPicture::class)->findOneBy(array("ticketPictureId" => $fid));
@unlink("uploads/ticket/".$tid."/".$picture->getPicturePath());
$entityManager->remove($picture);
$entityManager->flush();
$pictures = $this->getTicketFiles($entityManager, $tid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error' ));
}
/**
* @Route("/delete-supervision-file", name="/ws/delete-supervision-file"), methods={"GET", "POST"})
*/
public function deleteSupervisionFileAction(Request $request, EntityManagerInterface $entityManager) {
$pictures = [];
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$fid = $data->fid;
$supervision_id = $data->supervision_id;
$type = $data->comment_type;
$picture = $entityManager->getRepository(SupervisionPicture::class)->findOneBy(array("supervisionPictureId" => $fid));
@unlink("uploads/reports/s_".$supervision_id."/".$picture->getPicturePath());
$entityManager->remove($picture);
$entityManager->flush();
$pictures = $this->getSupervisionFiles($entityManager, $supervision_id, $type);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
return new JsonResponse(array('status' => 'error' ));
}
/**
* @Route("/upload-file-sanction-app", name="/ws/upload-file-sanction-app"), methods={"GET", "POST"})
*/
public function uploadFileSanctionAppAction(Request $request, EntityManagerInterface $entityManager) {
$em = $this->getDoctrine()->getManager();
$data = json_decode(file_get_contents("php://input"));
$paths = $this->getProjectPaths();
if($data)
{
$ext = $data->ext;
$base64 = $data->hash;
$sid = $data->sid;
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/sanctions/".$sid."/";
$new = $dir_path.$fileName;
//$newPath = $paths["uploads_path"].$fileName;
$obj = $entityManager->getRepository(Sanction::class)->findOneBy(array("sanctionId" => $sid));
if($obj)
{
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$decoded = base64_decode($base64);
file_put_contents($new, $decoded);
$newObj = new SanctionPicture();
$newObj->setSanction($obj);
$newObj->setPicturePath($fileName);
$newObj->setCreatedAt(new \DateTime());
$entityManager->persist($newObj);
$entityManager->flush();
$pictures = $this->getSanctionFiles($entityManager, $sid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
} else {
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-vapicture-app", name="/ws/upload-file-vapicture-app"), methods={"GET", "POST"})
*/
public function uploadFileVapictureAppAction(Request $request, EntityManagerInterface $entityManager) {
$em = $this->getDoctrine()->getManager();
$data = json_decode(file_get_contents("php://input"));
$paths = $this->getProjectPaths();
if($data)
{
$ext = $data->ext;
$base64 = $data->hash;
$vaid = $data->vaid;
$type = $data->type;
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/vehicle/";
$new = $dir_path.$fileName;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$decoded = base64_decode($base64);
file_put_contents($new, $decoded);
//FAIL TYPE --
if($type == 'fail')
{
$obj = $entityManager->getRepository(VehicleAssignmentFail::class)->findOneBy(array(
"vehicleAssignmentFailId" => $vaid
));
if($obj)
{
$objPicture = new VehiclePicture();
$objPicture->setVehicleAssignmentFail($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setType($type);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getVehicleAssignmentFiles($entityManager, $vaid, $type);
return new JsonResponse(array('status' => 'success','pictures' => $pictures));
}
} else {
$obj = $entityManager->getRepository(VehiclePanic::class)->findOneBy(array(
"vehiclePanicId" => $vaid
));
if($obj)
{
$objPicture = new VehiclePicture();
$objPicture->setVehiclePanic($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setType($type);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getVehicleAssignmentFiles($entityManager, $vaid, $type);
return new JsonResponse(array('status' => 'success','pictures' => $pictures));
}
}
} else {
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-electronic-app", name="/ws/upload-file-electronic-app"), methods={"GET", "POST"})
*/
public function uploadFileElectronicAppAction(Request $request, EntityManagerInterface $entityManager) {
$em = $this->getDoctrine()->getManager();
$data = json_decode(file_get_contents("php://input"));
$paths = $this->getProjectPaths();
if($data)
{
$ext = $data->ext;
$base64 = $data->hash;
$eid = $data->eid;
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/electronic/".$eid."/";
$new = $dir_path.$fileName;
//$newPath = $paths["uploads_path"].$fileName;
$obj = $entityManager->getRepository(Electronic::class)->findOneBy(array("electronicId" => $eid));
if($obj)
{
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$decoded = base64_decode($base64);
file_put_contents($new, $decoded);
$newObj = new ElectronicPicture();
$newObj->setElectronic($obj);
$newObj->setPicturePath($fileName);
$newObj->setCreatedAt(new \DateTime());
$entityManager->persist($newObj);
$entityManager->flush();
$pictures = $this->getElectronicFiles($entityManager, $eid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
} else {
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-ticket-app", name="/ws/upload-file-ticket-app"), methods={"GET", "POST"})
*/
public function uploadFileTicketAppAction(Request $request, EntityManagerInterface $entityManager) {
$em = $this->getDoctrine()->getManager();
$data = json_decode(file_get_contents("php://input"));
$paths = $this->getProjectPaths();
if($data)
{
$ext = $data->ext;
$base64 = $data->hash;
$tid = $data->tid;
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/ticket/".$tid."/";
$new = $dir_path.$fileName;
//$newPath = $paths["uploads_path"].$fileName;
$obj = $entityManager->getRepository(Ticket::class)->findOneBy(array("ticketId" => $tid));
if($obj)
{
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$decoded = base64_decode($base64);
file_put_contents($new, $decoded);
$newObj = new TicketPicture();
$newObj->setTicket($obj);
$newObj->setPicturePath($fileName);
$newObj->setCreatedAt(new \DateTime());
$entityManager->persist($newObj);
$entityManager->flush();
$pictures = $this->getTicketFiles($entityManager, $tid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
} else {
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-reaction-app", name="/ws/upload-file-reaction-app"), methods={"GET", "POST"})
*/
public function uploadFileReactionAppAction(Request $request, EntityManagerInterface $entityManager) {
$em = $this->getDoctrine()->getManager();
$data = json_decode(file_get_contents("php://input"));
$paths = $this->getProjectPaths();
if($data)
{
$ext = $data->ext;
$base64 = $data->hash;
$rid = $data->rid;
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/reactions/".$rid."/";
$new = $dir_path.$fileName;
//$newPath = $paths["uploads_path"].$fileName;
$obj = $entityManager->getRepository(Reaction::class)->findOneBy(array("reactionId" => $rid));
if($obj)
{
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$decoded = base64_decode($base64);
file_put_contents($new, $decoded);
$newObj = new ReactionPicture();
$newObj->setReaction($obj);
$newObj->setPicturePath($fileName);
$newObj->setCreatedAt(new \DateTime());
$entityManager->persist($newObj);
$entityManager->flush();
$pictures = $this->getReactionFiles($entityManager, $rid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
} else {
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-vehicle-app", name="/ws/upload-file-vehicle-app"), methods={"GET", "POST"})
*/
public function uploadFileVehicleAppAction(Request $request, EntityManagerInterface $entityManager) {
$em = $this->getDoctrine()->getManager();
$data = json_decode(file_get_contents("php://input"));
$paths = $this->getProjectPaths();
if($data)
{
$ext = $data->ext;
$base64 = $data->hash;
$aid = $data->assignment_id;
$number = $data->number;
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/vehicle/".$aid."/";
$new = $dir_path.$fileName;
//$newPath = $paths["uploads_path"].$fileName;
$obj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy(array("vehicleAssignmentId" => $aid));
if($obj)
{
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$decoded = base64_decode($base64);
file_put_contents($new, $decoded);
//Si ya existe que elimine la foto que habia
$checkObj = $entityManager->getRepository(VehicleAssignmentPicture::class)->findOneBy([
"VehicleAssignment" => $aid,
"picture_number" => $number
]);
if($checkObj)
{
//unlink picture
$file = "uploads/vehicle/".$aid."/".$checkObj->getPicturePath();
if(file_exists($file))
{
unlink($file);
}
$entityManager->remove($checkObj);
$entityManager->flush();
}
$objPicture = new VehicleAssignmentPicture();
$objPicture->setVehicleAssignment($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setPictureNumber($number);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getVehicleFiles($entityManager, $aid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/upload-file-report-app", name="/ws/upload-file-report-app"), methods={"GET", "POST"})
*/
public function uploadFileReportAppAction(Request $request, EntityManagerInterface $entityManager) {
$em = $this->getDoctrine()->getManager();
$data = json_decode(file_get_contents("php://input"));
$paths = $this->getProjectPaths();
if($data)
{
$ext = $data->ext;
$base64 = $data->hash;
$seid = $data->seid;
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/reports/".$seid."/";
$new = $dir_path.$fileName;
//$newPath = $paths["uploads_path"].$fileName;
$shiftEventObj = $entityManager->getRepository(ShiftEvent::class)->findOneBy(array("shiftEventId" => $seid));
if($shiftEventObj)
{
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$decoded = base64_decode($base64);
file_put_contents($new, $decoded);
$obj = new ShiftEventPicture();
$obj->setShiftEvent($shiftEventObj);
$obj->setPicturePath($fileName);
$obj->setCreatedAt(new \DateTime());
$entityManager->persist($obj);
$entityManager->flush();
$pictures = $this->getReportFiles($entityManager, $seid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
} else {
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-supervision-app", name="/ws/upload-file-supervision-app"), methods={"GET", "POST"})
*/
public function uploadFileSupervisionAppAction(Request $request, EntityManagerInterface $entityManager) {
$em = $this->getDoctrine()->getManager();
$data = json_decode(file_get_contents("php://input"));
$paths = $this->getProjectPaths();
if($data)
{
$ext = $data->ext;
$base64 = $data->hash;
$supervision_id = $data->supervision_id;
$commentType = $data->comment_type;
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/reports/s_".$supervision_id."/";
$new = $dir_path.$fileName;
//$newPath = $paths["uploads_path"].$fileName;
$mainObj = $entityManager->getRepository(Supervision::class)->findOneBy(array("supervisionId" => $supervision_id));
if($mainObj)
{
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$decoded = base64_decode($base64);
file_put_contents($new, $decoded);
$obj = new SupervisionPicture();
$obj->setSupervision($mainObj);
$obj->setPicturePath($fileName);
$obj->setPictureType($commentType);
$obj->setCreatedAt(new \DateTime());
$entityManager->persist($obj);
$entityManager->flush();
$pictures = $this->getSupervisionFiles($entityManager, $supervision_id, $commentType);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
} else {
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-report-browser", name="/ws/upload-file-report-browser"), methods={"GET", "POST"})
*/
public function uploadFileReportBrowserAction(Request $request, EntityManagerInterface $entityManager)
{
$uploadfile = $_FILES['file']['name'];
$uploadfilename = $_FILES['file']['tmp_name'];
$array = array();
if($uploadfile)
{
$ext = $_POST['ext'];
$seid = $_POST['seid'];
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/reports/".$seid."/";
$new = $dir_path.$fileName;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($uploadfilename, $new))
{
$shiftEventObj = $entityManager->getRepository(ShiftEvent::class)->findOneBy(array("shiftEventId" => $seid));
if($shiftEventObj)
{
$obj = new ShiftEventPicture();
$obj->setShiftEvent($shiftEventObj);
$obj->setPicturePath($fileName);
$obj->setCreatedAt(new \DateTime());
$entityManager->persist($obj);
$entityManager->flush();
$pictures = $this->getReportFiles($entityManager, $seid);
return new JsonResponse(array('status' => 'success','pictures' => $pictures));
}
}
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-electronic-browser", name="/ws/upload-file-electronic-browser"), methods={"GET", "POST"})
*/
public function uploadFileElectronicBrowserAction(Request $request, EntityManagerInterface $entityManager)
{
$uploadfile = $_FILES['file']['name'];
$uploadfilename = $_FILES['file']['tmp_name'];
$array = array();
if($uploadfile)
{
$ext = $_POST['ext'];
$eid = $_POST['eid'];
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/electronic/".$eid."/";
$new = $dir_path.$fileName;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($uploadfilename, $new))
{
$obj = $entityManager->getRepository(Electronic::class)->findOneBy(array("electronicId" => $eid));
if($obj)
{
$objPicture = new ElectronicPicture();
$objPicture->setElectronic($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getElectronicFiles($entityManager, $eid);
return new JsonResponse(array('status' => 'success','pictures' => $pictures));
}
}
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-ticket-browser", name="/ws/upload-file-ticket-browser"), methods={"GET", "POST"})
*/
public function uploadFileTicketBrowserAction(Request $request, EntityManagerInterface $entityManager)
{
$uploadfile = $_FILES['file']['name'];
$uploadfilename = $_FILES['file']['tmp_name'];
$array = array();
if($uploadfile)
{
$ext = $_POST['ext'];
$tid = $_POST['tid'];
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/ticket/".$tid."/";
$new = $dir_path.$fileName;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($uploadfilename, $new))
{
$obj = $entityManager->getRepository(Ticket::class)->findOneBy(array("ticketId" => $tid));
if($obj)
{
$objPicture = new TicketPicture();
$objPicture->setTicket($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getTicketFiles($entityManager, $tid);
return new JsonResponse(array('status' => 'success','pictures' => $pictures));
}
}
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-vehicle-browser", name="/ws/upload-file-vehicle-browser"), methods={"GET", "POST"})
*/
public function uploadFileVehicleBrowserAction(Request $request, EntityManagerInterface $entityManager)
{
$uploadfile = $_FILES['file']['name'];
$uploadfilename = $_FILES['file']['tmp_name'];
$array = array();
if($uploadfile)
{
$ext = $_POST['ext'];
$aid = $_POST['aid']; //Assignment Id
$number = $_POST['number'];
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/vehicle/".$aid."/";
$new = $dir_path.$fileName;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($uploadfilename, $new))
{
$obj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy(array("vehicleAssignmentId" => $aid));
if($obj)
{
//Si ya existe que elimine la foto que habia
$checkObj = $entityManager->getRepository(VehicleAssignmentPicture::class)->findOneBy([
"VehicleAssignment" => $aid,
"picture_number" => $number
]);
if($checkObj)
{
//unlink picture
$file = "uploads/vehicle/".$aid."/".$checkObj->getPicturePath();
if(file_exists($file))
{
unlink($file);
}
$entityManager->remove($checkObj);
$entityManager->flush();
}
$objPicture = new VehicleAssignmentPicture();
$objPicture->setVehicleAssignment($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setPictureNumber($number);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getVehicleFiles($entityManager, $aid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
}
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-vehicle-fuel-browser", name="/ws/upload-file-vehicle-fuel-browser"), methods={"GET", "POST"})
*/
public function uploadFileVehicleFuelBrowserAction(Request $request, EntityManagerInterface $entityManager)
{
$uploadfile = $_FILES['file']['name'];
$uploadfilename = $_FILES['file']['tmp_name'];
$uploadfile2 = $_FILES['file2']['name'];
$uploadfilename2 = $_FILES['file2']['tmp_name'];
$array = array();
if($uploadfile)
{
$ext = $_POST['ext'];
$extTwo = $_POST['extTwo'];
$aid = $_POST['aid']; //Assignment Id
$quantity = $_POST['quantity'];
$mileage = $_POST['mileage'];
$type = $_POST['type'];
$fileName = md5(date("YmdHis"))."_fuel.".$ext;
$dir_path = "uploads/vehicle/".$aid."/";
$new = $dir_path.$fileName;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$fileName2 = md5(date("YmdHis"))."_fuel_2.".$extTwo;
$newTwo = $dir_path.$fileName2;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($uploadfilename, $new))
{
if(move_uploaded_file($uploadfilename2, $newTwo))
{
$obj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy(array("vehicleAssignmentId" => $aid));
if($obj)
{
//Si ya existe que elimine la foto que habia
/*$checkObj = $entityManager->getRepository(VehicleAssignmentFuel::class)->findOneBy([
"VehicleAssignment" => $aid
]);
if($checkObj)
{
//unlink picture
$file = "uploads/vehicle/".$aid."/".$checkObj->getPicturePath();
if(file_exists($file))
{
unlink($file);
}
$entityManager->remove($checkObj);
$entityManager->flush();
}*/
$objPicture = new VehicleAssignmentFuel();
$objPicture->setVehicleAssignment($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setOdometerPath($fileName2);
$objPicture->setQuantity($quantity);
$objPicture->setMileage($mileage);
$objPicture->setRecordType($type);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getVehicleFilesFuel($entityManager, $aid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
}
}
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-vehicle-supervision-browser", name="/ws/upload-file-vehicle-supervision-browser"), methods={"GET", "POST"})
*/
public function uploadFileVehicleSupervisionBrowserAction(Request $request, EntityManagerInterface $entityManager)
{
//return new JsonResponse(array('status' => 'success', 'POST' => $_POST, 'FILES' => $_FILES));
if(isset($_POST) or isset($_FILES))
{
$templateId = $_POST['templateId'];
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
"employeeId" => $_POST['eid']
]);
$templateObj = $entityManager->getRepository(DocumentTemplate::class)->findOneBy([
"documentTemplateId" => $templateId
]);
$documentParent = new DocumentParent();
$documentParent->setDocumentTemplate($templateObj);
$documentParent->setIsActive(1);
$documentParent->setCreatedAt(new \DateTime());
$documentParent->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($documentParent);
$entityManager->flush();
if($templateObj)
{
foreach($_POST as $key => $post)
{
$fieldObj = $entityManager->getRepository(DocumentTemplateField::class)->findOneBy([
"documentTemplateFieldId" => $key
]);
if($fieldObj)
{
$document = new Document();
$document->setDocumentParent($documentParent);
$document->setDocumentTemplateGroup($fieldObj->getDocumentTemplateGroup());
$document->setDocumentTemplateField($fieldObj);
$document->setLabel($fieldObj->getName());
if($fieldObj->getFieldType() == 'opcion_multiple')
{
$fieldValueObj = $entityManager->getRepository(DocumentTemplateFieldValue::class)->findOneBy([
"documentTemplateFieldValueId" => $post
]);
if($fieldValueObj)
{
$document->setInputValue($fieldValueObj->getValueName());
}
} else {
if($fieldObj->getFieldType() == 'fecha')
{
$document->setInputValue(substr($post,0,10));
} else {
$document->setInputValue($post);
}
}
$document->setCreatedAt(new \DateTime());
$document->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($document);
$entityManager->flush();
}
}
foreach($_FILES as $key => $file)
{
$fieldObj = $entityManager->getRepository(DocumentTemplateField::class)->findOneBy([
"documentTemplateFieldId" => $key
]);
if($fieldObj)
{
$arr = explode(".",$file['name']);
$fileName = md5(date("YmdHis"))."_supervision.".$arr[1];
$dir_path = "uploads/vehicle/supervision/";
$new = $dir_path.$fileName;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($file['tmp_name'], $new))
{
$document = new Document();
$document->setDocumentParent($documentParent);
$document->setDocumentTemplateGroup($fieldObj->getDocumentTemplateGroup());
$document->setDocumentTemplateField($fieldObj);
$document->setLabel($fieldObj->getName());
$document->setInputValue($new);
$document->setCreatedAt(new \DateTime());
$entityManager->persist($document);
$entityManager->flush();
}
}
}
return new JsonResponse(array('status' => 'success'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/upload-file-refuel-app", name="/ws/upload-file-refuel-app"), methods={"GET", "POST"})
*/
public function uploadFileRefuelAppAction(Request $request, HelperService $helperService, EntityManagerInterface $entityManager) {
$em = $this->getDoctrine()->getManager();
$data = json_decode(file_get_contents("php://input"));
$paths = $this->getProjectPaths();
if($data)
{
$file = $data->file;
$ext = $data->ext;
$file2 = $data->file2;
$ext2 = $data->ext2;
$quantity = $data->quantity;
$plate = $data->plate;
$mileage = $data->mileage;
$eid = $data->eid;
$externalId = $data->external_id;
$dir_path = "uploads/vehicle/";
$fileName = md5(date("YmdHis"))."_refuel.".$ext;
$new = $dir_path.$fileName;
$fileName2 = md5(date("YmdHis"))."_2_refuel.".$ext2;
$new2 = $dir_path.$fileName2;
//$newPath = $paths["uploads_path"].$fileName;
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
"employeeId" => $eid
]);
if($employeeObj)
{
// ----------------------------- MILEAGE CHECK ----------------------------
// ------------------------------------------------------------------------
$arrayInfo = $this->getLatestMileage($helperService, $entityManager, $plate);
$mileageCheck = $arrayInfo['mileageCheck'];
$checked = $arrayInfo['checked'];
// ------------------------------------------------------------------------
// ----------------------------- MILEAGE CHECK ----------------------------
if($mileage > $mileageCheck)
{
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$decoded = base64_decode($file);
file_put_contents($new, $decoded);
$decoded2 = base64_decode($file2);
file_put_contents($new2, $decoded2);
$objPicture = new Refuel();
$objPicture->setExternalVehicleId($externalId);
$objPicture->setPicturePath($fileName);
$objPicture->setFuelPicturePath($fileName2);
$objPicture->setPlateNumber($plate);
$objPicture->setMileage($mileage);
$objPicture->setQuantity($quantity);
$objPicture->setCreatedAt(new \DateTime());
$objPicture->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($objPicture);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error', 'message' => "El kilometraje ingresado es menor al último registrado ($mileageCheck) en $checked. Por favor verifique e intente nuevamente."));
}
} else {
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-fail-app", name="/ws/upload-file-fail-app"), methods={"GET", "POST"})
*/
public function uploadFileFailAppAction(Request $request, HelperService $helperService, EntityManagerInterface $entityManager) {
$em = $this->getDoctrine()->getManager();
$data = json_decode(file_get_contents("php://input"));
$paths = $this->getProjectPaths();
if($data)
{
$file = $data->file;
$ext = $data->ext;
$description = $data->description;
$plate = $data->plate;
$vaid = $data->vaid;
$eid = $data->eid;
$externalId = $data->external_id;
$dir_path = "uploads/vehicle/";
$fileName = md5(date("YmdHis"))."_refuel.".$ext;
$new = $dir_path.$fileName;
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
"employeeId" => $eid
]);
if($employeeObj)
{
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$decoded = base64_decode($file);
file_put_contents($new, $decoded);
$assignmentObj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy([
"vehicleAssignmentId" => $vaid
]);
$objPicture = new VehicleAssignmentFail();
$objPicture->setExternalId($externalId);
$objPicture->setPicturePath($fileName);
$objPicture->setPlateNumber($plate);
$objPicture->setDescription($description);
$objPicture->setVehicleAssignment($assignmentObj);
$objPicture->setCreatedAt(new \DateTime());
$objPicture->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($objPicture);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/upload-file-refuel-browser", name="/ws/upload-file-refuel-browser"), methods={"GET", "POST"})
*/
public function uploadFileRefuelBrowserAction(Request $request, EntityManagerInterface $entityManager, HelperService $helperService)
{
$uploadfile = $_FILES['file']['name'];
$uploadfilename = $_FILES['file']['tmp_name'];
$uploadfileTwo = $_FILES['file2']['name'];
$uploadfilenameTwo = $_FILES['file2']['tmp_name'];
$array = array();
if($uploadfile && $uploadfilenameTwo)
{
$ext = $_POST['ext'];
$ext2 = $_POST['ext2'];
$externalId = $_POST['external_id']; //Assignment Id
$quantity = $_POST['quantity'];
$plate = $_POST['plate'];
$mileage = $_POST['mileage'];
$eid = $_POST['eid'];
$lat = $_POST['lat'];
$lng = $_POST['lng'];
$dir_path = "uploads/vehicle/";
$fileName = md5(date("YmdHis"))."_refuel.".$ext;
$new = $dir_path.$fileName;
$fileName2 = md5(date("YmdHis"))."_2_refuel.".$ext2;
$new2 = $dir_path.$fileName2;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($uploadfilename, $new))
{
if(move_uploaded_file($uploadfilenameTwo, $new2))
{
//Si ya existe que elimine la foto que habia
/*$checkObj = $entityManager->getRepository(VehicleAssignmentFuel::class)->findOneBy([
"VehicleAssignment" => $aid
]);
if($checkObj)
{
//unlink picture
$file = "uploads/vehicle/".$aid."/".$checkObj->getPicturePath();
if(file_exists($file))
{
unlink($file);
}
$entityManager->remove($checkObj);
$entityManager->flush();
}*/
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
"employeeId" => $eid
]);
// ----------------------------- MILEAGE CHECK ----------------------------
// ------------------------------------------------------------------------
$arrayInfo = $this->getLatestMileage($helperService, $entityManager, $plate);
$mileageCheck = $arrayInfo['mileageCheck'];
$checked = $arrayInfo['checked'];
// ------------------------------------------------------------------------
// ----------------------------- MILEAGE CHECK ----------------------------
if($mileage > $mileageCheck)
{
$objPicture = new Refuel();
$objPicture->setExternalVehicleId($externalId);
$objPicture->setPicturePath($fileName);
$objPicture->setFuelPicturePath($fileName2);
$objPicture->setPlateNumber($plate);
$objPicture->setMileage($mileage);
$objPicture->setQuantity($quantity);
$objPicture->setLat($lat);
$objPicture->setLng($lng);
$objPicture->setCreatedAt(new \DateTime());
$objPicture->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($objPicture);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error', 'message' => "El kilometraje ingresado es menor al último registrado ($mileageCheck) en $checked. Por favor verifique e intente nuevamente."));
}
}
return new JsonResponse(array('status' => 'error', 'message' => 'No se puede realizar la operación en este momento, por favor intente más tarde.'));
}
}
/**
* @Route("/upload-file-fail-browser", name="/ws/upload-file-fail-browser"), methods={"GET", "POST"})
*/
public function uploadFileFailBrowserAction(Request $request, EntityManagerInterface $entityManager, HelperService $helperService)
{
$uploadfile = $_FILES['file']['name'];
$uploadfilename = $_FILES['file']['tmp_name'];
$array = array();
if($uploadfile)
{
$ext = $_POST['ext'];
$externalId = $_POST['external_id'];
$description = $_POST['description'];
$plate = $_POST['plate'];
$vaid = $_POST['vaid'];
$eid = $_POST['eid'];
$dir_path = "uploads/vehicle/";
$fileName = md5(date("YmdHis"))."_refuel.".$ext;
$new = $dir_path.$fileName;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($uploadfilename, $new))
{
$assignmentObj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy([
"vehicleAssignmentId" => $vaid
]);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
"employeeId" => $eid
]);
if($employeeObj)
{
$objPicture = new VehicleAssignmentFail();
$objPicture->setExternalId($externalId);
$objPicture->setPicturePath($fileName);
$objPicture->setPlateNumber($plate);
$objPicture->setDescription($description);
$objPicture->setVehicleAssignment($assignmentObj);
$objPicture->setCreatedAt(new \DateTime());
$objPicture->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($objPicture);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
}
return new JsonResponse(array('status' => 'error', 'message' => 'No se puede realizar la operación en este momento, por favor intente más tarde.'));
}
}
/**
* @Route("/vehicle-panic-create", name="/ws/vehicle-panic-create"), methods={"GET", "POST"})
*/
public function vehiclePanicCreateAction(Request $request, EntityManagerInterface $entityManager, HelperService $helperService)
{
$pictures = [];
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$description = $data->description;
$reason = $data->reason;
//$externalId = $data->external_id;
$plate = $data->plate;
$eid = $data->eid;
$vaid = $data->vaid;
$lat = $data->lat;
$lng = $data->lng;
$assignmentObj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy(array("vehicleAssignmentId" => $vaid));
if($assignmentObj)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy(array("employeeId" => $eid));
if($employeeObj)
{
$vehiclePanic = new VehiclePanic();
$vehiclePanic->setVehicleAssignment($assignmentObj);
$vehiclePanic->setExternalId($assignmentObj->getExternalId());
$vehiclePanic->setDescription($description);
$vehiclePanic->setReason($reason);
$vehiclePanic->setPlateNumber($plate);
$vehiclePanic->setLng($lng);
$vehiclePanic->setLat($lat);
$vehiclePanic->setIsActive(1);
$vehiclePanic->setCreatedAt(new \DateTime());
$vehiclePanic->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($vehiclePanic);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/vehicle-fuel-create", name="/ws/vehicle-fuel-create"), methods={"GET", "POST"})
*/
public function vehicleFuelCreateAction(Request $request, EntityManagerInterface $entityManager, HelperService $helperService)
{
$pictures = [];
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$mileage = $data->mileage;
$quantity = $data->quantity;
$type = $data->type;
$eid = $data->eid;
$aid = $data->aid;
$lat = $data->lat;
$lng = $data->lng;
$ext2 = $data->ext2;
$base642 = $data->file2;
$ext = $data->ext;
$base64 = $data->file;
$dir_path = "uploads/vehicle/".$aid."/";
$obj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy(array("vehicleAssignmentId" => $aid));
if($obj)
{
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
$fileName = md5(date("YmdHis"))."_fuel.".$ext;
$new = $dir_path.$fileName;
$fileName2 = md5(date("YmdHis"))."_fuel_2.".$ext2;
$newTwo = $dir_path.$fileName2;
$decoded = base64_decode($base64);
file_put_contents($new, $decoded);
$decoded2 = base64_decode($base642);
file_put_contents($newTwo, $decoded2);
$objPicture = new VehicleAssignmentFuel();
$objPicture->setVehicleAssignment($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setOdometerPath($fileName2);
$objPicture->setQuantity($quantity);
$objPicture->setMileage($mileage);
$objPicture->setRecordType($type);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getVehicleFilesFuel($entityManager, $aid);
return new JsonResponse(array('status' => 'success', 'pictures' => $pictures));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/vehicle-fails-create", name="/ws/vehicle-fails-create"), methods={"GET", "POST"})
*/
public function vehicleFailsCreateAction(Request $request, EntityManagerInterface $entityManager, HelperService $helperService)
{
$pictures = [];
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$description = $data->description;
//$externalId = $data->external_id;
$plate = $data->plate;
$eid = $data->eid;
$vaid = $data->vaid;
$lat = $data->lat;
$lng = $data->lng;
$assignmentObj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy(array("vehicleAssignmentId" => $vaid));
if($assignmentObj)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy(array("employeeId" => $eid));
if($employeeObj)
{
$vehiclePanic = new VehicleAssignmentFail();
$vehiclePanic->setVehicleAssignment($assignmentObj);
$vehiclePanic->setExternalId($assignmentObj->getExternalId());
$vehiclePanic->setDescription($description);
$vehiclePanic->setPlateNumber($plate);
$vehiclePanic->setLat($lat);
$vehiclePanic->setLng($lng);
$vehiclePanic->setIsActive(1);
$vehiclePanic->setCreatedAt(new \DateTime());
$vehiclePanic->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($vehiclePanic);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
}
}
return new JsonResponse(array('status' => 'error'));
}
public function getLatestMileage($helperService, $entityManager, $plate)
{
$checked = ".";
$mileageCheckInfo = 0;
$mileageRefuelInfo = 0;
$mileageInfo = $helperService->externalDb_getLatestMileage($plate);
if($mileageInfo)
{
$kmInicial = $mileageInfo['KmInicial'];
$kmFinal = $mileageInfo['KmFinal'];
if($kmFinal > 0)
{
$mileageCheckInfo = $kmFinal;
} else {
$mileageCheckInfo = $kmInicial;
}
}
$vehicleAssignmentFuelObj = $entityManager->getRepository(Refuel::class)->findOneBy([
"plate_number" => $plate
], ['created_at' => 'DESC']);
if($vehicleAssignmentFuelObj)
{
$mileageRefuelInfo = $vehicleAssignmentFuelObj->getMileage();
}
//Se obtiene el mayor de los dos
if($mileageCheckInfo > $mileageRefuelInfo)
{
$mileageCheck = $mileageCheckInfo;
$checked = 'el registro de asignaciones';
} else {
$mileageCheck = $mileageRefuelInfo;
$checked = 'el registro de reabastecimiento anterior';
}
$array = ['mileageCheck' => $mileageCheck, 'checked' => $checked];
return $array;
}
/**
* @Route("/upload-file-reaction-browser", name="/ws/upload-file-reaction-browser"), methods={"GET", "POST"})
*/
public function uploadFileReactionBrowserAction(Request $request, EntityManagerInterface $entityManager)
{
$uploadfile = $_FILES['file']['name'];
$uploadfilename = $_FILES['file']['tmp_name'];
$array = array();
if($uploadfile)
{
$ext = $_POST['ext'];
$rid = $_POST['rid'];
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/reactions/".$rid."/";
$new = $dir_path.$fileName;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($uploadfilename, $new))
{
$obj = $entityManager->getRepository(Reaction::class)->findOneBy(array("reactionId" => $rid));
if($obj)
{
$objPicture = new ReactionPicture();
$objPicture->setReaction($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getReactionFiles($entityManager, $rid);
return new JsonResponse(array('status' => 'success','pictures' => $pictures));
}
}
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-vapicture-browser", name="/ws/upload-file-vapicture-browser"), methods={"GET", "POST"})
*/
public function uploadFileVapictureBrowserAction(Request $request, EntityManagerInterface $entityManager)
{
$uploadfile = $_FILES['file']['name'];
$uploadfilename = $_FILES['file']['tmp_name'];
$array = array();
if($uploadfile)
{
$ext = $_POST['ext'];
$vaid = $_POST['vaid'];
$type = $_POST['type'];
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/vehicle/";
$new = $dir_path.$fileName;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($uploadfilename, $new))
{
//FAIL TYPE --
if($type == 'fail')
{
$obj = $entityManager->getRepository(VehicleAssignmentFail::class)->findOneBy(array(
"vehicleAssignmentFailId" => $vaid
));
if($obj)
{
$objPicture = new VehiclePicture();
$objPicture->setVehicleAssignmentFail($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setType($type);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getVehicleAssignmentFiles($entityManager, $vaid, $type);
return new JsonResponse(array('status' => 'success','pictures' => $pictures));
}
} else {
$obj = $entityManager->getRepository(VehiclePanic::class)->findOneBy(array(
"vehiclePanicId" => $vaid
));
if($obj)
{
$objPicture = new VehiclePicture();
$objPicture->setVehiclePanic($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setType($type);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getVehicleAssignmentFiles($entityManager, $vaid, $type);
return new JsonResponse(array('status' => 'success','pictures' => $pictures));
}
}
}
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-sanction-browser", name="/ws/upload-file-sanction-browser"), methods={"GET", "POST"})
*/
public function uploadFileSanctionBrowserAction(Request $request, EntityManagerInterface $entityManager)
{
$uploadfile = $_FILES['file']['name'];
$uploadfilename = $_FILES['file']['tmp_name'];
$array = array();
if($uploadfile)
{
$ext = $_POST['ext'];
$sid = $_POST['sid']; //sanction Id
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/sanctions/".$sid."/";
$new = $dir_path.$fileName;
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($uploadfilename, $new))
{
$obj = $entityManager->getRepository(Sanction::class)->findOneBy(array("sanctionId" => $sid));
if($obj)
{
$objPicture = new SanctionPicture();
$objPicture->setSanction($obj);
$objPicture->setPicturePath($fileName);
$objPicture->setCreatedAt(new \DateTime());
$entityManager->persist($objPicture);
$entityManager->flush();
$pictures = $this->getSanctionFiles($entityManager, $sid);
return new JsonResponse(array('status' => 'success','pictures' => $pictures));
}
}
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/upload-file-supervision-browser", name="/ws/upload-file-supervision-browser"), methods={"GET", "POST"})
*/
public function uploadFileSupervisionBrowserAction(Request $request, EntityManagerInterface $entityManager)
{
$uploadfile = $_FILES['file']['name'];
$uploadfilename = $_FILES['file']['tmp_name'];
$array = array();
if($uploadfile)
{
$ext = $_POST['ext'];
$supervisionId = $_POST['supervision_id'];
$commentTypeId = $_POST['comment_type'];
$fileName = md5(date("YmdHis")).".".$ext;
$dir_path = "uploads/reports/s_".$supervisionId."/";
$new = $dir_path.$fileName;
/*$t1 = "Ruta relativa: " . $dir_path . " ";
$t2 = "Ruta absoluta: " . realpath($dir_path) . " ";
$t3 = "cwd (current working directory): " . getcwd() . " ";
return new JsonResponse(array('status' => 'success','INFO' => $t1." -- ".$t2." ---".$t3));*/
if(!is_dir($dir_path))
{
mkdir($dir_path, 0777, true);
}
if(move_uploaded_file($uploadfilename, $new))
{
$mainObj = $entityManager->getRepository(Supervision::class)->findOneBy(array("supervisionId" => $supervisionId));
if($mainObj)
{
$obj = new SupervisionPicture();
$obj->setSupervision($mainObj);
$obj->setPicturePath($fileName);
$obj->setPictureType($commentTypeId);
$obj->setCreatedAt(new \DateTime());
$entityManager->persist($obj);
$entityManager->flush();
$pictures = $this->getSupervisionFiles($entityManager, $supervisionId, $commentTypeId);
return new JsonResponse(array('status' => 'success','pictures' => $pictures));
}
}
return new JsonResponse(array('status' => 'error'));
}
}
public function getTicketFiles($entityManager, $tid)
{
$path = $this->getProjectPaths();
$array = [];
$pictures = $entityManager->getRepository(TicketPicture::class)->findBy(array("Ticket" => $tid));
foreach($pictures as $picture)
{
$picturePath = $path['public_path']."uploads/ticket/".$tid."/".$picture->getPicturePath();
$array[] = array(
'picture_id' => $picture->getTicketPictureId(),
'picture_path' => $picturePath
);
}
return $array;
}
public function getElectronicFiles($entityManager, $eid)
{
$path = $this->getProjectPaths();
$array = [];
$pictures = $entityManager->getRepository(ElectronicPicture::class)->findBy(array("Electronic" => $eid));
foreach($pictures as $picture)
{
$picturePath = $path['public_path']."uploads/electronic/".$eid."/".$picture->getPicturePath();
$array[] = array(
'picture_id' => $picture->getElectronicPictureId(),
'picture_path' => $picturePath
);
}
return $array;
}
public function getSanctionFiles($entityManager, $sid)
{
$path = $this->getProjectPaths();
$array = [];
$pictures = $entityManager->getRepository(SanctionPicture::class)->findBy(array("Sanction" => $sid));
foreach($pictures as $picture)
{
$picturePath = $path['public_path']."uploads/sanctions/".$sid."/".$picture->getPicturePath();
$array[] = array(
'picture_id' => $picture->getSanctionPictureId(),
'picture_path' => $picturePath
);
}
return $array;
}
public function getVehicleFiles($entityManager, $aid)
{
$path = $this->getProjectPaths();
$array = [];
$pictures = $entityManager->getRepository(VehicleAssignmentPicture::class)->findBy(array("VehicleAssignment" => $aid));
foreach($pictures as $picture)
{
$picturePath = $path['public_path']."uploads/vehicle/".$aid."/".$picture->getPicturePath();
$array[] = array(
'picture_id' => $picture->getVehicleAssignmentPictureId(),
'picture_path' => $picturePath,
'number' => $picture->getPictureNumber()
);
}
return $array;
}
public function getVehicleFilesFuel($entityManager, $aid)
{
$path = $this->getProjectPaths();
$array = [];
$pictures = $entityManager->getRepository(VehicleAssignmentFuel::class)->findBy(array("VehicleAssignment" => $aid));
foreach($pictures as $picture)
{
$picturePath = $path['public_path']."uploads/vehicle/".$aid."/".$picture->getPicturePath();
$array[] = array(
'picture_id' => $picture->getVehicleAssignmentFuelId(),
'picture_path' => $picturePath,
'quantity' => $picture->getQuantity()
);
}
return $array;
}
public function getReactionFiles($entityManager, $rid)
{
$path = $this->getProjectPaths();
$array = [];
$pictures = $entityManager->getRepository(ReactionPicture::class)->findBy(array("Reaction" => $rid));
foreach($pictures as $picture)
{
$picturePath = $path['public_path']."uploads/reactions/".$rid."/".$picture->getPicturePath();
$array[] = array(
'picture_id' => $picture->getReactionPictureId(),
'picture_path' => $picturePath
);
}
return $array;
}
public function getVehicleAssignmentFiles($entityManager, $vaid, $type)
{
$path = $this->getProjectPaths();
$array = [];
$pictures = [];
if($type == 'fail')
{
$pictures = $entityManager->getRepository(VehiclePicture::class)->findBy(array(
"VehicleAssignmentFail" => $vaid,
"type" => $type
));
}
if($type == 'panic')
{
$pictures = $entityManager->getRepository(VehiclePicture::class)->findBy(array(
"VehiclePanic" => $vaid,
"type" => $type
));
}
foreach($pictures as $picture)
{
$picturePath = $path['public_path']."uploads/vehicle/".$picture->getPicturePath();
$array[] = array(
'picture_id' => $picture->getVehiclePictureId(),
'picture_path' => $picturePath
);
}
return $array;
}
public function getReportFiles($entityManager, $seid)
{
$path = $this->getProjectPaths();
$array = [];
$pictures = $entityManager->getRepository(ShiftEventPicture::class)->findBy(array("ShiftEvent" => $seid));
foreach($pictures as $picture)
{
$picturePath = $path['public_path']."uploads/reports/".$seid."/".$picture->getPicturePath();
$array[] = array(
'picture_id' => $picture->getShiftEventPictureId(),
'picture_path' => $picturePath
);
}
return $array;
}
/**
* @Route("/get-agent-reports", name="get-agent-reports", methods={"GET", "POST"})
*/
public function getAgentReports(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$seid = $data->seid;
$hash = $data->hash;
if($hash != "HASHBLACKTHORNESECURITY2023**")
{
return new JsonResponse(array('status' => 'error'));
}
$objs = $entityManager->getRepository(ShiftEvent::class)->findBy([
'is_active' => 1,
'is_empty_event' => 0,
'ShiftEmployee' => $seid,
'is_panic' => 0
]);
if($objs)
{
$list = [];
foreach($objs as $item)
{
$pictures = $entityManager->getRepository(ShiftEventPicture::class)->findBy([
'ShiftEvent' => $item->getShiftEventId()
]);
$list[] = [
"shiftEventId" => $item->getShiftEventId(),
"employeeId" => $item->getEmployee()->getEmployeeId(),
"comments" => $item->getComments(),
"locationId" => $item->getLocation()->getLocationId(),
"locationName" => $item->getLocation()->getName(),
"reportTypeId" => $item->getShiftReportType()->getShiftReportTypeId(),
"reportTypeName" => $item->getShiftReportType()->getName(),
"createdAt" => $item->getCreatedAt()->format("Y-m-d H:i:s"),
'pictures' => count($pictures)
];
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
} else {
return new JsonResponse(array('status' => 'success', 'data' => []));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/save-employee-terms", name="save-employee-terms", methods={"GET", "POST"})
*/
public function saveEmployeeTerms(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$signature = $data->signature;
$terms = $data->terms;
$signaturePath = $this->saveSignature($signature);
if($signaturePath)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $eid
]);
$agreement = new EmployeeAgreement();
$agreement->setEmployee($employeeObj);
$agreement->setSignaturePath($signaturePath);
$agreement->setTermsContent($terms->body);
$agreement->setCreatedAt(new \DateTime());
$entityManager->persist($agreement);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success', 'data' => $agreement->getEmployeeAgreementId()));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-vehicle-terms", name="get-vehicle-terms", methods={"GET", "POST"})
*/
public function getVehicleTerms(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$list = [];
$objs = $entityManager->getRepository(Help::class)->findOneBy(['helpId' => 2]);
if($objs)
{
$list = [
"title" => $objs->getName(),
"body" => $objs->getContent()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-refueling", name="get-refueling", methods={"GET", "POST"})
*/
public function getRefueling(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$list = [];
$objs = $entityManager->getRepository(Refuel::class)->getRefueling($eid);
if($objs)
{
foreach($objs as $item)
{
$paths = $this->getProjectPaths();
$image = $paths['public_path'].'uploads/vehicle/'.$item['picture_path'];
$list[] = [
"refuel_id" => $item['refuel_id'],
"quantity" => $item['quantity'],
"mileage" => $item['mileage'],
"plate" => $item['plate_number'],
"picture_path" => $image,
"external_id" => $item['external_vehicle_id'],
"created_at" => $item['created_at']
];
}
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-sliders", name="get-sliders", methods={"GET", "POST"})
*/
public function getSliders(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$sliders = $entityManager->getRepository(Slider::class)->findBy([
'is_active' => 1
], ['sliderId' => 'ASC']);
if($sliders)
{
$list = [];
foreach($sliders as $item)
{
$paths = $this->getProjectPaths();
$image = $paths['public_path'].'uploads/'.$item->getImagePath();
$list[] = $image;
}
return new JsonResponse(array('status' => 'success', 'data' => $list));
}
}
return new JsonResponse(array('status' => 'error'));
}
public function getLastReport($entityManager, $eid, $lid)
{
$shiftEvent = $entityManager->getRepository(ShiftEvent::class)->findOneBy([
'Employee' => $eid,
'Location' => $lid,
'is_active' => 1
], ['shiftEventId' => 'DESC']);
$lastReport = "";
if($shiftEvent)
{
$lastReport = $shiftEvent->getCreatedAt()->format("Y-m-d H:i:s");
}
return $lastReport;
}
public function getPanicStatus($entityManager, $eid, $lid)
{
$shiftEvent = $entityManager->getRepository(ShiftEvent::class)->findOneBy([
'Employee' => $eid,
'Location' => $lid,
'is_active' => 1,
'is_panic' => 1,
'is_panic_active' => 1
], ['shiftEventId' => 'DESC']);
$lastReport = false;
if($shiftEvent)
{
$lastReport = true;
}
return $lastReport;
}
/**
* @Route("/get-shifts-available", name="get-shifts-available", methods={"GET", "POST"})
*/
public function shiftsAvailable(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$shiftsAvailable = $entityManager->getRepository(ShiftEmployee::class)->getShiftsAvailable($eid);
$arr = [];
foreach($shiftsAvailable as $shift)
{
if($shift['first_name'])
{
$creatorName = $shift['first_name']." ".$shift['last_name'];
} else {
$creatorName = $shift['creator_name'];
}
$arr[] = [
"project_name" => $shift['project_name'],
"client_name" => $shift['client_name'],
"location_id" => $shift['location_id'],
"location_name" => $shift['location_name'],
'location_polygon_list' => json_decode($shift["polygon_list"], true),
"location_address" => $shift['address'],
"location_employee_id" => $shift['location_employee_id'],
"assigned_by" => $creatorName,
"date_from" => $shift['date_from'],
"date_to" => $shift['date_to'],
"already_started" => $shift['already_started']
];
}
return new JsonResponse(array('status' => 'success', 'data' => $arr));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/search-external-vehicle", name="search-external-vehicle", methods={"GET", "POST"})
*/
public function searchExternalVehicle(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$plate = $data->plate;
$result = $helperService->externalDb_searchVehicleByPlate($plate);
return new JsonResponse(array('status' => 'success', 'data' => $result));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/search-overtime-cut", name="search-overtime-cut", methods={"GET", "POST"})
*/
public function searchOvertimeCut(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$cutId = $data->cutId;
$result = $helperService->externalDb_searchOvertimeCut($cutId);
if($result)
{
return new JsonResponse(array('status' => 'success', 'data' => $result));
}
return new JsonResponse(array('status' => 'error', 'message' => "No se encontró un registro vigente con el ID proporcionado."));
}
return new JsonResponse(array('status' => 'error', 'message' => "No se pudo realizar la consulta en este momento, intente de nuevo más tarde."));
}
/**
* @Route("/external-get-absences", name="external-get-absences", methods={"GET", "POST"})
*/
public function getGetAbsences(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$locationId = $data->location_id;
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $locationId
]);
if($locationObj && $locationObj->getIdPuesto())
{
$result = $helperService->externalDb_getAusencias($locationObj->getIdPuesto());
if($result)
{
return new JsonResponse(array('status' => 'success', 'data' => $result));
}
return new JsonResponse(array('status' => 'error', 'message' => "No hay un registro de ausencía que coincida con el criterio de búsqueda."));
}
return new JsonResponse(array('status' => 'error', 'message' => "El ID del puesto es incorrecto."));
}
return new JsonResponse(array('status' => 'error', 'message' => "No se pudo realizar la consulta en este momento, intente de nuevo más tarde."));
}
/**
* @Route("/external-save-asignacion", name="external-save-asignacion", methods={"GET", "POST"})
*/
public function setAsignacion(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$form = $data->form;
$info = $data->info;
$IdCorte = $info->IdCorte;
$employeeId = $form->agente;
$locationId = $form->puesto;
$DescripcionAsignacion = $form->descripcion;
$IdTipo = $form->tipo;
$IdTipoAsignacion = $form->tipoAsignacion;
$IdMotivo = $form->motivo;
$Cantidad = 1;
$IdUsuario = 101;
$Fecha = date('Y-m-d');
$Estado = "O";
$Activo = 1;
$IdAusencia = $form->ausencia;
$Turno = "";
$Actividad = "";
$IdEstadodeFuerza = 0;
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
if($employeeObj && $employeeObj->getAlias())
{
$IdEstadodeFuerza = $employeeObj->getAlias();
}
if($IdEstadodeFuerza == 0)
{
return new JsonResponse(array('status' => 'error', 'message' => "No se encontro un ID Estado de fuerza valido en la base local. Reporte este error al administrador del sistema"));
}
$IdPuesto = 0;
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $locationId
]);
if($locationObj && $locationObj->getIdPuesto())
{
$IdPuesto = $locationObj->getIdPuesto();
}
if($IdPuesto == 0)
{
return new JsonResponse(array('status' => 'error', 'message' => "No se encontro un ID de puesto en la base local. Reporte este error al administrador del sistema"));
}
$hexTipoAsignacionArray = $helperService->externalDb_getHexTipoById($IdTipoAsignacion);
if($hexTipoAsignacionArray)
{
$Turno = $hexTipoAsignacionArray['Cantidad'];
$Actividad = $hexTipoAsignacionArray['Actividad'];
// Primera validación --> El agente puede hacer más turnos extras?
$checkOne = $helperService->externalDb_getHexAsignacionByEstadoFuerzaId($IdEstadodeFuerza, $Fecha);
if($checkOne)
{
//foreach($checkOne as $check)
//{
if($checkOne['Turno'] == '24')
{
return new JsonResponse(array('status' => 'error', 'message' => "No se puede crear un registro para este agente, ya cuenta con un turno extra que colisiona con el registro actual (24 horas)."));
} else {
if($checkOne['Actividad'] == $Actividad)
{
return new JsonResponse(array('status' => 'error', 'message' => "No se puede crear un registro para este agente, ya cuenta con un turno extra que colisiona con el registro actual ($Actividad)."));
}
}
//}
}
// Segunda validación --> El puesto permite que alguien mas este cubriendo?
$checkTwo = $helperService->externalDb_getBiSemanalByIdPuesto($IdPuesto);
if($checkTwo)
{
//Solo en estos IDs se tomará en cuenta esta validación
if($IdMotivo == 1 || $IdMotivo == 5 || $IdMotivo == 9)
{
//Todas las vacantes naturales se toman como suma
$sum = 0;
foreach($checkTwo as $check)
{
$IdEstadoDeFuerza = $check['IdEstadodefuerza'];
if($IdEstadoDeFuerza == 0)
{
$sum++;
}
}
//Todas las asuencias reportadas se suman
if($IdAusencia > 0)
{
$absencesCheck = $helperService->externalDb_getBiAusenciasByIdPuesto($IdPuesto, $Fecha);
foreach($absencesCheck as $absence)
{
$sum++;
}
}
//Todos los turnos extra reportados se restan
$absencesCheck = $helperService->externalDb_getHexAsignacionByIdPuesto($IdPuesto, $Fecha);
foreach($absencesCheck as $absence)
{
$sum--;
}
//Si ya no hay disponibilidad
if($sum < 1)
{
return new JsonResponse(array('status' => 'error', 'message' => "No se puede crear un nuevo registro porque el puesto no tiene vacantes. ($sum)"));
}
}
} else {
return new JsonResponse(array('status' => 'error', 'message' => "No se puede crear un nuevo registro porque no hay vacantes (L:6164)"));
}
$form = [
'IdCorte' => $IdCorte,
'IdEstadodeFuerza' => $IdEstadodeFuerza,
'IdPuesto' => $IdPuesto,
'IdTipoAsignacion' => $IdTipoAsignacion,
'DescripcionAsignacion' => $DescripcionAsignacion,
'IdMotivo' => $IdMotivo,
'Cantidad' => $Cantidad,
'IdUsuario' => $IdUsuario,
'Fecha' => $Fecha,
'Estado' => $Estado,
'Activo' => 1,
'IdAusencia' => $IdAusencia,
'Turno' => $Turno,
'Actividad' => $Actividad
];
//Insertar en HEX_ASIGNACION
if($helperService->externalDb_setHexAsignacion($form))
{
//Registrar en la ausencia, quien va a cubrir
if($helperService->externalDb_updateBiAusencia($IdEstadodeFuerza, $IdCorte, $IdAusencia))
{
}
return new JsonResponse(array('status' => 'success'));
}
}
}
return new JsonResponse(array('status' => 'error', 'message' => "No se pudo realizar la consulta en este momento, intente de nuevo más tarde."));
}
/**
* @Route("/overtime-get-tipos-asignaciones", name="overtime-get-tipos-asignaciones", methods={"GET", "POST"})
*/
public function getTiposAsignaciones(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$result = $helperService->externalDb_getHexTipoAsignacionYAsignaciones();
if($result)
{
return new JsonResponse(array('status' => 'success', 'data' => $result));
}
return new JsonResponse(array('status' => 'error', 'message' => "No se pudo realizar la consulta en este momento, intente de nuevo más tarde."));
}
return new JsonResponse(array('status' => 'error', 'message' => "No se pudo realizar la consulta en este momento, intente de nuevo más tarde."));
}
/**
* @Route("/overtime-get-asignaciones-validate", name="overtime-get-asignaciones-validate", methods={"GET", "POST"})
*/
public function getAsignacionesForValidate(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$result = $helperService->externalDb_getHexAsignacionesForValidate();
if($result)
{
return new JsonResponse(array('status' => 'success', 'data' => $result));
}
return new JsonResponse(array('status' => 'error', 'message' => "No se pudo realizar la consulta en este momento, intente de nuevo más tarde."));
}
return new JsonResponse(array('status' => 'error', 'message' => "No se pudo realizar la consulta en este momento, intente de nuevo más tarde."));
}
/**
* @Route("/overtime-update-asignaciones-validate", name="overtime-update-asignaciones-validate", methods={"GET", "POST"})
*/
public function updateAsignacionesForValidate(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$assignmentId = $data->IdAsignacion;
$idValidador = $data->userInfo->alias;
if($helperService->externalDb_checkIdEstadoDeFuerza($idValidador))
{
$result = $helperService->externalDb_updateHexAsignacionValidate($assignmentId, $idValidador);
if($result)
{
return new JsonResponse(array('status' => 'success', 'data' => $result));
}
return new JsonResponse(array('status' => 'error', 'message' => "No se pudo realizar la consulta en este momento, intente de nuevo más tarde."));
} else {
return new JsonResponse(array('status' => 'error', 'message' => "No existe este ID en el estado de fuerza, consulte con el administrador del sistema."));
}
}
return new JsonResponse(array('status' => 'error', 'message' => "No se pudo realizar la consulta en este momento, intente de nuevo más tarde."));
}
/**
* @Route("/overtime-get-motivos", name="overtime-get-motivos", methods={"GET", "POST"})
*/
public function getMotivos(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$result = $helperService->externalDb_getHexMotivos();
if($result)
{
return new JsonResponse(array('status' => 'success', 'data' => $result));
}
return new JsonResponse(array('status' => 'error', 'message' => "No se pudo realizar la consulta en este momento, intente de nuevo más tarde."));
}
return new JsonResponse(array('status' => 'error', 'message' => "No se pudo realizar la consulta en este momento, intente de nuevo más tarde."));
}
/**
* @Route("/get-shifts-available-supervisor", name="get-shifts-available-supervisor", methods={"GET", "POST"})
*/
public function shiftsAvailableSupervisor(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$shiftsAvailable = $entityManager->getRepository(Shift::class)->getShiftsAvailableSupervisor($eid);
$arr = [];
foreach($shiftsAvailable as $shift)
{
$arr[] = [
"shift_id" => $shift['shift_id'],
"location_id" => $shift['location_id'],
"project_id" => $shift['project_id'],
"location_name" => $shift['location_name'],
"project_name" => $shift['project_name'],
"date_from" => $shift['date_from'],
"date_to" => $shift['date_to']
];
}
return new JsonResponse(array('status' => 'success', 'data' => $arr));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/supervisor-agent-set-get", name="supervisor-agent-set-get", methods={"GET", "POST"})
*/
public function supervisorAgentSetGet(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$tracking = "";
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$type = $data->type;
if($type == 'get')
{
$employeeId = $data->employee_id;
$supervisionId = $data->supervision_id;
$supervisionEmployeeObj = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
'Supervision' => $supervisionId,
'Employee' => $employeeId
]);
$data = [
'is_present' => '',
'coverage_employee_id' => '',
'absence_reason' => '',
'asu_absence' => '',
'absence_description' => '',
'is_present_comment' => ''
];
if($supervisionEmployeeObj)
{
$coverageEmployee = '';
$isPresent = '';
if($supervisionEmployeeObj->getIsPresent() == "1")
{
$isPresent = 'yes';
}
if($supervisionEmployeeObj->getIsPresent() == "0")
{
$isPresent = 'no';
$coverageEmployee = ($supervisionEmployeeObj->getCoverageEmployeeId() ? $supervisionEmployeeObj->getCoverageEmployeeId()->getEmployeeId() : '');
}
$data = [
'is_present' => $isPresent,
'coverage_employee_id' => $coverageEmployee,
'absence_reason' => $supervisionEmployeeObj->getAbsenceReason(),
'absence_description' => $supervisionEmployeeObj->getAbsenceDescription(),
'asu_absence' => $supervisionEmployeeObj->getAsuAbsence(),
'is_present_comment' => $supervisionEmployeeObj->getIsPresentComment()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $data));
} else {
$tracking .= "1";
$isPresent = $data->is_present;
$absenceReason = $data->absence_reason;
$absenceDescription = $data->absence_description;
$asuAbsence = $data->asu_absence;
$employeeId = $data->employee_id;
$supervisionId = $data->supervision_id;
$creatorEmployeeId = $data->creator_employee_id;
$selectedEmployee = $data->selected_employee;
$is_present_comment = $data->is_present_comment;
if($isPresent == 'yes')
{
$isPresent = 1;
} else {
$isPresent = 0;
}
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervisionId
]);
if($supervisionObj)
{
$tracking .= "2";
$supervisionEmployeeObj = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
'Supervision' => $supervisionId,
'Employee' => $employeeId
]);
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $creatorEmployeeId
]);
if($supervisionEmployeeObj)
{
$tracking .= "3";
$selectedEmployeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $selectedEmployee
]);
$supervisionEmployeeObj->setIsPresentComment($is_present_comment);
$supervisionEmployeeObj->setIsPresent($isPresent);
$supervisionEmployeeObj->setCoverageEmployeeId($selectedEmployeeObj);
$supervisionEmployeeObj->setAbsenceReason($absenceReason);
$supervisionEmployeeObj->setAbsenceDescription($absenceDescription);
$supervisionEmployeeObj->setAsuAbsence($asuAbsence);
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
} else {
$tracking .= "4";
$selectedEmployeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $selectedEmployee
]);
$agentObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
$supervisionEmployeeObj = new SupervisionEmployee();
if($selectedEmployeeObj)
{
$supervisionEmployeeObj->setCoverageEmployee($selectedEmployeeObj);
}
$supervisionEmployeeObj->setSupervision($supervisionObj);
$supervisionEmployeeObj->setEmployee($agentObj);
$supervisionEmployeeObj->setIsPresentComment($is_present_comment);
$supervisionEmployeeObj->setIsPresent($isPresent);
$supervisionEmployeeObj->setAbsenceReason($absenceReason);
$supervisionEmployeeObj->setAbsenceDescription($absenceDescription);
$supervisionEmployeeObj->setAsuAbsence($asuAbsence);
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedAt(new \DateTime());
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
$tracking .= "5";
}
// ------------------------------------------------------------------------------------
// ------ SI NO ESTA PRESENTE, SE DEBE DE CREAR UNA AUSENCIA EN EL SISTEMA EXTERNO
// ------
if($isPresent == 0)
{
if($supervisionEmployeeObj->getEmployee()->getAlias())
{
$idEstadoDeFuerza = $supervisionEmployeeObj->getEmployee()->getAlias();
if($helperService->externalDb_checkIdEstadoDeFuerza($idEstadoDeFuerza))
{
$idPuesto = $supervisionEmployeeObj->getSupervision()->getLocation()->getIdPuesto();
if($idPuesto)
{
if($helperService->externalDb_checkIdPuesto($idPuesto))
{
$supervisorName = $supervisorObj->getName();
if($helperService->externalDb_insertBiAusencias($idEstadoDeFuerza, $idPuesto, $asuAbsence, $absenceReason, $absenceDescription, $supervisionEmployeeObj->getSupervisionEmployeeId(), $supervisorName))
{
$msg = 'OK: Se guardo en BI_AUSENCIAS: '.$supervisionEmployeeObj->getSupervisionEmployeeId();
$this->saveSyncLog('supervisor-agent-set-get', $msg);
} else {
$locationId = $supervisionEmployeeObj->getSupervision()->getLocation()->getLocationId();
$msg = 'No se pudo guardar en BI_AUSENCIAS: '.$supervisionEmployeeObj->getSupervisionEmployeeId()." ($idEstadoDeFuerza, $idPuesto -".$locationId."-, $asuAbsence, $absenceReason, $absenceDescription, ".$supervisionEmployeeObj->getSupervisionEmployeeId().", $supervisorName)";
$this->saveSyncLog('supervisor-agent-set-get', $msg);
};
} else{
$msg = 'No se encontro el IdPuesto '.$idPuesto.' (Location Id: '.$supervisionEmployeeObj->getSupervision()->getLocation()->getLocationId().') en el sistema externo';
$this->saveSyncLog('supervisor-agent-set-get', $msg);
};
} else {
$msg = 'No hay IdPuesto (Location Id: '.$supervisionEmployeeObj->getSupervision()->getLocation()->getLocationId().') en el sistema externo';
$this->saveSyncLog('supervisor-agent-set-get', $msg);
}
} else {
$msg = 'No se encontro el IdEstadoDeFuerza '.$idEstadoDeFuerza.' ('.$supervisionEmployeeObj->getEmployee()->getName().') en el sistema externo';
$this->saveSyncLog('supervisor-agent-set-get', $msg);
}
} else {
$this->saveSyncLog('supervisor-agent-set-get', 'No existe el campo ALIAS');
}
}
// ------------------------------------------------------------------------------------
$tracking .= "6";
return new JsonResponse(array('status' => 'success'));
}
}
}
return new JsonResponse(array('status' => 'error', 'tracking' => $tracking));
}
public function saveSyncLog($name, $detail)
{
$entityManager = $this->getDoctrine()->getManager();
$syncLog = new SyncLog();
$syncLog->setName($name);
$syncLog->setDetail($detail);
$syncLog->setCreatedAt(new \DateTime());
$entityManager->persist($syncLog);
$entityManager->flush();
return true;
}
/**
* @Route("/supervisor-agent-inventory-set-get", name="supervisor-agent-inventory-set-get", methods={"GET", "POST"})
*/
public function supervisorInventoryAgentSetGet(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$type = $data->type;
if($type == 'get')
{
$employeeId = $data->employee_id;
$supervisionId = $data->supervision_id;
$supervisionEmployeeObj = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
'Supervision' => $supervisionId,
'Employee' => $employeeId
]);
$data = [
'inventory_weapon' => '',
'inventory_phone' => '',
'inventory_radio' => ''
];
/*$supervisionEmployeeObj->setInventoryWeaponServer($weapon_serial_server);
$supervisionEmployeeObj->setWeaponMismatch($serial_mismatch);
$supervisionEmployeeObj->setWeaponMismatchComment($weapon_mismatch_comment*/
if($supervisionEmployeeObj)
{
$data = [
'weapon_mismatch' => $supervisionEmployeeObj->getWeaponMismatch(),
'weapon_mismatch_comment' => $supervisionEmployeeObj->getWeaponMismatchComment(),
'inventory_weapon' => $supervisionEmployeeObj->getInventoryWeapon(),
'inventory_phone' => $supervisionEmployeeObj->getInventoryPhone(),
'inventory_radio' => $supervisionEmployeeObj->getInventoryRadio()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $data));
} else {
$weaponSerial = $data->weapon_serial;
$weapon_serial_server = $data->weapon_serial_server;
$phoneNumber = $data->phone_number;
$radioSerial = $data->radio_serial;
$employeeId = $data->employee_id;
$supervisionId = $data->supervision_id;
$creatorEmployeeId = $data->creator_employee_id;
$serial_mismatch = false;
if(isset($data->serial_mismatch)){
$serial_mismatch = $data->serial_mismatch;
}
$weapon_mismatch_comment = "";
if(isset($data->mismatch_comment)){
$weapon_mismatch_comment = $data->mismatch_comment;
}
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervisionId
]);
if($supervisionObj)
{
$supervisionEmployeeObj = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
'Supervision' => $supervisionId,
'Employee' => $employeeId
]);
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $creatorEmployeeId
]);
if($supervisionEmployeeObj)
{
$supervisionEmployeeObj->setInventoryWeapon($weaponSerial);
$supervisionEmployeeObj->setInventoryWeaponServer($weapon_serial_server);
$supervisionEmployeeObj->setWeaponMismatch($serial_mismatch);
$supervisionEmployeeObj->setWeaponMismatchComment($weapon_mismatch_comment);
$supervisionEmployeeObj->setInventoryRadio($radioSerial);
$supervisionEmployeeObj->setInventoryPhone($phoneNumber);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
} else {
$agentObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
$supervisionEmployeeObj = new SupervisionEmployee();
$supervisionEmployeeObj->setSupervision($supervisionObj);
$supervisionEmployeeObj->setEmployee($agentObj);
$supervisionEmployeeObj->setInventoryWeapon($weaponSerial);
$supervisionEmployeeObj->setInventoryRadio($radioSerial);
$supervisionEmployeeObj->setInventoryWeaponServer($weapon_serial_server);
$supervisionEmployeeObj->setWeaponMismatch($serial_mismatch);
$supervisionEmployeeObj->setWeaponMismatchComment($weapon_mismatch_comment);
$supervisionEmployeeObj->setInventoryPhone($phoneNumber);
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedAt(new \DateTime());
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
}
if($serial_mismatch === true ){
$this->createSupervisionTicket($supervisionEmployeeObj, "ERROR ASIGNACIÓN" , "WEAPON" , $weaponSerial , array(), array(), "Supervisor indico que existen datos incorrectos, Arma asignada no corresponde. Arma reportada $weaponSerial ($weapon_serial_server Externo).", $supervisorObj );
}else if( $weaponSerial != $weapon_serial_server ){
$this->createSupervisionTicket($supervisionEmployeeObj, "ERROR ASIGNACIÓN" , "WEAPON" , $weaponSerial , array(), array(), "Arma asignada no corresponde. Arma reportada $weaponSerial ($weapon_serial_server Externo).", $supervisorObj );
}
return new JsonResponse(array('status' => 'success'));
}
}
}
return new JsonResponse(array('status' => 'error'));
}
function createSupervisionTicket($supervisionEmployee = array(), $ticketType = "" , $supervisionType = "" , $control_number = "" , $correctEmployee = array(), $correctLocation = array(), $error_description = "", $createdBy = array() ){
$supervisionTicket = new SupervisionTicket();
$supervisionTicket->setSupervision($supervisionEmployee->getSupervision());
$supervisionTicket->setSupervisionEmployee($supervisionEmployee);
$supervisionTicket->setTicketType($ticketType);
$supervisionTicket->setSupervisionType($supervisionType);
$supervisionTicket->setControlNumber($control_number);
if($correctEmployee){
$supervisionTicket->setCorrectEmployee($correctEmployee);
}
if($correctLocation){
$supervisionTicket->setCorrectLocation($correctLocation);
}
$supervisionTicket->setErrorDescription($error_description);
$supervisionTicket->setIsActive(1);
$supervisionTicket->setCreatedAt(new \DateTime());
if($createdBy){
$supervisionTicket->setCreatedByEmployee($createdBy);
}
$this->entityManager->persist($supervisionTicket);
$this->entityManager->flush();
}
/**
* @Route("/supervisor-presentation-set-get", name="supervisor-presentation-set-get", methods={"GET", "POST"})
*/
public function supervisorPresentationSetGet(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$type = $data->type;
if($type == 'get')
{
$employeeId = $data->employee_id;
$supervisionId = $data->supervision_id;
$supervisionEmployeeObj = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
'Supervision' => $supervisionId,
'Employee' => $employeeId
]);
$arr = [];
$arr[] = ['val' => 'Botas', 'isChecked' => false];
$arr[] = ['val' => 'Camisa', 'isChecked' => false];
$arr[] = ['val' => 'Pantalon', 'isChecked' => false];
$arr[] = ['val' => 'Gorra', 'isChecked' => false];
$arr[] = ['val' => 'Implementos', 'isChecked' => false];
$data = [
'is_presentable' => '',
'presentation_aspect' => '',
'requires_change' => json_encode($arr)
];
if($supervisionEmployeeObj)
{
$newArr = [];
$changeList = explode(",",$supervisionEmployeeObj->getRequiresChange());
foreach($arr as $uniformCheck)
{
if(in_array($uniformCheck['val'], $changeList))
{
$newArr[] = ['val' => $uniformCheck['val'], 'isChecked' => true];
} else {
$newArr[] = ['val' => $uniformCheck['val'], 'isChecked' => false];
}
}
$isPresentable = "";
if($supervisionEmployeeObj->getIsPresentable() == "1")
{
$isPresentable = 'correct';
}
if($supervisionEmployeeObj->getIsPresentable() == "0")
{
$isPresentable = 'incorrect';
}
$data = [
'is_presentable' => $isPresentable,
'presentation_aspect' => $supervisionEmployeeObj->getPresentationAspect(),
'requires_change' => json_encode($newArr)
];
}
return new JsonResponse(array('status' => 'success', 'data' => $data));
} else {
$isPresentable = $data->is_presentable;
$presentationAspect = $data->presentation_aspect;
$requires_change = $data->requires_change;
$employeeId = $data->employee_id;
$supervisionId = $data->supervision_id;
$creatorEmployeeId = $data->creator_employee_id;
if($isPresentable == 'correct')
{
$isPresentable = 1;
} else {
$isPresentable = 0;
}
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervisionId
]);
if($supervisionObj)
{
$supervisionEmployeeObj = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
'Supervision' => $supervisionId,
'Employee' => $employeeId
]);
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $creatorEmployeeId
]);
$requires_change_final = [];
foreach($requires_change as $uniform)
{
if($uniform->isChecked)
{
$requires_change_final[] = $uniform->val;
}
}
if($supervisionEmployeeObj)
{
$supervisionEmployeeObj->setIsPresentable($isPresentable);
$supervisionEmployeeObj->setPresentationAspect($presentationAspect);
$supervisionEmployeeObj->setRequiresChange(implode(",", $requires_change_final));
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
} else {
$agentObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
$supervisionEmployeeObj = new SupervisionEmployee();
$supervisionEmployeeObj->setSupervision($supervisionObj);
$supervisionEmployeeObj->setEmployee($agentObj);
$supervisionEmployeeObj->setIsPresentable($isPresentable);
$supervisionEmployeeObj->setPresentationAspect($presentationAspect);
$supervisionEmployeeObj->setRequiresChange(implode(",", $requires_change_final));
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedAt(new \DateTime());
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/supervisor-facility-set-get", name="supervisor-facility-set-get", methods={"GET", "POST"})
*/
public function supervisorFacilitySetGet(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$type = $data->type;
if($type == 'get')
{
$locationId = $data->location_id;
$supervisionId = $data->supervision_id;
$supervisionFacilityObj = $entityManager->getRepository(SupervisionFacility::class)->findOneBy([
'Supervision' => $supervisionId,
'Location' => $locationId
]);
$arr = [];
$arr[] = ['val' => 'Limpieza en Puesto', 'isChecked' => false];
$arr[] = ['val' => 'Estado de Mobiliario', 'isChecked' => false];
$arr[] = ['val' => 'No cuenta con Procedimiento', 'isChecked' => false];
$arr[] = ['val' => 'No cuenta con Sanitario', 'isChecked' => false];
$arr[] = ['val' => 'No cuenta con Ventilación', 'isChecked' => false];
$data = [
'facility_status' => '',
'facility_requires_change' => json_encode($arr)
];
if($supervisionFacilityObj)
{
$newArr = [];
$changeList = explode(",",$supervisionFacilityObj->getFacilityRequiresChange());
foreach($arr as $uniformCheck)
{
if(in_array($uniformCheck['val'], $changeList))
{
$newArr[] = ['val' => $uniformCheck['val'], 'isChecked' => true];
} else {
$newArr[] = ['val' => $uniformCheck['val'], 'isChecked' => false];
}
}
$facilityStatus = '';
if($supervisionFacilityObj->getFacilityStatus() == "1")
{
$facilityStatus = 'correct';
}
if($supervisionFacilityObj->getFacilityStatus() == "0")
{
$facilityStatus = 'incorrect';
}
$data = [
'facility_status' => $facilityStatus,
'facility_requires_change' => json_encode($newArr)
];
}
return new JsonResponse(array('status' => 'success', 'data' => $data));
} else {
$facilityStatus = $data->facility_status;
$facility_requires_change = $data->facility_requires_change;
$locationId = $data->location_id;
$supervisionId = $data->supervision_id;
$creatorEmployeeId = $data->creator_employee_id;
//$shiftId = $data->shift_id;
if($facilityStatus == 'correct')
{
$facilityStatus = 1;
} else {
$facilityStatus = 0;
}
/*$shiftObj = $entityManager->getRepository(Shift::class)->findOneBy([
'shiftId' => $shiftId
]);*/
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervisionId
]);
if($supervisionObj)
{
$supervisionFacilityObj = $entityManager->getRepository(SupervisionFacility::class)->findOneBy([
'Supervision' => $supervisionId,
'Location' => $locationId
]);
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $creatorEmployeeId
]);
$requires_change_final = [];
foreach($facility_requires_change as $uniform)
{
if($uniform->isChecked)
{
$requires_change_final[] = $uniform->val;
}
}
if($supervisionFacilityObj)
{
$supervisionFacilityObj->setFacilityStatus($facilityStatus);
$supervisionFacilityObj->setFacilityRequiresChange(implode(",", $requires_change_final));
$supervisionFacilityObj->setIsActive(1);
//$supervisionFacilityObj->setShift($shiftObj);
$supervisionFacilityObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionFacilityObj);
$entityManager->flush();
} else {
$supervisionFacilityObj = new SupervisionFacility();
$supervisionFacilityObj->setSupervision($supervisionObj);
$supervisionFacilityObj->setLocation($supervisionObj->getLocation());
$supervisionFacilityObj->setFacilityStatus($facilityStatus);
$supervisionFacilityObj->setFacilityRequiresChange(implode(",", $requires_change_final));
$supervisionFacilityObj->setIsActive(1);
//$supervisionFacilityObj->setShift($shiftObj);
$supervisionFacilityObj->setCreatedAt(new \DateTime());
$supervisionFacilityObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionFacilityObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/supervision-comments-set-get", name="supervision-comments-set-get", methods={"GET", "POST"})
*/
public function supervisionCommentsSetGet(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$type = $data->type;
$commentType = $data->comment_type;
$comments = $data->comments;
$supervisionId = $data->supervision_id;
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervisionId
]);
if($supervisionObj)
{
if($type == 'set')
{
if($commentType == 1)
{
$supervisionObj->setClientComments($comments);
} else {
$supervisionObj->setEventComments($comments);
}
$entityManager->persist($supervisionObj);
$entityManager->flush();
return new JsonResponse(array('status' => 'success', 'message' => 'Se guardo el comentario correctamente'));
} else {
$commentInfo = [
'client' => $supervisionObj->getClientComments(),
'event' => $supervisionObj->getEventComments()
];
return new JsonResponse(array('status' => 'success', 'data' => $commentInfo));
}
}
}
return new JsonResponse(array('status' => 'error', 'message' => 'No se pueden guardar los comentarios'));
}
/**
* @Route("/upload-json", name="upload-json", methods={"GET", "POST"})
*/
public function uploadJson(Request $request, EntityManagerInterface $entityManager): Response
{
if ($_SERVER['REQUEST_METHOD'] === 'POST')
{
// Asegurarse de que el archivo ha sido enviado
if (isset($_FILES['fileContent']) && isset($_POST['fileName'])) {
// Obtener el nombre del archivo
$fileName = $_POST['fileName'];
$token = json_decode($_POST['data']);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $token->employee_id
]);
// Obtener la ruta temporal del archivo subido
$tempFilePath = $_FILES['fileContent']['tmp_name'];
// Leer el contenido del archivo
$fileContent = file_get_contents($tempFilePath);
// Decodificar el JSON
$jsonData = json_decode($fileContent, true);
if (json_last_error() === JSON_ERROR_NONE) {
// Directory where the files will be uploaded
$uploadDirectory = 'uploads/json/';
// Check if the directory exists, if not create it
if(!is_dir($uploadDirectory))
{
if(!mkdir($uploadDirectory, 0777, true))
{
return new JsonResponse(array('status' => 'error', 'message' => 'Failed to create upload directory'));
}
}
$destinationPath = $uploadDirectory . basename($fileName);
if(move_uploaded_file($tempFilePath, $destinationPath))
{
$locationArr = explode("_",$fileName);
if($locationArr > 0)
{
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $locationArr[1]
]);
$syncControl = new SyncControl();
$syncControl->setName($fileName);
$syncControl->setLocation($locationObj);
$syncControl->setStepNumber(1);
$syncControl->setIsDone(0);
$syncControl->setCreatedAt(new \DateTime());
$syncControl->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($syncControl);
$entityManager->flush();
//$return = $this->startSync($syncControl->getSyncControlId(), $entityManager);
//return new JsonResponse(array('status' => 'error', 'data' => $return));
if($this->startSync($syncControl->getSyncControlId(), $entityManager))
{
return new JsonResponse(array('status' => 'success', 'message' => 'File processed successfully'));
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'File could not be processed'));
}
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'Failed to move uploaded file'));
}
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'Failed to move uploaded file'));
}
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'Invalid JSON data'));
}
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'No file or file name provided'));
}
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'Invalid request method'));
}
}
public function startSync($syncId, $entityManager)
{
$syncObj = $entityManager->getRepository(SyncControl::class)->findOneBy([
'syncControlId' => $syncId
]);
$syncObj->setStepNumber(2);
$entityManager->persist($syncObj);
$entityManager->flush();
//Se abre el archivo para leer el resultado
$path = 'uploads/json/'.$syncObj->getName();
if(!file_exists($path))
{
throw $this->createNotFoundException('El archivo '.$path.' JSON no existe.');
}
$jsonContent = file_get_contents($path);
$data = json_decode($jsonContent, true);
if(json_last_error() !== JSON_ERROR_NONE)
{
throw new \Exception('Error al decodificar el JSON: ' . json_last_error_msg());
}
$facility = false;
if(isset($data["facility"]))
{
$facility = $data["facility"];
}
$comments = null;
if(isset($data["comments"]))
{
$comments = $data["comments"];
}
$observations = null;
if(isset($data["observations"]))
{
$observations = $data["observations"];
}
//Primer paso, se crea una supervisión
$supervision = new Supervision();
$supervision->setProject($syncObj->getLocation()->getProject());
$supervision->setLocation($syncObj->getLocation());
$supervision->setClientComments($comments);
$supervision->setEventComments($observations);
$supervision->setSyncControl($syncObj);
$supervision->setIsActive(1);
$supervision->setIsCompleted(1);
$supervision->setCreatedAt(new \DateTime());
$supervision->setClosedAt(date("Y-m-d H:i:s"));
$supervision->setCreatedByEmployeeId($syncObj->getCreatedByEmployeeId());
$entityManager->persist($supervision);
$entityManager->flush();
//Segundo paso, se almacenan los datos de la supervisión para la ubicación
$syncObj->setStepNumber(3);
$entityManager->persist($syncObj);
$entityManager->flush();
if($facility)
{
$requires_change_final = [];
foreach($facility["facility_requires_change"] as $item)
{
if($item["isChecked"])
{
$requires_change_final[] = $item["val"];
}
}
$supervisionFacilityObj = new SupervisionFacility();
$supervisionFacilityObj->setSupervision($supervision);
$supervisionFacilityObj->setLocation($syncObj->getLocation());
$supervisionFacilityObj->setFacilityStatus($facility["facility_status"]);
$supervisionFacilityObj->setFacilityRequiresChange(implode(",", $requires_change_final));
$supervisionFacilityObj->setIsActive(1);
$supervisionFacilityObj->setCreatedAt(new \DateTime());
$supervisionFacilityObj->setCreatedByEmployeeId($syncObj->getCreatedByEmployeeId());
$entityManager->persist($supervisionFacilityObj);
$entityManager->flush();
}
//Cuarto paso, se desactivan de location_employee los empleados que no deberian estar
$syncObj->setStepNumber(4);
$entityManager->persist($syncObj);
$entityManager->flush();
$employees = [];
if(isset($data["employees"]))
{
$employees = $data["employees"];
}
$extraEmployees = [];
if(isset($data["extra_employees"]))
{
$extraEmployees = $data["extra_employees"];
}
$employeeIds = array_map(function ($employee)
{
return $employee["employee_id"];
}, $employees);
// Obtener todos los LocationEmployee
$locationEmployees = $entityManager->getRepository(LocationEmployee::class)->findBy([
'Location' => $syncObj->getLocation(),
'is_active' => 1
]);
// Filtrar los empleados que están en LocationEmployee pero no en el listado de employees
$employeesNotInList = array_filter($locationEmployees, function ($locationEmployee) use ($employeeIds) {
return !in_array($locationEmployee->getEmployee()->getEmployeeId(), $employeeIds);
});
$notInListIds = array_map(function ($locationEmployee) {
return $locationEmployee->getEmployee()->getEmployeeId();
}, $employeesNotInList);
foreach($notInListIds as $notInList)
{
$locationEmployeeCheckObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'Employee' => $notInList,
'Location' => $syncObj->getLocation(),
'is_active' => 1
]);
if($locationEmployeeCheckObj)
{
//Si no esta en la lista de empleados, se desactiva
$locationEmployeeCheckObj->setIsActive(0);
$locationEmployeeCheckObj->setSyncPending(1);
$locationEmployeeCheckObj->setSyncControl($syncObj);
$locationEmployeeCheckObj->setUpdatedAt(new \Datetime());
$locationEmployeeCheckObj->setUpdatedByEmployeeId($syncObj->getCreatedByEmployeeId());
$entityManager->persist($locationEmployeeCheckObj);
$entityManager->flush();
}
}
//Quinto paso, se dan de alta / o se actualiza la fecha de los que existen
$syncObj->setStepNumber(5);
$entityManager->persist($syncObj);
$entityManager->flush();
$locationPositionObj = $entityManager->getRepository(LocationPosition::class)->findOneBy([
'locationPositionId' => 1
]);
foreach($employees as $employee)
{
$locationEmployeeCheckObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'Employee' => $employee["employee_id"],
"Location" => $syncObj->getLocation(),
'is_active' => 1
]);
if(!$locationEmployeeCheckObj)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employee["employee_id"]
]);
//Si no esta en la lista de empleados, se agrega
$locationEmployeeCheck = new LocationEmployee();
$locationEmployeeCheck->setIsActive(1);
$locationEmployeeCheck->setLocationPosition($locationPositionObj);
$locationEmployeeCheck->setLocation($syncObj->getLocation());
$locationEmployeeCheck->setEmployee($employeeObj);
$locationEmployeeCheck->setSyncPending(1);
$locationEmployeeCheck->setSyncControl($syncObj);
$locationEmployeeCheck->setLocation($syncObj->getLocation());
$locationEmployeeCheck->setCreatedAt(new \Datetime());
$locationEmployeeCheck->setCreatedByEmployeeId($syncObj->getCreatedByEmployeeId());
$entityManager->persist($locationEmployeeCheck);
$entityManager->flush();
} else {
//Si si existe el registro, se actualiza la fecha para saber que la supervisión confirmo a este empleado
$locationEmployeeCheckObj->setSyncControl($syncObj);
$locationEmployeeCheckObj->setUpdatedAt(new \Datetime());
$locationEmployeeCheckObj->setUpdatedByEmployeeId($syncObj->getCreatedByEmployeeId());
$entityManager->persist($locationEmployeeCheckObj);
$entityManager->flush();
}
}
//Paso seis, se ingresa la supervisión de los empleados
$syncObj->setStepNumber(6);
$syncObj->setIsDone(0);
$entityManager->persist($syncObj);
$entityManager->flush();
foreach($employees as $employee)
{
$supervisionEmployeeObj = $this->processEmployeesSync($employee, $entityManager, $supervision);
//Grabación final
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedAt(new \DateTime());
$supervisionEmployeeObj->setCreatedByEmployeeId($syncObj->getCreatedByEmployeeId());
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
}
//Paso siete, se ingresa la supervisión de los empleados extras (Extrero / descansero)
$syncObj->setStepNumber(7);
$syncObj->setIsDone(1);
$entityManager->persist($syncObj);
$entityManager->flush();
foreach($extraEmployees as $employee)
{
$supervisionEmployeeObj = $this->processEmployeesSync($employee, $entityManager, $supervision);
//Grabación final
$supervisionEmployeeObj->setIsExtra(1);
$supervisionEmployeeObj->setExtraType($employee["type"]);
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedAt(new \DateTime());
$supervisionEmployeeObj->setCreatedByEmployeeId($syncObj->getCreatedByEmployeeId());
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
// ----------------------------------------------------------------------------------------
// Sección de BI_Ausencias
//
if($employee["is_present"] == 'yes')
{
if($supervisionEmployeeObj->getEmployee()->getAlias())
{
$idEstadoDeFuerza = $supervisionEmployeeObj->getEmployee()->getAlias();
if($helperService->externalDb_checkIdEstadoDeFuerza($idEstadoDeFuerza))
{
$idPuesto = $supervisionEmployeeObj->getSupervision()->getLocation()->getIdPuesto();
if($idPuesto)
{
if($helperService->externalDb_checkIdPuesto($idPuesto))
{
$supervisorName = $syncObj->getCreatedByEmployeeId()->getName();
if($helperService->externalDb_insertBiAusencias($idEstadoDeFuerza, $idPuesto, $employee["asu_absence"], $employee["absence_reason"], $employee["absence_description"], $supervisionEmployeeObj->getSupervisionEmployeeId(), $supervisorName))
{
$msg = 'OK: Se guardo en BI_AUSENCIAS: '.$supervisionEmployeeObj->getSupervisionEmployeeId();
$this->saveSyncLog('supervisor-agent-set-get', $msg);
} else {
$locationId = $supervisionEmployeeObj->getSupervision()->getLocation()->getLocationId();
$msg = 'No se pudo guardar en BI_AUSENCIAS: '.$supervisionEmployeeObj->getSupervisionEmployeeId()." ($idEstadoDeFuerza, $idPuesto -".$locationId."-, $asuAbsence, $absenceReason, $absenceDescription, ".$supervisionEmployeeObj->getSupervisionEmployeeId().", $supervisorName)";
$this->saveSyncLog('supervisor-agent-set-get', $msg);
};
} else{
$msg = 'No se encontro el IdPuesto '.$idPuesto.' (Location Id: '.$supervisionEmployeeObj->getSupervision()->getLocation()->getLocationId().') en el sistema externo';
$this->saveSyncLog('supervisor-agent-set-get', $msg);
};
} else {
$msg = 'No hay IdPuesto (Location Id: '.$supervisionEmployeeObj->getSupervision()->getLocation()->getLocationId().') en el sistema externo';
$this->saveSyncLog('supervisor-agent-set-get', $msg);
}
} else {
$msg = 'No se encontro el IdEstadoDeFuerza '.$idEstadoDeFuerza.' ('.$supervisionEmployeeObj->getEmployee()->getName().') en el sistema externo';
$this->saveSyncLog('supervisor-agent-set-get', $msg);
}
} else {
$this->saveSyncLog('supervisor-agent-set-get', 'No existe el campo ALIAS');
}
}
// ----------------------------------------------------------------------------------------
}
return true;
}
public function processEmployeesSync($employee, $entityManager, $supervision)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employee["employee_id"]
]);
$supervisionEmployeeObj = new SupervisionEmployee();
$supervisionEmployeeObj->setSupervision($supervision);
$supervisionEmployeeObj->setEmployee($employeeObj);
//Puesto
if(isset($employee["is_present"]) && isset($employee["absence_reason"]) && isset($employee["asu_absence"]) && isset($employee["absence_description"]))
{
if($employee["is_present"] == 'yes')
{
$isPresent = 1;
} else {
$isPresent = 0;
}
$supervisionEmployeeObj->setIsPresent($isPresent);
$supervisionEmployeeObj->setAbsenceReason($employee["absence_reason"]);
$supervisionEmployeeObj->setAbsenceDescription($employee["absence_description"]);
$supervisionEmployeeObj->setAsuAbsence($employee["asu_absence"]);
}
//Presentacion
if(isset($employee["is_presentable"]))
{
if($employee["is_presentable"] == 'correct')
{
$isPresentable = 1;
} else {
$isPresentable = 0;
}
$requires_change_final = [];
if(isset($employee["requires_change"]) && isset($employee["presentation_aspect"]))
{
foreach($employee["requires_change"] as $uniform)
{
if($uniform["isChecked"])
{
$requires_change_final[] = $uniform["val"];
}
}
$supervisionEmployeeObj->setRequiresChange(implode(",", $requires_change_final));
}
$supervisionEmployeeObj->setIsPresentable($isPresentable);
$supervisionEmployeeObj->setPresentationAspect($employee["presentation_aspect"]);
}
//Armamento
if(isset($employee["armory_status"]))
{
if($employee["armory_status"] == 'working')
{
$armoryStatus = 1;
} else {
$armoryStatus = 0;
}
$requires_armory_change_final = [];
if(isset($employee["armory_requires_change"]))
{
foreach($employee["armory_requires_change"] as $uniform)
{
if($uniform["isChecked"])
{
$requires_armory_change_final[] = $uniform["val"];
}
}
$supervisionEmployeeObj->setArmoryRequiresChange(implode(",", $requires_armory_change_final));
}
$supervisionEmployeeObj->setArmoryStatus($armoryStatus);
}
//Inventario
if(isset($employee["inventory_weapon"]) || isset($employee["inventory_phone"]) || isset($employee["inventory_radio"]))
{
$weapon = "";
if($employee["inventory_phone"])
{
$weapon = $employee["inventory_weapon"];
}
$phone = "";
if($employee["inventory_weapon"])
{
$phone = $employee["inventory_phone"];
}
$radio = "";
if($employee["inventory_radio"])
{
$radio = $employee["inventory_radio"];
}
$supervisionEmployeeObj->setInventoryWeapon($weapon);
$supervisionEmployeeObj->setInventoryPhone($phone);
$supervisionEmployeeObj->setInventoryRadio($radio);
}
return $supervisionEmployeeObj;
}
/**
* @Route("/supervisor-armory-set-get", name="supervisor-armory-set-get", methods={"GET", "POST"})
*/
public function supervisorArmorySetGet(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$type = $data->type;
if($type == 'get')
{
$employeeId = $data->employee_id;
$supervisionId = $data->supervision_id;
$supervisionEmployeeObj = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
'Supervision' => $supervisionId,
'Employee' => $employeeId
]);
$arr = [];
$arr[] = ['val' => 'Reparación Arma', 'isChecked' => false];
$arr[] = ['val' => 'Reparación Radio', 'isChecked' => false];
$arr[] = ['val' => 'Reparación Celular', 'isChecked' => false];
$arr[] = ['val' => 'Estado Sintético', 'isChecked' => false];
$arr[] = ['val' => 'Portación Vencida', 'isChecked' => false];
$arr[] = ['val' => 'No Tiene Portación', 'isChecked' => false];
$data = [
'armory_status' => '',
'armory_requires_change' => json_encode($arr)
];
if($supervisionEmployeeObj)
{
$newArr = [];
$changeList = explode(",",$supervisionEmployeeObj->getArmoryRequiresChange());
foreach($arr as $uniformCheck)
{
if(in_array($uniformCheck['val'], $changeList))
{
$newArr[] = ['val' => $uniformCheck['val'], 'isChecked' => true];
} else {
$newArr[] = ['val' => $uniformCheck['val'], 'isChecked' => false];
}
}
$armoryStatus = "";
if($supervisionEmployeeObj->getArmoryStatus() == "1")
{
$armoryStatus = "working";
}
if($supervisionEmployeeObj->getArmoryStatus() == "0")
{
$armoryStatus = "fix";
}
$data = [
'armory_status' => $armoryStatus,
'armory_requires_change' => json_encode($newArr)
];
}
return new JsonResponse(array('status' => 'success', 'data' => $data));
} else {
$armoryStatus = $data->armory_status;
$armory_requires_change = $data->armory_requires_change;
$employeeId = $data->employee_id;
$supervisionId = $data->supervision_id;
$creatorEmployeeId = $data->creator_employee_id;
if($armoryStatus == 'working')
{
$armoryStatus = 1;
} else {
$armoryStatus = 0;
}
$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'supervisionId' => $supervisionId
]);
if($supervisionObj)
{
$supervisionEmployeeObj = $entityManager->getRepository(SupervisionEmployee::class)->findOneBy([
'Supervision' => $supervisionId,
'Employee' => $employeeId
]);
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $creatorEmployeeId
]);
$requires_change_final = [];
foreach($armory_requires_change as $uniform)
{
if($uniform->isChecked)
{
$requires_change_final[] = $uniform->val;
}
}
if($supervisionEmployeeObj)
{
$supervisionEmployeeObj->setArmoryStatus($armoryStatus);
$supervisionEmployeeObj->setArmoryRequiresChange(implode(",", $requires_change_final));
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
} else {
$agentObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
$supervisionEmployeeObj = new SupervisionEmployee();
$supervisionEmployeeObj->setSupervision($supervisionObj);
$supervisionEmployeeObj->setEmployee($agentObj);
$supervisionEmployeeObj->setArmoryStatus($armoryStatus);
$supervisionEmployeeObj->setArmoryRequiresChange(implode(",", $requires_change_final));
$supervisionEmployeeObj->setIsActive(1);
$supervisionEmployeeObj->setCreatedAt(new \DateTime());
$supervisionEmployeeObj->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervisionEmployeeObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/start-supervision", name="start-supervision", methods={"GET", "POST"})
*/
public function startSupervision(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$location_id = $data->location_id;
$lat = $data->lat;
$lng = $data->lng;
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $eid
]);
if($supervisorObj)
{
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $location_id
]);
$array = json_decode($locationObj->getPolygonList());
$polygonList = [];
//
// 17 de enero 2024:
// Si no hay poligono, se ignora todo esto, para impedir que este causando problema
//
if(isset($array->coordinates[0]))
{
foreach($array->coordinates[0] as $item)
{
if(isset($item[0]) && isset($item[1]))
{
$polygonList[] = ['lat' => $item[1], 'lng' => $item[0]];
}
}
$point = ['lat' => $lat, 'lng' => $lng];
$res = $this->isInsidePolygon($point, $polygonList);
if(!$res)
{
$shiftLog = new ShiftEmployeeLog();
$shiftLog->setLocation($locationObj);
$shiftLog->setLat($lat);
$shiftLog->setLng($lng);
$shiftLog->setCreatedAt(new \DateTime());
$shiftLog->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($shiftLog);
$entityManager->flush();
return new JsonResponse(array('status' => 'error', 'message' => 'No se puede iniciar el proceso de supervisión porque no se encuentra dentro de la ubicación autorizada para el puesto seleccionado. Si considera que se trata de un error, por favor verifique la conexión a Internet y la función de Geolocalización del dispositivo | '.$shiftLog->getShiftEmployeeLogId()));
}
}
//Parche para ubicar el shift actual
$path = $this->getProjectPaths();
$employees = [];
$shiftArray = $entityManager->getRepository(Shift::class)->getActiveShifts($location_id);
if($shiftArray)
{
$employeesObj = $entityManager->getRepository(ShiftEmployee::class)->findBy([
'Shift' => $shiftArray['shift_id'],
'is_active' => 1
]);
$shiftObj = $entityManager->getRepository(Shift::class)->findOneBy([
'shiftId' => $shiftArray['shift_id']
]);
foreach($employeesObj as $item)
{
if($item->getEmployee()->getAvatarPath())
{
$avatar = $path['public_path'].'uploads/'.$item->getEmployee()->getAvatarPath();
} else {
$avatar = $path['public_path'].'assets/img/empty_user.png';
}
$employees[] = [
'employee_id' => $item->getEmployee()->getEmployeeId(),
'name' => $item->getEmployee()->getName(),
'position' => $item->getEmployee()->getJobPosition()->getName(),
'avatar' => $avatar,
'location_position' => $item->getLocationPosition()->getName(),
'citizen_id' => $item->getEmployee()->getCitizenId(),
'firearm_credential' => $item->getEmployee()->getFirearmCredential(),
'firearm_expiration' => $item->getEmployee()->getFirearmExpiration()
];
}
}
//24 DE AGOSTO
//SE SEPARO TOTALMENTE EL PROCESO DE CREACION DE SUPERVISION DE LA SUPERVISION DEL TURNO
//
/*$supervisionObj = $entityManager->getRepository(Supervision::class)->findOneBy([
'Shift' => $shiftObj->getShiftId(),
'is_active' => 1
]);
if($supervisionObj)
{
$supervisionId = $supervisionObj->getSupervisionId();
} else {*/
$supervision = new Supervision();
//$supervision->setShift($shiftObj);
$supervision->setProject($locationObj->getProject());
$supervision->setLocation($locationObj);
$supervision->setIsActive(1);
$supervision->setCreatedAt(new \DateTime());
$supervision->setCreatedByEmployeeId($supervisorObj);
$entityManager->persist($supervision);
$entityManager->flush();
$supervisionId = $supervision->getSupervisionId();
//}
if($locationObj->getProject())
{
$projectName = $locationObj->getProject()->getName();
$projectId = $locationObj->getProject()->getProjectId();
} else {
$projectName = '-';
$projectId = '0';
}
//QUITAR ESTO PARA RETORNAR A LA LISTA DE EMPLEADOS AUTOMATICA
$employees = [];
$data = [
//'shift_id' => $shiftObj->getShiftId(),
'supervision_id' => $supervisionId,
'project_id' => $projectId,
'project_name' => $projectName,
'location_id' => $locationObj->getLocationId(),
'location_name' => $locationObj->getName(),
//'date_from' => $shiftObj->getDateFrom(),
//'date_to' => $shiftObj->getDateTo(),
'employees' => $employees
];
return new JsonResponse(array('status' => 'success', 'data' => $data));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/search_agent_bulk", name="ws_search_agent_bulk", methods={"GET", "POST"})
*/
public function searchAgentBulk(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
//$eid = $data->eid;
$location_id = $data->location_id;
$citizen_idRaw = $data->citizen_id;
//Limpiamos espacios en blanco para los DPIs que vienen desde el QR con espacio en blanco
$citizen_id = preg_replace('/\s+/', '', $citizen_idRaw);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $citizen_id//,
//'employeeStatus' => 1
]);
$employees = [];
if($employeeObj)
{
if($employeeObj->getEmployeeStatus()->getEmployeeStatusId() != 1)
{
return new JsonResponse(array('status' => 'error', 'message' => 'Este colaborador no se encuentra activo. Por favor, verifique que no se encuentre de baja, ausente, suspendido o de vacaciones.'));
}
$path = $this->getProjectPaths();
if($employeeObj->getAvatarPath())
{
$avatar = $path['public_path'].'uploads/'.$employeeObj->getAvatarPath();
} else {
$avatar = $path['public_path'].'assets/img/empty_user.png';
}
$type = "extra";
$locationEmployeeObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'Employee' => $employeeObj->getEmployeeId(),
'Location' => $location_id
]);
if($locationEmployeeObj)
{
$type = 'asignado';
}
$openedAt = "";
$shiftEmployeeObj = $entityManager->getRepository(ShiftEmployee::class)->findOneBy([
'Employee' => $employeeObj->getEmployeeId(),
'Location' => $location_id,
'is_done' => 0
]);
if($shiftEmployeeObj)
{
$openedAt = $shiftEmployeeObj->getOpenedAt();
}
$employees = [
'employee_id' => $employeeObj->getEmployeeId(),
'name' => $employeeObj->getName(),
'position' => $employeeObj->getJobPosition()->getName(),
'avatar' => $avatar,
'citizen_id' => $employeeObj->getCitizenId(),
'type' => $type,
'opened_at' => $openedAt
];
return new JsonResponse(array('status' => 'success', 'data' => $employees));
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'No se encontro al colaborador con este DPI'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/search_agent", name="ws_search_agent", methods={"GET", "POST"})
*/
public function searchAgent(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
//$location_id = $data->location_id;
$citizen_id = $data->citizen_id;
//$supervision_id = $data->supervision_id;
//$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
// 'locationId' => $location_id
//]);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $citizen_id,
'employeeStatus' => 1
]);
$employees = [];
if($employeeObj)
{
$path = $this->getProjectPaths();
if($employeeObj->getAvatarPath())
{
$avatar = $path['public_path'].'uploads/'.$employeeObj->getAvatarPath();
} else {
$avatar = $path['public_path'].'assets/img/empty_user.png';
}
$employees = [
'employee_id' => $employeeObj->getEmployeeId(),
'name' => $employeeObj->getName(),
'position' => $employeeObj->getJobPosition()->getName(),
'avatar' => $avatar,
'location_position' => '',
'location_place' => '',
'citizen_id' => $employeeObj->getCitizenId(),
'firearm_credential' => $employeeObj->getFirearmCredential(),
'firearm_expiration' => $employeeObj->getFirearmExpiration()
];
return new JsonResponse(array('status' => 'success', 'data' => $employees));
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'No se encontro al colaborador con este DPI'));
}
//Todo cambio que se haga aca, tambien debe hacerse en "start_supervision"
/*$data = [
//'shift_id' => $shiftObj->getShiftId(),
'supervision_id' => $supervision_id,
'project_id' => $locationObj->getProject()->getProjectId(),
'project_name' => $locationObj->getProject()->getName(),
'location_id' => $locationObj->getLocationId(),
'location_name' => $locationObj->getName(),
//'date_from' => $shiftObj->getDateFrom(),
//'date_to' => $shiftObj->getDateTo(),
'employees' => $employee
];*/
//return new JsonResponse(array('status' => 'success', 'data' => $employee));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/search_agent_vehicle", name="ws_search_agent_vehicle", methods={"GET", "POST"})
*/
public function searchAgentVehicle(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
$debug = 0;
if($data)
{
$eid = $data->eid;
$citizen_id = $data->citizen_id;
$vehicle_info = $data->current_vehicle;
$mileage = $data->mileage;
$vehicleAssignmentObj = $entityManager->getRepository(VehicleAssignment::class)->findOneBy([
'vehicleAssignmentId' => $vehicle_info->vehicle_assignment_id
]);
if($mileage < $vehicleAssignmentObj->getMileage())
{
return new JsonResponse(array('status' => 'error', 'message' => 'El kilometraje final no puede ser menor al inicial ('.$vehicleAssignmentObj->getMileage().')'));
}
$debug = 1;
$employeeFromObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $eid
]);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'citizenId' => $citizen_id,
'employeeStatus' => 1
]);
$employees = [];
if($employeeObj)
{
$debug = 2;
$path = $this->getProjectPaths();
if($employeeObj->getAvatarPath())
{
$avatar = $path['public_path'].'uploads/'.$employeeObj->getAvatarPath();
} else {
$avatar = $path['public_path'].'assets/img/empty_user.png';
}
$employees = [
'employee_id' => $employeeObj->getEmployeeId(),
'name' => $employeeObj->getName(),
'position' => $employeeObj->getJobPosition()->getName(),
'avatar' => $avatar,
'location_position' => '',
'location_place' => '',
'citizen_id' => $employeeObj->getCitizenId(),
'firearm_credential' => $employeeObj->getFirearmCredential(),
'firearm_expiration' => $employeeObj->getFirearmExpiration()
];
if($vehicle_info->external_id)
{
$debug = 3;
$externalId = $vehicle_info->external_id;
if($positionFound = $helperService->externalDb_checkVehicleAssignments($externalId, $employeeObj->getName()))
{
$debug = 4;
$transferFrom = $employeeFromObj->getName();
$transferTo = $employeeObj->getName();
$transfer = new VehicleTransfer();
$transfer->setMileage($mileage);
$transfer->setTransferedFrom($transferFrom);
$transfer->setTransferedTo($transferTo);
$transfer->setEmployeeIdFrom($employeeFromObj);
$transfer->setEmployeeIdTo($employeeObj);
$transfer->setVehicleAssignment($vehicleAssignmentObj);
$transfer->setIsActive(1);
$transfer->setCreatedAt(new \DateTime());
$transfer->setCreatedByEmployeeId($employeeFromObj);
$entityManager->persist($transfer);
$entityManager->flush();
//Para registrar la transferencia efectiva del vehiculo, vamos a cambiar el valor de
//Asignado y Asignado2, para intercambiar.
if($helperService->externalDb_transferVehicleAssignments($externalId, $transferFrom, $transferTo, $positionFound, $employeeFromObj->getAlias(), $employeeObj->getAlias()))
{
$debug = 5;
$vehicleAssignmentObj->setMileageFinal($mileage);
$vehicleAssignmentObj->setIsReturned(1);
$vehicleAssignmentObj->setReturnedAt(new \DateTime());
$entityManager->persist($vehicleAssignmentObj);
$entityManager->flush();
return new JsonResponse(array('status' => 'success', 'data' => $employees, 'message' => "La transferencia ha sido completada exitosamente", 'found' => $positionFound));
};
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'El colaborador que recibirá el vehículo no se encuentra autorizado', 'debug' => $debug));
}
}
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'No se encontro al colaborador con este DPI'));
}
}
return new JsonResponse(array('status' => 'error', 'message' => 'No se puede realizar la transferencia en este momento, por favor comunicarse con soporte tecnico (Error 21)', 'debug' => $debug));
}
/**
* @Route("/check_pause", name="check_pause", methods={"GET", "POST"})
*/
public function checkPause(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$seid = $data->seid;
$shiftEmployeeObj = $entityManager->getRepository(ShiftEmployeePause::class)->findOneBy([
'ShiftEmployee' => $seid,
'ended_at' => null
]);
if($shiftEmployeeObj)
{
return new JsonResponse(array('status' => 'success', 'data' => '1'));
} else {
return new JsonResponse(array('status' => 'success', 'data' => '0'));
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/send_bulk", name="send_bulk", methods={"GET", "POST"})
*/
public function sendBulk(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$location_id = $data->location_id;
$employees = $data->employees;
$control = date("YmdHis");
foreach($employees as $employee)
{
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $eid
]);
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employee->employee_id
]);
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $location_id
]);
$locationEmployeeObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'Location' => $location_id,
'Employee' => $employee->employee_id,
'is_active' => 1
]);
$shiftEmployeeObj = $entityManager->getRepository(ShiftEmployee::class)->findOneBy([
'Location' => $location_id,
'Employee' => $employee->employee_id,
'is_done' => 0
]);
if($shiftEmployeeObj)
{
$shift = $shiftEmployeeObj;
} else {
$shift = new ShiftEmployee();
}
$shift->setEmployee($employeeObj);
$shift->setLocation($locationObj);
$shift->setIsActive(1);
if($locationEmployeeObj)
{
$shift->setLocationEmployee($locationEmployeeObj);
}
if($employee->type != 'asignado')
{
$shift->setIsExtra(1);
$shift->setExtraType($employee->type);
}
//Si ya existia
if($shiftEmployeeObj)
{
//si no esta ni abierto ni cerrado el turno
if(!$shiftEmployeeObj->getOpenedAt() && !$shiftEmployeeObj->getClosedAt())
{
$shift->setBulkControl($control);
$shift->setCreatedByEmployeeId($supervisorObj);
$shift->setCreatedAt(new \DateTime());
$shift->setOpenedAt(date("Y-m-d H:i:s"));
$shift->setIsStarted(1);
$shift->setIsDone(0);
}
//Si ya aparece turno iniciado pero no cerrado
if($shiftEmployeeObj->getOpenedAt() && !$shiftEmployeeObj->getClosedAt())
{
$shift->setBulkControlClose($control);
$shift->setUpdatedByEmployeeId($supervisorObj);
$shift->setUpdatedAt(new \DateTime());
$shift->setClosedAt(date("Y-m-d H:i:s"));
$shift->setIsDone(1);
}
} else {
//Si no esta creado
$shift->setBulkControl($control);
$shift->setCreatedByEmployeeId($supervisorObj);
$shift->setOpenedAt(date("Y-m-d H:i:s"));
$shift->setIsStarted(1);
$shift->setIsDone(0);
}
$entityManager->persist($shift);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/shift-report", name="shift-report", methods={"GET", "POST"})
*/
public function shiftReport(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$type = $data->type;
$lat = $data->lat;
$lng = $data->lng;
$seid = $data->seid;
$leid = $data->leid; //Eso es location_employee_Id o solo location_id para extrero o descansero
$isExtra = $data->isExtra;
$inventory = $data->inventory;
$pauseType = "";
if(isset($data->selectedPauseType))
{
$pauseType = $data->selectedPauseType;
}
$sharedCode = false;
$administrative_job_position = array("2","3","24","11","21","5","26","16","22","30","34","36","35","20","37","40","42","43","47");//los job position administrativos BRIAN
//En cualquier escenario si viene INVENTORY:
if($inventory)
{
if(strlen($inventory->weapon)>0)
{
//Estos campos ahora ya no son requeridos, solo se almacenarán como INFORMACIÓN pero ya no
//habrá validación con la base de datos de ellos
//Esto se hizo el 28 de abril de 2025
/*if(!$helperService->externalDb_checkArmTenencia($inventory->weapon))
{
return new JsonResponse(array('status' => 'error', 'message' => 'El número de serie del arma es invalido. Ingrese un número de serie valido del arma.'));
}*/
}
}
//Nueva dinamica de PAUSA
if($type == 'pause_open')
{
$shiftEmployeeObj = $entityManager->getRepository(ShiftEmployee::class)->findOneBy([
'shiftEmployeeId' => $seid
]);
if($shiftEmployeeObj)
{
$pauseTypeObj = $entityManager->getRepository(ShiftEmployeePauseType::class)->findOneBy([
'shiftEmployeePauseTypeId' => $pauseType
]);
$shiftPause = new ShiftEmployeePause();
$shiftPause->setEmployee($shiftEmployeeObj->getEmployee());
$shiftPause->setLocation($shiftEmployeeObj->getLocation());
$shiftPause->setShiftEmployee($shiftEmployeeObj);
$shiftPause->setShiftEmployeePauseType($pauseTypeObj);
$shiftPause->setStartedAt(date("Y-m-d H:i:s"));
$entityManager->persist($shiftPause);
$entityManager->flush();
return new JsonResponse(array('status' => 'success', 'shift_employee_id' => $shiftEmployeeObj->getShiftEmployeeId()));
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'No se encontro el turno para pausar.'));
}
}
if($type == 'pause_close')
{
$shiftEmployeeObj = $entityManager->getRepository(ShiftEmployeePause::class)->findOneBy([
'ShiftEmployee' => $seid,
'ended_at' => null
]);
if($shiftEmployeeObj)
{
$shiftEmployeeObj->setEndedAt(date("Y-m-d H:i:s"));
$entityManager->persist($shiftEmployeeObj);
$entityManager->flush();
return new JsonResponse(array('status' => 'success', 'shift_employee_id' => $shiftEmployeeObj->getShiftEmployee()->getShiftEmployeeId()));
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'No se encontro el turno para pausar.'));
}
}
//Revisamos si ya existio un reporte de APERTURA para este empleado hoy
if($type == 'open')
{
//Validacion de apertura
$inventoryObj = false;
if(strlen($inventory->code)>0)
{
$inventoryObj = $entityManager->getRepository(ShiftEmployee::class)->findOneBy([
'inventory_code' => $inventory->code
]);
if(!$inventoryObj)
{
return new JsonResponse(array('status' => 'error', 'message' => 'El código de entrega de inventario no existe o ya no es valido. No se puede aperturar el turno.'));
} else {
$checkShiftEmployeeId = $inventoryObj->getShiftEmployeeId();
$checkInventoryObj = $entityManager->getRepository(ShiftEmployee::class)->findOneBy([
'inventory_shift_employee_id' => $checkShiftEmployeeId
]);
if($checkInventoryObj)
{
return new JsonResponse(array('status' => 'error', 'message' => 'El código de entrega ya fue utilizado.'));
}
}
}
$shiftEmployeeCheck = $entityManager->getRepository(ShiftEmployee::class)->checkForShiftsOpenedToday($eid);
if($shiftEmployeeCheck)
{
$controlNumbers = [];
foreach($shiftEmployeeCheck as $checkItem)
{
if($checkItem['hours_elapsed'] < 18)
{
$controlNumbers[] = '#'.$checkItem['shift_employee_id'];
}
}
if(count($controlNumbers)>0)
{
//return new JsonResponse(array('status' => 'error', 'message' => 'Ya existe un reporte de apertura para un turno el dia de hoy. Si considera que se trata de un error, por favor solicite al administrador del sistema borrar el registro de apertura con el número de control: '.implode(', ', $controlNumbers)));
}
}
}
//Buscamos sesiones activas (Que aún no se han completado)
$checkIfHasActiveShift = false;
if(strlen($seid) > 0)
{
$shiftObj = $entityManager->getRepository(ShiftEmployee::class)->findOneBy([
'shiftEmployeeId' => $seid
]);
} else {
$checkIfHasActiveShift = true;
$shiftObj = $entityManager->getRepository(ShiftEmployee::class)->findOneBy([
'Employee' => $eid,
'is_active' => 1,
'is_started' => 1,
'is_done' => 0
], ['created_at' => 'DESC']);
}
//Si encontramos sesiones activas entonces informamos según el tipo de solicitud
if($shiftObj)
{
if($type == 'check')
{
$resetSession = $this->sessionEmployee($shiftObj->getEmployee(), $shiftObj->getLocation(), $shiftObj);
return new JsonResponse(array('status' => 'success', 'reset_session' => $resetSession));
}
} else {
if($type == 'check')
{
return new JsonResponse(array('status' => 'ignore', 'message' => 'No hay sesiones activas, ignorando.'));
}
if(!$isExtra)
{
$locationEmployeeObj = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'locationEmployeeId' => $leid
]);
}
//Si no existe, es porque no hay ningun registro de apertura de sesion activa
//return new JsonResponse(array('status' => 'ignore', 'message' => 'No hay turnos asignados disponibles. Consulte con su supervisor.'));
if(!$isExtra && $locationEmployeeObj)
{
$shiftObj = new ShiftEmployee();
$shiftObj->setLocationEmployee($locationEmployeeObj);
$shiftObj->setEmployee($locationEmployeeObj->getEmployee());
$shiftObj->setLocation($locationEmployeeObj->getLocation());
$shiftObj->setLocationPosition($locationEmployeeObj->getLocationPosition());
$shiftObj->setOpenedAt(date("Y-m-d H:i:s"));
$shiftObj->setIsActive(1);
$shiftObj->setIsStarted(1);
$shiftObj->setIsDone(0);
$shiftObj->setCreatedAt(new \DateTime());
$entityManager->persist($shiftObj);
$entityManager->flush();
} else {
//Si no es extrero o descansero, aplica esta validacion
if($isExtra)
{
//Si es extrero o descansero, entonces se crea sin location_employee_id
$employeeExtraObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $eid
]);
$locationExtraObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $leid
]);
$lpid = $data->lpid; //Eso es location_place_Id para extrero o descansero
$locationPlaceObj = $entityManager->getRepository(LocationPlace::class)->findOneBy([
'locationPlaceId' => $lpid
]);
$shiftObj = new ShiftEmployee();
$shiftObj->setLocationEmployee(null);
$shiftObj->setEmployee($employeeExtraObj);
$shiftObj->setLocation($locationExtraObj);
if($locationPlaceObj){
$shiftObj->setLocationPlace($locationPlaceObj);
}else{
$shiftObj->setLocationPlace(null);
}
$shiftObj->setLocationPosition(null);
$shiftObj->setOpenedAt(date("Y-m-d H:i:s"));
$shiftObj->setIsExtra(1);
$shiftObj->setExtraType($isExtra);
$shiftObj->setIsActive(1);
$shiftObj->setIsStarted(1);
$shiftObj->setIsDone(0);
$shiftObj->setCreatedAt(new \DateTime());
$entityManager->persist($shiftObj);
$entityManager->flush();
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'No hay puesto asignado para este agente. El número de control es: '.$leid));
}
}
}
//revisamos si se encuentra dentro de un poligono, a la hora de abrir o cerrar
if($type == 'open' || $type == 'close')
{
if($isExtra)
{
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $leid
]);
} else {
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $shiftObj->getLocation()->getLocationId()
]);
}
if($locationObj->getPolygonList())
{
$array = json_decode($locationObj->getPolygonList());
$polygonList = [];
foreach($array->coordinates[0] as $item)
{
if(isset($item[0]) && isset($item[1]))
{
$polygonList[] = ['lat' => $item[1], 'lng' => $item[0]];
}
}
$point = ['lat' => $lat, 'lng' => $lng];
$res = $this->isInsidePolygon($point, $polygonList);
if(!$res)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $eid
]);
$job_position_id = $employeeObj->getJobPosition()->getJobPositionId();
$exceptionCode = $data->exceptionCode;
$exceptionMessage = $data->exceptionMessage;
if(strlen($exceptionCode)>0){
$exceptionValid = $this->validateExceptionCode($entityManager,$employeeObj, $shiftObj, $exceptionCode, $locationObj );
if($exceptionValid){
}else{
if($shiftObj && $type == 'open'){
$entityManager->remove($shiftObj);
$entityManager->flush();
}
$shiftLog = new ShiftEmployeeLog();
$shiftLog->setShiftEmployee($shiftObj);
$shiftLog->setLocation($locationObj);
$shiftLog->setLat($lat);
$shiftLog->setLng($lng);
$shiftLog->setCreatedAt(new \DateTime());
$shiftLog->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($shiftLog);
$entityManager->flush();
return new JsonResponse(array('status' => 'error2', 'message' => '<h4>Código de excepción invalido.</h4>No se puede actualizar porque no se encuentra dentro de la ubicación autorizada para el turno asignado. Puede continuar solicitando un codigo de excepción a la administración e ingresandolo abajo. | '.$shiftLog->getShiftEmployeeLogId()));
}
}elseif(strlen($exceptionMessage)>0 && in_array($job_position_id, $administrative_job_position)){
if($type == 'close'){
$shiftObj->setCloseDescription($exceptionMessage);
}else{
$shiftObj->setOpenDescription($exceptionMessage);
}
} else{
$shiftLog = new ShiftEmployeeLog();
$shiftLog->setShiftEmployee($shiftObj);
$shiftLog->setLocation($locationObj);
$shiftLog->setLat($lat);
$shiftLog->setLng($lng);
$shiftLog->setCreatedAt(new \DateTime());
$shiftLog->setCreatedByEmployeeId($employeeObj);
$entityManager->persist($shiftLog);
$entityManager->flush();
//ACA los job position administrativos
if(in_array($job_position_id, $administrative_job_position ) ){
if($shiftObj && $type == 'open'){
$entityManager->remove($shiftObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'error3', 'message' => '<h4>Fuera de ubicación</h4>No se puede actualizar porque no se encuentra dentro de la ubicación autorizada para el turno asignado. Debe ingresarse un comentario justificativo, ya que la geolocalización registrada se encuentra fuera del rango permitido.'));
exit;
}else{
if($type == 'close'){
if($shiftObj && $type == 'open'){
$entityManager->remove($shiftObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'error2', 'message' => '<h4>Fuera de ubicación</h4>No se puede actualizar porque no se encuentra dentro de la ubicación autorizada para el turno asignado. Puede continuar solicitando un codigo de excepción a la administración e ingresandolo abajo. '.$shiftLog->getShiftEmployeeLogId()));
exit;
}else{
if($shiftObj && $type == 'open'){
$entityManager->remove($shiftObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'error', 'message' => '<h4>Fuera de ubicación</h4>No se puede completar la actualización de turno porque según las coordenadas de su GPS, usted no se encuentra dentro de la ubicación autorizada para el turno que tiene asignado. Si considera que se trata de un error, por favor verifique la conexión a Internet y la función de Geolocalización del dispositivo ('.$shiftLog->getShiftEmployeeLogId().')'));
exit;
}
}
}
}
} else {
if($shiftObj && $type == 'open'){
$entityManager->remove($shiftObj);
$entityManager->flush();
}
return new JsonResponse(array('status' => 'error', 'message' => 'No se puede continuar, se requiere un poligono en el puesto'));
}
}
if($type == 'check')
{
$resetSession = false;
if($checkIfHasActiveShift)
{
$resetSession = $this->sessionEmployee($shiftObj->getEmployee(), $shiftObj->getLocation(), $shiftObj);
}
$checkPanic = $this->getPanicStatus($entityManager, $eid, $shiftObj->getLocation()->getLocationId());
return new JsonResponse(array('status' => 'success', 'type' => 'check', 'shift_employee_id' => $shiftObj->getShiftEmployeeId(), 'has_panic' => $checkPanic, 'reset_session' => $resetSession));
}
if($type == 'close')
{
// ------------------------------------------------------------------------
// Validacion de inventario
// ------------------------------------------------------------------------
if($inventory)
{
if(strlen($inventory->weapon)>0 && strlen($inventory->ammunition)>0)
{
$sharedCode = $this->generateInventoryCode();
$shiftObj->setInventoryCode($sharedCode);
$shiftObj->setInventoryWeaponSn($inventory->weapon);
$shiftObj->setInventoryAmmunitionClose($inventory->ammunition);
}
}
// ------------------------------------------------------------------------
$shiftObj->setIsDone(1);
$shiftObj->setClosedAt(date("Y-m-d H:i:s"));
//28 de abril del 2025 - se agregaron Lat y Lng para ser guardados
$shiftObj->setLat($lat);
$shiftObj->setLng($lng);
$entityManager->persist($shiftObj);
$entityManager->flush();
$data = $this->sessionEmployee($shiftObj->getEmployee());
return new JsonResponse(array('status' => 'success', 'type' => 'close', 'shift_employee_id' => 0, 'data' => $data, 'sharedCode' => $sharedCode));
}
if($type == 'open')
{
//creamos un registro de turno nuevo
//$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
// 'employeeId' => $eid
//]);
//$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
// 'locationId' => $lid
//]);
// ------------------------------------------------------------------------
// Validacion de inventario
// ------------------------------------------------------------------------
if($inventory)
{
if($inventoryObj)
{
$shiftObj->setInventoryShiftEmployeeId($inventoryObj);
$shiftObj->setInventoryWeaponSn($inventoryObj->getInventoryWeaponSn());
$shiftObj->setInventoryAmmunition($inventoryObj->getInventoryAmmunitionClose());
} else {
if(strlen($inventory->weapon)>0 && strlen($inventory->ammunition)>0)
{
$shiftObj->setInventoryWeaponSn($inventory->weapon);
$shiftObj->setInventoryAmmunition($inventory->ammunition);
}
}
}
// ------------------------------------------------------------------------
//$shiftObjN = new ShiftReport();
//$shiftObjN->setEmployee($employeeObj);
//$shiftObjN->setLocation($locationObj);
$shiftObj->setOpenedAt(date("Y-m-d H:i:s"));
$shiftObj->setIsStarted(1);
$shiftObj->setIsDone(0);
//28 de abril del 2025 - se agregaron Lat y Lng para ser guardados
$shiftObj->setLat($lat);
$shiftObj->setLng($lng);
$entityManager->persist($shiftObj);
$entityManager->flush();
$data = $this->sessionEmployee($shiftObj->getEmployee(), $shiftObj->getLocation(), $shiftObj);
return new JsonResponse(array('status' => 'success', 'type' => 'open', 'shift_employee_id' => $shiftObj->getShiftEmployeeId(), 'data' => $data));
}
}
return new JsonResponse(array('status' => 'error'));
}
public function validateExceptionCode( $entityManager,$employeeObj, $shiftEmployeeObj, $exceptionCode, $locationObj){
$exceptionAgent = $entityManager->getRepository(ExceptionAgent::class)->findOneBy([
'exception_code' => $exceptionCode, 'is_available' => 1, 'is_active' => 1
]);
if($exceptionAgent){
$exceptionAgent->setLocation($locationObj);
$exceptionAgent->setEmployee($shiftEmployeeObj->getEmployee());
$exceptionAgent->setShiftEmployee($shiftEmployeeObj);
$exceptionAgent->setIsAvailable(0);
$exceptionAgent->setUpdatedAt(new \DateTime());
$exceptionAgent->setUpdatedEmployee($employeeObj);
$entityManager->persist($exceptionAgent);
$entityManager->flush();
$shiftEmployeeObj->setExceptionAgent($exceptionAgent);
$entityManager->persist($shiftEmployeeObj);
$entityManager->flush();
return true;
}else{
return false;
}
return false;
}
public function generateInventoryCode() {
$caracteres = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
$codigo = '';
$longitud = 6;
for ($i = 0; $i < $longitud; $i++) {
$indice = rand(0, strlen($caracteres) - 1);
$codigo .= $caracteres[$indice];
}
return $codigo;
}
/**
* @Route("/get-location-position", name="ws_get_location_position", methods={"GET", "POST"})
*/
public function getLocationPositions(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$locationId = $data->locationId;
$employeeId = $data->employeeId;
$forms = [];
$formList = $entityManager->getRepository(LocationPosition::class)->findBy([
'isActive' => 1
]);
foreach($formList as $form)
{
$forms[] = [
'location_position_id' => $form->getLocationPositionId(),
'name' => $form->getName()
];
}
$places = [];
$placesList = $entityManager->getRepository(LocationPlace::class)->findBy([
'is_active' => 1,
'Location' => $locationId
]);
foreach($placesList as $item)
{
$places[] = [
'location_place_id' => $item->getLocationPlaceId(),
'name' => $item->getName()
];
}
$assignedPlace = 0;
$assignedPosition = 0;
$locationEmployee = $entityManager->getRepository(LocationEmployee::class)->findOneBy([
'Location' => $locationId,
'Employee' => $employeeId,
'is_active' => 1
]);
if($locationEmployee)
{
if($locationEmployee->getLocationPlace())
{
$assignedPlace = $locationEmployee->getLocationPlace()->getLocationPlaceId();
}
if($locationEmployee->getLocationPosition())
{
$assignedPosition = $locationEmployee->getLocationPosition()->getLocationPositionId();
}
}
return new JsonResponse(array('status' => 'success', 'data' => $forms, 'places' => $places, 'assigned_place' => $assignedPlace, 'assigned_position' => $assignedPosition));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-pause-types", name="ws_get_pause_types", methods={"GET", "POST"})
*/
public function getPauseTypes(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$formList = $entityManager->getRepository(ShiftEmployeePauseType::class)->findBy([
'is_active' => 1,
]);
foreach($formList as $form)
{
$forms[] = [
'id' => $form->getShiftEmployeePauseTypeId(),
'name' => $form->getName()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $forms));
}
return new JsonResponse(array('status' => 'error', 'data' => []));
}
/**
* @Route("/get-location-assets", name="ws_get_location_assets", methods={"GET", "POST"})
*/
public function getLocationAssets(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$locationId = $data->locationId;
$employeeId = $data->employeeId;
$forms = [];
$formList = $entityManager->getRepository(AssetLocation::class)->findBy([
'is_active' => 1,
'Location' => $locationId
]);
foreach($formList as $form)
{
$forms[] = [
'location_asset_id' => $form->getAssetLocationId(),
'location_id' => $form->getLocation()->getLocationId(),
'asset_name' => $form->getAsset()->getName(),
'asset_id' => $form->getAsset()->getAssetId(),
'asset_control' => $form->getAsset()->getIdControl(),
'asset_plate' => $form->getAsset()->getPlate(),
'asset_description' => $form->getAsset()->getDescription()
];
}
return new JsonResponse(array('status' => 'success', 'data' => $forms));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/create-sanction", name="ws_create_sanction", methods={"GET", "POST"})
*/
public function createSanctionReequest(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$supervisorId = $data->supervisor_id;
$employeeId = $data->employee_id;
$locationId = $data->location_id;
$type = $data->type;
$amount = $data->amount;
$supSignature = $data->sup_signature;
$agentSignature = $data->agent_signature;
$description = $data->description;
$sanction_data = $data->sanction_date;
$supSignaturePath = "";
$agentSignaturePath = "";
if($supSignature)
{
$supSignaturePath = $this->saveSignature($supSignature);
}
if($agentSignature)
{
$agentSignaturePath = $this->saveSignature($agentSignature);
}
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $locationId
]);
$supervisorObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $supervisorId
]);
//Si es administrativa, se le asigna el status uno
$statusObj = $entityManager->getRepository(SanctionStatus::class)->findOneBy([
'sanctionStatusId' => 1
]);
if($type == 'monetaria')
{
//Si es monetaria, de una vez se pasa al estatus final
$statusObj = $entityManager->getRepository(SanctionStatus::class)->findOneBy([
'is_final' => 1
]);
}
$sanctionObj = new Sanction();
$sanctionObj->setEmployee($employeeObj);
$sanctionObj->setLocation($locationObj);
$sanctionObj->setCreatedByEmployee($supervisorObj);
$sanctionObj->setDescription($description);
$sanctionObj->setIsActive(1);
$sanctionObj->setSanctionDate($sanction_data);
$sanctionObj->setSanctionType($type);
$sanctionObj->setAmount($amount);
$sanctionObj->setSignatureSupervisor($supSignaturePath);
$sanctionObj->setSignatureSanctioned($agentSignaturePath);
$sanctionObj->setSanctionStatus($statusObj);
$sanctionObj->setCreatedAt(new \DateTime());
$entityManager->persist($sanctionObj);
$entityManager->flush();
return new JsonResponse(array('status' => 'success'));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-sanctions", name="ws_get_sanctions_list", methods={"GET", "POST"})
*/
public function getSanctionsRequest(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeeId = $data->employee_id;
$supervisorId = $data->supervisor_id;
$locationId = $data->location_id;
$arr = [];
if($locationId > 0)
{
$list = $entityManager->getRepository(Sanction::class)->findBy([
'Employee' => $employeeId,
'Created_by_employee' => $supervisorId,
'Location' => $locationId
],[
'sanctionId' => 'DESC'
]);
} else {
$list = $entityManager->getRepository(Sanction::class)->findBy([
'Employee' => $employeeId,
'Created_by_employee' => $supervisorId
],[
'sanctionId' => 'DESC'
]);
}
foreach($list as $item)
{
$pictures = $entityManager->getRepository(SanctionPicture::class)->findBy([
'Sanction' => $item->getSanctionId(),
]);
$arr[] = [
'name' => $item->getEmployee()->getName(),
'location_name' => ($item->getLocation() ? $item->getLocation()->getName() : ''),
'sanction_id' => $item->getSanctionId(),
'description' => $item->getDescription(),
'sanction_date' => $item->getSanctionDate(),
'sanction_status' => $item->getSanctionStatus()->getName(),
'pictures' => count($pictures)
];
}
return new JsonResponse(array('status' => 'success', 'data' => $arr));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/get-agent-request-list", name="ws_get_agent_request_list", methods={"GET", "POST"})
*/
public function getAgentReequest(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$forms = [];
$formList = $entityManager->getRepository(RequestTypeApply::class)->getAgentForms();
foreach($formList as $form)
{
$path = $this->getProjectPaths();
if($form['img_path'])
{
$image = $path['public_path'].'uploads/'.$form['img_path'];
} else {
$image = '';//$path['public_path'].'assets/img/empty_user.png';
}
$forms[] = [
'request_type_id' => $form['request_type_id'],
'name' => $form['name'],
'description' => $form['description'],
'img_path' => $image
];
}
return new JsonResponse(array('status' => 'success', 'data' => $forms));
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/send-email-test", name="ws_send_email_test", methods={"GET", "POST"})
*/
public function sendEmailTest(MailHelper $mailHelper): Response
{
exit;
$content = "Fecha: ".date('Y-m-d H:i:s')."";
$result = $mailHelper::sendEmail("servicio@aguilalibreweb.com", "Prueba de email", $content);
return new JsonResponse(array('status' => 'success', 'msg' => $result));
}
/**
* @Route("/shift-event", name="ws_shift_event", methods={"GET", "POST"})
*/
public function shiftEvent(Request $request, MailHelper $mailHelper, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$seid = $data->seid;
$type = $data->type;
$shiftEmployeeObj = $entityManager->getRepository(ShiftEmployee::class)->findOneBy([
'shiftEmployeeId' => $seid
]);
if($shiftEmployeeObj)
{
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $shiftEmployeeObj->getEmployee()->getEmployeeId()
]);
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => $shiftEmployeeObj->getLocation()->getLocationId()
]);
if($type == 'empty')
{
$shiftEventObj = new ShiftEvent();
$shiftEventObj->setShiftEmployee($shiftEmployeeObj);
$shiftEventObj->setEmployee($employeeObj);
$shiftEventObj->setLocation($locationObj);
$shiftEventObj->setIsEmptyEvent(1);
$shiftEventObj->setIsActive(1);
$shiftEventObj->setIsPanic(0);
$shiftEventObj->setCreatedAt(new \DateTime());
$entityManager->persist($shiftEventObj);
$entityManager->flush();
$lastReport = "";//$this->getLastReport($entityManager, $eid, $lid);
//--------------- ALERTA DE EMAILS ---------------//
$emailAlertObj = $entityManager->getRepository(EmailAlert::class)->findOneBy([
'emailAlertId' => 1
]);
if($emailAlertObj->getEmail())
{
$content = "El agente ".$employeeObj->getName()." ha reportado que no ha tenido novedades en su turno.";
$content .= "Ubicación: ".$locationObj->getName()."";
$content .= "Fecha: ".date('Y-m-d H:i:s')."";
$mailHelper::sendEmail($emailAlertObj->getEmail(), "Reporte sin novedad - ".$employeeObj->getName(), $content);
};
//--------------- ALERTA DE EMAILS ---------------//
return new JsonResponse(array('status' => 'success', 'last_report' => $lastReport));
}
if($type == 'panic')
{
$shiftEventObj = new ShiftEvent();
$shiftEventObj->setShiftEmployee($shiftEmployeeObj);
$shiftEventObj->setEmployee($employeeObj);
$shiftEventObj->setLocation($locationObj);
$shiftEventObj->setIsEmptyEvent(0);
$shiftEventObj->setIsActive(1);
$shiftEventObj->setIsPanic(1);
$shiftEventObj->setIsPanicActive(1);
$shiftEventObj->setCreatedAt(new \DateTime());
$entityManager->persist($shiftEventObj);
$entityManager->flush();
$lastReport = $this->getLastReport($entityManager, $shiftEmployeeObj->getEmployee()->getEmployeeId(), $shiftEmployeeObj->getLocation()->getLocationId());
return new JsonResponse(array('status' => 'success', 'last_report' => $lastReport));
}
/*if($employeeObj)
{
$currentShiftObj = $entityManager->getRepository(EmployeeShift::class)->getCurrentShift($employeeObj->getEmployeeId());
if($currentShiftObj)
{
$data = [
'employee_id' => $employeeObj->getEmployeeId(),
'name' => $employeeObj->getName(),
'alias' => $employeeObj->getAlias(),
'position' => $employeeObj->getJobPosition()->getName(),
'current_shift_id' => $currentShiftObj['employee_shift_id'],
'current_location_id' => $currentShiftObj['location_id']
];
return new JsonResponse(array('status' => 'success', 'data' => $data, 'message' => 'Bienvenido '.$employeeObj->getName()));
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'El empleado no tiene turno asignado'));
}
}*/
}
}
return new JsonResponse(array('status' => 'error'));
}
/**
* @Route("/vehicle-panic", name="ws_vehicle_panic", methods={"GET", "POST"})
*/
public function vehiclePanic(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$eid = $data->eid;
$plate = $data->plate;
$employeeObj = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $eid
]);
if($employeeObj)
{
$vehiclePanicObj = $entityManager->getRepository(VehiclePanic::class)->findOneBy([
'created_by_employee_id' => $eid,
'is_active' => 1
]);
if($vehiclePanicObj)
{
return new JsonResponse(array('status' => 'error', 'message' => 'Ya existe una alerta activa'));
} else {
$shiftEventObj = new VehiclePanic();
$shiftEventObj->setPlateNumber($plate);
$shiftEventObj->setCreatedByEmployeeId($employeeObj);
$shiftEventObj->setIsActive(1);
$shiftEventObj->setCreatedAt(new \DateTime());
$entityManager->persist($shiftEventObj);
$entityManager->flush();
//$lastReport = $this->getLastReport($entityManager, $shiftEmployeeObj->getEmployee()->getEmployeeId(), $shiftEmployeeObj->getLocation()->getLocationId());
$lastReport = "";
return new JsonResponse(array('status' => 'success', 'last_report' => $lastReport));
}
}
}
return new JsonResponse(array('status' => 'error', 'No se puede generar la alerta en este momento'));
}
/**
* @Route("/check_user", name="ws_index", methods={"GET", "POST", "OPTIONS"})
*/
public function checkUserAction(Request $request, EntityManagerInterface $entityManager): Response
{
$paths = $this->getProjectPaths();
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$user = $data->user;
$pwd = $data->pwd;
$token = $data->token;
$em = $this->getDoctrine()->getManager();
$user = $em->getRepository(User::class)->findOneBy(array(
"email" => $user,
'status' => 'ACTIVO',
'UserRole' => ['1','3']
));
if($user)
{
if($this->checkCredentials($pwd, $user))
{
$data = [
'id' => $user->getId(),
'name' => $user->getFirstName()." ".$user->getLastName(),
'first_name' => $user->getFirstName(),
'last_name' => $user->getLastName(),
'email' => $user->getEmail(),
'role_id' => $user->getUserRole()->getId(),
'token' => md5($user->getId()),
];
$user->setToken($token);
$em->persist($user);
$em->flush();
return new JsonResponse(array('status' => 'success', 'data' => $data ));
} else {
return new JsonResponse(array('status' => 'invalid'));
}
} else {
return new JsonResponse(array('status' => 'invalid'));
}
} else {
return new JsonResponse(array('status' => 'error'));
}
}
/**
* @Route("/app-push/send", name="ws_app_push_send", methods={"GET", "POST"})
*/
public function appPushSend( Request $request, EntityManagerInterface $entityManager): Response
{
//TODOS
//https://dev2.datoscontinuos.net/1618/symfony5/bts_interno/public/index.php/ws/app-push/send?content=Prueba&key=8er9euj2tYigKq12iiMBRIXAOpl8Ok&type=1&sendType=1
//Usuario
//https://dev2.datoscontinuos.net/1618/symfony5/bts_interno/public/ws/app-push/send?content=Prueba&key=8er9euj2tYigKq12iiMBRIXAOpl8Ok&type=1&to=2&id=231
$apiKey = $request->get('key');
$content = $request->get('content');
//1 = Alerta, 2 = Info
$type = $request->get('type');
if($type == 1 || $type == 2)
{
//1 = Todos, 2 = Usuario
$sendType = $request->get('to');
if($sendType == 1 || $sendType == 2)
{
$pushKeyObj = $entityManager->getRepository(PushKey::class)->findOneBy([
'api_key' => $apiKey
]);
if($pushKeyObj)
{
if($type == 1)
{
$type = 'Alerta';
} else {
$type = 'Info';
}
if(strlen($content) == 0)
{
return new JsonResponse(array('status' => 'error', 'message' => 'Content is required'));
}
$pushObj = new Push();
$pushObj->setPushKey($pushKeyObj);
$pushObj->setPushType($type);
if($sendType == 1)
{
$pushObj->setSendType('Todos');
} else {
$pushObj->setSendType('Usuario');
//ID solo es requerido si TO, aca viene el user_id
$userId = $request->get('id');
$userObj = $entityManager->getRepository(User::class)->findOneBy([
'id' => $userId
]);
$pushObj->setUser($userObj);
}
$pushObj->setTextContent($content);
$pushObj->setIsActive(1);
$pushObj->setIsFired(0);
$pushObj->setCreatedAt(new \DateTime());
$entityManager->persist($pushObj);
$entityManager->flush();
//---
if($pushObj->getSendType() == 'Todos')
{
$userRepository = $entityManager->getRepository(\App\Entity\User::class);
$queryBuilder = $userRepository->createQueryBuilder('u')->where('u.token IS NOT NULL');
$users = $queryBuilder->getQuery()->getResult();
foreach($users as $value)
{
$pushUser = new \App\Entity\PushUser();
$pushUser->setUser($value);
$pushUser->setPush($pushObj);
$pushUser->setIsFired(0);
$pushUser->setCreatedAt(new \DateTime());
$entityManager->persist($pushUser);
}
}
if($pushObj->getSendType() == 'Usuario')
{
$userSelected = $entityManager->getRepository(\App\Entity\User::class)->findOneBy(['id' => $pushObj->getUser()->getId()]);
if(strlen($userSelected->getToken())>0)
{
$pushUser = new \App\Entity\PushUser();
$pushUser->setUser($userSelected);
$pushUser->setPush($pushObj);
$pushUser->setIsFired(0);
$pushUser->setCreatedAt(new \DateTime());
$entityManager->persist($pushUser);
} else {
return new JsonResponse(array('status' => 'error', 'message' => 'This user does not have a delivery token'));
}
}
$entityManager->flush();
return new JsonResponse(array('status' => 'success', 'message' => $pushObj->getPushId()));
}
}
}
return new JsonResponse(array('status' => 'error', 'message' => 'Invalid API Key or parameters'));
}
/**
* @Route("/playground", name="ws_playground", methods={"GET", "POST"})
*/
public function playground( Request $request, EntityManagerInterface $entityManager): Response
{
$locationObj = $entityManager->getRepository(Location::class)->findOneBy([
'locationId' => 1
]);
$array = json_decode($locationObj->getPolygonList());
$polygonList = [];
foreach($array->coordinates[0] as $item)
{
$polygonList[] = ['lat' => $item[1], 'lng' => $item[0]];
}
//$fenceArea = json_encode($polygonList);
$point = ['lat' => 14.509689173106889, 'lng' => -90.57686018592483];
$res = $this->isInsidePolygon($point, $polygonList);
return new JsonResponse(array('result' => $res));
}
public function isInsidePolygon($point, $fenceArea)
{
$x = $point['lat']; $y = $point['lng'];
$inside = false;
for ($i = 0, $j = count($fenceArea) - 1; $i < count($fenceArea); $j = $i++) {
$xi = $fenceArea[$i]['lat']; $yi = $fenceArea[$i]['lng'];
$xj = $fenceArea[$j]['lat']; $yj = $fenceArea[$j]['lng'];
$intersect = (($yi > $y) != ($yj > $y))
&& ($x < ($xj - $xi) * ($y - $yi) / ($yj - $yi) + $xi);
if ($intersect) $inside = !$inside;
}
return $inside;
}
/**
* @Route("/get-terms", name="get-terms", methods={"GET", "POST"})
*/
public function getTerms(Request $request, EntityManagerInterface $entityManager): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$helpObj = $entityManager->getRepository(Help::class)->findOneBy([
'helpId' => 1
]);
if($helpObj)
{
return new JsonResponse(array('status' => 'success', 'content' => $helpObj->getContent(), 'name' => $helpObj->getName()));
}
}
return new JsonResponse(array('status' => 'error'));
}
/* DE ACA PARA ABAJO NO CREO QUE SE USE */
/**
* @Route("/sendCommand", name="ws_send_command", methods={"GET", "POST"})
*/
public function sendCommand( Request $request, EntityManagerInterface $entityManager, SmsHistory $smsHistory): Response
{
$array_test = array("to"=>"345901013148857", "message" => "(P02)") ;
$postdata = json_encode($array_test);
$url = "https://aithera.api-01.dev.pentcloud.com/api/v1/sms";
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $postdata);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));
$result = curl_exec($ch);
curl_close($ch);
print_r ($result);
$result_arr = json_decode($result);
/*print_r($result_arr);
exit;*/
return $result_arr;
}
/**
* @Route("/getMessagesCommand", name="ws_get_messages_command", methods={"GET", "POST"})
*/
public function getMessagesCommand( Request $request, EntityManagerInterface $entityManager, SmsHistoryRepository $smsHistoryRepository , SmsStatusRepository $smsStatusRepository): Response
{
$array_test = array("to"=>"345901013148857", "message" => "(P02)") ;
$postdata = json_encode($array_test);
$phones = array();
$smsStatusUpdate = $smsStatusRepository->findOneBySmsStatusId(2);
$smsStatus = $smsStatusRepository->findOneBy( ['smsStatusId'=> '1'] );
$smsHistory = $smsHistoryRepository->findBy( ['SmsStatus' => $smsStatus, 'is_active' => '1'] , ["created_at" => "asc"]);
$first_date = "";
foreach($smsHistory as $info){
if(strlen($first_date) <= 0){
$first_date = $info->getCreatedAt()->format("d-m-Y");
}
$phones[$info->getPhone()][$info->getSmsHistoryId()]["sms"] = $info->getSms();
$phones[$info->getPhone()][$info->getSmsHistoryId()]["petition_response"] = $info->getPetitionResponse();
$phones[$info->getPhone()][$info->getSmsHistoryId()]["created_at"] = $info->getCreatedAt()->format("d-m-Y");
}
foreach($phones as $phone => $info2 ){
$url = "https://aithera.api-01.dev.pentcloud.com/api/v1/sms/".$phone;
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$result = curl_exec($ch);
curl_close($ch);
$result_arr = json_decode($result);
$compare = array();
foreach($result_arr as $info3){
$compare[$info3->timestamp][$info3->from] = $info3;
}
foreach($info2 as $smsHistoryId => $details){
$petition_arr = json_decode($details["petition_response"]);
if(isset($petition_arr->response->timestamp)) {
$timeStamp = $petition_arr->response->timestamp;
if(isset($compare[$timeStamp][$petition_arr->phone] ) ){
$response_encode = json_encode($compare[$timeStamp][$petition_arr->phone]);
$smsHistoryUpdate = $smsHistoryRepository->findOneBy( ['smsHistoryId'=> $smsHistoryId] );
$smsHistoryUpdate->setResponse($response_encode);
$smsHistoryUpdate->setUpdatedAt( new \Datetime() );
$smsHistoryUpdate->setSmsStatus( $smsStatusUpdate );
$entityManager->persist($smsHistoryUpdate);
$entityManager->flush();
echo " ";
}else{
echo "no esta seteado el valor";
}
}else{
}
}
}
exit;
}
/**
* @Route("/getAllMessagesCommand", name="ws_get_all_messages_command", methods={"GET", "POST"})
*/
public function getAllMessagesCommand( Request $request, EntityManagerInterface $entityManager, SmsHistoryRepository $smsHistoryRepository , SmsStatusRepository $smsStatusRepository): Response
{
$phone = "345901013149211";
$url = "https://aithera.api-01.dev.pentcloud.com/api/v1/sms/".$phone;
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$result = curl_exec($ch);
curl_close($ch);
$result_arr = json_decode($result);
var_dump($result_arr);
exit;
}
/**
* @Route("/supervisor-agent-inventory-server-values", name="supervisor-agent-inventory-server-values", methods={"GET", "POST"})
*/
public function supervisorInventoryAgentServerValues(Request $request, EntityManagerInterface $entityManager, HelperService $helperService): Response
{
$data = json_decode(file_get_contents("php://input"));
if($data)
{
$employeeId = $data->employee_id;
$employee = $entityManager->getRepository(Employee::class)->findOneBy([
'employeeId' => $employeeId
]);
$idEstadoDeFuerza = $employee->getAlias();
$inventory_weapon = $helperService->externalDb_getWeaponAssignInfo($idEstadoDeFuerza);
$data = [
'inventory_weapon' => $inventory_weapon,
'inventory_phone' => '',
'inventory_radio' => ''
];
return new JsonResponse(array('status' => 'success', 'data' => $data));
}
return new JsonResponse(array('status' => 'error'));
}
}

src/Controller/Webservice/WebserviceController.php line 621