487 lines
24 KiB
PHP
Executable File
487 lines
24 KiB
PHP
Executable File
<?php
|
|
|
|
namespace App\Http\Controllers;
|
|
|
|
use App\Models\ConstructionWorkstation;
|
|
use App\Models\ControlEquipmentWorkstation;
|
|
use App\Models\ElementalTasks;
|
|
use App\Models\Equipment;
|
|
use App\Models\EquipmentWorkHistory;
|
|
use App\Models\OrderEquipmentTasks;
|
|
use App\Models\workstationsTaskAnswers;
|
|
|
|
use Illuminate\Http\Request;
|
|
use Illuminate\Support\Facades\Auth;
|
|
use Illuminate\Support\Facades\DB;
|
|
|
|
|
|
class WorkstationsJobsController extends Controller
|
|
{
|
|
|
|
// public function reloadWsPage(Request $request, $controlEquipmentId)
|
|
// {
|
|
// $active = $request->input('active', false);
|
|
// if (!$active) {
|
|
// // Se o 'active' for false, isso significa que o usuário saiu da página
|
|
// // e você deve fazer a limpeza necessária.
|
|
// $receiveDataControlEquipment = ControlEquipmentWorkstation::find($controlEquipmentId);
|
|
// if ($receiveDataControlEquipment) {
|
|
// $receiveDataControlEquipment->delete();
|
|
// }
|
|
// } else {
|
|
// // Se o 'active' for true, atualize o timestamp para refletir que o usuário ainda está ativo.
|
|
// ControlEquipmentWorkstation::where('control_equipment_workstation_id', $controlEquipmentId)
|
|
// ->update(['last_active_at' => now()]);
|
|
// }
|
|
// return response()->json(['success' => true]);
|
|
// }
|
|
|
|
// public function reloadWsPage(Request $request, $controlEquipmentId)
|
|
// {
|
|
// dd($controlEquipmentId);
|
|
// // Aqui você pode implementar a lógica para atualizar ou excluir o registro
|
|
// $receiveDataControlEquipment = ControlEquipmentWorkstation::find($controlEquipmentId);
|
|
// if($receiveDataControlEquipment){
|
|
// $receiveDataControlEquipment->delete();
|
|
// }
|
|
// return response()->json(['success' => true]);
|
|
// }
|
|
|
|
// public function reloadWsPage(Request $request, $controlEquipmentId)
|
|
// {
|
|
// // Ao buscar o id da control vamos desassociar a Ws atual com a linha de dados da control atual, sendo assim ele ficara disponivel para os outros metados,
|
|
// $receiveDataControlEquipment = ControlEquipmentWorkstation::find($controlEquipmentId);
|
|
// if ($receiveDataControlEquipment) {
|
|
// $receiveDataControlEquipment->id_workstations = null;
|
|
// $receiveDataControlEquipment->save();
|
|
// }
|
|
|
|
// // Não precisa retornar uma resposta detalhada pois sendBeacon não manipula respostas
|
|
// return response()->json(['success' => true]);
|
|
// }
|
|
|
|
|
|
// public function updateWorkstationStatus(Request $request)
|
|
// {
|
|
// $controlEquipmentId = $request->id;
|
|
// $status = $request->status;
|
|
|
|
// $controlEquipment = ControlEquipmentWorkstation::find($controlEquipmentId);
|
|
// if ($controlEquipment) {
|
|
// $controlEquipment->status = $status;
|
|
// $controlEquipment->save();
|
|
// }
|
|
|
|
// return response()->json(['success' => true]);
|
|
// }
|
|
|
|
// public function closeWorkstationSession(Request $request)
|
|
// { dd($request);
|
|
// $controlEquipmentId = $request->id;
|
|
|
|
// $controlEquipment = ControlEquipmentWorkstation::find($controlEquipmentId);
|
|
// if ($controlEquipment) {
|
|
// $controlEquipment->delete(); // Ou defina status como inativo, conforme a lógica do negócio.
|
|
// }
|
|
|
|
// return response()->json(['success' => true]);
|
|
// }
|
|
public function updateSessionStatus(Request $request, $controlEquipmentId)
|
|
{
|
|
|
|
$controlEquipment = ControlEquipmentWorkstation::find($controlEquipmentId);
|
|
if ($controlEquipment) {
|
|
$controlEquipment->status = $request->input('status', 1); // Assume 1 como padrão para sessão ativa
|
|
$controlEquipment->last_active_at = now(); // Atualiza o timestamp da última atividade
|
|
$controlEquipment->save();
|
|
|
|
return response()->json(['success' => true, 'message' => 'Sessão atualizada com sucesso.']);
|
|
}
|
|
|
|
return response()->json(['success' => false, 'message' => 'Equipamento não encontrado.']);
|
|
}
|
|
|
|
// public function closeSession(Request $request, $controlEquipmentId)
|
|
// {
|
|
// $controlEquipment = ControlEquipmentWorkstation::find($controlEquipmentId);
|
|
// if ($controlEquipment) {
|
|
// $controlEquipment->status = 0; // Marca a sessão como inativa
|
|
// $controlEquipment->save();
|
|
|
|
// return response()->json(['success' => true, 'message' => 'Sessão fechada com sucesso.']);
|
|
// }
|
|
|
|
// return response()->json(['success' => false, 'message' => 'Equipamento não encontrado.']);
|
|
// }
|
|
|
|
public function receiveAnswersEquipment(Request $request, $control_equipment_workstation_id)
|
|
{
|
|
//No request recebemos ID(NUmero da tarela elementar) , esta variavel vai receber este ID apos selerar o id da string
|
|
$elementalTaskID = 0;
|
|
|
|
// Deve receber o id da control atual.
|
|
$requestData = $request->all();
|
|
|
|
foreach ($requestData as $key => $value) {
|
|
// Verifica se a chave começa com 'ID'
|
|
if (preg_match('/ID(\d+)/', $key, $matches)) {
|
|
// $matches[1] conterá o número após 'ID'
|
|
$elementalTaskID = intval($matches[1]);
|
|
break; // Sai do loop após encontrar o primeiro match
|
|
}
|
|
}
|
|
|
|
//Ele deve criar a associação entre id atual do control + perguntas e respostas
|
|
$receiveAnswersElementalTasks = new workstationsTaskAnswers;
|
|
$receiveAnswersElementalTasks->control_equipment_workstation_id = $control_equipment_workstation_id;
|
|
|
|
// Inicializando o array que vai armazenar os objetos JSON
|
|
$answersArray = []; // Array para armazenar as respostas
|
|
|
|
// Iterar sobre o array externo
|
|
foreach ($request->all() as $idKey => $subArray) {
|
|
// Verificar se a chave atual é uma das chaves de ID (ID1, ID2, etc.)
|
|
if (strpos($idKey, 'ID') === 0 && is_array($subArray)) {
|
|
// Iterar sobre o array interno
|
|
foreach ($subArray as $key => $value) {
|
|
// Ignorando a chave control_equipment_workstation_id
|
|
if ($key !== 'controlEquipmentID') {
|
|
// Verificando se $key contém '-'
|
|
if (strpos($key, '-') !== false) {
|
|
// Dividindo a chave em duas partes: question e type
|
|
list($question, $type) = explode('-', $key);
|
|
|
|
// Adicionando um novo objeto JSON ao array
|
|
$answersArray[] = [
|
|
'type' => $type,
|
|
'value' => $value,
|
|
'question' => $question,
|
|
'idKey' => $idKey // Adicionando a chave do ID se necessário
|
|
];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Convertendo o array em uma string JSON
|
|
$jsonString = json_encode($answersArray);
|
|
|
|
// Armazenando a string JSON no banco de dados
|
|
$receiveAnswersElementalTasks->answer_json = $jsonString;
|
|
|
|
// Busca a Ws com base no id recebido da tabela Control.
|
|
$recebeDataControlWs = ControlEquipmentWorkstation::find($control_equipment_workstation_id);
|
|
$recebeDataControlWs->elemental_tasks_id = $elementalTaskID;
|
|
$recebeDataControlWs->departure_date = now();
|
|
|
|
$requestData = $request->all();
|
|
|
|
// Iterar sobre o array de parâmetros do request
|
|
foreach ($requestData as $key => $value) {
|
|
if (preg_match('/^ID(\d+)$/', $key, $matches)) {
|
|
// $matches[1] contém o número após 'ID'
|
|
$idNumber = $matches[1];
|
|
// Atribuir o número extraído diretamente ao elemental_tasks_id
|
|
$recebeDataControlWs->elemental_tasks_id = $idNumber;
|
|
break; // Se você só espera um ID, pare o loop depois de encontrar
|
|
}
|
|
}
|
|
|
|
// Primeiro adicionamos a tarefa que acabou de completar, em seguida salvamos a respostas recebidas.
|
|
$recebeDataControlWs->save();
|
|
$receiveAnswersElementalTasks->save();
|
|
|
|
// Agora que guardamos os dados anteriores, vamos criar a nova linha na tabela Control Equipment ID para que o equipamento continue
|
|
// $newControlEquipment = new ControlEquipmentWorkstation;
|
|
// $newControlEquipment->equipmentWorkHistorys_id = $recebeDataControlWs->equipmentWorkHistorys_id;
|
|
// $newControlEquipment->id_workstations = $recebeDataControlWs->id_workstations;
|
|
// $newControlEquipment->entry_date = now();
|
|
// $newControlEquipment->save();
|
|
|
|
// Vamos buscar os dados da tarefa elementar comcluida para mandar uma mensagem ao Front e indicar que esta completada
|
|
$receiveDataElementalTask = ElementalTasks::find($recebeDataControlWs->elemental_tasks_id, 'elemental_tasks_id')->first();
|
|
|
|
return back()->with('success', 'Tarefa :: ' . $receiveDataElementalTask->elemental_tasks_code . '-' . $receiveDataElementalTask->elemental_tasks_code . ' Concluída com sucesso!');
|
|
|
|
// return route('getEquipmentData', $recebeDataControlWs->equipment_id);
|
|
|
|
}
|
|
|
|
// Ao selecionar o equipamento para se inicializar a tarefa deve mostrar os dados relacionados.
|
|
public function getEquipmentData($equipment_id, $component_tag)
|
|
{
|
|
//vai receber o email atual, no caso o da workstation que se encontra
|
|
$userEmail = Auth::user();
|
|
|
|
// Busca os dados da Ws com base no Login
|
|
$receiveDataWs = ConstructionWorkstation::where('name_workstations', $userEmail->user_name)->first();
|
|
|
|
|
|
// Recebe os dados do Equipamento
|
|
$receiveDataEquipment = Equipment::where('equipment_id', $equipment_id)->first();
|
|
|
|
// Recebe o id do Historico do equipamento, em sua obra atual
|
|
$receiveEquipmentWorkHistory = EquipmentWorkHistory::where('equipment_id', $receiveDataEquipment->equipment_id)
|
|
->where('company_projects_id', $receiveDataEquipment->company_projects_id)
|
|
->first();
|
|
|
|
|
|
|
|
//Verificar se o equipamento ja esta sendo utilizado em outra Ws se sim, retorna para a pagina anterior.
|
|
$equipmentInUse = ControlEquipmentWorkstation::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_id)
|
|
->whereNull('departure_date')
|
|
->whereNotNull('id_workstations')
|
|
->where('id_workstations', '!=', $receiveDataWs->id_workstations)
|
|
->where('status', 1)
|
|
->exists();
|
|
|
|
// Se o equipamento já estiver em uso, redirecione com uma mensagem de erro
|
|
if ($equipmentInUse) {
|
|
return redirect()->back()->with('danger', 'O equipamento já se encontra a executar tarefas noutro posto de trabalho.');
|
|
}
|
|
|
|
// Recebe todas as tarefas elementares do equipamento.
|
|
$recebeTasksForEquipment = OrderEquipmentTasks::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_id)->get();
|
|
|
|
|
|
//Busca as tarefas que podem ser feitas pela WS Atual a partir do Email
|
|
$userTasks = DB::table('users as u')
|
|
->join('construction_workstations as cw', 'u.user_name', '=', 'cw.name_workstations')
|
|
->join('workstations_association_tasks as wat', 'cw.id_workstations', '=', 'wat.id_workstations')
|
|
->where('u.email', $userEmail->email)
|
|
->select('cw.id_workstations', 'cw.name_workstations', DB::raw('GROUP_CONCAT(COALESCE(wat.elemental_tasks_id, wat.further_tasks_id)) AS all_tasks'))
|
|
->groupBy('cw.id_workstations', 'cw.name_workstations')
|
|
->get();
|
|
|
|
// Primeiro, obtenha todos os IDs de tarefas elementares e outras tarefas de $userTasks
|
|
$userTasksIds = $userTasks->pluck('all_tasks')->map(function ($tasks) {
|
|
// Transforma a string 'all_tasks' em um array e remove espaços em branco
|
|
return array_map('trim', explode(',', $tasks));
|
|
})->flatten()->unique();
|
|
|
|
// Em seguida, obtenha todos os IDs de tarefas elementares de $recebeTasksForEquipment
|
|
$equipmentTasksIds = $recebeTasksForEquipment->pluck('elemental_tasks_id')->filter()->unique();
|
|
|
|
// Agora, compare os dois conjuntos de IDs para encontrar os IDs comuns
|
|
$comparisonBetweenBothTasks = $equipmentTasksIds->intersect($userTasksIds);
|
|
|
|
//recebe as tarefas que a Ws atual pode fazer.
|
|
$divisionElementalTasks = [
|
|
1 => $comparisonBetweenBothTasks->all(),
|
|
];
|
|
|
|
// IDs que estão em $recebeTasksForEquipment mas não em $userTasks ou seja sao os ids que a Ws nao pode executar estas tarefas.
|
|
$receiveTasksThatCannotBeDone = $equipmentTasksIds->diff($userTasksIds);
|
|
// Adicione esses IDs únicos ao array $divisionElementalTasks na chave [2]
|
|
$divisionElementalTasks[2] = $receiveTasksThatCannotBeDone->all();
|
|
|
|
|
|
//Aplica 2 condicoes a variavel a primeira e se os 3 campos forem nulos e a segunda e se a id_workstations nao for null e tiver o valor igual ao da sessao atual,
|
|
$existingDataControlEquipment = ControlEquipmentWorkstation::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_id)
|
|
->where(function ($query) use ($receiveDataWs) {
|
|
$query->where(function ($q) {
|
|
$q->whereNull('elemental_tasks_id')
|
|
->whereNull('departure_date')
|
|
->whereNull('id_workstations');
|
|
})->orWhere(function ($q) use ($receiveDataWs) {
|
|
$q->whereNotNull('id_workstations')
|
|
->where('id_workstations', $receiveDataWs->id_workstations)
|
|
->whereNull('departure_date');
|
|
});
|
|
})
|
|
->first();
|
|
|
|
|
|
if ($existingDataControlEquipment) {
|
|
// Registro existente encontrado, atualize conforme necessário
|
|
if (strpos($component_tag, '@Obturador') !== false) {
|
|
$existingDataControlEquipment->elemental_tasks_id = 9;
|
|
}
|
|
$existingDataControlEquipment->id_workstations = $receiveDataWs->id_workstations;
|
|
$existingDataControlEquipment->entry_date = now();
|
|
$existingDataControlEquipment->status = 1;
|
|
$existingDataControlEquipment->last_active_at = now();
|
|
|
|
$existingDataControlEquipment->save();
|
|
|
|
$receiveDataControlEquipment = $existingDataControlEquipment;
|
|
} else {
|
|
// Nenhum registro existente encontrado, crie um novo
|
|
$newDataControlEquipment = new ControlEquipmentWorkstation;
|
|
$newDataControlEquipment->equipmentWorkHistorys_id = $receiveEquipmentWorkHistory->equipmentWorkHistorys_id;
|
|
$newDataControlEquipment->id_workstations = $receiveDataWs->id_workstations;
|
|
$newDataControlEquipment->entry_date = now();
|
|
|
|
if (strpos($component_tag, '@Obturador') !== false) {
|
|
$newDataControlEquipment->elemental_tasks_id = 9;
|
|
}
|
|
|
|
$newDataControlEquipment->status = 1;
|
|
$newDataControlEquipment->save();
|
|
|
|
$receiveDataControlEquipment = $newDataControlEquipment;
|
|
}
|
|
|
|
|
|
// Primeiro, obtenha o registro de ControlEquipmentWorkstation que não deve ter 'elemental_tasks_id' e 'departure_date' como null
|
|
$completedTasks = ControlEquipmentWorkstation::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_id)
|
|
->whereNotNull('elemental_tasks_id')
|
|
->whereNotNull('departure_date')
|
|
->pluck('elemental_tasks_id')->toArray(); // Supondo que você quer apenas os IDs das tarefas
|
|
|
|
//Agora, verifique se algum desses IDs está em $divisionElementalTasks[1] e mova para $divisionElementalTasks[3]
|
|
//O id que for movido para o [3] sua inica condicao sera quando o 'entry_date' e 'departure_date' forem diferentes de null, assim indica ser uma tarefa Finalizada.
|
|
foreach ($completedTasks as $completedTaskId) {
|
|
if (in_array($completedTaskId, $divisionElementalTasks[1])) {
|
|
// Encontre a chave do valor correspondente em [1]
|
|
$key = array_search($completedTaskId, $divisionElementalTasks[1]);
|
|
// Mova a tarefa de [1] para [3]
|
|
$divisionElementalTasks[3][$key] = $completedTaskId;
|
|
// Remova a tarefa de [1]
|
|
unset($divisionElementalTasks[1][$key]);
|
|
}
|
|
}
|
|
|
|
$recebeTasksForEquipment->map(function ($task) use ($divisionElementalTasks) {
|
|
// Verifica se o id da tarefa está no array de tarefas que podem ser feitas
|
|
if (in_array($task->elemental_tasks_id, $divisionElementalTasks[1])) {
|
|
$task->cardType = 'card-primary';
|
|
$task->cardTypeStyle = 'blue'; // Define o estilo de cor
|
|
|
|
}
|
|
// Verifica se o id da tarefa está no array de tarefas que não podem ser feitas
|
|
elseif (in_array($task->elemental_tasks_id, $divisionElementalTasks[2])) {
|
|
$task->cardType = 'card-primary';
|
|
$task->cardTypeStyle = 'gray'; // Define o estilo de cor
|
|
// Consulta ControlEquipmentWorkstation para verificar as condições especificadas
|
|
$controlEquipment = ControlEquipmentWorkstation::where('elemental_tasks_id', $task->elemental_tasks_id)
|
|
->whereNotNull('entry_date')
|
|
->whereNotNull('departure_date')
|
|
->first();
|
|
|
|
if ($controlEquipment) {
|
|
// Se encontrar, atribuir control_equipment_workstation_id
|
|
$task->control_equipment_workstation_id = $controlEquipment->control_equipment_workstation_id;
|
|
|
|
//buscar dados na model workstationsTaskAnswers
|
|
$workstationTaskAnswer = WorkstationsTaskAnswers::where('control_equipment_workstation_id', $task->control_equipment_workstation_id)
|
|
->first();
|
|
|
|
if ($workstationTaskAnswer) {
|
|
// Decodifica o JSON para um array
|
|
$answersArray = json_decode($workstationTaskAnswer->answer_json, true);
|
|
|
|
// Cria um array associativo onde as chaves são as perguntas e os valores são as respostas
|
|
$formattedAnswers = [];
|
|
foreach ($answersArray as $item) {
|
|
$formattedAnswers[$item['question']] = $item['value'];
|
|
}
|
|
|
|
// Atribui o array formatado ao task
|
|
$task->formatted_answers = $formattedAnswers;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Verifica se o id da tarefa está no array de tarefas já feitas
|
|
elseif (in_array($task->elemental_tasks_id, $divisionElementalTasks[3])) {
|
|
$task->cardType = 'card-info';
|
|
$task->cardTypeStyle = 'green'; // Define o estilo de cor
|
|
|
|
// Consulta ControlEquipmentWorkstation para verificar as condições especificadas
|
|
$controlEquipment = ControlEquipmentWorkstation::where('equipmentWorkHistorys_id', $task->equipmentWorkHistorys_id)
|
|
->where('elemental_tasks_id', $task->elemental_tasks_id)
|
|
->whereNotNull('entry_date')
|
|
->whereNotNull('departure_date')
|
|
->first();
|
|
|
|
if ($controlEquipment) {
|
|
// Se encontrar, atribuir control_equipment_workstation_id
|
|
$task->control_equipment_workstation_id = $controlEquipment->control_equipment_workstation_id;
|
|
|
|
//buscar dados na model workstationsTaskAnswers
|
|
$workstationTaskAnswer = WorkstationsTaskAnswers::where('control_equipment_workstation_id', $task->control_equipment_workstation_id)
|
|
->first();
|
|
|
|
if ($workstationTaskAnswer) {
|
|
// Decodifica o JSON para um array
|
|
$answersArray = json_decode($workstationTaskAnswer->answer_json, true);
|
|
|
|
// Cria um array associativo onde as chaves são as perguntas e os valores são as respostas
|
|
$formattedAnswers = [];
|
|
foreach ($answersArray as $item) {
|
|
$formattedAnswers[$item['question']] = $item['value'];
|
|
}
|
|
|
|
// Atribui o array formatado ao task
|
|
$task->formatted_answers = $formattedAnswers;
|
|
}
|
|
}
|
|
}
|
|
return $task;
|
|
});
|
|
|
|
|
|
// Verificar se component_tag contém '@Obturador'
|
|
if (strpos($component_tag, '@Obturador') !== false) {
|
|
// Filtrar para manter apenas a tarefa : elemental_tasks_id = 9 (Retificação e lapidação)
|
|
$recebeTasksForEquipment = $recebeTasksForEquipment->filter(function ($task) {
|
|
return $task->elemental_tasks_id == 9;
|
|
});
|
|
} else {
|
|
//Se a Tag nao contém '@Obturador' significa que e um '@Corpo' sendo assim vai ser organizado o Menor para o maior entre as tarefas de acordo com o elemental_tasks_id
|
|
// Alem de remover o 'elemental_tasks_id == 9' das tarefas, pois se é o corpo, nao faz sentido fazer a tarefas de (Retificação e lapidação), sendo assim para realizar esta tarefa so se entrar com a 'TAG de Obturador'.
|
|
$recebeTasksForEquipment = $recebeTasksForEquipment->reject(function ($task) {
|
|
return $task->elemental_tasks_id == 9;
|
|
})->sortBy('elemental_tasks_id');
|
|
|
|
// Se desejar aplicar a ordenação de forma geral, independente da condição
|
|
$recebeTasksForEquipment = $recebeTasksForEquipment->sortBy('elemental_tasks_id');
|
|
}
|
|
|
|
dd($receiveDataControlEquipment);
|
|
|
|
return view('workstations.workstations', [
|
|
// Deve receber o atual COntrol ID ? tudo a vez que atualizar ??
|
|
'dataControlEquipment' => $receiveDataControlEquipment,
|
|
'receiveDataEquipment' => $receiveDataEquipment,
|
|
'recebeTasksForEquipment' => $recebeTasksForEquipment,
|
|
'receiveComponentTag' => $component_tag
|
|
// 'divisionElementalTasks' => $divisionElementalTasks,
|
|
]);
|
|
}
|
|
|
|
|
|
public function cancelElementalTaskForEquipment($equipmentID,)
|
|
{
|
|
//Nesta funcao se o utilizador da Ws utilizar o botao cancelar na view principal,o equipamento deve se desvincular na Ws atual e poder ser selecionado por outra.
|
|
// Assim sendo mais pratico excluindo o ultimo dado desta Ws da tabela control_equipment_workstation, quando seu 'elemental_tasks_id' e 'departure_date' forem 'Null'
|
|
$receiveDataEquipment = Equipment::where('equipment_id', $equipmentID)->first();
|
|
|
|
// Recebe o id do Historico do equipamento, em sua obra atual
|
|
$receiveEquipmentWorkHistory = EquipmentWorkHistory::where('equipment_id', $receiveDataEquipment->equipment_id)
|
|
->where('company_projects_id', $receiveDataEquipment->company_projects_id)
|
|
->first();
|
|
|
|
$existingControlEquipment = ControlEquipmentWorkstation::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_id)
|
|
->whereNull('elemental_tasks_id')
|
|
->whereNull('departure_date')
|
|
->first();
|
|
|
|
if ($existingControlEquipment) {
|
|
$existingControlEquipment->id_workstations = null;
|
|
$existingControlEquipment->elemental_tasks_id = null;
|
|
$existingControlEquipment->status = 0;
|
|
$existingControlEquipment->entry_date = null;
|
|
$existingControlEquipment->last_active_at = null;
|
|
$existingControlEquipment->save();
|
|
}
|
|
|
|
|
|
return redirect(route('enterWorkstation'));
|
|
}
|
|
}
|