mirror of
https://git.imnavajas.es/jjimenez/safekat.git
synced 2025-07-25 22:52:08 +00:00
660 lines
28 KiB
PHP
Executable File
660 lines
28 KiB
PHP
Executable File
<?php
|
|
|
|
namespace App\Services;
|
|
|
|
use CodeIgniter\Config\BaseService;
|
|
|
|
|
|
|
|
|
|
class PresupuestoService extends BaseService
|
|
{
|
|
/**
|
|
* CONSTANTES USADAS PARA LOS CALCULOS
|
|
*/
|
|
|
|
const MARGEN_PAGINAS_ROTATIVA = 15.0;
|
|
const SANGRE_FORMAS = 5.0;
|
|
const SANGRE_FORMAS_CUBIERTA = 20.0;
|
|
|
|
|
|
/**
|
|
* @param mixed $uso
|
|
* contiene algun parametro de la lista ['interior,'cubierta','sobrecubierta']
|
|
* @param mixed $tipo
|
|
* contiene algun parametro de la lista ['negro','color','negrohq','bicolor','colorhq']
|
|
* @param mixed $datosPedido
|
|
* objeto con la siguiente extructura:
|
|
* -> paginas: numero de paginas por libro
|
|
* -> tirada: numero de unidades a imprimir
|
|
* -> merma: unidades que se añaden a la tirada
|
|
*
|
|
* @param mixed $maquina
|
|
* objeto con la siguiente estructura:
|
|
* -> id: el id de la maquina
|
|
* -> nombre: nombre de la maquina
|
|
* -> ancho_impresion: valor maximo del ancho para imprimir
|
|
* -> alto_impresion: valor maximo del alto para imprimir
|
|
* @param mixed $papel_impresion
|
|
* @param mixed $tarifa
|
|
*
|
|
* @return [type]
|
|
*/
|
|
public static function getCostesLinea($uso, $datosPedido, $maquina, $papel_impresion, $opciones_papel, $tarifa, $forzar_a_favor_fibra = false)
|
|
{
|
|
$response['fields'] = [];
|
|
|
|
if ($uso!='rotativa') {
|
|
|
|
$ancho_calculo = ($uso=='cubierta' || $uso=='sobrecubierta') ? $datosPedido->anchoExteriores : $datosPedido->ancho;
|
|
$alto_calculo = ($uso=='cubierta' || $uso=='sobrecubierta') ? $datosPedido->altoExteriores : $datosPedido->alto;
|
|
$formas = PresupuestoService::getNumFormasPlana($uso, $maquina, $ancho_calculo, $alto_calculo, $datosPedido->isCosido, $forzar_a_favor_fibra);
|
|
$response['fields'] = $formas;
|
|
}
|
|
|
|
|
|
if ($response['fields']['num_formas']['posicion_formas'] == 'n/a') {
|
|
$response['error']['value'] = true;
|
|
$response['error']['message'] = 'no_formas_disponibles';
|
|
return $response;
|
|
}
|
|
|
|
// precio del pliego de impresion
|
|
[$precio_pliego_impresion, $margen_pliego_impresion] = PresupuestoService::getPrecioPliego($maquina, $papel_impresion, $datosPedido->paginas);
|
|
|
|
$precio_click = 0;
|
|
$precio_click_pedido = 0;
|
|
$pliegos_libro = 0;
|
|
|
|
$cubierta = array_key_exists('cubierta', $opciones_papel) ? $opciones_papel['cubierta'] : 0;
|
|
$sobrecubierta = array_key_exists('sobrecubierta', $opciones_papel) ? $opciones_papel['sobrecubierta'] : 0;
|
|
$rotativa = array_key_exists('rotativa', $opciones_papel) ? $opciones_papel['rotativa'] : 0;
|
|
|
|
//interior (bn o color)
|
|
if ($cubierta == 0 && $sobrecubierta == 0 && $rotativa == 0) {
|
|
// precio papel
|
|
$pliegos_libro = ceil(($datosPedido->paginas / 2.0) / $response['fields']['num_formas']['value']);
|
|
if($pliegos_libro<1)
|
|
$pliegos_libro = 1;
|
|
$pliegos_pedido = $pliegos_libro * ($datosPedido->tirada + $datosPedido->merma);
|
|
$precio_libro = $pliegos_libro * ($precio_pliego_impresion+$margen_pliego_impresion);
|
|
$margen_papel_pedido = $pliegos_libro * $margen_pliego_impresion * ($datosPedido->tirada + $datosPedido->merma);
|
|
$precio_pedido = $precio_libro * ($datosPedido->tirada + $datosPedido->merma);
|
|
|
|
$mano = PresupuestoService::computeLomoInterior($datosPedido->paginas, $papel_impresion->espesor);
|
|
|
|
// peso
|
|
$peso = PresupuestoService::computePeso(
|
|
ancho: $datosPedido->isCosido ? $datosPedido->ancho / 2.0 : $datosPedido->ancho,
|
|
alto: $datosPedido->alto,
|
|
gramaje: $papel_impresion->gramaje,
|
|
paginas: $datosPedido->paginas
|
|
);
|
|
|
|
// impresion
|
|
$precio_click = $tarifa;
|
|
if($uso=='guardas'){
|
|
if(floatval($datosPedido->paginas_impresion)==0)
|
|
$precio_click_pedido = 0;
|
|
elseif (floatval($datosPedido->paginas_impresion)==4) // Una cara
|
|
$precio_click_pedido = $pliegos_pedido * $precio_click;
|
|
else // dos caras (impresion normal)
|
|
$precio_click_pedido = $pliegos_pedido * 2 * $precio_click;
|
|
}
|
|
else
|
|
$precio_click_pedido = $pliegos_pedido * 2 * $precio_click;
|
|
|
|
}
|
|
// cubierta o sobrecubierta (siempre a color)
|
|
else if (($cubierta == 1 || $sobrecubierta == 1) && $rotativa == 0) {
|
|
// precio papel
|
|
$pliegos_libro = 1.0 / $response['fields']['num_formas']['value'];
|
|
// En cubierta y sobrecubierta siempre el mínimo pliego es 1
|
|
$pliegos_libro = $pliegos_libro<1?1:$pliegos_libro;
|
|
$pliegos_pedido = $pliegos_libro * ($datosPedido->tirada + $datosPedido->merma);
|
|
$precio_libro = $pliegos_libro * $precio_pliego_impresion;
|
|
$margen_papel_pedido = $pliegos_libro * $margen_pliego_impresion * ($datosPedido->tirada + $datosPedido->merma);
|
|
$precio_pedido = $precio_libro * ($datosPedido->tirada + $datosPedido->merma);
|
|
|
|
$mano = PresupuestoService::computeLomoPortada($papel_impresion->espesor);
|
|
|
|
// peso
|
|
$ancho_total = $datosPedido->anchoExteriores + $mano;
|
|
$peso = PresupuestoService::computePeso($ancho_total, $datosPedido->alto, $papel_impresion->gramaje);
|
|
|
|
// impresion
|
|
if ($tarifa) {
|
|
$precio_click = $tarifa;
|
|
$precio_click_pedido = $pliegos_pedido * $precio_click;
|
|
|
|
// dos caras
|
|
if($datosPedido->paginas > 2) {
|
|
$precio_click_pedido *= 2.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// response
|
|
$response['fields']['pliegos_libro'] = $pliegos_libro;
|
|
$response['fields']['pliegos_pedido'] = $pliegos_pedido;
|
|
$response['fields']['precios_pliegos'] = $precio_pliego_impresion;
|
|
$response['fields']['precio_libro'] = $precio_libro;
|
|
$response['fields']['margen_papel_pedido'] = $margen_papel_pedido;
|
|
$response['fields']['precio_pedido'] = $precio_pedido;
|
|
$response['fields']['mano'] = $mano;
|
|
$response['fields']['peso'] = $peso;
|
|
$response['fields']['precio_click'] = $precio_click;
|
|
$response['fields']['precio_click_pedido'] = $precio_click_pedido;
|
|
|
|
$response['fields']['dimensiones_maquina'] = [$maquina->ancho, $maquina->alto];
|
|
$response['fields']['dimensiones_maquina_impresion'] = [$maquina->ancho_impresion, $maquina->alto_impresion];
|
|
$response['fields']['dimensiones_maquina_click'] = [$maquina->ancho_impresion, $maquina->alto_click];
|
|
$response['fields']['dimensiones_libro'] = [$datosPedido->ancho, $datosPedido->alto];
|
|
|
|
return $response;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Devuelve los calculos para la linea de rotativa.
|
|
*/
|
|
public static function getCostesLineaRotativa($maquina, $papel_impresion, $datosPedido, $parametrosRotativa)
|
|
{
|
|
$data = [];
|
|
|
|
[$data['ancho'], $data['alto']] = PresupuestoService::calculoDimForma($datosPedido, $parametrosRotativa);
|
|
|
|
// calculo de papel y clicks
|
|
$factor_anchura = round($maquina->ancho_impresion / $data['ancho'], 2);
|
|
$factor_altura = round($maquina->alto_impresion / ($data['alto'] + self::MARGEN_PAGINAS_ROTATIVA), 2);
|
|
$factor_altura_click = round($maquina->alto_click / ($data['alto'] + self::MARGEN_PAGINAS_ROTATIVA), 2);
|
|
|
|
$multiplicador_pliego = $datosPedido->isCosido ? 4 : 2;
|
|
$paginas_por_pliego = round(floor($factor_anchura) * $factor_altura * $multiplicador_pliego, 2);
|
|
$pliegos_libro = round($paginas_por_pliego ? $datosPedido->paginas / $paginas_por_pliego : 0, 2);
|
|
$metros_papel_libro = round($pliegos_libro * ($maquina->alto_impresion / 1000.0), 2);
|
|
$metros_papel_total = round($metros_papel_libro * ($datosPedido->tirada + $datosPedido->merma), 2);
|
|
|
|
$paginas_por_pliego_click = round(floor($factor_anchura) * $factor_altura_click * $multiplicador_pliego, 2);
|
|
$pliegos_libro_click = round($paginas_por_pliego_click ? $datosPedido->paginas / $paginas_por_pliego_click : 0, 2);
|
|
$clicks_libro = round(ceil($pliegos_libro_click) * 2, 2);
|
|
$clicks_pedido = round($clicks_libro * ($datosPedido->tirada + $datosPedido->merma), 2);
|
|
|
|
$data['factor_altura'] = $factor_altura;
|
|
$data['factor_anchura'] = $factor_anchura;
|
|
$data['paginas_por_pliego'] = $paginas_por_pliego;
|
|
$data['pliegos_libro'] = $pliegos_libro;
|
|
$data['pliegos_pedido'] = $pliegos_libro * ($datosPedido->tirada + $datosPedido->merma);
|
|
$data['metros_papel_libro'] = $metros_papel_libro;
|
|
$data['metros_papel_total'] = $metros_papel_total;
|
|
$data['clicks_libro'] = $clicks_libro;
|
|
$data['clicks_pedido'] = $clicks_pedido;
|
|
|
|
// calculo de tintas
|
|
$data = array_merge($data, PresupuestoService::calculoCosteTintas($maquina, $datosPedido, $parametrosRotativa));
|
|
|
|
// calculo de corte
|
|
$data['velocidad_corte'] = $maquina->velocidad_corte;
|
|
$data['precio_hora_corte'] = $maquina->precio_hora_corte;
|
|
$data['tiempo_corte'] = $maquina->velocidad_corte > 0 ? round($metros_papel_total / $maquina->velocidad_corte, 2) : 0;
|
|
$data['total_corte'] = round(($data['tiempo_corte'] / 60.0) * $maquina->precio_hora_corte, 2);
|
|
|
|
$data['mano'] = PresupuestoService::computeLomoInterior($datosPedido->paginas, $papel_impresion->espesor);
|
|
// ($paginas / 2.0) * (($gramaje / 1000.0) * $papel_compra->mano);
|
|
|
|
// peso
|
|
$data['peso'] = PresupuestoService::computePeso(
|
|
ancho: $datosPedido->isCosido ? $datosPedido->ancho / 2.0 : $datosPedido->ancho,
|
|
alto: $datosPedido->alto,
|
|
gramaje: $papel_impresion->gramaje,
|
|
paginas: $datosPedido->paginas
|
|
);
|
|
|
|
$data['dimensiones_maquina'] = [$maquina->ancho, $maquina->alto];
|
|
$data['dimensiones_maquina_impresion'] = [$maquina->ancho_impresion, $maquina->alto_impresion];
|
|
$data['dimensiones_maquina_click'] = [$maquina->ancho_impresion, $maquina->alto_click];
|
|
$data['dimensiones_libro'] = [$datosPedido->ancho, $datosPedido->alto];
|
|
|
|
$data['alto_click'] = $maquina->alto_click;
|
|
|
|
$formas = PresupuestoService::getNumFormasRot(
|
|
$maquina,
|
|
$datosPedido->ancho,
|
|
$datosPedido->alto,
|
|
$datosPedido->isCosido,
|
|
$parametrosRotativa->a_favor_fibra);
|
|
$data['num_formas'] = $formas;
|
|
|
|
return $data;
|
|
}
|
|
|
|
|
|
/**
|
|
* Devuelve los calculos de las dimensiones de la forma
|
|
*/
|
|
public static function calculoDimForma($datosPedido, $parametros){
|
|
// posicionamos paginas en función de a favor de fibra o no
|
|
if (!$parametros->a_favor_fibra) {
|
|
$anchoLibro = $datosPedido->alto;
|
|
$altoLibro = $datosPedido->ancho;
|
|
}
|
|
else{
|
|
$anchoLibro = $datosPedido->ancho;
|
|
$altoLibro = $datosPedido->alto;
|
|
}
|
|
|
|
// si es cosido ancho x 2
|
|
if ($datosPedido->isCosido) {
|
|
if (!$parametros->a_favor_fibra) {
|
|
$altoLibro = $altoLibro * 2;
|
|
} else {
|
|
$anchoLibro = $anchoLibro * 2;
|
|
}
|
|
}
|
|
|
|
return [$anchoLibro, $altoLibro];
|
|
}
|
|
|
|
|
|
/**
|
|
* Devuelve los calculos para el coste de tintas
|
|
*/
|
|
public static function calculoCosteTintas($maquina, $datosPedido, $parametros)
|
|
{
|
|
$data = [];
|
|
|
|
$data['pulgada'] = 1 / 1000000000000.0;
|
|
$data['resolucion'] = 600;
|
|
$data['superficie'] = round((($datosPedido->ancho / 2.54) / 10) * (($datosPedido->alto / 2.54) / 10), 2);
|
|
|
|
$data['num_gotas_negro'] = round($data['superficie'] * $data['resolucion'] * $data['resolucion'] * ($parametros->rotativa_negro / 100.0), 0);
|
|
$data['num_gotas_cyan'] = round($data['superficie'] * $data['resolucion'] * $data['resolucion'] * ($parametros->rotativa_cyan / 100.0), 0);
|
|
$data['num_gotas_magenta'] = round($data['superficie'] * $data['resolucion'] * $data['resolucion'] * ($parametros->rotativa_magenta / 100.0), 0);
|
|
$data['num_gotas_amarillo'] = round($data['superficie'] * $data['resolucion'] * $data['resolucion'] * ($parametros->rotativa_amarillo / 100.0), 0);
|
|
|
|
$pag_negro = $parametros->bnPages;
|
|
$pag_color = 0;
|
|
if ($parametros->colorPages>0) {
|
|
$pag_color = $parametros->colorPages;
|
|
}
|
|
|
|
// peso tintas
|
|
$data['peso_gotas_negro'] = round((($data['num_gotas_negro'] * $parametros->rotativa_gota_negro * $data['pulgada']) / (17.91 / 20.0)) * $pag_negro * 1000, 6);
|
|
$data['peso_gotas_negro'] += round((($data['num_gotas_negro'] * $parametros->rotativa_gota_negro * $data['pulgada']) / (17.91 / 20.0)) * $pag_color * 1000, 6);
|
|
$data['peso_gotas_cyan'] = round((($data['num_gotas_cyan'] * $parametros->rotativa_gota_color * $data['pulgada']) / (17.65 / 20.0)) * $pag_color * 1000, 6);
|
|
$data['peso_gotas_magenta'] = round((($data['num_gotas_magenta'] * $parametros->rotativa_gota_color * $data['pulgada']) / (17.65 / 20.0)) * $pag_color * 1000, 6);
|
|
$data['peso_gotas_amarillo'] = round((($data['num_gotas_amarillo'] * $parametros->rotativa_gota_color * $data['pulgada']) / (17.65 / 20.0)) * $pag_color * 1000, 6);
|
|
|
|
// costes de tintas
|
|
$data['peso_gotas_negro_pedido'] = round($data['peso_gotas_negro'], 2) * ($datosPedido->tirada + $datosPedido->merma);
|
|
$data['peso_gotas_cyan_pedido'] = round($data['peso_gotas_cyan'], 2) * ($datosPedido->tirada + $datosPedido->merma);
|
|
$data['peso_gotas_magenta_pedido'] = round($data['peso_gotas_magenta'], 2) * ($datosPedido->tirada + $datosPedido->merma);
|
|
$data['peso_gotas_amarillo_pedido'] = round($data['peso_gotas_amarillo'], 2) * ($datosPedido->tirada + $datosPedido->merma);
|
|
|
|
// precio tinta
|
|
$data['precio_tinta'] = round(
|
|
round(($data['peso_gotas_negro_pedido'] / 1000.0) * $maquina->precio_tinta_negro, 2) +
|
|
round(($data['peso_gotas_cyan_pedido'] / 1000.0) * $maquina->precio_tinta_color, 2) +
|
|
round(($data['peso_gotas_magenta_pedido'] / 1000.0) * $maquina->precio_tinta_color, 2) +
|
|
round(($data['peso_gotas_amarillo_pedido'] / 1000.0) * $maquina->precio_tinta_color, 2)
|
|
, 2);
|
|
|
|
|
|
if($maquina->is_inkjet){
|
|
$data['num_gotas_cg'] = round($data['superficie'] * $data['resolucion'] * $data['resolucion'] * ($parametros->rotativa_cg / 100.0), 0);
|
|
$data['peso_gotas_cg'] = round((($data['num_gotas_cg'] * $parametros->rotativa_gota_color * $data['pulgada']) / (17.65 / 20.0)) * $pag_color * 1000, 6) +
|
|
round((($data['num_gotas_cg'] * $parametros->rotativa_gota_negro * $data['pulgada']) / (17.65 / 20.0)) * $pag_negro * 1000, 6);
|
|
$data['peso_gotas_cg_pedido'] = round($data['peso_gotas_cg'], 2) * ($datosPedido->tirada + $datosPedido->merma);
|
|
|
|
$data['precio_tinta'] += round(($data['peso_gotas_cg_pedido'] / 1000.0) * $maquina->precio_tinta_cg, 2);
|
|
}
|
|
|
|
// precio pagina
|
|
$data['precio_pagina_negro'] = round($pag_negro ? $data['precio_tinta'] / ($pag_negro * ($datosPedido->tirada + $datosPedido->merma)) : 0, 6);
|
|
$data['precio_pagina_color'] = round($pag_color ? $data['precio_tinta'] / ($pag_color * ($datosPedido->tirada + $datosPedido->merma)) : 0, 6);
|
|
|
|
return $data;
|
|
}
|
|
|
|
|
|
public static function getNumFormasRot($maquina, $ancho, $alto, $isCosido, $a_favor_fibra = true)
|
|
{
|
|
// El ancho si es cosido es el doble
|
|
$anchoForCalculo = $isCosido ? $ancho * 2 : $ancho;
|
|
|
|
$altoForCalculo = $alto;
|
|
|
|
$h1_temp = floor($maquina->ancho_impresion / $anchoForCalculo);
|
|
$h2_temp = floor($maquina->ancho_impresion / $altoForCalculo);
|
|
|
|
// horizontales
|
|
if($a_favor_fibra){
|
|
|
|
$calles = (new \App\Models\Configuracion\MaquinasCallesModel())->getCallesForMaquina($maquina->maquina_id, $h1_temp);
|
|
// Si son mas de 2 formas
|
|
if(count($calles)>0)
|
|
$h1 = ($h1_temp * $anchoForCalculo + 2 * $calles[0]->externas + ($h1_temp - 1) * $calles[0]->internas < ($maquina->ancho)) ? $h1_temp : $h1_temp - 1;
|
|
else
|
|
$h1 = $h1_temp;
|
|
|
|
$v1 = floor($maquina->alto_click / $altoForCalculo);
|
|
$formas_h = $h1 * $v1; //p1
|
|
}
|
|
// verticales
|
|
else{
|
|
|
|
$calles = (new \App\Models\Configuracion\MaquinasCallesModel())->getCallesForMaquina($maquina->maquina_id, $h2_temp);
|
|
if(count($calles)>0)
|
|
$h2 = ($h2_temp * $altoForCalculo + 2 * $calles[0]->externas + ($h2_temp - 1) * $calles[0]->internas < ($maquina->ancho)) ? $h2_temp : $h2_temp - 1;
|
|
else
|
|
$h2 = $h2_temp;
|
|
$v2 = floor($maquina->alto_click / $anchoForCalculo);
|
|
$formas_v = $h2 * $v2; //p2
|
|
}
|
|
|
|
$num_formas = $a_favor_fibra ? $formas_h : $formas_v;
|
|
$num_formas = $isCosido ? $num_formas * 2 : $num_formas;
|
|
|
|
|
|
// si no hay formas se devuelve n/a
|
|
if ($num_formas == 0) {
|
|
$response['posicion_formas'] = 'n/a'; // not available
|
|
} else if ($a_favor_fibra) {
|
|
$response['posicion_formas'] = 'h';
|
|
$response['num_formas_horizontales'] = $h1;
|
|
$response['num_formas_verticales'] = $v1;
|
|
$response['value'] = $num_formas;
|
|
} else {
|
|
$response['posicion_formas'] = 'v';
|
|
$response['num_formas_horizontales'] = $h2;
|
|
$response['num_formas_verticales'] = $v2;
|
|
$response['value'] = $num_formas;
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
public static function getNumFormasPlana($uso, $maquina, $ancho, $alto, $isCosido, $forzar_a_favor_fibra = false)
|
|
{
|
|
$h1_temp = 0;
|
|
$h2_temp = 0;
|
|
|
|
// El ancho si es cosido es el doble
|
|
if($uso != 'cubierta' && $uso != 'sobrecubierta'){
|
|
$anchoForCalculo = $isCosido ? $ancho * 2 : $ancho;
|
|
}
|
|
else{
|
|
$anchoForCalculo = $ancho;
|
|
}
|
|
|
|
$altoForCalculo = $alto;
|
|
/*
|
|
Log ancho y alto de impresion y libro
|
|
$info = [
|
|
'ancho' => $anchoForCalculo,
|
|
'alto' => $altoForCalculo,
|
|
'maquina_ancho' => $maquina->ancho_impresion,
|
|
'maquina_alto' => $maquina->alto_impresion,
|
|
];
|
|
|
|
if($uso == 'cubierta' )
|
|
log_message('error', 'ancho:{ancho} --- alto:{alto} --- ancho2:{maquina_ancho} --- alto2:{maquina_alto} ---', $info);*/
|
|
|
|
if($uso == 'cubierta' || $uso == 'sobrecubierta') {
|
|
if(property_exists($maquina, 'forzar_num_formas_horizontales_cubierta') &&
|
|
property_exists($maquina, 'forzar_num_formas_verticales_cubierta')){
|
|
|
|
if($maquina->forzar_num_formas_horizontales_cubierta > 0 &&
|
|
$maquina->forzar_num_formas_verticales_cubierta > 0){
|
|
|
|
// Hay que comprobar que entran
|
|
$h1_temp = $maquina->forzar_num_formas_horizontales_cubierta;
|
|
$h2_temp = $maquina->forzar_num_formas_verticales_cubierta;
|
|
//$num_formas = $h1_temp * $h2_temp;
|
|
}
|
|
}
|
|
|
|
}
|
|
// No es cubierta ni sobrecubierta
|
|
else{
|
|
// horizontales
|
|
$h1_temp = floor(floatval($maquina->ancho_impresion) / $anchoForCalculo);
|
|
$h2_temp = floor(floatval($maquina->ancho_impresion) / $altoForCalculo);
|
|
}
|
|
|
|
|
|
|
|
// horizontales
|
|
$calles = (new \App\Models\Configuracion\MaquinasCallesModel())->getCallesForMaquina($maquina->maquina_id, $h1_temp);
|
|
// Si son mas de 2 formas
|
|
if(count($calles)>0)
|
|
$h1 = ($h1_temp * $anchoForCalculo + 2 * $calles[0]->externas + ($h1_temp - 1) * $calles[0]->internas < ($maquina->ancho)) ? $h1_temp : $h1_temp - 1;
|
|
else{
|
|
$h1 = $anchoForCalculo<=$maquina->ancho_impresion?$h1_temp:0;
|
|
}
|
|
|
|
|
|
$v1 = floor($maquina->alto_impresion / $altoForCalculo);
|
|
$formas_h = $h1 * $v1; //p1
|
|
|
|
|
|
// verticales
|
|
$calles = (new \App\Models\Configuracion\MaquinasCallesModel())->getCallesForMaquina($maquina->maquina_id, $h2_temp);
|
|
if(count($calles)>0)
|
|
$h2 = ($h2_temp * $altoForCalculo + 2 * $calles[0]->externas + ($h2_temp - 1) * $calles[0]->internas < ($maquina->ancho)) ? $h2_temp : $h2_temp - 1;
|
|
else{
|
|
$h2 = $altoForCalculo<=$maquina->ancho_impresion?$h2_temp:0;
|
|
}
|
|
|
|
$v2 = floor($maquina->alto_impresion / $anchoForCalculo);
|
|
$formas_v = $h2 * $v2; //p2
|
|
|
|
|
|
// Se calcula el numero de formas
|
|
if($uso != 'cubierta' && $uso != 'sobrecubierta' && !$forzar_a_favor_fibra){
|
|
$num_formas = ($formas_h > $formas_v) ? $formas_h : $formas_v;
|
|
$num_formas = $isCosido ? $num_formas * 2 : $num_formas;
|
|
}
|
|
else if ($forzar_a_favor_fibra){
|
|
|
|
$num_formas = $formas_h;
|
|
$num_formas = $isCosido ? $num_formas * 2 : $num_formas;
|
|
|
|
}
|
|
else{
|
|
|
|
$num_formas = $h1*$v1;
|
|
}
|
|
|
|
|
|
// si no hay formas se devuelve n/a
|
|
if ($num_formas == 0) {
|
|
$response['num_formas']['posicion_formas'] = 'n/a'; // not available
|
|
}
|
|
else{
|
|
if ($formas_h > $formas_v || $forzar_a_favor_fibra && $formas_h != 0) {
|
|
$response['num_formas']['posicion_formas'] = 'h';
|
|
$response['num_formas']['num_formas_horizontales'] = $h1;
|
|
$response['num_formas']['num_formas_verticales'] = $v1;
|
|
$response['num_formas']['value'] = $num_formas;
|
|
}
|
|
else {
|
|
if($formas_v != 0){
|
|
$response['num_formas']['posicion_formas'] = 'v';
|
|
$response['num_formas']['num_formas_horizontales'] = $h2;
|
|
$response['num_formas']['num_formas_verticales'] = $v2;
|
|
$response['num_formas']['value'] = $num_formas;
|
|
}
|
|
}
|
|
|
|
if(($uso == 'cubierta' || $uso == 'sobrecubierta') && $num_formas>0) {
|
|
if(property_exists($maquina, 'forzar_num_formas_horizontales_cubierta') &&
|
|
property_exists($maquina, 'forzar_num_formas_horizontales_cubierta')){
|
|
$response['num_formas']['num_formas_verticales'] = $h2_temp;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
|
|
public static function getPrecioPliego($maquina, $papel_impresion, $paginas)
|
|
{
|
|
$margen = (new \App\Models\Configuracion\PapelImpresionMargenModel())->getMargenFormPags($papel_impresion->id, $paginas);
|
|
if (count($margen) > 0) {
|
|
$peso_por_pliego = $maquina->alto * $maquina->ancho * $papel_impresion->gramaje / 1000000;
|
|
$precio_pliego = ($peso_por_pliego * $papel_impresion->precio_tonelada / 1000000.0) ;
|
|
$margen_pliego = ($peso_por_pliego * $papel_impresion->precio_tonelada / 1000000.0) * (floatval($margen[0]['margen']) / 100.0);
|
|
return [round($precio_pliego, 6), round($margen_pliego, 6)];
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static function getTiempoMaquina($totalClicks, $precioClick, $velocidadMaquina) {
|
|
try {
|
|
|
|
if($precioClick>0 && $velocidadMaquina>0)
|
|
$minutos = (1.0*$totalClicks/$precioClick)/$velocidadMaquina;
|
|
else
|
|
$minutos = 0;
|
|
|
|
return gmdate("H:i:s", round($minutos*60,0));
|
|
|
|
} catch (Exception $e) {
|
|
return gmdate("H:i:s", round(0,0));
|
|
}
|
|
}
|
|
|
|
public static function getHorasMaquina($totalClicks, $precioClick, $velocidadMaquina) {
|
|
try {
|
|
|
|
if($precioClick>0 && $velocidadMaquina>0)
|
|
$horas = (1.0*$totalClicks/$precioClick)/$velocidadMaquina/60.0;
|
|
else
|
|
$horas = 0;
|
|
|
|
return round($horas,2);
|
|
|
|
} catch (Exception $e) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Devuelve el ancho de la cubierta/sobrecubierta, incluido el lomo.
|
|
* El $uso tiene que ser "cubierta" o "sobrecubierta"
|
|
*/
|
|
public static function getAnchoTotalExteriores($uso="cubierta", $tipo_impresion_id, $datosPedido=null)
|
|
{
|
|
$ancho_total = 0;
|
|
|
|
if ($datosPedido) {
|
|
// Tapa blanda (cosido y fresado)
|
|
if($tipo_impresion_id == 2 || $tipo_impresion_id == 4){
|
|
$ancho_total = floatval($datosPedido->ancho)*2 + floatval($datosPedido->lomo);
|
|
|
|
// añadimos ancho de las solapas
|
|
// si se añaden solapas hay que sumar 3mm de los dobleces
|
|
if ($datosPedido->solapas) {
|
|
$ancho_total += (floatval($datosPedido->solapas_ancho) * 2) + 6;
|
|
}
|
|
// En cualquier otro caso se le suma 5mm de sangre por cada lado
|
|
$ancho_total += (2*self::SANGRE_FORMAS);
|
|
}
|
|
// Tapa dura cosido y fresado
|
|
else if($tipo_impresion_id == 1 || $tipo_impresion_id == 3){
|
|
$ancho_total = floatval($datosPedido->ancho)*2 + floatval($datosPedido->lomo);
|
|
// si es cubierta
|
|
// Se añaden 20mm de sangre por cada lado + 2 * 7mm de vuelo portada y contraportada -> total 52
|
|
// por último se añaden 7mm para tener en cuenta el ancho del carton
|
|
if($uso=="cubierta")
|
|
$ancho_total += (2*7 + 2*self::SANGRE_FORMAS_CUBIERTA + 7);
|
|
// si es sobrecubierta
|
|
// Se añaden 5mm de sangre por cada lado + 2 * 7mm de vuelo portada y contraportada -> total 52
|
|
else
|
|
$ancho_total += (2*7 + 2*self::SANGRE_FORMAS) + 7;
|
|
}
|
|
else{
|
|
// En cualquier otro caso se le suma 5mm de sangre por cada lado
|
|
$ancho_total += (2*self::SANGRE_FORMAS);
|
|
}
|
|
}
|
|
return $ancho_total;
|
|
}
|
|
|
|
/**
|
|
* Devuelve el alto de la cubierta/sobrecubierta
|
|
*/
|
|
public static function getAltoTotalExteriores($uso="cubierta", $tipo_impresion_id, $datosPedido=null)
|
|
{
|
|
$alto_total = 0;
|
|
|
|
if ($datosPedido) {
|
|
$alto_total = floatval($datosPedido->alto);
|
|
// Tapa dura (cosido y fresado)
|
|
if($tipo_impresion_id == 1 || $tipo_impresion_id == 3){
|
|
// Se añaden 20mm de sangre por cada lado + 7mm extra que sobresale -> total 47
|
|
if($uso=="cubierta")
|
|
$alto_total += (7+2*self::SANGRE_FORMAS_CUBIERTA);
|
|
// si es sobrecubierta
|
|
// Se añaden 5mm de sangre por cada lado + 7mm de vuelo -> total 52
|
|
else
|
|
$alto_total += (7+2*self::SANGRE_FORMAS);
|
|
|
|
}
|
|
// En cualquier otro caso se le suma 5mm de sangre por cada lado
|
|
else{
|
|
$alto_total += (2*self::SANGRE_FORMAS);
|
|
}
|
|
}
|
|
return $alto_total;
|
|
}
|
|
|
|
/**
|
|
* Devuelve la dimensión del lomo interior.
|
|
*/
|
|
private static function computeLomoInterior($paginas = null, $espesor = null)
|
|
{
|
|
$lomo = 0;
|
|
|
|
if (!is_null($paginas) && !is_null($espesor)) {
|
|
|
|
$lomo += (($espesor * $paginas / 2.0) + 1) / 1000.0;
|
|
}
|
|
|
|
return $lomo;
|
|
}
|
|
|
|
/**
|
|
* Calcula la dimensión del lomo para portada y cubierta
|
|
*/
|
|
private static function computeLomoPortada($espesor)
|
|
{
|
|
return ($espesor * 2.0) / 1000.0;
|
|
}
|
|
|
|
/**
|
|
* Devuelve el peso de un pedido.
|
|
*/
|
|
private static function computePeso($ancho, $alto, $gramaje, $paginas = null)
|
|
{
|
|
$peso = ($ancho / 1000.0) * ($alto / 1000.0) * $gramaje;
|
|
|
|
if (!is_null($paginas)) {
|
|
if ($paginas > 0) {
|
|
$peso *= ($paginas / 2.0);
|
|
}
|
|
}
|
|
|
|
return $peso;
|
|
}
|
|
|
|
|
|
}
|