1829 lines
87 KiB
PHP
Executable File
1829 lines
87 KiB
PHP
Executable File
<?php
|
|
|
|
namespace App\Http\Controllers;
|
|
|
|
use App\Models\AssociationCompanyUser;
|
|
use App\Models\Company;
|
|
use App\Models\EquipmentWorkHistory;
|
|
use App\Models\ProjectExcelLog;
|
|
use Illuminate\Http\Request;
|
|
use Illuminate\Support\Facades\DB;
|
|
use PhpOffice\PhpSpreadsheet\IOFactory;
|
|
|
|
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
|
|
use Symfony\Component\HttpFoundation\StreamedResponse;
|
|
|
|
|
|
use App\Models\User;
|
|
use App\Models\CompanyProject;
|
|
use App\Models\Unit;
|
|
use App\Models\EquipmentType;
|
|
use App\Models\Equipment;
|
|
use App\Models\Plant;
|
|
use App\Models\SpecificAttributesEquipmentType;
|
|
use App\Models\GeneralAttributesEquipment;
|
|
use App\Models\PendingEquipment;
|
|
use App\Models\AmbitsEquipment;
|
|
use App\Models\EquipmentAssociationAmbit;
|
|
use App\Models\ConstructionWorkstation;
|
|
use App\Models\ElementalTasks;
|
|
use App\Models\OrderEquipmentTasks;
|
|
use App\Models\FurtherTasks;
|
|
use App\Models\WorkstationsAssociationTasks;
|
|
use App\Models\TasksAssociationAmbits;
|
|
use App\Models\QrcodesAssociatedEquipment;
|
|
|
|
use LengthException;
|
|
|
|
// use DataTables;
|
|
|
|
class CreateProjectController extends Controller
|
|
{
|
|
public function changeStateProject($projectId)
|
|
{
|
|
$detailsPrpject = CompanyProject::where('company_projects_id', $projectId)->first();
|
|
$detailsPrpject->order_project = 3;
|
|
$detailsPrpject->save();
|
|
|
|
// Redireciona para a rota 'home' após alterar o estado para Execussao
|
|
return redirect()->route('home');
|
|
}
|
|
|
|
public function deleteProject($projectId)
|
|
{
|
|
// Encontra o projeto pelo ID
|
|
$deleteProject = CompanyProject::where('company_projects_id', $projectId)->first();
|
|
|
|
if ($deleteProject) {
|
|
// Busca todas as ConstructionWorkstation associadas ao projeto
|
|
$workstations = ConstructionWorkstation::where('company_projects_id', $projectId)->get();
|
|
|
|
foreach ($workstations as $workstation) {
|
|
// Para cada workstation, busca usuários com o mesmo nome
|
|
$user = User::where('user_name', $workstation->name_workstations)->first();
|
|
|
|
if ($user) {
|
|
$user->delete();
|
|
}
|
|
}
|
|
|
|
// Deleta o projeto após processar as workstations
|
|
$deleteProject->delete();
|
|
|
|
// Redireciona para a rota 'home' após a deleção
|
|
return redirect()->route('home');
|
|
}
|
|
|
|
}
|
|
|
|
public function changeAmbitEquipment(Request $request)
|
|
{
|
|
|
|
$receiveAmbitEquipmentId = $request->receveAmbit;
|
|
$equipmentId = $request->equipmentID;
|
|
|
|
$receiveEquipment = Equipment::where('equipment_id', $equipmentId)->first();
|
|
|
|
$receiveEquipmentWorkHistorys = EquipmentWorkHistory::where('equipment_id', $receiveEquipment->equipment_id)
|
|
->where('company_projects_id', $receiveEquipment->company_projects_id)
|
|
->first();
|
|
|
|
$receiveDataEquipmentAssociationAmbit = EquipmentAssociationAmbit::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistorys->equipmentWorkHistorys_id)->first();
|
|
|
|
if ($receiveDataEquipmentAssociationAmbit->ambits_id == $receiveAmbitEquipmentId) {
|
|
return back()->with('danger', 'Âmbito selecionado é igual ao anterior!');
|
|
} else {
|
|
// Deleta as tarefas associadas ao equipamento no âmbito atual
|
|
OrderEquipmentTasks::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistorys->equipmentWorkHistorys_id)->delete();
|
|
|
|
// Atualiza o âmbito do equipamento
|
|
$receiveDataEquipmentAssociationAmbit->ambits_id = $receiveAmbitEquipmentId;
|
|
$receiveDataEquipmentAssociationAmbit->save();
|
|
|
|
// Insere as novas tarefas para o novo âmbito
|
|
$TasksAssociationAmbits = TasksAssociationAmbits::where('ambits_equipment_id', $receiveAmbitEquipmentId)->get();
|
|
$execution_order = 1;
|
|
foreach ($TasksAssociationAmbits as $TasksAssociationAmbit) {
|
|
$JoinsEquipmentsWithTasks = new OrderEquipmentTasks;
|
|
$JoinsEquipmentsWithTasks->equipmentWorkHistorys_id = $receiveEquipmentWorkHistorys->equipmentWorkHistorys_id;
|
|
$JoinsEquipmentsWithTasks->execution_order = $execution_order++;
|
|
$JoinsEquipmentsWithTasks->elemental_tasks_id = $TasksAssociationAmbit->elemental_tasks_id;
|
|
$JoinsEquipmentsWithTasks->inspection = 2; // ou outro valor conforme necessário
|
|
$JoinsEquipmentsWithTasks->save();
|
|
}
|
|
|
|
return back()->with('success', 'Equipamento: ' . $receiveEquipment->equipment_id . ' trocado de âmbito com sucesso!');
|
|
}
|
|
|
|
}
|
|
|
|
public function deleteEquipmentInProject(Request $request)
|
|
{
|
|
$receiveEquipment = Equipment::where('equipment_id', $request->equipmentId)->first();
|
|
$receiveStatus = $request->deleteEquipmentProject;
|
|
|
|
//Independente do tipo de select ele vai deletar o equipamento do Historico
|
|
EquipmentWorkHistory::where('equipment_id', $receiveEquipment->equipment_id)
|
|
->where('company_projects_id', $receiveEquipment->company_projects_id)
|
|
->delete();
|
|
|
|
// Deleta o equipamento por completo e retorna
|
|
if ($receiveStatus == 'complete') {
|
|
$receiveEquipment->delete();
|
|
|
|
return redirect()->back()
|
|
->with('success', 'Equipamento: ' . $receiveEquipment->equipment_id . ' excluído com sucesso!');
|
|
} else {
|
|
// Deleta apaga a associacao do equipamento a Obra
|
|
$receiveEquipment->company_projects_id = null;
|
|
$receiveEquipment->save();
|
|
|
|
return redirect()->back()
|
|
->with('success', 'Equipamento: ' . $receiveEquipment->equipment_id . ' retirado da obra com sucesso!');
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public function deletePendingEquipments(Request $request)
|
|
{
|
|
$pendingEquipmentIds = $request->input('pendingEquipmentIds', []);
|
|
|
|
// Verifica se o array não está vazio
|
|
if (!empty($pendingEquipmentIds)) {
|
|
// Deleta todos os registros de PendingEquipment que correspondam aos IDs
|
|
PendingEquipment::whereIn('pending_equipment_id', $pendingEquipmentIds)->delete();
|
|
}
|
|
|
|
return redirect()->back()
|
|
->with('success', 'Todos os equipamentos pendentes apagados com sucesso!');
|
|
}
|
|
|
|
|
|
public function receiveUnits($numberProject)
|
|
{
|
|
$PlantData = CompanyProject::where('company_projects_id', $numberProject)->first();
|
|
|
|
if (!$PlantData) {
|
|
return response()->json([]);
|
|
}
|
|
|
|
$receiveUnits = Unit::where('plant_id', $PlantData->plant_id)->get();
|
|
|
|
// Formatar a resposta para o formato esperado pelo JavaScript
|
|
$formattedUnits = $receiveUnits->map(function ($unit) {
|
|
return [
|
|
'id' => $unit->receiveUnits, // Ajuste para o nome da sua coluna correta
|
|
'name' => $unit->unit_name // Ajuste para o nome da sua coluna correta
|
|
];
|
|
});
|
|
|
|
return response()->json($formattedUnits);
|
|
}
|
|
|
|
|
|
public function deleteFurtherTasks(Request $request)
|
|
{
|
|
//Se o utilizador click mas nao associar as tarefas.
|
|
$selectedTasks = $request->input('selectedTasks', []);
|
|
|
|
if (empty($selectedTasks)) {
|
|
return back()->with('danger', 'Não existem tarefas complementares selecionadas para exclusão.');
|
|
}
|
|
|
|
$receiveDataEquipment = Equipment::where('equipment_id', $request->equipmentID)->first();
|
|
// Buscar os registros que correspondem ao equipmentID e que têm further_tasks_id nos selectedTasks
|
|
//Nao deve ter mais further_tasks_id, pois agora as further tasks devem ficar nas tarefas elementares
|
|
$detailsEquipmentWorkHistory = EquipmentWorkHistory::where('equipment_id', $request->equipmentID)->first();
|
|
|
|
$tasksToDelete = OrderEquipmentTasks::where('equipmentWorkHistorys_id', $detailsEquipmentWorkHistory->equipmentWorkHistorys_id)
|
|
->whereIn('elemental_tasks_id', $request->selectedTasks)
|
|
->get();
|
|
|
|
// Excluir esses registros
|
|
foreach ($tasksToDelete as $task) {
|
|
$task->delete();
|
|
}
|
|
|
|
// Se o treatmentFurtherTask for "DeleteFurtherTask", exclua os registros da tabela principal FurtherTasks
|
|
if ($request->treatmentFurtherTask == "DeleteFurtherTask") {
|
|
ElementalTasks::whereIn('elemental_tasks_id', $request->selectedTasks)->delete();
|
|
}
|
|
|
|
// Reordenar os registros restantes
|
|
$remainingTasks = OrderEquipmentTasks::where('equipmentWorkHistorys_id', $detailsEquipmentWorkHistory->equipmentWorkHistorys_id)
|
|
->orderBy('execution_order', 'asc')
|
|
->get();
|
|
|
|
$executionOrder = 1;
|
|
foreach ($remainingTasks as $task) {
|
|
$task->execution_order = $executionOrder;
|
|
$task->save();
|
|
$executionOrder++;
|
|
}
|
|
return redirect()->back()->with('success', 'Ordem de execução do equipamento: ' . $receiveDataEquipment->equipment_tag . ' Atulizada!');
|
|
}
|
|
|
|
public function addFurtherTasks(Request $request)
|
|
{
|
|
// Recebe os detalhes do Equipment
|
|
$receiveDataEquipment = Equipment::where('equipment_id', $request->equipmentID)->first();
|
|
|
|
// Recebe os detalhes do EquipmentWorkHistory
|
|
$receiveEquipmentWorkHistory = EquipmentWorkHistory::where('equipment_id', $request->equipmentID)
|
|
->where('company_projects_id', $receiveDataEquipment->company_projects_id)
|
|
->first();
|
|
|
|
//Ordena os valores de OrderEquipmentTasks deste equipamento do Menor para o Maior
|
|
$tasksToReorder = OrderEquipmentTasks::where('equipmentWorkHistorys_id', $receiveEquipmentWorkHistory->equipmentWorkHistorys_id)
|
|
->orderBy('execution_order', 'asc')
|
|
->get();
|
|
|
|
//indica onde vai ficar na nova organizacao das tarefas
|
|
$insertPosition = $request->ArrayListElementsTasks + 1;
|
|
|
|
if ($request->selectedFurtherTaskExisting != 'null') {
|
|
|
|
//Se o $resquest->selectedFurtherTaskExisting nao for null significa que selecionou uma tarefa complementar existente
|
|
//Se for diferente o campo de descricao,, Adicionamos.
|
|
$detailsFutherTaskSelected = ElementalTasks::where('elemental_tasks_id', $request->selectedFurtherTaskExisting)->first();
|
|
$detailsFutherTaskSelected->further_tasks_description = $request->furtherTaskDescription;
|
|
$detailsFutherTaskSelected->save();
|
|
|
|
} else {
|
|
|
|
// Conta o número de registros na ElementalTasks com o company_projects_id especificado
|
|
$count = ElementalTasks::where('company_projects_id', $request->company_projects_id)->count();
|
|
|
|
// Se não existir nenhum registro, define $count como 1
|
|
$count = $count > 0 ? $count : 0;
|
|
|
|
|
|
$maxElementalTaskId = ElementalTasks::max('elemental_tasks_id');
|
|
// Precisa Saber a Obra para ver quantos tarefas Complementares, ja existe para esta Obra
|
|
|
|
// Calcule o valor de further_tasks_name
|
|
$newFurtherTaskName = 'TC' . ($count + 1);
|
|
|
|
|
|
//Cria uma nova Tarefa Complementar
|
|
$newFurtherTask = new ElementalTasks;
|
|
//Ao definir exatamente o numero ao invez de deixar por auto Incremento, quando apagar essas tarefas complementares, ao proximas podem usar o mesmo Id
|
|
$newFurtherTask->elemental_tasks_id = $maxElementalTaskId + 1;
|
|
$newFurtherTask->elemental_tasks_code = $newFurtherTaskName;
|
|
$newFurtherTask->elemental_tasks_description = $request->furtherTask;
|
|
$newFurtherTask->further_tasks_description = $request->furtherTaskDescription;
|
|
$newFurtherTask->company_projects_id = $request->company_projects_id;
|
|
$newFurtherTask->save();
|
|
}
|
|
|
|
|
|
// Incrementar a execution_order das tarefas após a posição de inserção
|
|
foreach ($tasksToReorder as $task) {
|
|
if ($task->execution_order >= $insertPosition) {
|
|
$task->execution_order += 1;
|
|
$task->save();
|
|
}
|
|
}
|
|
|
|
|
|
//Adiciona essa tarefa a Ordem indicada em relação a execussão de tarefa.
|
|
$newOrderEquipmentTask = new OrderEquipmentTasks;
|
|
$newOrderEquipmentTask->equipmentWorkHistorys_id = $receiveEquipmentWorkHistory->equipmentWorkHistorys_id;
|
|
$newOrderEquipmentTask->execution_order = $insertPosition;
|
|
|
|
if ($request->selectedFurtherTaskExisting != 'null') {
|
|
// Se selectedFurtherTaskExisting não for 'null', então usa o ID da tarefa complementar selecionada
|
|
$newOrderEquipmentTask->elemental_tasks_id = $request->selectedFurtherTaskExisting;
|
|
} else {
|
|
// Caso contrário, usa o elemental_tasks_id do $newFurtherTask
|
|
$newOrderEquipmentTask->elemental_tasks_id = $newFurtherTask->elemental_tasks_id;
|
|
}
|
|
|
|
//Inspecionar Ainda não esta sendo utilizado.
|
|
$newOrderEquipmentTask->inspection = 2;
|
|
$newOrderEquipmentTask->save();
|
|
|
|
return redirect()->back()->with('success', 'Ordem de execução do equipamento: ' . $receiveDataEquipment->equipment_tag . ' Atulizada!');
|
|
}
|
|
|
|
public function receiveEquipmentToAssociateTasks(Request $request)
|
|
{
|
|
$receiveIsptNumber = 0;
|
|
|
|
// Obter o maior ispt_number da tabela EquipmentWorkHistory que corresponde aos valores em Equipment
|
|
$highestIsptNumber = EquipmentWorkHistory::select('equipment_work_historys.ispt_number')
|
|
->join('equipments', function ($join) {
|
|
$join->on('equipments.equipment_id', '=', 'equipment_work_historys.equipment_id')
|
|
->on('equipments.company_projects_id', '=', 'equipment_work_historys.company_projects_id');
|
|
})
|
|
->orderBy('equipment_work_historys.ispt_number', 'desc')
|
|
->first();
|
|
|
|
// Se existir, ele busca o maior número e acrescenta mais um para adicionar um novo equipamento.
|
|
if ($highestIsptNumber) {
|
|
$receiveIsptNumber = $highestIsptNumber->ispt_number + 1;
|
|
} else {
|
|
// Se não houver registros, comece com 1
|
|
$receiveIsptNumber = 1;
|
|
}
|
|
|
|
$execution_order = 1;
|
|
|
|
foreach ($request->equipment as $equipment) {
|
|
$equipmentModel = Equipment::where('equipment_id', $equipment['equipment_id'])->first();
|
|
|
|
//Atualiza a tabela equipment para associar o equipamento a uma Obra.
|
|
if ($equipmentModel) {
|
|
$equipmentModel->company_projects_id = $request->receiveNumberProject;
|
|
$equipmentModel->save();
|
|
|
|
// Utiliza firstOrCreate para evitar duplicidades
|
|
$attributes = [
|
|
'equipment_id' => $equipment['equipment_id'],
|
|
'company_projects_id' => $request->receiveNumberProject
|
|
];
|
|
|
|
$values = [
|
|
'ispt_number' => $receiveIsptNumber++ // Incrementa o número ISPT se criar um novo registro
|
|
];
|
|
|
|
$createEquipmentWorkHistory = EquipmentWorkHistory::firstOrCreate($attributes, $values);
|
|
|
|
//Criar associacao do equipamento ao Âmbito
|
|
$AssociationEquipmentAmbit = new EquipmentAssociationAmbit;
|
|
$AssociationEquipmentAmbit->equipment_type_id = $equipment['equipment_type_id'];
|
|
$AssociationEquipmentAmbit->ambits_id = $equipment['ambit_id'];
|
|
$AssociationEquipmentAmbit->equipmentWorkHistorys_id = $createEquipmentWorkHistory->id; // Note que mudamos para id
|
|
$AssociationEquipmentAmbit->save();
|
|
|
|
//Recebe a tabela com as associações entre Âmbitos e tarefas Elementares
|
|
$TasksAssociationAmbits = TasksAssociationAmbits::where('ambits_equipment_id', $AssociationEquipmentAmbit->ambits_id)->get();
|
|
|
|
foreach ($TasksAssociationAmbits as $TasksAssociationAmbit) {
|
|
$JoinsEquipmentsWithTasks = new OrderEquipmentTasks;
|
|
$JoinsEquipmentsWithTasks->equipmentWorkHistorys_id = $createEquipmentWorkHistory->id; // Note que mudamos para id
|
|
$JoinsEquipmentsWithTasks->execution_order = $execution_order++;
|
|
$JoinsEquipmentsWithTasks->elemental_tasks_id = $TasksAssociationAmbit->elemental_tasks_id;
|
|
// $JoinsEquipmentsWithTasks->further_tasks_id = null;
|
|
$JoinsEquipmentsWithTasks->inspection = 2;
|
|
$JoinsEquipmentsWithTasks->save();
|
|
}
|
|
}
|
|
}
|
|
|
|
return redirect()->back()->with('success', 'Equipametos associados a Obra com Sucesso !');
|
|
}
|
|
|
|
|
|
public function receiveUnitsForExcelTemplate($numberProject)
|
|
{
|
|
// Dados do Projecto
|
|
$receveCompanyProject = CompanyProject::where('company_projects_id', $numberProject)->first();
|
|
// Dados da Instalação
|
|
$recevePlant = Plant::where('plant_id', $receveCompanyProject->plant_id)->first();
|
|
// Dados das Fabricas
|
|
$receveUnits = Unit::where('plant_id', $recevePlant->plant_id)->get();
|
|
|
|
// dd($receveUnits);
|
|
$filePath = public_path('templateExcel/Valves_Template.xlsx');
|
|
// Load the spreadsheet
|
|
$spreadsheet = IOFactory::load($filePath);
|
|
// Get the second sheet
|
|
$sheet = $spreadsheet->getSheet(1); // Sheet index starts from 0
|
|
$row = 2; // Row number where you want to start inserting data
|
|
foreach ($receveUnits as $unit) {
|
|
// Set value for column D
|
|
$sheet->setCellValue('A' . $row, $unit->unit_name);
|
|
$row++;
|
|
}
|
|
|
|
$formattedDateTime = date('Y-m-d_H-i'); // Formato: Ano-Mês-Dia_Hora-Minuto
|
|
$fileName = "Valves_Template_{$numberProject}_{$formattedDateTime}.xlsx";
|
|
|
|
// Generate and return the download response
|
|
// return $this->createDownloadResponse($spreadsheet, 'Valves_Template.xlsx');
|
|
return $this->createDownloadResponse($spreadsheet, $fileName);
|
|
}
|
|
|
|
protected function createDownloadResponse($spreadsheet, $filename)
|
|
{
|
|
// Create a writer object
|
|
$writer = new Xlsx($spreadsheet);
|
|
// Create a StreamedResponse with a callback
|
|
$response = new StreamedResponse(
|
|
function () use ($writer) {
|
|
$writer->save('php://output');
|
|
}
|
|
);
|
|
// Set headers to indicate we're sending an Excel file
|
|
$response->headers->set('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
|
|
$response->headers->set('Content-Disposition', 'attachment;filename="' . $filename . '"');
|
|
$response->headers->set('Cache-Control', 'max-age=0');
|
|
|
|
return $response;
|
|
}
|
|
|
|
public function finishCreatingProject($numberProject)
|
|
{
|
|
// recebe atraves de sessao toda a vez quem entra no componente 'SelectElementalTasksInWonkstation' para selecionar as tarefas de cada Workstation
|
|
$receiveAllFurtherTasks = session('receiveAllFurtherTasks');
|
|
$receiveElementalTasks = session('receiveElementalTasks');
|
|
|
|
// Inicializar a matriz de IDs faltantes
|
|
$missingElementalTasks = [];
|
|
$missingFurtherTasksDetails = [];
|
|
$missingWorkstations = [];
|
|
|
|
// Recebe todos os dados dos postos de Trabalho
|
|
$receiveWorkstaions = ConstructionWorkstation::where('company_projects_id', $numberProject)->get();
|
|
|
|
foreach ($receiveWorkstaions as $workstation) {
|
|
// Verifica se o ID da workstation está presente na tabela WorkstationsAssociationTasks
|
|
$exists = WorkstationsAssociationTasks::where('id_workstations', $workstation->id_workstations)->exists();
|
|
|
|
// Se não existe na tabela, adiciona à lista das workstations onde nao tem tarefas atribuidas ainda.
|
|
if (!$exists) {
|
|
$missingWorkstations[$workstation->id_workstations] = [
|
|
'name_workstations' => $workstation->name_workstations,
|
|
'nomenclature_workstation' => $workstation->nomenclature_workstation
|
|
];
|
|
}
|
|
}
|
|
|
|
// Extrai apena o id_workstations de cada um
|
|
$workstationIds = $receiveWorkstaions->pluck('id_workstations')->toArray();
|
|
|
|
// Iterar sobre cada tarefa em $receiveElementalTasks
|
|
foreach ($receiveElementalTasks as $taskGroup) {
|
|
foreach ($taskGroup as $taskId => $taskDetails) {
|
|
// Verificar se a tarefa está associada a algum id_workstations
|
|
$exists = WorkstationsAssociationTasks::whereIn('id_workstations', $workstationIds)
|
|
->where('elemental_tasks_id', $taskId)
|
|
->exists();
|
|
|
|
// Se não existe, adicionar à lista de tarefas faltantes
|
|
if (!$exists) {
|
|
$missingElementalTasks[$taskId] = $taskDetails;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Iterar sobre cada tarefa em $receiveAllFurtherTasks
|
|
foreach ($receiveAllFurtherTasks as $furtherTask) {
|
|
// Obter o ID da tarefa
|
|
$taskId = $furtherTask->elemental_tasks_id;
|
|
|
|
// Verificar se a tarefa está associada a algum id_workstations
|
|
$checkExistFurtherTaskInWs = WorkstationsAssociationTasks::whereIn('id_workstations', $workstationIds)
|
|
->where('elemental_tasks_id', $taskId)
|
|
->exists();
|
|
|
|
// Se não existe, adicionar à lista de tarefas faltantes
|
|
if (!$checkExistFurtherTaskInWs) {
|
|
$missingFurtherTasksDetails[$taskId] = [
|
|
'name' => $furtherTask->elemental_tasks_code,
|
|
'description' => $furtherTask->elemental_tasks_description
|
|
];
|
|
}
|
|
|
|
}
|
|
// dd($missingFurtherTasksDetails);
|
|
|
|
// A Partir daqui ja temos as 2 variaveis a receberem array com as tarefas que faltam ser associadas.
|
|
$allMissingTasks = [
|
|
'elemental' => $missingElementalTasks,
|
|
'further' => $missingFurtherTasksDetails,
|
|
'workstation' => $missingWorkstations
|
|
];
|
|
// Verificar se todos os arrays internos estão vazios
|
|
$isEmpty = empty($allMissingTasks['elemental']) && empty($allMissingTasks['further']) && empty($allMissingTasks['workstation']);
|
|
|
|
if (!$isEmpty) {
|
|
return redirect()->back()->with('errors', $allMissingTasks);
|
|
} else {
|
|
$project = CompanyProject::find($numberProject);
|
|
$project->order_project = 2;
|
|
$project->save();
|
|
|
|
return redirect()->route('home');
|
|
}
|
|
}
|
|
|
|
public function deleteWorkstation($name)
|
|
{
|
|
$workstation = ConstructionWorkstation::where('name_workstations', $name)->first();
|
|
$removeAcountUserWorkstation = User::where('user_name', $workstation->name_workstations)->first();
|
|
|
|
if ($workstation && $removeAcountUserWorkstation) {
|
|
$workstation->delete();
|
|
$removeAcountUserWorkstation->delete();
|
|
|
|
// pegar o número da estação de trabalho que está sendo deletada
|
|
preg_match('/workstation(\d+)-/', $workstation->name_workstations, $matches);
|
|
$deletedWorkstationNumber = $matches[1];
|
|
|
|
// pega o número do projeto da estação de trabalho que está sendo deletada
|
|
$projectNumber = explode('-', $workstation->name_workstations)[1];
|
|
|
|
// pegar todas as estações de trabalho e Utilizadors com números maiores que o deletado e renumerá-los
|
|
$workstationsToUpdate = ConstructionWorkstation::where('company_projects_id', $projectNumber)
|
|
->whereRaw("SUBSTRING_INDEX(name_workstations, '-', 1) REGEXP '^workstation[0-9]+$'")
|
|
->whereRaw("CAST(SUBSTRING(SUBSTRING_INDEX(name_workstations, '-', 1), 12) AS UNSIGNED) >= ?", [$deletedWorkstationNumber])
|
|
->orderByRaw("CAST(SUBSTRING(SUBSTRING_INDEX(name_workstations, '-', 1), 12) AS UNSIGNED) DESC")
|
|
->get();
|
|
|
|
foreach ($workstationsToUpdate as $workstationToUpdate) {
|
|
// pegar o número da estação de trabalho atual
|
|
preg_match('/workstation(\d+)-/', $workstationToUpdate->name_workstations, $matches);
|
|
$currentWorkstationNumber = $matches[1];
|
|
|
|
// atualizar nome da estação de trabalho
|
|
$workstationToUpdate->name_workstations = 'workstation' . ($currentWorkstationNumber - 1) . '-' . $projectNumber;
|
|
$workstationToUpdate->save();
|
|
|
|
// atualizar Utilizador associado
|
|
$userToUpdate = User::where('user_name', 'workstation' . $currentWorkstationNumber . '-' . $projectNumber)->first();
|
|
if ($userToUpdate) {
|
|
$userToUpdate->user_name = 'workstation' . ($currentWorkstationNumber - 1) . '-' . $projectNumber;
|
|
$userToUpdate->save();
|
|
}
|
|
}
|
|
|
|
return back()->with('success', 'Posto de Trabalho removido com sucesso!');
|
|
}
|
|
return back()->with('danger', 'Posto de Trabalho não encontrado!');
|
|
}
|
|
|
|
public function removeProjectEquipment(Request $request)
|
|
{
|
|
|
|
$equipment = Equipment::find($request->EquipmentID);
|
|
|
|
if ($request->removalType == 'total') {
|
|
$equipment->delete();
|
|
|
|
return back()->with('success', 'Equipamento Excluido com sucesso!');
|
|
} else
|
|
$equipment->company_projects_id = null;
|
|
$equipment->save();
|
|
|
|
return back()->with('success', 'Equipamento retirado da obra !');
|
|
}
|
|
public function EditEquipment(Request $request)
|
|
{
|
|
// Localiza o equipment pelo numberProject
|
|
$dataEquipment = Equipment::where('equipment_id', $request->equipmentID)->first();
|
|
|
|
// $receiveEquipmentWorkHistori = EquipmentWorkHistory::where('equipment_id', $request->equipmentID)
|
|
// ->where('company_projects_id', $dataEquipment->company_projects_id)
|
|
// ->first();
|
|
|
|
// Atualiza os campos
|
|
$dataEquipment->equipment_tag = $request->tag;
|
|
$dataEquipment->equipment_description = $request->equipmentDescription;
|
|
$dataEquipment->equipment_serial_number = $request->serialNumberEquipment;
|
|
$dataEquipment->equipment_brand = $request->equipmentBrand;
|
|
$dataEquipment->equipment_model = $request->equipmentModel;
|
|
|
|
$dataEquipment->save();
|
|
|
|
if ($request->input('attributes')) {
|
|
foreach ($request->input('attributes') as $key => $value) {
|
|
// Verifica se o valor é null e a chave é um número (correspondendo aos general_attributes_equipment_id)
|
|
if ($value == null && is_numeric($key)) {
|
|
// Procura o registro relevante em SpecificAttributesEquipmentType
|
|
$specificAttributes = SpecificAttributesEquipmentType::where('equipment_id', $dataEquipment->equipment_id)
|
|
->where('general_attributes_equipment_id', $key)
|
|
->first();
|
|
|
|
// Se o registro existir, o deleta
|
|
if ($specificAttributes) {
|
|
$specificAttributes->delete();
|
|
}
|
|
}
|
|
// Se o valor não for null, atualiza ou cria um novo registro
|
|
elseif ($value !== null && is_numeric($key)) {
|
|
|
|
// Procura o registro relevante em SpecificAttributesEquipmentType
|
|
$specificAttributes = SpecificAttributesEquipmentType::where('equipment_id', $dataEquipment->equipment_id)
|
|
->where('general_attributes_equipment_id', $key)
|
|
->first();
|
|
|
|
// Se o registro existir, atualiza o valor
|
|
if ($specificAttributes) {
|
|
$specificAttributes->specific_attributes_value = $value;
|
|
$specificAttributes->save();
|
|
}
|
|
// Se não existir, cria um novo
|
|
else {
|
|
// Cria um novo registro em SpecificAttributesEquipmentType
|
|
$specificAttributes = new SpecificAttributesEquipmentType();
|
|
$specificAttributes->equipment_id = $dataEquipment->equipment_id;
|
|
$specificAttributes->equipment_type_id = $dataEquipment->equipment_type_id;
|
|
$specificAttributes->general_attributes_equipment_id = $key;
|
|
$specificAttributes->specific_attributes_value = $value;
|
|
$specificAttributes->save();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return back()->with('success', 'Equipamento Atualizado!');
|
|
}
|
|
|
|
public function showJson($id)
|
|
{
|
|
$attributes = SpecificAttributesEquipmentType::where('equipment_id', $id)->get();
|
|
$OrdemTasks = OrderEquipmentTasks::where('equipment_id', $id)->get();
|
|
$allElementalTasks = ElementalTasks::all();
|
|
|
|
return response()->json([
|
|
'attributes' => $attributes,
|
|
'OrdemTasks' => $OrdemTasks,
|
|
'allElementalTasks' => $allElementalTasks
|
|
]);
|
|
}
|
|
|
|
public function receveTasksWorkstationPlanning($WorkstationId)
|
|
{
|
|
$workstationsAssociationTasks = WorkstationsAssociationTasks::where('id_workstations', $WorkstationId)->get();
|
|
|
|
return response()->json([
|
|
'workstationsAssociationTasks' => $workstationsAssociationTasks
|
|
]);
|
|
}
|
|
|
|
|
|
public function createWorkStations(Request $request)
|
|
{
|
|
// Pega o número de estações de trabalho do request
|
|
$numberWorkstations = $request->numberWorkstations;
|
|
|
|
// Pega o número do projeto do request
|
|
$numberProject = $request->numberProject;
|
|
|
|
$listWorkstations = ConstructionWorkstation::where('company_projects_id', $numberProject)->get();
|
|
$receveProjectCompanyNumber = CompanyProject::where('company_projects_id', $numberProject)->first();
|
|
|
|
// Pega o último elemento da lista
|
|
$lastWorkstation = $listWorkstations->last();
|
|
|
|
|
|
// Se houver uma estação de trabalho anterior, extrai o número dela
|
|
$startNumber = 1;
|
|
if ($lastWorkstation) {
|
|
$parts = explode('-', $lastWorkstation->name_workstations);
|
|
$startNumber = intval(str_replace('workstation', '', $parts[0])) + 1;
|
|
}
|
|
|
|
// Loop para criar as estações de trabalho e seus logins
|
|
for ($i = $startNumber; $i < $startNumber + $numberWorkstations; $i++) {
|
|
$workstation = new ConstructionWorkstation();
|
|
$workstation->name_workstations = 'workstation' . $i . '-' . $numberProject;
|
|
$workstation->company_projects_id = $numberProject;
|
|
$workstation->save();
|
|
|
|
preg_match('/workstation(\d+)-/', $workstation->name_workstations, $matches);
|
|
$receiveNumberWorkstation = $matches[1];
|
|
|
|
//Apos criar a Workstation vamos criar um login para pode aceder os postos de trabalho na obra
|
|
$loginWorkStation = new User;
|
|
$loginWorkStation->user_name = $workstation->name_workstations;
|
|
$loginWorkStation->email = $receveProjectCompanyNumber->project_company_name . '-' . $receiveNumberWorkstation . '@isptgroup.com';
|
|
$loginWorkStation->password = bcrypt($receveProjectCompanyNumber->project_company_name . '-' . $receiveNumberWorkstation);
|
|
$loginWorkStation->type_users = 5;
|
|
$loginWorkStation->user_nif = $receveProjectCompanyNumber->project_company_name . '-' . $receiveNumberWorkstation;
|
|
$loginWorkStation->save();
|
|
}
|
|
|
|
// Redireciona para onde você quiser após a criação das workstations
|
|
return redirect()->route('workStation_3', ['id' => $request->numberProject])
|
|
->with('success', $numberWorkstations . ' Postos de Trabalho criados !!!')
|
|
->with('listWorkstations', $listWorkstations);
|
|
}
|
|
|
|
// Funcao apenas para retornar os dados necessarios para a view criar uma Obra.
|
|
public function createProjectForStep1()
|
|
{
|
|
// $companies = User::where('type_users', 3)->get();
|
|
$companies = Company::all();
|
|
// Apos terminar não vai ficar step 1
|
|
return view('projectsClients/createProject', ['step' => 1], ['companies' => $companies]);
|
|
}
|
|
|
|
// Progress Bar
|
|
//Devolve para a primeira para na Descrição do projecto apenas user com ID 3, quer dizer que apenas as "empresas"
|
|
public function showStep1($company_projects_id)
|
|
{
|
|
$projects = CompanyProject::find($company_projects_id);
|
|
|
|
$companies = Company::all();
|
|
|
|
$receiveDetailsPlant = Plant::where('plant_id', $projects->plant_id)->first();
|
|
|
|
$receiveDetailsCompany = Company::where('company_id', $receiveDetailsPlant->company_id)->first();
|
|
// $receiveDetailsUser = User::where('user_id', $receiveDetailsPlant->user_id)->first();
|
|
// $receiveDetailsUser->plantName = $receiveDetailsPlant->plant_name;
|
|
|
|
$projects->plantName = $receiveDetailsPlant->plant_name;
|
|
$projects->userName = $receiveDetailsCompany->company_name;
|
|
|
|
$receiveCompanyManager = '';
|
|
$receiveCompanyManagerID = null; // Inicialize com null ou um valor padrão apropriado
|
|
|
|
// Se o project_company_responsible for igual a null, significa que ainda não foi definido após a criação da Obra.
|
|
// Se foi definido, deve buscar o nome do User atribuído.
|
|
if ($projects->project_company_responsible === null) {
|
|
$receiveCompanyManager = 'Gestor da empresa ainda não atribuído...';
|
|
} else {
|
|
$NameCompanyManager = User::where('user_id', $projects->project_company_responsible)->first();
|
|
// Verifica se um usuário foi encontrado antes de tentar acessar a propriedade user_name.
|
|
if ($NameCompanyManager) {
|
|
$receiveCompanyManager = $NameCompanyManager->user_name;
|
|
$receiveCompanyManagerID = $NameCompanyManager->user_id;
|
|
} else {
|
|
$receiveCompanyManager = 'Usuário não encontrado'; // Mensagem caso o ID não corresponda a nenhum usuário.
|
|
$receiveCompanyManagerID = null; // Assegure-se que há um valor definido mesmo em caso de falha
|
|
}
|
|
}
|
|
$projects->NameCompanyManager = $receiveCompanyManager;
|
|
$projects->NameCompanyManagerID = $receiveCompanyManagerID;
|
|
|
|
|
|
//deve receber os User disponiveis da Empresa atual da Obra.
|
|
$receiveAllCompanyManager = AssociationCompanyUser::where('company_id', $projects->plant->company_id)->get();
|
|
|
|
return view('projectsClients/projectDetails_1', ['step' => 1], ['companies' => $companies])
|
|
->with('projects', $projects)
|
|
->with('receiveAllCompanyManager', $receiveAllCompanyManager);
|
|
}
|
|
|
|
// Se forem alterados dados dos Detalhes da Obra, vai ser alterado
|
|
public function EditprocessStep1(Request $request)
|
|
{
|
|
// Validação...
|
|
$project = CompanyProject::where('company_projects_id', $request->projectId)->first();
|
|
|
|
$project->company_project_description = $request->input('description_project');
|
|
$project->project_company_name = $request->input('project_company_name');
|
|
$project->project_ispt_number = $request->input('n_project_ispt');
|
|
$project->project_ispt_responsible = $request->input('responsible_project_ispt');
|
|
|
|
// Correção aqui: A verificação de 'undefined' deve ser feita corretamente
|
|
if ($request->input('responsible_project_company') === 'undefined') {
|
|
$project->project_company_responsible = null;
|
|
} else {
|
|
$project->project_company_responsible = $request->input('responsible_project_company');
|
|
}
|
|
|
|
// Verifica se existe uma nova data, se existe atualiza o projeto com a nova, se não existir usa a antiga
|
|
if ($request->input('date_started') !== null) {
|
|
$project->date_started = $request->input('date_started');
|
|
} else {
|
|
$project->date_started = $request->input('date_started_present');
|
|
}
|
|
|
|
$project->save();
|
|
|
|
session(['form_data.step1' => $request->all()]);
|
|
|
|
$receiveAllLogsProject = ProjectExcelLog::where('company_projects_id', $project->company_projects_id)
|
|
->get()
|
|
->groupBy('excel_name')
|
|
->map(function ($group) {
|
|
return $group->sortByDesc('project_excel_logs_id')->first();
|
|
});
|
|
|
|
return redirect()->route('articulated_2', ['projectID' => $project->company_projects_id])
|
|
->with('receiveAllLogsProject', $receiveAllLogsProject)
|
|
->with('success', 'Detalhes do Project atualizados!');
|
|
}
|
|
|
|
public function removePendingEquipment($id)
|
|
{
|
|
$equipment = PendingEquipment::findOrFail($id);
|
|
$equipment->delete();
|
|
return back()->with('success', 'Equipamento pendente removido com sucesso!');
|
|
}
|
|
|
|
public function CreateNewEquipmentFromPendingEquipment(Request $request, $id)
|
|
{
|
|
$checkPendingEquipment = PendingEquipment::findOrFail($id);
|
|
|
|
$counter = 2;
|
|
$baseTag = $checkPendingEquipment->pending_equipment_tag;
|
|
$baseDescription = $checkPendingEquipment->pending_equipment_description;
|
|
|
|
// Ciclo para verificar se já existe um equipamento com o mesmo nome se existir vai criando com o contador iniciado a partir de (2)
|
|
while (Equipment::where('equipment_tag', $baseTag . "({$counter})")->orWhere('equipment_description', $baseDescription . "({$counter})")->exists()) {
|
|
$counter++;
|
|
}
|
|
|
|
$attributes = [
|
|
'unit_id' => $checkPendingEquipment->pending_equipment_unit_id,
|
|
'equipment_type_id' => $checkPendingEquipment->pending_equipment_type_id,
|
|
'equipment_tag' => $baseTag . "({$counter})",
|
|
'equipment_description' => $baseDescription . "({$counter})",
|
|
'company_projects_id' => $checkPendingEquipment->pending_company_projects_id
|
|
];
|
|
|
|
$newEquipment = Equipment::firstOrCreate($attributes);
|
|
|
|
$newEquipmentWorkHistoryAttributes = [
|
|
'equipment_id' => $newEquipment->equipment_id,
|
|
'company_projects_id' => $newEquipment->company_projects_id
|
|
];
|
|
|
|
$lastIsptNumber = EquipmentWorkHistory::where('company_projects_id', $newEquipment->company_projects_id)->max('ispt_number');
|
|
$newIsptNumber = $lastIsptNumber ? $lastIsptNumber + 1 : 1;
|
|
|
|
$valuesWorkHistory = [
|
|
'ispt_number' => $newIsptNumber,
|
|
'equipment_status_project' => 0
|
|
];
|
|
|
|
$newEquipmentWorkHistory = EquipmentWorkHistory::firstOrCreate($newEquipmentWorkHistoryAttributes, $valuesWorkHistory);
|
|
|
|
$newEquipmentAssociationAmbits = new EquipmentAssociationAmbit;
|
|
$newEquipmentAssociationAmbits->equipmentWorkHistorys_id = $newEquipmentWorkHistory->equipmentWorkHistorys_id;
|
|
$newEquipmentAssociationAmbits->ambits_id = $request->EquipmentAmbit;
|
|
$newEquipmentAssociationAmbits->equipment_type_id = $newEquipment->equipment_type_id;
|
|
$newEquipmentAssociationAmbits->save();
|
|
|
|
|
|
$TasksAssociationAmbits = TasksAssociationAmbits::where('ambits_equipment_id', $newEquipmentAssociationAmbits->ambits_id)->get();
|
|
|
|
foreach ($TasksAssociationAmbits as $TasksAssociationAmbit) {
|
|
$JoinsEquipmentsWithTasks = new OrderEquipmentTasks;
|
|
$JoinsEquipmentsWithTasks->equipmentWorkHistorys_id = $newEquipmentWorkHistory->equipmentWorkHistorys_id;
|
|
$JoinsEquipmentsWithTasks->elemental_tasks_id = $TasksAssociationAmbit->elemental_tasks_id;
|
|
$JoinsEquipmentsWithTasks->save();
|
|
}
|
|
|
|
$checkPendingEquipment->delete();
|
|
|
|
return back()->with('success', 'Equipamento ' . $newEquipment->equipment_tag . ' criado com sucesso');
|
|
}
|
|
|
|
|
|
|
|
public function processStep1(Request $request)
|
|
{
|
|
//NAO DEVE SER CRIAR UMA NOVA EMPRESA NA CRIACAO DA OBRA (era uma boa ideia para facilitar ao Admin ter que criar a empresa para Depois a Obra, mas e necessario pelo facto da autentificao de 2 factores e envio e email , entao devido essa adicoes, nao preciso atualmente fazer sentido criar isto)
|
|
// Dito isto vamos sempre pensar que o Cliente ja deve estar criado , para ser feita uma Obra para o mesmo.
|
|
// dd($request);
|
|
// Validação...
|
|
|
|
if ($request->input('installation_id')) {
|
|
|
|
$installationId = $request->input('installation_id');
|
|
|
|
//Para criar uma nova instalacao
|
|
if ($installationId <> null && $installationId == 'new_install') {
|
|
|
|
// Criar uma nova instalação...
|
|
$newInstallation = new Plant;
|
|
|
|
$newInstallation->plant_name = $request->input('new_company_name');
|
|
$newInstallation->plant_address = $request->input('new_company_address');
|
|
$newInstallation->company_id = $request->input('company_select');
|
|
|
|
$newInstallation->save();
|
|
|
|
// Use o id da nova instalação.
|
|
$installationId = $newInstallation->plant_id;
|
|
|
|
// Verifica se há nomes de fábricas para criar
|
|
$factoryNames = $request->input('factoryNames', []);
|
|
|
|
foreach ($factoryNames as $factoryName) {
|
|
$newUnit = new Unit; // Supondo que `Unit` é o seu modelo para as fábricas
|
|
$newUnit->unit_name = $factoryName;
|
|
$newUnit->plant_id = $installationId; // ID da instalação criada anteriormente
|
|
$newUnit->save(); // Salva a nova fábrica no banco de dados
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
$receiveDetailsPlant = Plant::where('plant_id', $installationId)->first();
|
|
|
|
//Code apenas para criacao de Obra sem criar instlacao ou empresa
|
|
$project = new CompanyProject;
|
|
$project->company_project_description = $request->input('description_project');
|
|
$project->project_ispt_number = $request->input('n_project_ispt');
|
|
$project->project_company_name = $request->input('project_company_name');
|
|
$project->project_ispt_responsible = $request->input('responsible_project_ispt');
|
|
|
|
if ($request->input('user_id') == 'ispt') {
|
|
$project->project_company_responsible = null;
|
|
} else {
|
|
$project->project_company_responsible = $request->input('user_id');
|
|
}
|
|
|
|
$project->plant_id = $receiveDetailsPlant->plant_id;
|
|
$project->order_project = 1;
|
|
$project->date_started = $request->input('date_started');
|
|
|
|
$project->save();
|
|
|
|
return redirect()->route('articulated_2', ['projectID' => $project->company_projects_id])
|
|
->with('success', 'Project criado com sucesso!');
|
|
}
|
|
|
|
public function showStep2($company_projects_id)
|
|
{
|
|
$groupedArrayForPendingEquipments = session('groupedArrayForPendingEquipments');
|
|
// Verifique se a etapa 1 foi concluída
|
|
|
|
// if (!session('form_data.step1')) {
|
|
// return redirect('/createProject');
|
|
// }
|
|
|
|
//recebe o Id de Plant vai devolver todos os equipamentos relacionados a esta Instalação(plant)
|
|
// Carregue o projeto com o id fornecido
|
|
$project = CompanyProject::find($company_projects_id);
|
|
|
|
$numberProject = $project->company_projects_id;
|
|
|
|
$typeEquipments = EquipmentType::all();
|
|
|
|
//Retorna todas as Fabricas Unit, com base na Instalação
|
|
$checkUnits = DB::table('units')
|
|
->join('plants', 'units.plant_id', '=', 'plants.plant_id')
|
|
->join('company_projects', 'plants.plant_id', '=', 'company_projects.plant_id')
|
|
->select('units.*')
|
|
->where('company_projects.company_projects_id', '=', $company_projects_id)
|
|
->get();
|
|
|
|
//Retorna todos os Equipamentos, com base na instalcao do projecto
|
|
$checkEquipments = DB::table('equipments')
|
|
->join('units', 'equipments.unit_id', '=', 'units.unit_id')
|
|
->join('plants', 'units.plant_id', '=', 'plants.plant_id')
|
|
->select('equipments.*') // Seleciona todas as colunas da tabela 'equipments'
|
|
->where('plants.plant_id', '=', $project['plant_id']) // Filtra baseado no 'plant_id'
|
|
->get();
|
|
|
|
// Para listar os equipamentos vinculados na obra, buscamos suas associações gerais entre suas tabelas , ou seja a : fabrica(unit), tipo de equipamento e o Âmbito para se realizar a tarefas pretendida neste obra.
|
|
// $listEquipmentsProjects = Equipment::with(['unit', 'equipmentType', 'equipmentAssociationAmbit.ambitsEquipment'])
|
|
// ->where('company_projects_id', $company_projects_id)
|
|
// ->get();
|
|
|
|
$listEquipmentsProjects = Equipment::with([
|
|
'unit',
|
|
'equipmentType',
|
|
// 'equipmentAssociationAmbit.ambitsEquipment',
|
|
'specificAttributes' => function ($query) {
|
|
$query->orderBy('specific_attributes_value', 'asc');
|
|
}
|
|
])
|
|
->where('company_projects_id', $company_projects_id)
|
|
->get();
|
|
|
|
$pendingEquipments = PendingEquipment::where('pending_company_projects_id', $numberProject)->get();
|
|
|
|
// $receiveAllLogsProject = ProjectExcelLog::where('company_projects_id', $company_projects_id)->get();
|
|
|
|
$receiveAllLogsProject = ProjectExcelLog::where('company_projects_id', $company_projects_id)
|
|
->get()
|
|
->groupBy('excel_name')
|
|
->map(function ($group) {
|
|
return $group->sortByDesc('project_excel_logs_id')->first();
|
|
});
|
|
|
|
|
|
|
|
if (!$pendingEquipments->isEmpty()) {
|
|
// Retornamos para a view 'step' => 2 indicando conclusao da primeira parte, $numberProject para associacao de equipamentos a esta obra, alem de todos os equipamentos e fabricao ja existente com base na Instalação que se iniciou a obra.
|
|
return view('projectsClients/articulated_2', ['step' => 2, 'numberProject' => $numberProject])
|
|
->with('danger', 'Equipamentos Pendentes: ' . count($pendingEquipments))
|
|
->with('pendingEquipments', $pendingEquipments)
|
|
->with('listEquipmentsProjects', $listEquipmentsProjects)
|
|
->with('typeEquipments', $typeEquipments)
|
|
->with('checkEquipments', $checkEquipments)
|
|
->with('checkUnits', $checkUnits)
|
|
->with('receiveNumberProject', $project)
|
|
->with('groupedArrayForPendingEquipments', $groupedArrayForPendingEquipments)
|
|
->with('receiveAllLogsProject', $receiveAllLogsProject);
|
|
}
|
|
return view('projectsClients/articulated_2', ['step' => 2, 'numberProject' => $numberProject])
|
|
->with('listEquipmentsProjects', $listEquipmentsProjects)
|
|
->with('typeEquipments', $typeEquipments)
|
|
->with('checkEquipments', $checkEquipments)
|
|
->with('checkUnits', $checkUnits)
|
|
->with('groupedArrayForPendingEquipments', $groupedArrayForPendingEquipments)
|
|
->with('receiveNumberProject', $project)
|
|
->with('receiveAllLogsProject', $receiveAllLogsProject);
|
|
}
|
|
|
|
public function createEquipmentManual(Request $request)
|
|
{
|
|
// EquipmentAmbit
|
|
// *** Recebe a Instalação(Plant), com base no número da Obra Criada
|
|
$receivePlant = DB::table('plants')
|
|
->join('company_projects', 'company_projects.plant_id', 'plants.plant_id')
|
|
->select('plants.plant_id')
|
|
->where('company_projects.company_projects_id', '=', $request->numberProject)
|
|
->get();
|
|
|
|
//recebe a lista de todos os equipmentos relacionados a obra que se esta a criar.
|
|
$listEquipmentsProjects = DB::table('equipments')
|
|
->select('equipments.*')
|
|
->where('equipments.company_projects_id', '=', $request->numberProject)
|
|
->get();
|
|
|
|
// Verifica se ja existe um equipamento com as as caracteristicas : tag,unit_id, iguais ao que pretendemos criar
|
|
$existingEquipment = Equipment::firstWhere([
|
|
'equipment_tag' => $request->tag,
|
|
'unit_id' => $request->unit_id
|
|
]);
|
|
|
|
if ($existingEquipment) {
|
|
return redirect()->route('articulated_2', ['projectID' => $request->numberProject])
|
|
->with('danger', 'Equipamento ja Existe !!')
|
|
->with('listEquipmentsProjects', $listEquipmentsProjects);
|
|
}
|
|
|
|
// Se realmente for um equipamento novo, verifica se ira associar a uma fabrica (unit) nova ou ja existente
|
|
$newEquipmentProject = new Equipment;
|
|
|
|
// Se for uma fabrica(Unit) existente
|
|
if ($request->new_unit_name == null) {
|
|
$newEquipmentProject->unit_id = $request->unit_id;
|
|
} else {
|
|
|
|
//ja retorna se for uma fabrica nova (Unit)
|
|
$newUnit = new Unit;
|
|
$newUnit->unit_name = $request->new_unit_name;
|
|
$newUnit->plant_id = $receivePlant[0]->plant_id;
|
|
$newUnit->save();
|
|
|
|
$newEquipmentProject->unit_id = $newUnit->unit_id;
|
|
}
|
|
|
|
$newEquipmentProject->equipment_type_id = $request->equipmentTypeId;
|
|
$newEquipmentProject->equipment_tag = $request->tag;
|
|
$newEquipmentProject->equipment_description = $request->equipmentDescription;
|
|
|
|
// Estes campos a baixo : podem ter valor ou não
|
|
$newEquipmentProject->equipment_serial_number = $request->serialNumberEquipment ?? NULL;
|
|
$newEquipmentProject->equipment_brand = $request->equipmentBrand ?? NULL;
|
|
$newEquipmentProject->equipment_model = $request->equipmentModel ?? NULL;
|
|
|
|
$newEquipmentProject->company_projects_id = $request->numberProject;
|
|
|
|
$newEquipmentProject->save();
|
|
|
|
// ID do equipamento criado
|
|
$equipmentID = $newEquipmentProject->equipment_id;
|
|
|
|
$newEquipmentWorkHistorys = new EquipmentWorkHistory;
|
|
|
|
// Verifica se já existem registros com o mesmo 'equipment_id' e 'company_projects_id'
|
|
$existingRecords = EquipmentWorkHistory::where('company_projects_id', $request->numberProject)
|
|
->orderBy('ispt_number', 'desc') // Ordena de forma decrescente
|
|
->first(); // Pega o primeiro resultado, que seria o maior número
|
|
|
|
if ($existingRecords) {
|
|
// Se existirem registros, o próximo número será o maior número existente + 1
|
|
$isptNumber = $existingRecords->ispt_number + 1;
|
|
} else {
|
|
// Se não existirem registros, começa com 1
|
|
$isptNumber = 1;
|
|
}
|
|
|
|
$newEquipmentWorkHistorys->equipment_status_project = 0;
|
|
$newEquipmentWorkHistorys->equipment_id = $equipmentID;
|
|
$newEquipmentWorkHistorys->ispt_number = $isptNumber;
|
|
$newEquipmentWorkHistorys->company_projects_id = $request->numberProject;
|
|
|
|
$newEquipmentWorkHistorys->save();
|
|
|
|
$equipmentWorkHistorysID = $newEquipmentWorkHistorys->equipmentWorkHistorys_id;
|
|
|
|
// Verifica os campos do Card_do tipo de valvula selecionado (Ex: psv_card) e de acordo com os campos preenchidos se for de atributos especificos, ele compara o 'name' dos inputs com os 'general_attributes_equipment_description' da tabela : GeneralAttributesEquipment e associa
|
|
$checkAtributs = GeneralAttributesEquipment::whereIn('general_attributes_equipment_description', array_keys($request->all()))
|
|
->pluck('general_attributes_equipment_id', 'general_attributes_equipment_description')
|
|
->toArray();
|
|
|
|
// Recebe esta associacao, e cria um array para cada 'name'(inputs) igual ao 'general_attributes_equipment_description', contanto que seu valor(input) seja diferente de *NULL, assim o "$receivesAssociationAttributes" recebe o id de acordo com a tabela , o nome de acordo com a tabela e o valor do $request recebido associado ao campo
|
|
$receivesAssociationAttributes = [];
|
|
foreach ($checkAtributs as $description => $id) {
|
|
if ($request[$description] !== null) {
|
|
$receivesAssociationAttributes[] = [
|
|
'general_attributes_equipment_id' => $id,
|
|
'general_attributes_equipment_description' => $description,
|
|
'value' => $request[$description]
|
|
];
|
|
}
|
|
}
|
|
// Para cada um dos Arrays criados acima, vai criar os novos dados na tabela 'SpecificAttributesEquipmentType'
|
|
foreach ($receivesAssociationAttributes as $receivesAssociationAttribute) {
|
|
|
|
$AddAtributsEquipments = new SpecificAttributesEquipmentType;
|
|
$AddAtributsEquipments->equipment_id = $equipmentID;
|
|
$AddAtributsEquipments->equipment_type_id = $request->equipmentTypeId;
|
|
$AddAtributsEquipments->general_attributes_equipment_id = $receivesAssociationAttribute['general_attributes_equipment_id'];
|
|
$AddAtributsEquipments->specific_attributes_value = $receivesAssociationAttribute['value'];
|
|
|
|
$AddAtributsEquipments->save();
|
|
}
|
|
//Criar associacao do equipamento ao Âmbito
|
|
$AssociationEquipmentAmbit = new EquipmentAssociationAmbit;
|
|
$AssociationEquipmentAmbit->equipment_type_id = $request->equipmentTypeId;
|
|
$AssociationEquipmentAmbit->ambits_id = $request->EquipmentAmbit;
|
|
$AssociationEquipmentAmbit->equipmentWorkHistorys_id = $equipmentWorkHistorysID;
|
|
|
|
$AssociationEquipmentAmbit->save();
|
|
|
|
$execution_order = 1;
|
|
|
|
//Recebe a tabela com as associoacoes entre Âmbitos e tarefas Elementares
|
|
$TasksAssociationAmbits = TasksAssociationAmbits::all()->where('ambits_equipment_id', $AssociationEquipmentAmbit->ambits_id);
|
|
|
|
foreach ($TasksAssociationAmbits as $TasksAssociationAmbit) {
|
|
$JoinsEquipmentsWithTasks = new OrderEquipmentTasks;
|
|
$JoinsEquipmentsWithTasks->equipmentWorkHistorys_id = $equipmentWorkHistorysID;
|
|
$JoinsEquipmentsWithTasks->execution_order = $execution_order++;
|
|
$JoinsEquipmentsWithTasks->elemental_tasks_id = $TasksAssociationAmbit->elemental_tasks_id;
|
|
// $JoinsEquipmentsWithTasks->further_tasks_id = null;
|
|
$JoinsEquipmentsWithTasks->inspection = 2;
|
|
$JoinsEquipmentsWithTasks->save();
|
|
}
|
|
|
|
// O $request->numberProject e sempre necessario retornar para indicar a obra que se esta modificando...
|
|
return redirect()->route('articulated_2', ['projectID' => $request->numberProject])
|
|
->with('success', 'Equipamento criado com sucesso')
|
|
->with('listEquipmentsProjects', $listEquipmentsProjects);
|
|
}
|
|
public function receiveIdEquipment(Equipment $equipment)
|
|
{
|
|
// return response()->json($equipment);
|
|
return view('projectsClients/articulated_2', ['equipment' => $equipment]);
|
|
}
|
|
|
|
public function processStep2(Request $request)
|
|
{
|
|
// Valide e processe os dados do formulário
|
|
$file = $request->file('documento');
|
|
// Criar o array para adicionar o HashMap
|
|
// $uniqueRowsHashmap = [];
|
|
// Recebe a id do Projecto criado
|
|
$company_projects_id = $request->numberProject;
|
|
// Recebe mais detalhes da Obra Atual.
|
|
$detailsCompanyProject = CompanyProject::where('company_projects_id', $company_projects_id)->first();
|
|
// Inicializa o contador para ispt_number
|
|
$isptNumber = 1;
|
|
|
|
// Confirma que o arquivo foi enviado,ou seja sua existencia.
|
|
// Antes de verificar o documento excel, deve ter uma forma de confirmar o mesmo como arquivo legitivo para criar dados de acordo com o nosso template.
|
|
if ($file) {
|
|
|
|
//Busca o nome do arquivo xslx.
|
|
$originalFileName = $file->getClientOriginalName();
|
|
// Carregue o arquivo Excel
|
|
$spreadsheet = IOFactory::load($file->path());
|
|
// Obtenha a primeira planilha, onde fica os nomes chaves para associar as tabelas : 'general_attributes_equipaments' ,'equipments' e 'equipmentWorkHistorys'
|
|
$worksheet = $spreadsheet->getSheet(0);
|
|
// Transforme os dados da planilha em um array
|
|
$data = $worksheet->toArray();
|
|
|
|
// Retorna um array com todos os names preenchidos na primeira linha do template de Excel
|
|
$columnNames = $data[0];
|
|
$countPendingEquipments = 0;
|
|
$countEquipment = 0;
|
|
|
|
// Recebo os nomes das colunas do execel dependendo da linguagem selecionada
|
|
$columnRealNames = $data[5];
|
|
|
|
// Inicialização do hashmap para rastrear as linhas únicas
|
|
$uniqueRowsHashmap = [];
|
|
$equipmentPendingLogs = [];
|
|
// $ignoredLines = [];
|
|
// $duplicateLines = [];
|
|
|
|
|
|
// Separa o nome do arquivo para obter o tipo de documento e a data-hora
|
|
$parts = explode('_', $originalFileName);
|
|
$documentType = $parts[2]; // 98
|
|
$timestamp = $parts[3]; // 2024-01-14_14-33
|
|
|
|
|
|
function normalize($value)
|
|
{
|
|
// Remove espaços em branco no início e no fim da string
|
|
$trimmed = trim($value);
|
|
// Remove espaços em branco no meio da string
|
|
$noInnerSpaces = str_replace(' ', '', $trimmed);
|
|
// Converte a string para minúsculas
|
|
$lowercase = strtolower($noInnerSpaces);
|
|
return $lowercase;
|
|
}
|
|
|
|
// Busca o ID de todas as unidades referentes à Instalação da Obra e coloca em um array
|
|
$allUnitsOnThePlantOfProject = Unit::where('plant_id', $detailsCompanyProject->plant_id)
|
|
->pluck('unit_id')
|
|
->toArray();
|
|
|
|
// Busca os equipamentos com base nos IDs das unidades encontradas
|
|
$equipments = Equipment::select('equipment_id', 'unit_id', 'equipment_tag') // Substitua 'equipment_id', 'equipment_tag' pelos nomes corretos das colunas, se necessário
|
|
->whereIn('unit_id', $allUnitsOnThePlantOfProject)
|
|
->get()->keyBy(function ($item) {
|
|
return normalize($item->unit->unit_name) . '-' . normalize($item->equipment_tag); // Cria uma chave única com 'unit_id-tag' para fácil comparação
|
|
});
|
|
|
|
// Verifica se já existem registros com o mesmo 'equipment_id' e 'company_projects_id'
|
|
$existingRecords = EquipmentWorkHistory::where('company_projects_id', $company_projects_id)
|
|
->orderBy('ispt_number', 'desc') // Ordena de forma decrescente
|
|
->first(); // Pega o primeiro resultado, que seria o maior número
|
|
|
|
if ($existingRecords) {
|
|
// Se existirem registros, o próximo número será o maior número existente + 1
|
|
$isptNumber = $existingRecords->ispt_number + 1;
|
|
} else {
|
|
// Se não existirem registros, começa com 1
|
|
$isptNumber = 1;
|
|
}
|
|
|
|
foreach ($data as $i => $dataLines) {
|
|
|
|
// Em cada um das linhas horizontais do excel, vai se guardar a 'key' vinculada ao valor do campo preenchido ou seja a 'key' vai ter o mesmo nome de um dos dados da tabela 'general_attributes_equipaments' na coluna : general_attributes_equipment_description, assim sendo mais facil implementar na tabela : specific_attributes_equipament_types
|
|
$joinArrays = array_combine($columnNames, $dataLines);
|
|
|
|
|
|
// vai guardar todos os campos de possiveis novos equipamentos, cada um em um array para multiplos inserts, na base de dados
|
|
$datas = array_filter($joinArrays, function ($chave) {
|
|
return !empty ($chave);
|
|
}, ARRAY_FILTER_USE_KEY);
|
|
|
|
// Verifica se a coluna 'fábrica' (primeiro campo) está vazia
|
|
if (empty($dataLines[0])) {
|
|
// Se a coluna 'fábrica' estiver vazia, pule para a próxima linha
|
|
|
|
continue;
|
|
}
|
|
|
|
// Recebe os detalhes da Unit recebida nesta linha do excel.
|
|
// Deve verificar a Plant tambem, pois pode ter outra plante com esse mesmo nome de fabrica.
|
|
//Nunca vai ser null ou diferente pois tem um code acima que se essa coluna for null faz um continue na linha atual XD
|
|
$detailsUnit = Unit::where('unit_name', $datas['unit'])
|
|
->where('plant_id', $detailsCompanyProject->plant_id)
|
|
->first();
|
|
|
|
|
|
//Indentifica qual o tipo de equipamento selecionado de acordo com a tabela EquipmentType
|
|
$equipmentType = EquipmentType::where('equipment_type_name', $datas['equipment_type_name'])->first();
|
|
|
|
//-------- Linhas Ignoradas
|
|
// Começa a contagem das linhas do excel a partir de 7 linha
|
|
if ($i < 6) {
|
|
continue;
|
|
}
|
|
// Contador para campos não vazios
|
|
$nonEmptyFieldsCount = 0;
|
|
// Array para rastrear campos não preenchidos
|
|
$missingFields = [];
|
|
|
|
// Verifica se os 5 primeiros campos estão preenchidos e conta os não vazios
|
|
for ($j = 0; $j < 5; $j++) {
|
|
if (!empty($dataLines[$j])) {
|
|
$nonEmptyFieldsCount++;
|
|
} else {
|
|
$missingFields[] = $columnRealNames[$j]; // Assume-se que $columnRealNames mapeia corretamente para os nomes dos campos
|
|
}
|
|
}
|
|
|
|
// Registra a linha como ignorada se menos de 2 campos estiverem preenchidos ou se houver campos não preenchidos
|
|
if ($nonEmptyFieldsCount > 2 && $nonEmptyFieldsCount < 5) {
|
|
$equipmentPendingLogs[] = [
|
|
'typePendingLog' => 0,
|
|
'line' => $i + 1,
|
|
'reason' => implode(', ', $missingFields), // Converte o array de campos faltantes para uma string
|
|
];
|
|
continue; // Pula para a próxima linha
|
|
}
|
|
|
|
|
|
//-------- Linhas Repetidas no Execel
|
|
$normalizedField1 = normalize($dataLines[0]);
|
|
$normalizedField2 = normalize($dataLines[1]);
|
|
$key = $normalizedField1 . '-' . $normalizedField2;
|
|
|
|
// Verifica duplicatas no Excel
|
|
if (!array_key_exists($key, $uniqueRowsHashmap)) {
|
|
$uniqueRowsHashmap[$key] = $i;
|
|
} else {
|
|
$duplicateLines[] = $i; // Linha duplicada no Excel
|
|
|
|
//Guardar os informacoes para o logs geral da pagina de articulado
|
|
$equipmentPendingLogs[] = [
|
|
'excel_Name' => $originalFileName,
|
|
'typePendingLog' => 1,
|
|
'duplicate_line' => $i + 1,
|
|
'original_line' => $uniqueRowsHashmap[$key] + 1,
|
|
'reason' => 'Duplicata no Excel - (Original Line '. $uniqueRowsHashmap[$key] + 1 .') referente aos campos: ' . $columnRealNames[0] . ' e ' . $columnRealNames[1] . '.'
|
|
];
|
|
|
|
//este e criado apenas para o PendingEquipment a indicar a reason de sua criacao.
|
|
$pending_equipment_creation_log = [
|
|
'excel_Name' => $originalFileName,
|
|
'reason' => 'Duplicata no Excel - (Original Line '. $uniqueRowsHashmap[$key] + 1 .') referente aos campos: ' . $columnRealNames[0] . ' e ' . $columnRealNames[1] . '.(Duplicate Line ' .$i + 1 .')'
|
|
];
|
|
|
|
$pendingEquipament = new PendingEquipment;
|
|
|
|
// Defina os atributos do pendingEquipament conforme necessário.
|
|
$pendingEquipament->pending_equipment_unit_id = $detailsUnit->unit_id;
|
|
$pendingEquipament->pending_equipment_type_id = $equipmentType->equipment_type_id;
|
|
$pendingEquipament->pending_equipment_tag = $datas['equipment_tag'];
|
|
$pendingEquipament->pending_equipment_description = $datas['equipment_description'];
|
|
|
|
//recebe os valores de $equipmentPendingLogs para guardar o logs de criacao deste pendente.
|
|
$pendingEquipament->pending_equipment_creation_log = json_encode($pending_equipment_creation_log);
|
|
|
|
$pendingEquipament->pending_equipment_serial_number = $datas['serial_number'];
|
|
$pendingEquipament->pending_equipment_brand = $datas['model'];
|
|
$pendingEquipament->pending_company_projects_id = $company_projects_id;
|
|
$pendingEquipament->save();
|
|
|
|
// Incremente o contador de PendingEquipments
|
|
$countPendingEquipments++;
|
|
|
|
continue; // Pula a próxima verificação para duplicatas identificadas no Excel
|
|
}
|
|
|
|
|
|
//--------- Linhas associada a equipamentos da base de dados.
|
|
// Verifica duplicatas na base de dados
|
|
if (isset($equipments[$key])) {
|
|
$duplicateLines[] = $i; // Linha duplicada na base de dados
|
|
$equipmentPendingLogs[] = [
|
|
'typePendingLog' => 2,
|
|
'line' => $i + 1,
|
|
'equipment_id' => $equipments[$key]->equipment_id, // Adiciona o ID do equipamento
|
|
'equipment_tag' => $equipments[$key]->equipment_tag, // Adiciona a tag do equipamento
|
|
'reason' => '' // Adiciona uma razão vazia por padrão que será atualizada mais tarde
|
|
];
|
|
|
|
// Busca o equipamento para ver se já está associado a algum projeto
|
|
$findEquipment = Equipment::find($equipments[$key]->equipment_id);
|
|
|
|
if ($findEquipment->company_projects_id != null && $findEquipment->company_projects_id == $company_projects_id) {
|
|
$equipmentPendingLogs[count($equipmentPendingLogs) - 1]['reason'] = 'Equipamento já associado a esta obra';
|
|
$equipmentPendingLogs[count($equipmentPendingLogs) - 1]['typePendingLog'] = 2.1;
|
|
|
|
} elseif ($findEquipment->company_projects_id != null && $findEquipment->company_projects_id != $company_projects_id) {
|
|
$findOtherCompanyProject = CompanyProject::find($findEquipment->company_projects_id);
|
|
$equipmentPendingLogs[count($equipmentPendingLogs) - 1]['reason'] = 'Equipamento associado a outra Obra: ' . $findOtherCompanyProject->company_project_description;
|
|
$equipmentPendingLogs[count($equipmentPendingLogs) - 1]['typePendingLog'] = 2.2;
|
|
|
|
} else {
|
|
//equipamentos novos nao entram na equipmentPendingLogs, criar um proprio apenas para teste.
|
|
$equipmentPendingLogs[count($equipmentPendingLogs) - 1]['reason'] = 'Equipamento associado a obra com sucesso!';
|
|
$equipmentPendingLogs[count($equipmentPendingLogs) - 1]['typePendingLog'] = 2.3;
|
|
|
|
// Associar o equipamento à Obra atual
|
|
$findEquipment->company_projects_id = $company_projects_id;
|
|
$findEquipment->save();
|
|
|
|
//Apenas para indicar qtd de equipamentos criados
|
|
$countEquipment++;
|
|
|
|
// Criar um equipment_work_historys
|
|
$newEquipmentWorkHistory = new EquipmentWorkHistory;
|
|
$newEquipmentWorkHistory->equipment_id = $findEquipment->equipment_id;
|
|
$newEquipmentWorkHistory->equipment_status_project = 0;
|
|
$newEquipmentWorkHistory->ispt_number = $isptNumber++;
|
|
$newEquipmentWorkHistory->company_projects_id = $company_projects_id;
|
|
$newEquipmentWorkHistory->save();
|
|
|
|
|
|
//Adicionar Ambito e Tarefas para fazer.
|
|
$ambit = AmbitsEquipment::where('ambits_description', $datas['ambit'])->first();
|
|
|
|
if ($ambit) {
|
|
$ambit_id = $ambit->ambits_id;
|
|
}
|
|
|
|
//Criar associacao do equipamento ao Âmbito
|
|
$AssociationEquipmentAmbit = new EquipmentAssociationAmbit;
|
|
$AssociationEquipmentAmbit->equipment_type_id = $findEquipment->equipment_type_id;
|
|
$AssociationEquipmentAmbit->ambits_id = $ambit_id;
|
|
$AssociationEquipmentAmbit->equipmentWorkHistorys_id = $newEquipmentWorkHistory->equipmentWorkHistorys_id;
|
|
|
|
$AssociationEquipmentAmbit->save();
|
|
|
|
//Recebe a tabela com as associoacoes entre Âmbitos e tarefas Elementares
|
|
$TasksAssociationAmbits = TasksAssociationAmbits::all()->where('ambits_equipment_id', $AssociationEquipmentAmbit->ambits_id);
|
|
$execution_order = 1;
|
|
|
|
foreach ($TasksAssociationAmbits as $TasksAssociationAmbit) {
|
|
$JoinsEquipmentsWithTasks = new OrderEquipmentTasks;
|
|
$newEquipmentWorkHistory->ispt_number = $isptNumber++;
|
|
$JoinsEquipmentsWithTasks->equipmentWorkHistorys_id = $newEquipmentWorkHistory->equipmentWorkHistorys_id;
|
|
$JoinsEquipmentsWithTasks->elemental_tasks_id = $TasksAssociationAmbit->elemental_tasks_id;
|
|
$JoinsEquipmentsWithTasks->save();
|
|
}
|
|
|
|
}
|
|
continue; // Pula para a próxima iteração
|
|
|
|
//----- Para equipamento novos, nao pendentes. ---------
|
|
// Caso a linha nao se enquadre em nenhuma das verificacoes anteriores, ele sera considerado um equipamento novo.
|
|
} else {
|
|
|
|
//Novo equipamento
|
|
$newEquipament = new Equipment;
|
|
$newEquipament->unit_id = $detailsUnit->unit_id;
|
|
$newEquipament->equipment_type_id = $equipmentType->equipment_type_id;
|
|
$newEquipament->equipment_Description = $datas['equipment_description'];
|
|
$newEquipament->equipment_tag = $datas['equipment_tag'];
|
|
$newEquipament->equipment_serial_number = $datas['serial_number'];
|
|
$newEquipament->equipment_brand = $datas['brand'];
|
|
$newEquipament->equipment_model = $datas['model'];
|
|
$newEquipament->company_projects_id = $company_projects_id;
|
|
$newEquipament->save();
|
|
|
|
$countEquipment++;
|
|
|
|
//Deve adicionar tambem os outros atributos espesificos para o equipameto.
|
|
|
|
|
|
//Criar o equipment Work History
|
|
$newEquipmentWorkHistory = new EquipmentWorkHistory;
|
|
$newEquipmentWorkHistory->equipment_id = $newEquipament->equipment_id;
|
|
$newEquipmentWorkHistory->ispt_number = $isptNumber++;
|
|
$newEquipmentWorkHistory->company_projects_id = $company_projects_id;
|
|
$newEquipmentWorkHistory->equipment_status_project = 0;
|
|
$newEquipmentWorkHistory->save();
|
|
|
|
$ambit = AmbitsEquipment::where('ambits_description', $datas['ambit'])->first();
|
|
|
|
if ($ambit) {
|
|
$ambit_id = $ambit->ambits_id;
|
|
}
|
|
|
|
//Criar associacao do equipamento ao Âmbito
|
|
$AssociationEquipmentAmbit = new EquipmentAssociationAmbit;
|
|
$AssociationEquipmentAmbit->equipment_type_id = $newEquipament->equipment_type_id;
|
|
$AssociationEquipmentAmbit->ambits_id = $ambit_id;
|
|
$AssociationEquipmentAmbit->equipmentWorkHistorys_id = $newEquipmentWorkHistory->equipmentWorkHistorys_id;
|
|
|
|
$AssociationEquipmentAmbit->save();
|
|
|
|
//Recebe a tabela com as associoacoes entre Âmbitos e tarefas Elementares
|
|
$TasksAssociationAmbits = TasksAssociationAmbits::all()->where('ambits_equipment_id', $AssociationEquipmentAmbit->ambits_id);
|
|
$execution_order = 1;
|
|
|
|
foreach ($TasksAssociationAmbits as $TasksAssociationAmbit) {
|
|
$JoinsEquipmentsWithTasks = new OrderEquipmentTasks;
|
|
$JoinsEquipmentsWithTasks->execution_order = $execution_order++;
|
|
$JoinsEquipmentsWithTasks->equipmentWorkHistorys_id = $newEquipmentWorkHistory->equipmentWorkHistorys_id;
|
|
$JoinsEquipmentsWithTasks->elemental_tasks_id = $TasksAssociationAmbit->elemental_tasks_id;
|
|
$JoinsEquipmentsWithTasks->save();
|
|
}
|
|
|
|
// Cria um array agrupado
|
|
$groupedArrayForPendingEquipments = [$documentType, [$timestamp, $equipmentPendingLogs]];
|
|
// Armazenar $groupedArrayForPendingEquipments na sessão
|
|
//------- Porem agora nao deve ser guardado em uma sessao em sim em uma tabela da Db ate terminar(concluir) a Obra
|
|
session(['groupedArrayForPendingEquipments' => $groupedArrayForPendingEquipments]);
|
|
// $pendingEquipments = PendingEquipment::where('pending_company_projects_id', $request->numberProject)->get();
|
|
|
|
$equipmentPendingLogs[] = [
|
|
'typePendingLog' => 3,
|
|
'line' => $i + 1,
|
|
'reason' => 'Equipamento Novo' // Adiciona uma razão vazia por padrão que será atualizada mais tarde
|
|
];
|
|
continue;
|
|
}
|
|
|
|
// Se a linha não for duplicada nem no Excel nem na base de dados,
|
|
// a linha é considerada para a criação de um novo equipamento.
|
|
// Sua lógica para criar um novo equipamento pode ser inserida aqui.
|
|
|
|
}
|
|
|
|
$countEquipment; //Qtd de equipamentos novos criados
|
|
$countPendingEquipments; // Qtd de equipamentos pendentes criados
|
|
|
|
|
|
$createProjectLogs = new ProjectExcelLog;
|
|
$createProjectLogs->company_projects_id = $detailsCompanyProject->company_projects_id;
|
|
$createProjectLogs->excel_name = $originalFileName;
|
|
$createProjectLogs->excel_logs = $equipmentPendingLogs;
|
|
|
|
$createProjectLogs->save();
|
|
|
|
|
|
return redirect()->route('articulated_2', ['projectID' => $request->numberProject])
|
|
->with('success', 'Equipamentos criados com sucesso !');
|
|
|
|
|
|
// if ($countPendingEquipments != 0 && !empty($equipmentPendingLogs)) {
|
|
// // Se houver equipamentos pendentes, redirecione com essa informação e inclua os $linhasIgnoradas se não estiverem vazios
|
|
// return redirect()->route('articulated_2', ['projectID' => $request->numberProject])
|
|
// ->with('danger', 'Equipamentos Pendentes criados: ' . $countPendingEquipments)
|
|
// ->with('dangerLogs', $ignoredLines)
|
|
// ->with('equipmentPendingLogs', $equipmentPendingLogs);
|
|
// // ->with('pendingEquipments', $pendingEquipments);
|
|
// } else {
|
|
// // Se não houver equipamentos pendentes, redirecione com uma mensagem de sucesso e inclua os $linhasIgnoradas se não estiverem vazios
|
|
// return redirect()->route('articulated_2', ['projectID' => $request->numberProject])
|
|
// ->with('success', 'Equipamentos Criados: ' . $countEquipment)
|
|
// ->with('dangerLogs', $ignoredLines);
|
|
// }
|
|
// return redirect()->route('articulated_2', ['projectID' => $request->numberProject])
|
|
// ->with('success', 'Equipamentos Adicionados a Obra com sucesso: ' . $countEquipment);
|
|
} else {
|
|
return redirect()->route('articulated_2', ['projectID' => $request->numberProject])
|
|
->with('danger', 'Arquivo ignorado , por nao ser compativel com a template 4.0');
|
|
// Nenhum arquivo enviado para verificacao do excel.
|
|
}
|
|
// //Nao chega aqui ainda pois volta para a pagina com dados ja carregados.
|
|
// session(['form_data.step2' => $request->all()]);
|
|
|
|
// // Redirecione o Utilizador para a próxima etapa
|
|
// return redirect('/workStation_3');
|
|
}
|
|
|
|
public function showStep3($company_projects_id)
|
|
{
|
|
$equipments = Equipment::where('company_projects_id', $company_projects_id)
|
|
->get();
|
|
|
|
foreach ($equipments as $equipment) {
|
|
$tags = [];
|
|
// Se for psv tem o id 3 e atualmente sao os unicos tipos de valvulas que tem obturador (cv),(isv) nao apresentam.
|
|
if ($equipment->equipment_type_id == 3) {
|
|
$tags = ['@Corpo', '@Flange', '@Obturador'];
|
|
} else {
|
|
$tags = ['@Corpo', '@Flange'];
|
|
}
|
|
|
|
|
|
foreach ($tags as $tag) {
|
|
$associatedEquipment = QrcodesAssociatedEquipment::where('equipment_id', $equipment->equipment_id)
|
|
->where('component_tag', 'LIKE', '%' . $tag)
|
|
->first();
|
|
|
|
if ($associatedEquipment) {
|
|
// Atualizar a coluna component_tag para ser igual à equipment_tag, mantendo a parte após o "@"
|
|
$newComponentTag = $equipment->equipment_tag . $tag;
|
|
$associatedEquipment->component_tag = $newComponentTag;
|
|
$associatedEquipment->save();
|
|
} else {
|
|
// Criar uma nova entrada
|
|
QrcodesAssociatedEquipment::create([
|
|
'equipment_id' => $equipment->equipment_id,
|
|
'component_tag' => $equipment->equipment_tag . $tag
|
|
]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Obter IDs de equipamentos ativos do projeto especificado.
|
|
$activeEquipmentIds = Equipment::where('company_projects_id', $company_projects_id)
|
|
->pluck('equipment_id')
|
|
->toArray();
|
|
|
|
// Identificar todos os equipment_id em QrcodesAssociatedEquipment.
|
|
$equipmentIdsInQrcodes = QrcodesAssociatedEquipment::pluck('equipment_id')->unique()->toArray();
|
|
|
|
// Verificar quais desses equipment_id foram desassociados de qualquer projeto na tabela Equipment.
|
|
$orphanEquipmentIds = Equipment::whereIn('equipment_id', $equipmentIdsInQrcodes)
|
|
->whereNull('company_projects_id')
|
|
->pluck('equipment_id')
|
|
->toArray();
|
|
|
|
// Excluir todas as entradas em QrcodesAssociatedEquipment para os equipment_id desassociados.
|
|
foreach ($orphanEquipmentIds as $orphanId) {
|
|
QrcodesAssociatedEquipment::where('equipment_id', $orphanId)->delete();
|
|
}
|
|
|
|
//Sempre que entrar na view ja verifica se existe 'Workstations' preparadas para esta obra.
|
|
$listWorkstations = ConstructionWorkstation::where('company_projects_id', $company_projects_id)->get();
|
|
|
|
$futherTasks = FurtherTasks::where('company_projects_id', $company_projects_id)
|
|
->get();
|
|
|
|
return view('projectsClients/workStation_3', ['step' => 3, 'numberProject' => $company_projects_id])
|
|
->with('listWorkstations', $listWorkstations)
|
|
->with('equipments', $equipments)
|
|
->with('futherTasks', $futherTasks);
|
|
}
|
|
|
|
public function workstationsAssociationTasks(Request $request)
|
|
{
|
|
// dd($request);
|
|
$workStation = ConstructionWorkstation::where('id_workstations', $request->idWorkStation)->first();
|
|
// Trocar o nome se for diferente do recebido
|
|
if ($workStation) {
|
|
$workStation->nomenclature_workstation = $request->nameWorkstation;
|
|
$workStation->save();
|
|
}
|
|
|
|
// Atualizar a lista de tipos de tarefas para incluir os novos grupos
|
|
$taskTypes = ['generalTasks', '1', '2', '3', 'FurtherTasks'];
|
|
|
|
|
|
foreach ($taskTypes as $groupTasks) {
|
|
if (isset($request[$groupTasks])) { // Checar se esse grupo de tarefas existe no request
|
|
foreach ($request[$groupTasks] as $taskID => $check) {
|
|
|
|
//Este code pode parecer repetitivo, pois antes tinha uma tabela para os 2 tipos de tarefa. TE e TC apos atualizacao ambas ficam em uma so tabela, porem por falta de tempo ainda nao foi melhorado sua logina , MAS FUNCIONA !!!!
|
|
if ($groupTasks == 'FurtherTasks') {
|
|
// Encontra a tarefa existente, se houver, para FurtherTasks
|
|
$taskAssociation = WorkstationsAssociationTasks::where('id_workstations', $workStation->id_workstations)
|
|
->where('elemental_tasks_id', $taskID)
|
|
->where('company_projects_id', $workStation->company_projects_id)
|
|
->first();
|
|
} else {
|
|
// Encontra a tarefa existente, se houver, para os outros grupos
|
|
$taskAssociation = WorkstationsAssociationTasks::where('id_workstations', $workStation->id_workstations)
|
|
->where('elemental_tasks_id', $taskID)
|
|
->where('company_projects_id', $workStation->company_projects_id)
|
|
->first();
|
|
}
|
|
|
|
if ($check == 'on') {
|
|
if (!$taskAssociation) {
|
|
$taskAssociation = new WorkstationsAssociationTasks;
|
|
$taskAssociation->id_workstations = $workStation->id_workstations;
|
|
if ($groupTasks == 'FurtherTasks') {
|
|
$taskAssociation->elemental_tasks_id = $taskID; // Usando $taskID, que é a key
|
|
} else {
|
|
$taskAssociation->elemental_tasks_id = $taskID; // Usando $taskID, que é a key
|
|
}
|
|
$taskAssociation->company_projects_id = $workStation->company_projects_id;
|
|
}
|
|
$taskAssociation->save();
|
|
} elseif ($check == 'off' && $taskAssociation) {
|
|
$taskAssociation->delete();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Redirecionar de volta com uma mensagem de sucesso
|
|
return back()->with('success', 'Posto de trabalho : ' . $workStation->name_workstations . ' atualizado com sucesso!');
|
|
}
|
|
|
|
public function processStep3(Request $request)
|
|
{
|
|
// Valide e processe os dados do formulário
|
|
// ...
|
|
session(['form_data.step3' => $request->all()]);
|
|
|
|
// Aqui, todas as etapas foram concluídas
|
|
// Você pode redirecionar o Utilizador para uma página de "Obrigado" ou processar os dados do formulário
|
|
// ...
|
|
}
|
|
|
|
public function index()
|
|
{
|
|
|
|
|
|
$results = DB::table('equipments')
|
|
->join('specific_attributes_equipament_types', 'equipments.equipment_id', '=', 'specific_attributes_equipament_types.equipment_id')
|
|
->join('general_attributes_equipaments', 'specific_attributes_equipament_types.specific_attributes_equipment_type_id', '=', 'general_attributes_equipaments.general_attributes_equipment_id')
|
|
->select('equipments.equipment_tag', 'general_attributes_equipaments.general_attributes_equipment_description', 'specific_attributes_equipament_types.specific_attributes_value')
|
|
->get();
|
|
|
|
|
|
// dd($results);
|
|
|
|
$groupedEquipments = [];
|
|
|
|
foreach ($results as $result) {
|
|
if (!isset($groupedEquipments[$result->tag])) {
|
|
$groupedEquipments[$result->tag] = [];
|
|
}
|
|
|
|
$groupedEquipments[$result->tag][] = [
|
|
'description' => $result->description,
|
|
'value' => $result->value
|
|
];
|
|
}
|
|
|
|
$equipments = DB::table('equipments')->get();
|
|
|
|
foreach ($equipments as $equipment) {
|
|
if (isset($groupedEquipments[$equipment->tag])) {
|
|
$equipment->specific_attributes = $groupedEquipments[$equipment->tag];
|
|
}
|
|
}
|
|
$allPossibleAttributes = GeneralAttributesEquipment::all()->pluck('description')->toArray();
|
|
|
|
return view('articulated_2', ['equipments' => $equipments, 'allAttributes' => $allPossibleAttributes]);
|
|
// Retorne a view com os dados
|
|
// return view('test', ['equipments' => $equipments]);
|
|
}
|
|
|
|
|
|
public function listCompanies()
|
|
{
|
|
$companies = User::where('type_users', 3)->get();
|
|
return view('projectsClients/createProject', ['companies' => $companies]);
|
|
}
|
|
|
|
|
|
public function createProject(Request $request)
|
|
{
|
|
|
|
// Validação...
|
|
$installationId = $request->input('installation_id');
|
|
|
|
if ($installationId == 'new_install') {
|
|
// Criar uma nova instalação...
|
|
$newInstallation = new Unit;
|
|
$newInstallation->installation_name = $request->input('new_company_name');
|
|
$newInstallation->address = $request->input('new_company_address');
|
|
$newInstallation->user_id = $request->input('user_id');
|
|
|
|
$newInstallation->save();
|
|
|
|
// Use o id da nova instalação.
|
|
$installationId = $newInstallation->id;
|
|
// dd($installationId);
|
|
}
|
|
|
|
$project = new CompanyProject;
|
|
|
|
$project->description_project = $request->input('description_project');
|
|
$project->n_project_ispt = $request->input('n_project_ispt');
|
|
$project->responsible_project_ispt = $request->input('responsible_project_ispt');
|
|
$project->responsible_project_company = $request->input('responsible_project_company');
|
|
$project->date_started = $request->input('date_started');
|
|
|
|
$project->installation_id = $installationId;
|
|
|
|
$project->save();
|
|
|
|
return redirect()->route('createProject')->with('success', 'Dados guardados com sucesso');
|
|
// return redirect()->route('createProject')->with('success', 'Dados guardados com sucesso');
|
|
|
|
}
|
|
|
|
public function storeProject(Request $request)
|
|
{
|
|
if ($request->input('company_id') == 'new') {
|
|
$company = new CompanyProject; // Substitua "Company" pelo nome do seu modelo de empresas
|
|
$company->name = $request->input('new_company_name');
|
|
$company->save();
|
|
|
|
$company_id = $company->id;
|
|
} else {
|
|
$company_id = $request->input('company_id');
|
|
}
|
|
|
|
// Agora, você pode usar $company_id ao criar o projeto
|
|
}
|
|
|
|
// public function getByUserNif(Request $request)
|
|
// {
|
|
|
|
// $user_id = $request->input('user_id'); //Check
|
|
// $installations = Plant::where('user_id', $user_id)->get();
|
|
|
|
// $associationUserCompany = AssociationCompanyUser::where('association_company_user_id',$user_id)->get();
|
|
|
|
// return response()->json($installations);
|
|
// }
|
|
|
|
public function getByUserNif(Request $request)
|
|
{
|
|
|
|
$companyId = $request->input('company_id'); // Considerando que este ID é na verdade o ID da empresa
|
|
|
|
// Busca as instalações associadas à empresa
|
|
$installations = Plant::where('company_id', $companyId)->get();
|
|
|
|
// Busca os usuários associados à empresa
|
|
$userIds = AssociationCompanyUser::where('company_id', $companyId)->pluck('user_id');
|
|
$users = User::whereIn('user_id', $userIds)->get();
|
|
|
|
return response()->json([
|
|
'installations' => $installations,
|
|
'users' => $users
|
|
]);
|
|
}
|
|
|
|
public function getAmbits($equipmentType)
|
|
{
|
|
|
|
$ambits = DB::table('ambits_equipments')
|
|
->select('ambits_equipments.*')
|
|
->where('ambits_equipments.equipment_type_id', $equipmentType)
|
|
->get();
|
|
return response()->json($ambits);
|
|
}
|
|
|
|
public function getAttributes($id)
|
|
{
|
|
$equipment = Equipment::with('specificAttributes')->find($id);
|
|
return response()->json($equipment->specificAttributes);
|
|
}
|
|
}
|