Clientes Controller

<?
php
namespace App\Http\Controllers;
use App\Models\AnteProyecto;
use App\Models\Area;
use App\Models\AvisoLlamada;
use App\Models\BarriosCerrados;
use App\Models\ChecklistPostVenta;
use App\Models\ClientAreas;
use App\Models\ClientsActivitiesTypes;
use App\Models\ComentarioAnteproyecto;
use App\Models\ComentarioPlano;
use App\Models\ComentarioPlanoPostVenta;
use App\Models\ComentarioVeriArquitectura;
use App\Models\Competencia;
use App\Models\ComentarioPeticiones;
use App\Models\DeclaracionJurada;
use App\Models\HistorialAnteproyecto;
use App\Models\HistorialPeticiones;
use App\Models\HistorialPlano;
use App\Models\HistorialPlanoPostVenta;
use App\Models\HistorialVeriArquitectura;
use App\Models\MarcasVehiculos;
use App\Models\ModelosVehiculos;
use App\Models\NotiCita;
use App\Models\NotiWA;
use App\Models\ObservacionEntrega;
use App\Models\Operacion;
use App\Models\Plano;
use App\Models\PlanoPostVenta;
use App\Models\RecibosEuroCasa;
use App\Models\RecibosLaEsperanza;
use App\Models\RecibosWhiteHouse;
use App\Models\ComentarioRenders;
use App\Models\HistorialRenders;
use App\Models\NotiRenders;
use App\Models\Renders;
use App\Models\SolicitudLlamada;
use App\Models\SolicitudLlamadaHabilitado;
use App\Models\StatusStadistics;
use App\Models\Subarea;
use App\Models\UserAreas;
use App\Models\Validacion;
use App\Models\VerificacionArquitectura;
use App\Models\VerificacionArquitecturaHabilitado;
use App\Models\Vivienda;
use App\Models\Peticiones;
use Auth;
use Gate;
use GuzzleHttp\Client;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Session;
use Illuminate\Support\Facades\URL;
use Validator;
use Excel;
use App\Exports\ClientesExport;
use App\Models\Activity;
use App\Models\ClientsActivities;
use App\Models\FormaPago;
use App\Models\Paises;
use App\Models\Planes;
use App\Models\Proyecto;
use App\Models\ProyectoStatus;
use App\Models\Razon;
use App\Models\Reuniones;
use App\Models\Tareas;
use App\Models\UserTypes;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Log;
use App\Models\Cliente;
use App\Models\User;
use App\Models\ClienteStatus;
use App\Models\Empresa;
use App\Models\UserGroup;
use App\Models\Group;
use App\Models\Producto;
use App\Models\Provincia;
use App\Models\Origen;
use App\Models\Consultas;
use App\Models\Campaign;
use App\Models\Financiacion;
use Carbon\Carbon;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Config;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Input;
use Illuminate\Support\Facades\View;
use App\Models\ClientCampaign;
use Yajra\Datatables\Datatables;
use App\Jobs\ReasignClients;
use App\Models\HistorialWhatsapp;
use Illuminate\Foundation\Bus\DispatchesJobs;
use Box\Spout\Writer\WriterFactory;
use Box\Spout\Common\Type;
use App\Utils\Utils;
use Illuminate\Support\Facades\Auth as FacadesAuth;
class ClientesController extends Controller {
/**
* Display a listing of the resource.
*
* @return \Illuminate\Http\Response
*/
public function __construct() {
$this->middleware('auth');
}
public function clientes_base_datos() {

if (Auth::user()->tipo == Config::get('constant.user_types.recepcion')) {
$vendedores = $this->getTodosVendedoresyCantidadAtendidos();
$primary_groups = Group::all()->where('primary', true);
$secondary_groups = Group::all()->where('primary', false);

foreach ($vendedores as $vendedor) {
$vendedor->groups = UserGroup::where('user_id', $vendedor->id)-
>groupBy('group_id')->lists('group_id')->toArray();
$vendedor->secondary_group = UserGroup::join('groups',
'user_groups.group_id', '=', 'groups.id')->where('user_id', $vendedor->id)-
>where('groups.primary', false)->pluck('name');
}
$vendedores = $vendedores->sortBy('secondary_group');
$empresas = Empresa::select('nombre_empresa', 'id')->whereIn('id',

Config::get('constant.empresas_habilitadas'))->get();
return view('pages.clientes.recepcion.base', compact('vendedores',

'empresas', 'primary_groups', 'secondary_groups'));
}
}
public function table_clientes_base() {
$user = Auth::user();
if ($user->tipo == Config::get('constant.user_types.recepcion')) {
$clientes = Cliente::select([
'clientes.query_date',
'clientes.id',
'clientes.updated_at',
'clientes.nombre_apellido',
'clientes.telefono',
'cliente_status.status',
'origens.nombre as canal',
'provincias.nombre_provincia as provincia',
'clientes.created_at'])
->join('cliente_status', 'clientes.status', '=',
'cliente_status.id')
->join('origens', 'clientes.id_lugar', '=', 'origens.id')
->join('provincias', 'clientes.provincia', '=',
'provincias.id')
->where('clientes.id_usuario', $user->id)
->whereIn('cliente_status.id', [5, 6, 12]);
return Datatables::of($clientes)->make(true);
}
}
public function clientes_plan_ahorro() {


$sec_groups = UserGroup::join('groups', 'user_groups.group_id',
'=', 'groups.id')->where('user_id', $vendedor->id)->where('groups.primary', false)-
>get();
$vendedor->secondary_group = $sec_groups->pluck('name');
}

return view('pages.clientes.recepcion.ahorro', compact('vendedores',

}
}
public function table_clientes_plan_ahorro() {
'clientes.id',
'ut.tipo as tipo',
'e.nombre_empresa as empresa',
'clientes.updated_at'])
->join('users', 'clientes.id_usuario', '=', 'users.id')
->join('user_types as ut', 'users.tipo', '=', 'ut.id')
->join('empresas as e', 'clientes.id_empresa', '=', 'e.id')
->whereIn('clientes.status', [10])
->whereIn('users.tipo', [4, 5]);
}
}
public function clientes_a_plazo_recepcion() {
extract($this->reasign_modal_vars());
return view('pages.clientes.recepcion.plazo', compact('vendedores',

}else{
return view('errors.accesodenegado');
}
}
public function clientes_a_plazo_ventas() {

if (Auth::user()->tipo == Config::get('constant.user_types.supervisor')) {
$razones = Razon::select('razon','id')->where('id_status','=',13)-
>orderBy('order', 'asc')->lists('razon','id');
$array_empresas = [];
foreach($empresas as $emp){
$array_empresas[$emp->id] = $emp->nombre_empresa;
}
return view('pages.clientes.supervisor.plazo_ventas',
compact('vendedores', 'array_empresas', 'primary_groups',
'secondary_groups','razones'));
}else{
}
}
public function clientes_a_plazo_callcenter() {

return view('pages.clientes.supervisor.plazo_callcenter',
compact('vendedores', 'empresas', 'primary_groups', 'secondary_groups'));
}else{
}
}
protected function reasign_modal_vars(){
$vendedores_LEC = $this->getTodosVendedoresyCantidadAtendidosLEC();
$sec_groups = UserGroup::join('groups', 'user_groups.group_id', '=',
'groups.id')->where('user_id', $vendedor->id)
->where('groups.primary', false)->get();
}
foreach ($vendedores_LEC as $vendedor) {

$sec_groups = UserGroup::join('groups', 'user_groups.group_id', '=',
'groups.id')->where('user_id', $vendedor->id)
->where('groups.primary', false)->get();
}
$vendedores_LEC = $vendedores_LEC->sortBy('secondary_group');

return compact('vendedores', 'vendedores_LEC', 'empresas',
'primary_groups', 'secondary_groups');
}
public function table_clientes_a_plazo() {
'clientes.id',
'clientes.contact_from as contact_from',
'clientes.contact_to as contact_to',
'ut.tipo as tipo',
'r.razon as razon',
'chu.updated_at as modificado_cliente'
])
->join('razones as r', 'clientes.id_razon', '=', 'r.id')
->leftJoin('cliente_horario_update as
chu','clientes.id','=','chu.id_cliente')
->whereIn('clientes.status', [13]);
}
if ($user->tipo == Config::get('constant.user_types.supervisor')) {
'clientes.id',
'ut.tipo as tipo',
'r.razon as razon',
])
}
}
public function table_clientes_a_plazo_callcenter() {
$groups_logged = UserGroup::select('group_id')->where('user_id',$user->id)-
>get();
'clientes.id',
'ut.tipo as tipo',
'r.razon as razon',
're.fecha as freunion',
're.visitado as reunionvisitado',
])

->join('user_groups as ug', 'users.id', '=', 'ug.user_id')
->whereIn('ug.group_id',$groups_logged )
->leftjoin('reuniones as re','re.id_cliente','=','clientes.id')
->whereIn('users.tipo', [5])
->whereNull('users.deleted_at')
->groupBy('clientes.id');
}
}
public function table_clientes_a_plazo_ventas(Request $request) {
>get();
'clientes.fecha_tentativa',
'clientes.id',
'r.razon as razon',
])

//Filtros
if(!empty($request->fecha_tentativa)) $clientes-
>whereBetween('clientes.fecha_tentativa', [Utils::startdate($request-
>fecha_tentativa), Utils::enddate($request->fecha_tentativa)]);
if(!empty($request->id_empresa))$clientes->whereIn("e.id",$request-
>id_empresa);
if(!empty($request->id_razones)) $clientes->whereIn("r.id",$request-
>id_razones);
if(!empty($request->query_date)) $clientes-
>whereBetween('clientes.query_date', [Utils::startdate($request->query_date),
Utils::enddate($request->query_date)]);
if(!empty($request->updated_at)) $clientes-
>whereBetween('clientes.updated_at', [Utils::startdate($request->updated_at),
Utils::enddate($request->updated_at)]);
}
}
public function table_clientes_a_plazo_ventas_filtrado(Request $request){

>get();
'clientes.fecha_tentativa',
'clientes.id',
'r.razon as razon',
])
//Filtros
if(!empty($request->fecha_tentativa)) $clientes-
>whereBetween('clientes.fecha_tentativa', [Utils::startdate($request-
>fecha_tentativa), Utils::enddate($request->fecha_tentativa)]);
if(!empty($request->id_empresa))$clientes->whereIn("e.id",$request-
>id_empresa);
if(!empty($request->id_razones)) $clientes->whereIn("r.id",$request-
>id_razones);
if(!empty($request->query_date)) $clientes-
>whereBetween('clientes.query_date', [Utils::startdate($request->query_date),
Utils::enddate($request->query_date)]);
if(!empty($request->updated_at)) $clientes-
>whereBetween('clientes.updated_at', [Utils::startdate($request->updated_at),
Utils::enddate($request->updated_at)]);
}
}
public function clientes_comprador_recepcion()

{
return view('pages.clientes.recepcion.comprador', compact('vendedores',
}
public function clientes_comprador_ventas()

{
return view('pages.clientes.supervisor.compradorventas',
}
}
public function clientes_comprador_callcenter()

{
return view('pages.clientes.supervisor.compradorcallcenter',
}
}
public function table_clientes_comprador()

{
'clientes.id',
'ut.tipo as tipo',
'clientes.updated_at'])
->whereIn('clientes.status', [1, 2]);
}
}
public function table_clientes_comprador_ventas()

{
>get();
'clientes.id',
'ut.tipo as tipo',
'users.name as asesor',
])
->whereIn('clientes.status', [1, 2])
}
}
public function table_clientes_comprador_callcenter()

{
>get();
'clientes.id',
'ut.tipo as tipo',
'r.fecha as freunion',
'r.visitado as reunionvisitado',
])
->leftjoin('reuniones as r','r.id_cliente','=','clientes.id')
}
}
public function massReasign() {

$d = Carbon::now();
Log::useDailyFiles(storage_path() . '/logs/massreasign-' . $d->day . '-' .
$d->month . '-' . $d->year . '.log');
Log::info("Mass Reasign Job Begins");

dispatch(new ReasignClients());
Log::info("Mass Reasign Job Ends");
}
public function reasign($client_id, $vendedor,Request $request=null) {

$cliente = Cliente::find($client_id);
$usuario = User::select('tipo')->where('id',$vendedor)->pluck('tipo');
if($usuario == Config::get('constant.user_types.asesor_comercial') ||
$usuario == Config::get('constant.user_types.call_center')){
Consultas::where('id_cliente',$cliente->id)->update(['leido' => 0]);
}
$notiWAOld = NotiWA::where('id_usuario',$cliente->id_usuario)->first();
$bandeNoti = false;
if(!empty($notiWAOld->ids)){
$notiWAOld->ids = json_decode($notiWAOld->ids);
$arrayWAOld = $notiWAOld->ids->ids;
foreach($arrayWAOld as $key => $noti){
$jnoti = json_decode($noti);
if($jnoti->id == $cliente->id){
unset($arrayWAOld[$key]);
$bandeNoti = true;
}
}
if($bandeNoti){
$notiWAOld->cant--;
$notiWAOld->ids->ids = array_values($arrayWAOld);
$notiWAOld->ids = json_encode($notiWAOld->ids);
$notiWAOld->save();
$notiWA = NotiWA::where('id_usuario',$vendedor)->first();
if(!empty($notiWA->ids)){
$notiWA->ids = json_decode($notiWA->ids);
$esta = false;
foreach($notiWA->ids->ids as $key => $client){
$jclient = json_decode($client);
if($jclient->id == $cliente->id){
$esta = true;
}
}
if(!$esta){
$data_client = [
"name" => $cliente->nombre_apellido,
"id" => $cliente->id
];
array_push($notiWA->ids->ids,json_encode($data_client));
$notiWA->cant++;
$notiWA->ids = json_encode($notiWA->ids);
} else {
$notiWA->ids = json_encode($notiWA->ids);
}
} else {
$notiWA->cant++;
$data_client = [
"id" => $cliente->id
];
$data_final = [
"ids" => [json_encode($data_client)]
];
$notiWA->ids = json_encode($data_final);
}
$notiWA->save();
}
}
$cliente->id_usuario = $vendedor;
$cliente->fecha_asignacion = Carbon::now();
if($cliente->status != Config::get('constant.cliente_status.senado') &&

$cliente->status != Config::get('constant.cliente_status.vendido') &&
$cliente->status !=
Config::get('constant.cliente_status.no_concretado') &&
$cliente->status !=
Config::get('constant.cliente_status.para_reciclar') &&
$cliente->status != Config::get('constant.cliente_status.cita') &&
$cliente->status != Config::get('constant.cliente_status.a_plazo') &&
$cliente->status !=
Config::get('constant.cliente_status.no_interesado') &&
$cliente->status != Config::get('constant.cliente_status.filtrado') &&
$cliente->status !=
Config::get('constant.cliente_status.en_seguimiento') &&
$cliente->status !=
Config::get('constant.cliente_status.sin_intervencion') &&
$cliente->status != Config::get('constant.cliente_status.negociacion')
&&
$cliente->status != Config::get('constant.cliente_status.instalada') &&
$cliente->status != Config::get('constant.cliente_status.rescision') &&
$cliente->status != Config::get('constant.cliente_status.reasignando'))
$cliente->status = Config::get('constant.cliente_status.nuevo');
}elseif($cliente->status == Config::get('constant.cliente_status.a_plazo')
|| $cliente->status == Config::get('constant.cliente_status.no_interesado') ||
$cliente->status == Config::get('constant.cliente_status.reasignando')){
$consultas = Consultas::ConsultasDelCliente($cliente->id)-
>with(['user'])->get();
foreach($consultas as $consulta){
if($consultas->last() != $consulta){
$consulta->delete();
}
}
}
/* CREAMOS LA ESTADISTICA CORRESPONDIENTE SI EL ESTADO ES NUEVO O PARA

RECICLAR */
if($cliente->status == Config::get('constant.cliente_status.nuevo') ||
$cliente->status == Config::get('constant.cliente_status.para_reciclar')){
$estadistica = new StatusStadistics();
$estadistica->id_cliente = $client_id;
$estadistica->id_usuario = $vendedor;
$estadistica->status = $cliente->status;
$estadistica->save();
}
$tareas = Tareas::where('id_cliente', '=', $client_id)->get();
foreach ($tareas as $tarea) {

$tarea->id_usuario = $vendedor;
$tarea->save();
}
if ($cliente->save()) {
if(Auth::user()){
if(!empty($request) && !empty($request->all())){
if($request->vendedor == 0){
ClientsActivities::register(env('USER_API_ID'), $cliente-
>id, ClientsActivities::ASIGNADO_POR, 'Asignado Por ');
} else {
ClientsActivities::register(Auth::user()->id, $cliente->id,
ClientsActivities::ASIGNADO_POR, 'Asignado Por ');
}
} else {
}
ClientsActivities::register($vendedor, $cliente->id,
ClientsActivities::ASIGNADO_A, 'Asignado A ');
if(!empty($request)){
if($request->boolean){
ClientsActivities::register(env('USER_API_ID'),$cliente-
>id,ClientsActivities::CITA_WEB, 'Agendada por el Cliente');
}
}
}
else{
ClientsActivities::register(env('USER_API_ID'), $cliente->id,
if(!empty($request)){
ClientsActivities::register(env('USER_API_ID'),$cliente-
>id,ClientsActivities::CITA_WEB, 'Agendada por el Cliente');
}
}
}
if($request) $request->session()->flash('alert-success', 'El cliente ha

sido reasignado con éxito');
return "ok";
} else {
if($request) $request->session()->flash('alert-danger', 'Hubo un
problema al reasignar el cliente');
return "errors";
}
}
/**
* Show the form for creating a new resource.
*
*/
public function create() {
if ($user->tipo == Config::get('constant.user_types.supervisor') || $user-

>tipo == Config::get('constant.user_types.recepcion')|| $user->tipo ==
Config::get('constant.user_types.post_ventas')
|| $user->tipo == Config::get('constant.user_types.socio_gerente') ||
$user->tipo == Config::get('constant.user_types.administrador') || $user->tipo ==
Config::get('constant.user_types.marketing')){
$paises = Paises::all()->lists('name', 'id');
$provincias = Provincia::orderBy('nombre_provincia', 'asc')-

>lists('nombre_provincia', 'id');
foreach ($provincias as $provincia_id => $nombre) {
if ($nombre == 'Sin especificar') {
$provincia_default = $provincia_id;
}
}
$empresas = Empresa::orderBy('nombre_empresa', 'asc')->whereIn('id',

[1, 2, 5, 8, 9,11,14,15])->lists('nombre_empresa', 'id');
$productos = Producto::where('id_empresa', Auth::user()->empresa)-

>orderBy('nombre', 'asc')->lists('nombre', 'id');
foreach ($productos as $producto_id => $nombre) {
if ($nombre == 'Sin modelo en especifico') {
$producto_default = $producto_id;
}
}
$origens = Origen::lists('nombre', 'id');

foreach ($origens as $origen_id => $nombre) {
if ($nombre == 'Chat online') {
$origen_default = $origen_id;
}
}
$campaigns = Campaign::lists('name', 'id');

foreach ($campaigns as $campaign_id => $nombre) {
if ($nombre == 'Organico') {
$campaign_default = $campaign_id;
}
}
$forma_pagos = Planes::lists('forma_pago', 'id');

foreach ($forma_pagos as $pago_id => $nombre) {
if ($nombre == 'Sin especificar') {
$pago_default = $pago_id;
}
}
$razon = Razon::orderBy('order', 'asc')->lists('razon', 'id');
$logo = Empresa::select('imgurl')->where('id', Auth::user()->empresa)-

>pluck('imgurl');
$cliente_status = ClienteStatus::where('id',
Config::get('constant.cliente_status.nuevo'))->lists('status', 'id');
foreach ($cliente_status as $status_id => $nombre) {
if ($nombre == 'Nuevo') {
$status_default = $status_id;
}
}
$vendedores = $this-
>getTodosVendedoresyCantidadAtendidosConRecepcion();
$empresas_vendedores = Empresa::select('nombre_empresa')->whereIn('id',
[Auth::user()->empresa])->get();

$vendedor->totalClientes =
Cliente::AtendidosHoyPorVendedor($vendedor->id)->count();
}


}
$vendedores = $vendedores->sortBy('totalClientes');
$fecha_consulta = Carbon::now();
return view('pages.clientes.recepcion.agregar',
compact('paises','vendedores', 'primary_groups', 'secondary_groups', 'provincias',
'productos', 'origens', 'logo', 'forma_pagos', 'cliente_status', 'razon',
'producto_default', 'provincia_default', 'pago_default', 'status_default',
'origen_default', 'campaigns', 'campaign_default', 'empresas','fecha_consulta'));
}
else{
}
/**
* Guardar Cliente.
*
* @param \Illuminate\Http\Request $request
*/
public function store(Request $request) {
$user_log = Auth::user();
if(!empty($request->agregacita)){
$request['boolean'] = true;
$request->cuando_cita = $request->cuando_cita.':00';
$request['fecha'] = Carbon::parse(str_replace('/','-',$request-
>cuando_cita));
}
$cliente = new Cliente($request->all());
$cliente->id_tipo = 1;
$consulta = New Consultas();
$return_json = false;
if(isset($request->jsonresponse) && $request->jsonresponse){

$return_json = true;
}
$validator = Validator::make($request->all(), [
'telefono' => 'digits_between:8,13',
]);
if ($validator->fails()) {
$request->session()->flash('alert-danger', "El teléfono no contiene mas
de 8 dígitos");
if($return_json){
$messages = $validator->errors();
return response()->json([
'success' => false,
'message' => 'El teléfono ingresado no cumple con la
validación.'.$messages->first('telefono')
], 200);
}else return redirect()->back()->withInput();
// Validación de la empresa
if (empty($cliente->id_empresa)) {
$request->session()->flash('alert-danger', 'Hubo un problema al guardar
la solicitud: La empresa esta vacía');
if($return_json){
'success' => false,
'message' => 'La empresa no puede estar vacía'
], 200);
}else return redirect()->back()->withInput();
}
/* Guardamos datos del usuario que lo agrego */

$cliente->id_usuario = ($request->vendedor != 0) ? $request->vendedor :
$user_log->id;
/* Guardamos Cliente */
$cliente->save();
if ($request->vendedor == 0) {
//Si viene con cita se asigna a Ventas
//Creo la reunión
$reunion = new Reuniones();
$reunion->id_cliente = $cliente->id;
$reunion->creado_por = env('USER_API_ID');
$reunion->modificado_por = env('USER_API_ID');
$reunion->visitado = 0;
$reunion->donde = $request->donde;
$reunion->fecha = $request->fecha;
$reunion->created_at = Carbon::now();
$reunion->updated_at = Carbon::now();
$reunion->save();
$next_user = User::asignacionCita($cliente,$reunion);
//Determino si el request viene del sitio de expo casa o no. Caso
contrario determino la empresa
if($request->utm_url == 'http://euro-casa-slim-slim.test/expo-casa-
2020' || $request->utm_url == 'https://eurocasa.com.ar/expo-casa-2020'){
Log::info('Cliente nuevo Inscripto a ExpoCasa 2020');
//Aca va el mail de cita para ExpoCasa
if(MailController::sendExpoCitaEmail($cliente, $reunion)){
Log::info('Se envía mail de expocasa');
}else{
Log::info('No se pudo enviar el mail de expocasa');
}
} else {
//Log::info('Cliente nuevo con CITA WEB');
//Aca va el mail de bienvenida a usuario nuevo con cita
if(MailController::sendBienvenidaCitaEmail($cliente, $reunion))
{
Log::info('Se envía mail de cita al nuevo cliente');
}else{
Log::info('No se pudo enviar el mail de cita al nuevo
cliente');
}
}
} elseif(isset($request->bs_as_direct)) {
//Asignar directamente a vendedores de Bs As
$next_user = User::asignacionDirectaBsAs($cliente);
} else {
$next_user = User::asignacionUniversal($cliente);
}
Log::info('Usuario asignado a ' . $next_user->name . ' (id Cliente: '.
$cliente->id.')');
ClientsActivities::register($user_log->id, $cliente->id,
ClientsActivities::CREADO, 'Cliente Creado');
$reasing = $this->reasign($cliente->id, $next_user->id,$request);

/* Creamos la Actividad */
$actividad = $this->create_activity($cliente->id, $user_log->id,
$next_user->id);
} else {
//Si viene con cita se Asigna a Ventas
//Creo la reunión
$reunion = new Reuniones();
$reunion->id_cliente = $cliente->id;
$reunion->creado_por = env('USER_API_ID');
$reunion->modificado_por = env('USER_API_ID');
$reunion->donde = $request->donde;
$reunion->fecha = $request->fecha;
$reunion->created_at = Carbon::now();
$reunion->updated_at = Carbon::now();
$reunion->save();
$next_user = User::asignacionCita($cliente,$reunion);
//Determino si el request viene del sitio de expo casa o no. Caso
contrario determino la empresa
if($request->utm_url == 'http://euro-casa-slim-slim.test/expo-casa-
2020' || $request->utm_url == 'https://eurocasa.com.ar/expo-casa-2020'){
Log::info('Cliente nuevo Inscripto a ExpoCasa 2020');
//Aca va el mail de cita para ExpoCasa
if(MailController::sendExpoCitaEmail($cliente, $reunion)){
Log::info('Se envía mail de expocasa');
}else{
Log::info('No se pudo enviar el mail de expocasa');
}
} else {
//Log::info('Cliente nuevo con CITA WEB');
//Aca va el mail de bienvenida a usuario nuevo con cita
if(MailController::sendBienvenidaCitaEmail($cliente, $reunion))
{
Log::info('Se envía mail de cita al nuevo cliente');
}else{
Log::info('No se pudo enviar el mail de cita al nuevo
cliente');
}
}
$request->vendedor = $next_user->id;
}
$reasing = $this->reasign($cliente->id, $request->vendedor);
/* Creamos la Actividad */
$actividad = $this->create_activity($cliente->id, $user_log->id,
$request->vendedor);
ClientsActivities::register($user_log->id, $cliente->id,
ClientsActivities::CREADO, 'Cliente Creado');
}
/* Guardamos la financiacion */
$financiacion = new Financiacion($request->all());
if ($request->localidad == "0") {
$financiacion->localidad_proyecto = "No informado";
}
$financiacion->provincia = $request->provincia_proyecto;
$financiacion->posee_terreno = $request->has('posee_terreno');
$financiacion->posee_vehiculos = $request->has('posee_vehiculos');
$financiacion->posee_propiedades = $request->has('posee_propiedades');
$financiacion->localidad_proyecto = $request->localidad_proyecto;
$financiacion->barrio_cerrado = $request->barrio_cerrado?$request-
>barrio_cerrado:'';
$financiacion->barrio_cerrado_name = $request->barrio_cerrado_name;
$financiacion->m_cuadrados = $request->m_cuadrados?$request-
>m_cuadrados:'';
$financiacion->monto_entrega = $request->monto_entrega ? $request-

>monto_entrega : '';
$financiacion->entrega_type = $request->entrega_type ? $request-

>entrega_type : '';
$financiacion->cant_habitaciones = $request->cant_habitaciones?$request-
>cant_habitaciones:'';
$financiacion->id_cliente = $cliente->id;
$financiacion->save();
/* Almacenar la campa;a con la que ingreso */

$client_campaign = new ClientCampaign;
$client_campaign->client_id = $cliente->id;
$client_campaign->campaign_id = $request->campana;
$client_campaign->url = $request->utm_url;
$client_campaign->source = $request->utm_source;
$client_campaign->medium = $request->utm_medium;
$client_campaign->campaign_name = $request->utm_campaign;
$client_campaign->ad_group = $request->utm_term;
$client_campaign->ad_name = $request->utm_content;
$client_campaign->network = $request->utm_network;
$client_campaign->keyword = $request->utm_keyword;
$client_campaign->matchtype = $request->utm_matchtype;
$client_campaign->device = $request->utm_device;
$client_campaign->save();
/* * Almacenar Consulta Nueva

*
*/
/* Guardamos Consulta */
$consulta->id_cliente = $cliente->id;
$consulta->id_producto = $request->id_producto;
$consulta->id_origen = $request->id_lugar;
$consulta->comentario = $cliente->comentario;
$consulta->id_usuario = $user_log->id;
$consulta->id_status = $cliente->status;
$consulta->id_razon = $request->id_razon;
$consulta->leido = 0;
$consulta->save();
if ($request->recordatorio == 1) {
$recordatorio = new Tareas();
$recordatorio->nombre = $request->titulo;
$format = 'd/m/Y H:i';
$recordatorio->fecha = Carbon::createFromFormat($format, $request-

>fecha_hora);
$recordatorio->leido = false;
$recordatorio->id_usuario = $user_log->id;
$recordatorio->id_cliente = $cliente->id;
$recordatorio->id_consulta = $consulta->id;
$recordatorio->save();
}
//Si el cliente no es ni de grupo max ni de viviendas unicas ni de

aberturas ya no envio ningun mail
if($cliente->id_empresa != 9 && $cliente->id_empresa != 5 && $cliente-
>id_empresa != 13 && $cliente->id_empresa != 14 && !$request->boolean){
if(MailController::sendWelcomeEmail($cliente)){
$request->session()->flash('alert-success', 'Cliente agregado
correctamente! También se envía mail de bienvenida');
}else{
$request->session()->flash('alert-success', 'Cliente agregado
correctamente!');
}
}
if ($user_log->tipo == 3 || $user_log->tipo == 4) {
if($return_json){
'success' => true,
'message' => 'Cliente agregado correctamente!',
'cliente_id' => $cliente->id
], 200);
}else return redirect()->route('clientes.todos');
} elseif ($user_log->tipo == 5) {
if ($return_json) {
'success' => true,
], 200);
} else return redirect()->route('clientes.asignados');
} elseif ($user_log->tipo == 8 || $user_log->tipo == 6 || $user_log->tipo
== 10 || $user_log->tipo == 1) {
if ($return_json) {
'success' => true,
], 200);
} else return redirect()->route('home');
} elseif ($user_log->tipo == 2) {
if($return_json){
'success' => true,
], 200);
} else return redirect()->route('clientes.create');
//Si el usuario es del tipo api retornamos json para control de errores
} else {
'success' => true,
'message' => 'Cliente agregado correctamente!'
], 200);
}
}
public function nuevo_cliente_referido(Request $request){
//TELEFONO
$telefono_parsed = preg_replace('/\D/', '',$request->telefono);
$tel_valid = strlen ($telefono_parsed) < 20;
$request->telefono = $telefono_parsed;
$tel_explode = Utils::tel_argentino($telefono_parsed);
$request->merge(['telefono' => $tel_explode['numero'] ]);
$request->merge(['vendedor' => $user->id ]);
//TELEFONO ALTERNATIVO (SI HUBIESE)

if($request->telefono_alt){
$telefono_alt_parsed = preg_replace('/\D/', '',$request->telefono_alt);
$tel_alt_valid = strlen ($telefono_alt_parsed) < 20;
$request->telefono_alt = $telefono_alt_parsed;
$tel_alt_explode = Utils::tel_argentino($telefono_alt_parsed);
$request->merge(['telefono_alt' => $tel_alt_explode['numero'] ]);
}
$data = $request->all();
$response = $this->validateData($data);
if ($response != 'valido') {
'success' => false,
'message' => 'Hubo un problema, ' . $response
], 422);
}
Log::info("NUEVO CLIENTE REFERIDO DE ".strtoupper($user->name).": " .

$telefono_parsed . " " . $request->email);
//si no existe el cliente por telefono
if (!$tel_valid || ($clientes = Cliente::existbyphone($request->telefono))
== false){
//si no existe por email
if($request->email != ''){
if (($clientes = Cliente::existbyemail($request->email)) == false)
{
//Si viene con telefono alternativo debo corroborar que no
exista por este numero tampoco
if(!$tel_alt_valid || ($clientes =
Cliente::existbyphone($request->telefono_alt)) == false){
$response_newclient = $this->newClient($request);
if ($response_newclient->success) {
'success' => true,
'message' => 'El cliente se ha cargado con
exito',
'cliente_id' => $response_newclient->cliente_id
], 200);
} else {
'success' => false,
'message' => $response_newclient->message
], 400);
}
} elseif($tel_alt_valid) {
//Buscamos si algunos de los clientes que existen estan
en la misma empresa
foreach ($clientes as $c) {
if ($c->id_empresa == $request->id_empresa) {
if($c->status ==
Config::get('constant.cliente_status.a_plazo')){
Log::info("CLIENTE REFERIDO YA EXISTIA COMO
A PLAZO (encontrado por telefono alternativo)");
Log::info('Cliente autoasignado a ' .

$user->name . ' (id '.$user->id.')');
$reasing = $this->reassignReferido($c->id,
$user->id);
$nuevaconsulta= $this-
>new_consulta_referido($request, $c);
'success' => true,
'message' => 'El cliente ya existia ,
se ha creado un nuevo comentario',
'cliente_id' => $c->id
], 200);
} elseif($c->status ==
Config::get('constant.cliente_status.no_interesado')){
Log::info("CLIENTE REFERIDO YA EXISTIA COMO
NO INTERESADO (encontrado por telefono alternativo)");
Log::info('Cliente autoasignado a ' .

$user->name . ' (id '.$user->id.')');
$user->id);
'success' => true,
'message' => 'El cliente ya existia ,
se ha creado un nuevo comentario',
], 200);
}
else {
Log::info('INTENTO FALLIDO DE CREAR
REFERIDO POR '.strtoupper($user->name).', CLIENTE YA EXISTE POR TELEFONO
ALTERNATIVO ('.$c->id.')');
$c->save();
'success' => false,
'message' => 'El cliente ya existia!',
], 200);
}
}
} else {
'success' => false,
'message' => 'Teléfono inválido'
], 400);
}
}
'success' => true,
'message' => 'El cliente se ha cargado con exito',
], 200);
} else {
'success' => false,
], 400);
}
} else {
if ($tel_valid) {
if(($c->email == '' && $request->email != '') ||
$c->email != $request->email){
$c->email = $request->email;
}
if(!empty($request->nombre_apellido)){
$c->nombre_apellido = $request-
>nombre_apellido;
}
if(!empty($request->edad)){
$c->edad = $request->edad;
}
if(!empty($request->telefono) && !empty($c-
>telefono) && $c->telefono != $request->telefono){
$c->telefono = $request->telefono;
} elseif(!empty($request->telefono_alt) &&
empty($c->telefono_alt)){
$c->telefono_alt = $request->telefono_alt;
}
if(!empty($request->from)){
$c->contact_from = $request->from;
}
if(!empty($request->to)){
$c->contact_to = $request->to;
}
if(!empty($request->campana)){
$campaign = Campaign::where('name',$request-
>campana)->pluck('id');
$c_campaign =
ClientCampaign::where('client_id',$c->id)->first();
if($c_campaign){
$c_campaign->campaign_id = $campaign;
$c_campaign->save();
} else {
$c_campaign = new ClientCampaign();
$c_campaign->client_id = $c->id;
if($campaign){
$c_campaign->campaign_id = $campaign;
}
$c_campaign->created_at = Carbon::now();
$c_campaign->updated_at = Carbon::now();
if(!empty($request->url)){
$c_campaign->url = $request->url;
}
$c_campaign->save();
}
}
if($c->status ==
Log::info("CLIENTE REFERIDO YA EXISTIA COMO A
PLAZO (encontrado por mail)");
Log::info('Cliente autoasignado a ' . $user-

>name . ' (id '.$user->id.')');
$user->id,$request);
'success' => true,
'message' => 'El cliente ya existia , se ha
creado un nuevo comentario',
], 200);
Log::info("CLIENTE REFERIDO YA EXISTIA COMO NO
INTERESADO (encontrado por mail)");

>name . ' (id '.$user->id.')');
$user->id);
'success' => true,
], 200);
} else {
Log::info('INTENTO FALLIDO DE CREAR REFERIDO
POR '.strtoupper($user->name).', CLIENTE YA EXISTE POR EMAIL ('.$c->id.')');
}
$c->save();
'success' => false,
], 200);
}
}
'success' => true,
], 200);
} else {
'success' => false,
], 400);
}
}
} else {
if(!$tel_alt_valid || ($clientes =
Cliente::existbyphone($request->telefono_alt)) == false){
'success' => true,
], 200);
} else {
'success' => false,
], 400);
}
} else {
//Buscamos si algunos de los clientes que existen estan en
la misma empresa
if ($c->status ==
Config::get('constant.cliente_status.a_plazo')) {
Log::info("CLIENTE REFERIDO YA EXISTIA COMO A
PLAZO (encontrado por telefono alternativo)");
>name . ' (id ' . $user->id . ')');
$user->id);
$nuevaconsulta = $this-
'success' => true,
], 200);
} elseif ($c->status ==
Config::get('constant.cliente_status.no_interesado')) {
Log::info("CLIENTE REFERIDO YA EXISTIA COMO NO
INTERESADO (encontrado por telefono alternativo)");

>name . ' (id ' . $user->id . ')');
$user->id);
$nuevaconsulta = $this-
'success' => true,
], 200);
} else {
Log::info('INTENTO FALLIDO DE CREAR REFERIDO
POR ' . strtoupper($user->name) . ', CLIENTE YA EXISTE POR TELEFONO ALTERNATIVO
(' . $c->id . ')');
$c->save();
'success' => false,
], 200);
}
}
}
} else {
'success' => true,
], 200);
} else {
'success' => false,
], 400);
}
}
}
//si existe por telefono y es valido
} else if ($tel_valid) {
//Buscamos si algunos de los clientes que existen estan en la misma
empresa
if($c->status ==
Log::info("CLIENTE REFERIDO YA EXISTIA COMO A PLAZO
(encontrado por telefono)");
Log::info('Cliente autoasignado a ' . $user->name . ' (id

'.$user->id.')');
$reasing = $this->reassignReferido($c->id, $user->id);
$this->new_consulta_referido($request, $c);
'success' => true,
'message' => 'El cliente ya existia , se ha creado un
nuevo comentario',
], 200);
Log::info("CLIENTE REFERIDO YA EXISTIA COMO NO INTERESADO
(encontrado por telefono)");
Log::info('Cliente autoasignado a ' . $user->name . ' (id

'.$user->id.')');
$reasing = $this->reassignReferido($c->id, $user->id);
$this->new_consulta_referido($request, $c);
'success' => true,
'message' => 'El cliente ya existia , se ha creado un
nuevo comentario',
], 200);
}
else {
Log::info('INTENTO FALLIDO DE CREAR REFERIDO POR
'.strtoupper($user->name).', CLIENTE YA EXISTE POR TELEFONO ('.$c->id.')');
}
$c->save();
'success' => false,
], 200);
}
}
'success' => true,
], 200);
} else {
'success' => false,
], 400);
}
}
}
private function new_consulta_referido($request,$cliente){
$producto = Producto::where('nombre','=','Sin modelo en especifico')-

>where('id_empresa','=',$request->id_empresa)->first();
if(!is_null($producto)){
$consulta = new Consultas();

$consulta->id_cliente = $cliente->id;
$consulta->id_producto = $producto->id; //sin especificar
$consulta->id_origen = $request->medio ? $request->medio : 3; //origen
default:formulario web
$consulta->id_status = 5; //Nuevo
$consulta->id_usuario = env('USER_API_ID');
$consulta->comentario = $request->comentario;
$consulta->id_razon = 4; //sin especificar
$consulta->leido = 0; //Consulta no leida
$consulta->save();
public function reassignReferido($client_id, $vendedor) {

$cliente = Cliente::find($client_id);
$cliente->id_usuario = $vendedor;
$tareas = Tareas::where('id_cliente', '=', $client_id)->get();

$tarea->id_usuario = $vendedor;
$tarea->save();
}
if ($cliente->save()) {
ClientsActivities::ASIGNADO_POR, 'Referido Asignado Por ');
return "ok";
} else {
return "errors";
}
}
private function newClient($request)

{
$producto = Producto::where('nombre','=','Sin modelo en especifico')-
>where('id_empresa','=',$request->id_empresa)->first();
$campana = Campaign::where('name' ,'=',$request->campana)->first();
if(empty($campana) && !empty($request->utm_source) ){
$campana = Campaign::where('name' ,'=',$request->utm_source)->first();
}
$tel_explode = Utils::tel_argentino($request->telefono);
$tel_valid = true;
if($tel_explode == false){
$tel_valid = false;
if(empty($request->telefono)){
$request->telefono = '';
}
} else {
$provincia = Utils::codigos_area_argentina($tel_explode['area']);
}
$new_client = [
'nombre_apellido'=> preg_replace('/[^A-Za-z áÁéÉíÍóÓúüÚÜñÑ]/', '',
$request->nombre_apellido),
'edad' => $request->edad? (int)$request->edad : 0,
'telefono'=> $tel_valid ? $tel_explode['numero'] : $request->telefono,
'telefono_alt' => $request->telefono_alt? $request->telefono_alt : 0,
'contact_from'=> $request->from?$request->from:'00:00:00',
'contact_to'=> $request->to?$request->to:'00:00:00',
'provincia' => $provincia ? $provincia : 28,
'provincia_proyecto' => $request->provincia_proyecto? $request-
>provincia_proyecto : 28,
'localidad' => 'Consultar',
'localidad_proyecto' => $request->localidad_proyecto? $request-
>localidad_proyecto : 'Consultar',
//'email' => $request->email, ya esta en el request
'posee_terreno' => $request->posee_terreno?$request->posee_terreno:'',
'barrio_cerrado' => $request->barrio_cerrado?$request-
>barrio_cerrado:'',
'barrio_cerrado_name' => $request->barrio_cerrado_name?$request-
>barrio_cerrado_name:'',
'comentario' => $request->comentario ? $request->comentario : 'Cliente
Referido.',
'id_empresa' => $request->id_empresa,
'id_producto' => $producto ? $producto->id : 160,
'id_lugar' => $request->medio ? $request->medio : 3,
'status' => $request->boolean?23:5, //Si es cita web lo pongo a
confirmar, sino lo pongo nuevo
'id_razon' => 4, //sin especificar
'forma_de_pago' => 3,
'query_date' => Carbon::now(),
'campana' => !empty($campana) ? $campana->id : 1,
'utm_url' => $request->utm_url?$request->utm_url:'',
'utm_source' => $request->utm_source?$request->utm_source:'',
'utm_medium' => $request->utm_medium?$request->utm_medium:'',
'utm_campaign_name' => $request->utm_campaign?$request-
>utm_campaign:'',
'utm_ad_group' => $request->utm_term?$request->utm_term:'',
'utm_ad_name' => $request->utm_content?$request->utm_content:'',
'utm_network' => $request->utm_network?$request->utm_network:'',
'utm_keyword' => $request->utm_keyword?$request->utm_keyword:'',
'utm_matchtype' => $request->utm_matchtype?$request->utm_matchtype:'',
'utm_device'=> $request->utm_device?$request->utm_device:'',
'm_cuadrados' => $request->m_cuadrados ? $request->m_cuadrados : 0,
'cant_habitaciones' => $request->cant_habitaciones ? $request-
>cant_habitaciones : 0,
'jsonresponse' => true,
];
$request->merge($new_client);
$response = app('App\Http\Controllers\ClientesController')-
>store($request);
if(!is_null($response))
return $response->getData();
else{
Log::info($response);
return $response;
}
}
private function validateData($data){
$rules = [
'nombre_apellido' => 'required',
'telefono' => 'required_without:email',
'email' => 'required_without:telefono|email',
'campana' => 'string',
'id_empresa' => 'required|digits_between:1,2|
exists:empresas,id,deleted_at,NULL',
'medio' => 'between:1,2|exists:origens,id,deleted_at,NULL'
];
$messages = [
'required' => ':attribute es obligatorio',
'size' => ':attribute debe tener 10 digitos',
'exists' => ':attribute no existe',
'min' => ':attribute tiene que ser minimo de 8 caracteres.',
'email' => ':attribute debe ser un email valido',
'numeric' => ':attribute debe ser solo numeros.',
'between' => ':attribute debe contener entre :min - :max digitos',
'required_without' => ':attribute es obligatorio',
];
$validator = \Illuminate\Support\Facades\Validator::make($data, $rules,

$messages);
if ($validator->fails()) {
$messages = $validator->errors();
if ($messages->has('nombre_apellido')) {
return $messages->first('nombre_apellido');
}
if ($messages->has('telefono')) {
return $messages->first('telefono');
}
if ($messages->has('email')) {
return $messages->first('email');
}
if ($messages->has('campana')) {
return $messages->first('campana');
}
if ($messages->has('id_empresa')) {
return $messages->first('id_empresa');
}
if ($messages->has('medio')) {
return $messages->first('medio');
}
}
else{
return 'valido';
}
public function search(){

if($user->tipo != Config::get('constant.user_types.rr_hh')){
return view('pages.clientes.buscar',compact('user'));
} else {
}
}
public function confirmar_reunion(Request $request){

$user = $request->user();
$reunion = Reuniones::findOrFail($request->id);
if(!empty($request->fecha))
$reunion->fecha = Carbon::createFromFormat('d/m/Y H:i', $request-
>fecha);
$reunion->visitado = $request->visitado;
if($reunion->visitado == 0 && empty($request->fecha) ){
}
if($reunion->save()){
$success['ok'] = 'Reunion actualizada';
}else{
$success['error'] = 'No hubo cambios';
}
return response()->json($success, 200);

}
public function confirmarReunion(Request $request){

$user = Auth::user()->id;
$reunion->modificado_por = $user;
$request->session()->flash('alert-success', 'Reunion Confirmada');
} else {
$request->session()->flash('alert-danger', 'No se pudo actualizar la
reunión');
}
return redirect()->back();
}
public function cancelar_reunion(Request $request){
$path = explode('/',URL::previous());
$sizeArray= sizeof($path);
$urlConcatenada='';
for($i=3;$i<($sizeArray-1);$i++){
$urlConcatenada= $urlConcatenada.$path[$i].'/';
}
$reunion->modificado_por = $user->id;
$state = true;
$request->session()->flash('alert-success', 'Reunión Cancelada');
}else{
$state = false;
reunión');
}
if($state){
if($urlConcatenada == "clientes/mostrar/"){
} else{
return response()->json(['status' => true]);
}
} else {
}
}
public function confirmar_cita_hoy(Request $request){

if($request->ajax()){
$user_default = 0;
//Quien tiene asignado el dato
$user_assign = Cliente::select([
'users.id',
'users.name',
'users.tipo'
])
->join('users','clientes.id_usuario','=','users.id')
->where('clientes.id',$request['id'])->first();
//si el usuario es tipo asesor comercial o supervisor lo dejo como

user_default
if($user_assign->tipo ==
Config::get('constant.user_types.asesor_comercial') || $user_assign->tipo ==
Config::get('constant.user_types.supervisor')){
$user_default = $user_assign->id;
}
//array de asesores comerciales y supervisores a excepción de Natalia
Daltolo, Belén Nosotti, Franco gervan, Romina Roque, Glenda Perez Sup, Leandro
Cejas, Lucas Guzmán, Fran Sesa (sup)
$users = User::whereIn('tipo',[2,3])->whereNotIn('id',
[289,457,500,518,520,529,537])->where('suspendido','<>',1)->lists('name','id');
return response()-
>json(['status'=>true,'vendedores'=>$users,'user_default'=>$user_default,
'client_id'=>$request['id']]);
} else {
dd('error');
}
}
public function confirmar_y_reasignar(Request $request){

$reunion = Reuniones::findOrFail($request['reunion_id']);
if($reunion){
$asignacion = $this->reasign($request['client_id'],
$request['user_id']);
if($asignacion == 'ok'){
return response()->json(['status'=>true]);
} else {
dd('error asignacion save');
}
} else {
dd('error reunion save');
}
}
}
/*public function stand_by_reunion(Request $request){

$request->session()->flash('alert-success', 'Reunión En Stand By');

}else{
reunión');
}
}*/
/*public function eliminar_reunion(Request $request){

if($reunion->delete()){
$request->session()->flash('alert-success', 'Reunión Eliminada con
éxito');
return response()->json([],200);
}else{
$request->session()->flash('alert-danger', 'Error al intentar eliminar
reunión');
return response()->json([],200);
}
}*/
/**
* Display the specified resource.
*
* @param int $id
*/
public function show($id) {
$cliente = Cliente::DatosDelCliente($id)->first();
if($cliente){
$user->presets = $user->presets;
if($user->presets->count()){
foreach($user->presets as $preset){
$preset->content = str_replace('${empresa}',$cliente-
>nombre_empresa,$preset->content);
$cliente_pila = explode(' ',$cliente->nombre_apellido);
$preset->content = str_replace('${client_name}',
$cliente_pila[0],$preset->content);
$preset->content = str_replace('${client_fullname}',$cliente-
>nombre_apellido,$preset->content);
}
}
$cliente->historial_whatsapp = HistorialWhatsapp::
select([
'historial_whatsapp.id',
'historial_whatsapp.flow',
'historial_whatsapp.type',
'historial_whatsapp.content',
'historial_whatsapp.created_at',
'users.name'
])
->where('historial_whatsapp.client_id',$cliente->id)
->leftJoin('users','users.id','=','historial_whatsapp.user_id')
->get();
switch($cliente->id_empresa){
case 1:
$cliente->logo_emp = 'logolaesperanza.png';
$cliente->svg = false;
break;
case 2:
$cliente->logo_emp = 'Logo_color_sin-slogan.svg';
$cliente->svg = true;
break;
case 8:
$cliente->logo_emp = 'logoeurocasa.png';
break;
case 14:
$cliente->logo_emp = 'casaya.png';
break;
case 15:
$cliente->logo_emp = 'logo-laeconomica.png';
break;
default:
$cliente->logo_emp = '';
break;
}
$planos = Plano::select([
'planos.id',
'planos.id_usuario',
'planos.membrete',
'planos.status',
'planos.substatus',
'un.name as userName',
'uv.name as userVentas',
'ua.name as userArqui',
'planos.id_arquitecto',
'planos.condi_modelo',
'plano_prod.nombre as modelo',
'planos.condicion',
'planos.construccion',
'planos.terraza_files_cant',
'planos.material_files_cant',
'planos.dimensiones',
'planos.linea',
'planos.localidad',
'provincias.nombre_provincia',
'planos.obse_gral',
'planos.frame',
'planos.plantas',
'planos.superficie',
'us.name as userSugerido',
'planos.created_at',
'planos.motivo_rescicion',
'planos.modify',
'planos.visto_solicitante'
])
->join('users as un','un.id','=','planos.id_usuario')
->leftJoin('users as uv','uv.id','=','planos.aprueba_ventas')
->leftJoin('users as ua','ua.id','=','planos.id_arquitecto')
->leftjoin('productos as
plano_prod','plano_prod.id','=','planos.modelo')
->join('provincias','provincias.id','=','planos.provincia')
->leftJoin('users as us','us.id','=','planos.id_user_sugerido')
->where('id_cliente',$cliente->id)->get();
if($planos->count()){
$cliente->planos = $planos;
foreach($cliente->planos as $plano){
//Verifico si corresponde quitar de las notificaciones de
calibotside
if($user->id == $plano->id_usuario && $plano->status ==
'Finalizado'){
$calibotsession = Session::get('calibotside.planos');
if(!empty($calibotsession)){
foreach($calibotsession as $key => $cali){
if($cali['id'] == $cliente->id && !$plano-
>visto_solicitante){
unset($calibotsession[$key]);
Session::forget('calibotside.planos');
Session::put('calibotside.planos',
$calibotsession);
$plano->visto_solicitante = true;
$plano->save();
}
}
}
}
$s3 = Storage::disk('s3');
$plano->dimensiones = json_decode($plano->dimensiones);
$plano->superficie = json_decode($plano->superficie);
$plano->modify = json_decode($plano->modify);
$commentsAndFiles = [];
if($plano->construccion == 'terraza'){
$directory = "clientes/$cliente->id/solicitudPlano/$plano-
>id/terraza/";
$archivos = $s3->files($directory);
$archivosTerraza = [];
if(!empty($archivos)){
foreach($archivos as $file) {
$array = [];
$array['path'] = $file;
$explode = explode('/', $array['path']);
$array['name'] = end($explode);
array_push($archivosTerraza, $array);
}
$plano->terrazaFiles = $archivosTerraza;
}
}
if($plano->material_files_cant){
>id/complemento/";
$archivosComplemento = [];
$array = [];
$array['extension'] = $s3->mimeType($file);
$array['size'] = $s3->size($file);
$array['size'] /= 1024;
if($array['size'] > 1024){
$array['size'] /= 1024;
$array['size'] =
number_format($array['size'],2,',','.').' MB';
} else {
$array['size'] =
number_format($array['size'],2,',','.').' KB';
}
$array['created_at'] = date(DATE_RFC822, $s3-
>lastModified($file));
$array['last_modified_date'] =
Carbon::parse($array['created_at'])->format('d-m-Y');
$array['last_modified_time'] =
Carbon::parse($array['created_at'])->format('H:i:s');
array_push($archivosComplemento, $array);
array_push($commentsAndFiles, $array);
}
usort($archivosComplemento, function($a, $b) {
$first = Carbon::parse($a['created_at']);
$second = Carbon::parse($b['created_at']);
return $first->greaterThan($second);
});
$plano->materialComplementario = $archivosComplemento;
}
}
if($plano->status == 'Solicitud Finalizado' || $plano->status
== 'Finalizado'){
>id/final/";
$archivosTerminado = [];
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
array_push($archivosTerminado, $array);
}
$plano->terminadoFiles = $archivosTerminado;
}
}
if(!empty($plano->modify)){
foreach($plano->modify as $modi){
$directory =
"clientes/$cliente->id/solicitudPlano/$plano->id/modificaciones/$modi->order/";
$archivosModi = [];
foreach($archivos as $file){
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
array_push($archivosModi, $array);
}
usort($archivosModi, function($a, $b) {
});
$modi->files = $archivosModi;
}
}
}
$plano->historial = HistorialPlano::select([
'userHistory.name as historyName',
'historial_planos.detail',
'historial_planos.created_at'
])
->join('users as
userHistory','userHistory.id','=','historial_planos.id_usuario')
->where('id_plano',$plano->id)->get();
$plano->comentarios = ComentarioPlano::select([
'userComment.name as usuario',
'userComment.tipo as tipo',
'comentario_plano.comentario',
'comentario_plano.created_at'
])
->join('users as
userComment','userComment.id','=','comentario_plano.id_usuario')
->where('id_plano',$plano->id)->get()->toArray();
foreach($plano->comentarios as $comment){
array_push($commentsAndFiles, $comment);
}
}
usort($commentsAndFiles, function($a, $b) {
});
$plano->comentarios = $commentsAndFiles;
} else {
$cliente->planos = '';
}
$planosPostVentas = PlanoPostVenta::select([
'planos_post_ventas.id',
'planos_post_ventas.id_solicitante',
'planos_post_ventas.membrete',
'planos_post_ventas.status',
'us.name as userSolicitante',
'ua.name as userArqui',
'planos_post_ventas.id_solicitante',
'planos_post_ventas.id_arquitecto',
'planos_post_ventas.observaciones',
'planos_post_ventas.enumerations',
'planos_post_ventas.motivo_rescicion',
'planos_post_ventas.created_at',
'planos_post_ventas.visto_solicitante'
])
->join('users as
us','us.id','=','planos_post_ventas.id_solicitante')
->leftJoin('users as
ua','ua.id','=','planos_post_ventas.id_arquitecto')
if($planosPostVentas->count()){
$cliente->planosPostVentas = $planosPostVentas;
foreach($cliente->planosPostVentas as $planoPost){
calibotside
if($user->id == $planoPost->id_solicitante && $planoPost-
>status == 'Finalizado'){
$calibotsession =
Session::get('calibotside.planosPostVentas');
if($cali['id'] == $cliente->id && !$planoPost-
Session::forget('calibotside.planosPostVentas');
Session::put('calibotside.planosPostVentas',
$calibotsession);
$planoPost->visto_solicitante = true;
$planoPost->save();
}
}
}
}
$planoPost->enumerations = json_decode($planoPost-
>enumerations);
$directory =
"clientes/$cliente->id/solicitudPlanoPostVentas/$planoPost->id/";
$archivosPlanosPostVentas = [];
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
$array['last_modified'] = date(DATE_RFC822, $s3-
Carbon::parse($array['last_modified'])->format('d-m-Y');
Carbon::parse($array['last_modified'])->format('H:i:s');
array_push($archivosPlanosPostVentas, $array);
}
usort($archivosPlanosPostVentas, function($a, $b) {
$first = Carbon::parse($a['last_modified']);
$second = Carbon::parse($b['last_modified']);
});
$planoPost->archivos = $archivosPlanosPostVentas;
}
if($planoPost->status == 'Solicitud Finalizado' || $planoPost-
$directory =
"clientes/$cliente->id/solicitudPlanoPostVentas/$planoPost->id/final/";
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
}
$planoPost->terminadoFiles = $archivosTerminado;
}
}
$planoPost->historial = HistorialPlanoPostVenta::select([
'historial_planos_post_ventas.detail',
'historial_planos_post_ventas.created_at'
])
->join('users as
userHistory','userHistory.id','=','historial_planos_post_ventas.id_usuario')
->where('id_plano_post',$planoPost->id)->get();
$planoPost->comentarios = ComentarioPlanoPostVenta::select([
'comentario_planos_post_venta.comentario',
'comentario_planos_post_venta.created_at'
])
->join('users as
userComment','userComment.id','=','comentario_planos_post_venta.id_usuario')
->where('id_plano_post',$planoPost->id)->get();
}
} else {
$cliente->planosPostVentas = '';
}
$anteproyectos = AnteProyecto::select([
'anteproyectos.id',
'anteproyectos.id_solicitante',
'anteproyectos.membrete',
'anteproyectos.status',
'ua.name as userArquitecto',
'anteproyectos.id_arquitecto',
'anteproyectos.prioridad',
'anteproyectos.observaciones',
'anteproyectos.f_estimativa',
'anteproyectos.created_at',
'anteproyectos.motivo_rescicion',
'anteproyectos.visto_solicitante'
])
->join('users as us','us.id','=','anteproyectos.id_solicitante')
->leftJoin('users as ua','ua.id','=','anteproyectos.id_arquitecto')
if($anteproyectos->count()){
$cliente->anteproyectos = $anteproyectos;
foreach($cliente->anteproyectos as $anteproyecto){
calibotside
if($user->id == $anteproyecto->id_solicitante && $anteproyecto-
$calibotsession =
Session::get('calibotside.anteproyectos');
if($cali['id'] == $cliente->id && !$anteproyecto-
Session::forget('calibotside.anteproyectos');
Session::put('calibotside.anteproyectos',
$calibotsession);
$anteproyecto->visto_solicitante = true;
$anteproyecto->save();
}
}
}
}
if($anteproyecto->f_estimativa)$anteproyecto->fecha_estimativa
= $anteproyecto->f_estimativa->format('d/m/Y');
$directory =
"clientes/$cliente->id/solicitudAnteproyecto/$anteproyecto->id/";
$archivosAnteproyecto = [];
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
array_push($archivosAnteproyecto, $array);
}
usort($archivosAnteproyecto, function($a, $b) {
});
$anteproyecto->archivos = $archivosAnteproyecto;
}
if($anteproyecto->status == 'Solicitud Finalizado' ||
$anteproyecto->status == 'Finalizado'){
$directory =
"clientes/$cliente->id/solicitudAnteproyecto/$anteproyecto->id/final/";
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
}
$anteproyecto->terminadoFiles = $archivosTerminado;
}
}
$anteproyecto->historial = HistorialAnteproyecto::select([
'historial_anteproyectos.detail',
'historial_anteproyectos.created_at'
])
->join('users as
userHistory','userHistory.id','=','historial_anteproyectos.id_usuario')
->where('id_anteproyecto',$anteproyecto->id)->get();
$anteproyecto->comentarios = ComentarioAnteproyecto::select([
'comentario_antepro.comentario',
'comentario_antepro.created_at'
])
->join('users as
userComment','userComment.id','=','comentario_antepro.id_usuario')
->where('id_anteproyecto',$anteproyecto->id)->get();
}
} else {
$cliente->anteproyectos = '';
}
$renders = Renders::select([
'renders.id',
'renders.id_solicitante',
'renders.membrete',
'renders.status',
'renders.substatus',
'renders.id_arquitecto',
'renders.f_estimativa',
'renders.observaciones',
'renders.created_at',
'renders.motivo_rescicion',
'renders.modify',
'renders.visto_solicitante'
])
->join('users as us','us.id','=','renders.id_solicitante')
->leftJoin('users as ua','ua.id','=','renders.id_arquitecto')
if($renders->count()){
$cliente->renders = $renders;
foreach($cliente->renders as $render){
calibotside
if($user->id == $render->id_solicitante && $render->status ==
'Finalizado'){
$calibotsession = Session::get('calibotside.renders');
if($cali['id'] == $cliente->id && !$render-
Session::forget('calibotside.renders');
Session::put('calibotside.renders',
$calibotsession);
$render->visto_solicitante = true;
$render->save();
}
}
}
}
$render->modify = json_decode($render->modify);
if($render->f_estimativa)$render->fecha_estimativa = $render-
>f_estimativa->format('d/m/Y');
$directory = "clientes/$cliente->id/solicitudRender/$render-
>id/";
$archivosRender = [];
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
array_push($archivosRender, $array);
}
usort($archivosRender, function($a, $b) {
});
$render->archivos = $archivosRender;
}
if($render->status == 'Solicitud Finalizado' || $render->status

== 'Finalizado'){
$directory =
"clientes/$cliente->id/solicitudRender/$render->id/final/";
$archivos_f = $s3->files($directory);
if(!empty($archivos_f)){
foreach($archivos_f as $file) {
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
}
$render->terminadoFiles = $archivosTerminado;
}
}
if(!empty($render->modify)){
foreach($render->modify as $modi){
$directory =
"clientes/$cliente->id/solicitudRender/$render->id/modificaciones/$modi->order/";
$archivosModi = [];
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
array_push($archivosModi, $array);
}
usort($archivosModi, function($a, $b) {
});
$modi->files = $archivosModi;
}
}
}
$render->historial = HistorialRenders::select([
'historial_renders.detail',
'historial_renders.created_at'
])
->join('users as
userHistory','userHistory.id','=','historial_renders.id_usuario')
->where('id_render',$render->id)->get();
$render->comentarios = ComentarioRenders::select([
'comentario_renders.comentario',
'comentario_renders.created_at'
])
->join('users as
userComment','userComment.id','=','comentario_renders.id_usuario')
->where('id_render',$render->id)->get();
foreach($render->comentarios as $comment){
}
}
});
$render->comentarios = $commentsAndFiles;
} else {
$cliente->renders = '';
}
$veriArquitecturas = VerificacionArquitectura::select([
'verificacion_arquitectura.id',
'verificacion_arquitectura.membrete',
'verificacion_arquitectura.status',
'verificacion_arquitectura.substatus',
'verificacion_arquitectura.prioridad',
'verificacion_arquitectura.id_arquitecto',
'verificacion_arquitectura.id_solicitante',
'verificacion_arquitectura.f_estimativa',
'verificacion_arquitectura.observaciones',
'verificacion_arquitectura.estado_entregado',
'verificacion_arquitectura.estado_recibido',
'verificacion_arquitectura.comentario_entregado',
'verificacion_arquitectura.comentario_recibido',
'verificacion_arquitectura.created_at',
'verificacion_arquitectura.motivo_rescicion',
'verificacion_arquitectura.notify',
])
->join('users as
us','us.id','=','verificacion_arquitectura.id_solicitante')
ua','ua.id','=','verificacion_arquitectura.id_arquitecto')
if($veriArquitecturas->count()){
$cliente->veriArquitecturas = $veriArquitecturas;
foreach($cliente->veriArquitecturas as $veriArquitectura){
if($veriArquitectura->f_estimativa)$veriArquitectura-
>fecha_estimativa = $veriArquitectura->f_estimativa->format('d/m/Y');
$directory =
"clientes/$cliente->id/veriArquitectura/$veriArquitectura->id/";
$archivosVeriArquitectura = [];
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
array_push($archivosVeriArquitectura, $array);
}
usort($archivosVeriArquitectura, function($a, $b) {
});
$veriArquitectura->archivos = $archivosVeriArquitectura;
}
if($veriArquitectura->status != 'Pendiente'){
$directory =
"clientes/$cliente->id/veriArquitectura/$veriArquitectura->id/entregado/";
$archivos_e = $s3->files($directory);
$archivosEntregado = [];
if(!empty($archivos_e)){
foreach($archivos_e as $file) {
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
array_push($archivosEntregado, $array);
}
$veriArquitectura->entregadoFiles = $archivosEntregado;
}
}
if($veriArquitectura->status != 'Pendiente'){
$directory =
"clientes/$cliente->id/veriArquitectura/$veriArquitectura->id/recibido/";
$archivos_r = $s3->files($directory);
$archivosRecibido = [];
if(!empty($archivos_r)){
foreach($archivos_r as $file) {
$array = [];
$array['size'] /= 1024;
$array['size'] /= 1024;
$array['size'] =
} else {
$array['size'] =
}
array_push($archivosRecibido, $array);
}
$veriArquitectura->recibidoFiles = $archivosRecibido;
}
}
$veriArquitectura->historial =
HistorialVeriArquitectura::select([
'historial_veri_arquitectura.detail',
'historial_veri_arquitectura.created_at'
])
->join('users as
userHistory','userHistory.id','=','historial_veri_arquitectura.id_usuario')
->where('id_veri_arquitectura',$veriArquitectura->id)-
>get();
$veriArquitectura->comentarios =
ComentarioVeriArquitectura::select([
'comentario_veri_arquitectura.comentario',
'comentario_veri_arquitectura.id_usuario',
'comentario_veri_arquitectura.created_at'
])
->join('users as
userComment','userComment.id','=','comentario_veri_arquitectura.id_usuario')
->where('id_veri_arquitectura',$veriArquitectura->id)-
>get();
foreach($veriArquitectura->comentarios as $comment){
}
}
});
$veriArquitectura->comentarios = $commentsAndFiles;
if($veriArquitecturas->first()->status == 'Finalizado'){
$cliente->observacionesEntrega = ObservacionEntrega::select([
'observaciones_entrega.id_usuario',
'users.name as usuario',
'observaciones_entrega.observacion',
'observaciones_entrega.public',
'observaciones_entrega.created_at'
])
-
>join('users','observaciones_entrega.id_usuario','=','users.id')
->where('id_cliente',$cliente->id)
->orderBy('created_at','desc')
->get();
$avatars = Storage::disk('avatars');
foreach($cliente->observacionesEntrega as $obseEntrega){
$files = $avatars->allFiles($obseEntrega->id_usuario);
if(!empty($files)){
$obseEntrega->avatar = '/avatars/'.$files[0];
} else {
$obseEntrega->avatar =
'/bower_components/admin-lte/dist/img/avatar7.png';
}
}
}
} else {
$cliente->veriArquitecturas = '';
}
$hoy = Carbon::today();
$diffStatus = $hoy->diffInDays($cliente->status_date);
$cliente->edad = Config::get('constant.edad.'.$cliente->edad);
$origenes = Origen::lists('nombre','id');
/* SI EL USUARIO ES POST VENTAS REGISTRO SU SUBAREA */

if($user->tipo == Config::get('constant.user_types.post_ventas')){
$user->subarea = $user->subareas();
}
if($user->can('view-validacion')){
$cliente->validacion = Validacion::where('id_cliente',$cliente-
>id)->first();
if($cliente->validacion){
if($cliente->validacion->finished_at){
$cliente->validacion->fondo = 'aprobado';
} elseif($cliente->validacion->refused_at){
$cliente->validacion->fondo = 'desaprobado';
} else {
$cliente->validacion->fondo = 'abstencion';
}
}
}
$check = $this->checkViewUser($user, $cliente);
$reuniones = Reuniones::select([
'reuniones.id',
'reuniones.donde',
'reuniones.fecha',
'reuniones.fecha_asignacion',
'reuniones.visitado',
'reuniones.creado_por as creado_por_id',
'reuniones.modificado_por as modificado_por_id',
'user_creado.name as creado_por',
'user_modificado.name as modificado_por',
'reuniones.usuario_asignado',
'user_asignado.name as asignado_a',
'reuniones.contactado',
'provincias.nombre_provincia as provincia',
'reuniones.localidad',
'reuniones.domicilio',
'reuniones.comisionable',
'reuniones.voucher_num',
'reuniones.voucher_desc',
'reuniones.voucher_url',
'reuniones.created_at',
'reuniones.updated_at'
])
->join('users as
user_creado','user_creado.id','=','reuniones.creado_por')
->leftjoin('users as
user_modificado','user_modificado.id','=','reuniones.modificado_por')
user_asignado','user_asignado.id','=','reuniones.usuario_asignado')
-
>leftJoin('provincias','provincias.id','=','reuniones.id_provincia')
->where('reuniones.id_cliente',$cliente->id)->get()->take(4);
$reunion_comisiona = Reuniones::select('reuniones.id')
->where('reuniones.id_cliente',$cliente->id)
->where('reuniones.comisionable',1)
->count();
if($reuniones->count()){
foreach($reuniones as $reunion){
$reunion->fecha_string = $reunion->fecha->format('l d, F Y');

$reunion->fecha_string =
str_replace(Config::get('constant.en_days'), Config::get('constant.esp_days'),
$reunion->fecha_string);
$reunion->fecha_string =
str_replace(Config::get('constant.en_months'), Config::get('constant.esp_months'),
$reunion->fecha_string);
$reunion->created_at_string = $reunion->created_at->format('l
d, F Y');
$reunion->created_at_string =
$reunion->created_at_string);
$reunion->created_at_string =
$reunion->created_at_string);
$reunion->updated_at_string = $reunion->updated_at->format('l
d, F Y');
$reunion->updated_at_string =
$reunion->updated_at_string);
$reunion->updated_at_string =
$reunion->updated_at_string);
//dd($reunion->fecha->diffInDays(Carbon::now(),false));
$files = $avatars->allFiles($reunion->creado_por_id);
if(!empty($files)){
$reunion->avatarCreador = '/avatars/'.$files[0];
} else {
$reunion->avatarCreador =
}
$files = $avatars->allFiles($reunion->modificado_por_id);
if(!empty($files)){
$reunion->avatarModificador = '/avatars/'.$files[0];
} else {
$reunion->avatarModificador = '/bower_components/admin-
lte/dist/img/avatar7.png';
}
if(Carbon::now()->diffInMinutes($reunion->fecha) > 0 &&

$reunion->visitado == 0 && ($cliente->id_empresa == 1 || $cliente->id_empresa == 14
|| $cliente->id_empresa == 8)){
$reunion->buttonWA = true;
} else {
$reunion->buttonWA = false;
}
switch($reunion->donde){
case 'bsas':
$reunion->donde_string = 'Hudson';
break;
case 'pilar':
$reunion->donde_string = 'Pilar';
break;
case 'hudson-expo':
$reunion->donde_string = 'ExpoCasa 2022-Hudson';
break;
case 'fabrica':
$reunion->donde_string = 'P. Ind. Ferreyra';
break;
case 'madero':
$reunion->donde_string = 'Puerto Madero';
break;
case 'uru':
$reunion->donde_string = 'Uruguay';
default:
$reunion->donde_string = 'A Domicilio';
break;
}
}
$subareas = Subarea::select('name')
->join('client_areas', 'client_areas.subarea_id', '=',
'subareas.id')
->where('client_areas.client_id',$cliente->id)
->get();
if ($check) {
$cliente->id_encode = base64_encode($cliente->id);
$cliente->nombre_apellido_encode = base64_encode($cliente-
>nombre_apellido);
$provincias = Provincia::orderBy('nombre_provincia', 'asc')-

>lists('nombre_provincia', 'id');
$competencias = Competencia::lists('name','id');
$provincia_default = null;
foreach($provincias as $key => $value){

if($value == $cliente->nombre_provincia){
$provincia_default = $key;
}
}
$consultas = Consultas::ConsultasDelCliente($id)->with(['user'])-
>get();
$proyectos = Proyecto::where('id_cliente', $id)->first();

if(!empty($proyectos)) {
$proyectos->provincia_instalacion = Provincia::where('id',
$proyectos->id_provincia)->pluck('nombre_provincia');
$proyectos->empresa_proyecto = Empresa::where('id', $proyectos-

>id_empresa)->pluck('nombre_empresa');
$proyectos->producto = Producto::where('id', $proyectos-

>id_producto)->pluck('nombre');
$proyectos->vendedor = User::where('id', $proyectos-

>id_usuario)->pluck('name');
$proyectos->como_paga = FormaPago::where('id', $proyectos-

>forma_pago)->pluck('forma_pago');
//si hay cheques

if (!empty($proyectos->cheques_sena)) {
$proyectos->cheques_sena = json_decode($proyectos-
>cheques_sena);
$proyectos->cant_cheques = $proyectos->cheques_sena->cant;
$proyectos->cheques = [];
for ($i = 1; $i <= $proyectos->cant_cheques; $i++) {
$nro_cheque = 'nro_cheque_' . $i;
$banco = 'banco_' . $i;
$fEmision = 'fecha_emision_' . $i;
$fPago = 'fecha_pago_' . $i;
$importetype = 'importe_type_' . $i;
$importe = 'importe_' . $i;
$estado = 'estado_' . $i;
//Veo si hay archivos del cheque
$num_cheque = $proyectos->cheques_sena->$nro_cheque;
$directory = 'clientes/' . $cliente->id .
'/ficha_sena/forma_pago/cheques/' . $num_cheque . '/';
$archivosChequesSenaArray = [];
if (!empty($archivos)) {
foreach ($archivos as $file) {
$array = [];
$array['last_modified'] = date(DATE_RFC822,
$s3->lastModified($file));
array_push($archivosChequesSenaArray, $array);
}
}
$proyectos->cheques += array($i => [

'nro_cheque' => $proyectos->cheques_sena-
>$nro_cheque,
'banco' => $proyectos->cheques_sena->$banco,
'fecha_emision' => $proyectos->cheques_sena-
>$fEmision,
'fecha_pago' => $proyectos->cheques_sena->$fPago,
'importe_type' => $proyectos->cheques_sena-
>$importetype,
'importe' => $proyectos->cheques_sena->$importe,
'estado' => isset($proyectos->cheques_sena-
>$estado) ? $proyectos->cheques_sena->$estado : '',
'archivos' => $archivosChequesSenaArray
]);
}
}
//si hay transferencias

if (!empty($proyectos->transferencia_sena)) {
$proyectos->transferencia_sena = json_decode($proyectos-
>transferencia_sena);
$proyectos->cant_transferencias = $proyectos-
>transferencia_sena->cant;
$proyectos->transferencias = [];
for ($i = 1; $i <= $proyectos->cant_transferencias; $i++) {
$nro_transferencia = 'nro_transferencia_' . $i;
$mismo_titular = 'mismo_titular_' . $i;
$titular = 'titular_' . $i;
$cuit = 'cuit_' . $i;
$banco = 'banco_' . $i;
$deposito_day = 'deposito_day_' . $i;
$importe = 'importe_' . $i;
//Si hay archivos de Seña Transferencia
$nro_trans = $proyectos->transferencia_sena-
>$nro_transferencia;
'/ficha_sena/forma_pago/transferencia/' . $nro_trans . '/';
$archivosSenaFormaPagoTransferencia = [];
$array = [];
array_push($archivosSenaFormaPagoTransferencia,
$array);
}
}
/* if (array_key_exists($deposito_day, $proyectos-
>transferencia_sena)) {
$depositod = $proyectos->transferencia_sena-
>$deposito_day;
} else {
$depositod = false;
}
if (array_key_exists($importe, $proyectos-
>transferencia_sena)) {
$imported = $proyectos->transferencia_sena-
>$importe;
} */ else {
$imported = false;
}
if ($proyectos->transferencia_sena->$mismo_titular ==
"true") {
$proyectos->transferencias += array($i => [
'nro_transferencia' => $proyectos-
>transferencia_sena->$nro_transferencia,
'mismo_titular' => $proyectos-
>transferencia_sena->$mismo_titular,
'banco' => $proyectos->transferencia_sena-
>$banco,
/* 'deposito_day' => $depositod,
'importe' => $imported, */
'archivos' =>
$archivosSenaFormaPagoTransferencia
]);
} else {
$proyectos->transferencias += array($i => [
'nro_transferencia' => $proyectos-
>transferencia_sena->$nro_transferencia,
'mismo_titular' => $proyectos-
>transferencia_sena->$mismo_titular,
'titular' => $proyectos->transferencia_sena-
>$titular,
'cuit' => $proyectos->transferencia_sena-
>$cuit,
'banco' => $proyectos->transferencia_sena-
>$banco,
'deposito_day' => $depositod,
'importe' => $imported,
'archivos' =>
$archivosSenaFormaPagoTransferencia
]);
}
}
}
if (!empty($proyectos->vehiculo)) {
$proyectos->vehiculo = json_decode($proyectos->vehiculo);
}
//Si es una venta

if ($proyectos->status == 2 || $proyectos->status == 1) {
if (!empty($proyectos->legales)) {
$proyectos->legales = json_decode($proyectos->legales);
}
$proyectos->operacion = Operacion::where('id_cliente',
$id)->first();
if ($proyectos->operacion) {
$proyectos->operacion->moneda = json_decode($proyectos-
>operacion->moneda);
$proyectos->operacion->agregados =
json_decode($proyectos->operacion->agregados);
$proyectos->operacion->cambios =
json_decode($proyectos->operacion->cambios);
$proyectos->operacion->entrega =
json_decode($proyectos->operacion->entrega);
$proyectos->operacion->contraentrega =
json_decode($proyectos->operacion->contraentrega);
$proyectos->operacion->forma_pago =
json_decode($proyectos->operacion->forma_pago);
}
if (!empty($proyectos->operacion->forma_pago-
>total_agregados)) {
if (is_numeric($proyectos->operacion->forma_pago-
>total_agregados)) {
$proyectos->operacion->forma_pago->total_agregados
= number_format($proyectos->operacion->forma_pago->total_agregados, 2, '.', ',');
}
}
if (!empty($proyectos->operacion->forma_pago->op_total)) {
>op_total)) {
$proyectos->operacion->forma_pago->op_total =
number_format($proyectos->operacion->forma_pago->op_total, 2, '.', ',');
}
}
if (!empty($proyectos->operacion->forma_pago->saldo)) {
>saldo)) {
$proyectos->operacion->forma_pago->saldo =
number_format($proyectos->operacion->forma_pago->saldo, 2, '.', ',');
}
}
if (!empty($proyectos->operacion->forma_pago->valor_cuota))
{
>valor_cuota)) {
$proyectos->operacion->forma_pago->valor_cuota =
number_format($proyectos->operacion->forma_pago->valor_cuota, 2, '.', ',');
}
}
if ($proyectos->operacion) {
$proyectos->operacion->precio_operacion =
json_decode($proyectos->operacion->precio_operacion);
}
$proyectos->viviendas = Vivienda::where('id_cliente', $id)-
>get();
if ($proyectos->viviendas) {
foreach ($proyectos->viviendas as $key => $value) {
$proyectos->viviendas[$key]->tipo =
json_decode($proyectos->viviendas[$key]->tipo);
$proyectos->viviendas[$key]->estructura =
json_decode($proyectos->viviendas[$key]->estructura);
$proyectos->viviendas[$key]->tipo->empresa =
Empresa::where('id', $proyectos->viviendas[$key]->tipo->empresa)-
>pluck('nombre_empresa');
$proyectos->viviendas[$key]->tipo->modelo =
Producto::where('id', $proyectos->viviendas[$key]->tipo->modelo)->pluck('nombre');
}
}
if (!empty($proyectos->operacion->fecha_contrato) &&
$proyectos->operacion->fecha_contrato != '0000-00-00') {
$proyectos->operacion->fecha_contrato =
Carbon::parse($proyectos->operacion->fecha_contrato)->format('d-m-Y');
$proyectos->operacion->fecha_contrato =
str_replace('-', '/', $proyectos->operacion->fecha_contrato);
}
//Veo si tiene archivos de entrega
//Si hay archivos de vehículo
'/ficha_venta/entrega/vehiculo';
$archivosVehiculoArray = [];
$array = [];
array_push($archivosVehiculoArray, $array);
}
$proyectos->operacion->entrega->vehiculo->detail-
>archivos = $archivosVehiculoArray;
}
//Si hay archivos de cheques
if (!empty($proyectos->operacion->entrega->cheques)) {
$cant = (int)$proyectos->operacion->entrega->cheques-
>detail->cant;
for ($i = 1; $i <= $cant; $i++) {
$num_cheque = $proyectos->operacion->entrega-
>cheques->$i->nro_cheque;
'/ficha_venta/entrega/cheques/' . $num_cheque;
$archivosChequesArray = [];
$array = [];
array_push($archivosChequesArray, $array);
}
$proyectos->operacion->entrega->cheques->$i-
>archivos = $archivosChequesArray;
}
}
}
//Veo si hay archivos de contraentrega
//Veo si hay vehículos
'/ficha_venta/contraentrega/vehiculo';
$archivosVehiculoArray = [];
$array = [];
array_push($archivosVehiculoArray, $array);
}
$proyectos->operacion->contraentrega->vehiculo->detail-
>archivos = $archivosVehiculoArray;
}
//Veo si hay cheques
if (!empty($proyectos->operacion->contraentrega->cheques))
{
$cant = (int)$proyectos->operacion->contraentrega-
>cheques->detail->cant;
for ($i = 1; $i <= $cant; $i++) {
$num_cheque = $proyectos->operacion->contraentrega-
>cheques->$i->nro_cheque;
'/ficha_venta/contraentrega/cheques/' . $num_cheque;
$archivosChequesArray = [];
$array = [];
array_push($archivosChequesArray, $array);
}
$proyectos->operacion->contraentrega->cheques-
>$i->archivos = $archivosChequesArray;
}
}
}
//Si hay archivos de DNI (clientes/ver)
'/datos_filiatorios/dni';
$archivosDNIClientesVerArray = [];
$array = [];
array_push($archivosDNIClientesVerArray, $array);
}
}
//Si hay archivos de DNI (ficha de venta)

'/ficha_venta/datos_filiatorios/dni';
$archivosDNIArray = [];
$array = [];
array_push($archivosDNIArray, $array);
}
}
//Si hay archivos de DNI (ficha seña)

'/ficha_sena/datos_filiatorios/dni';
$array = [];
array_push($archivosDNIArray, $array);
}
}
//Si hay archivos de Seña Efectivo

'/ficha_sena/forma_pago/efectivo';
$archivosSenaFormaPagoEfectivo = [];
$array = [];
array_push($archivosSenaFormaPagoEfectivo, $array);
}
}
//Si hay archivos de Seña Vehículo

'/ficha_sena/forma_pago/vehiculo';
$archivosSenaFormaPagoVehiculo = [];
$array = [];
array_push($archivosSenaFormaPagoVehiculo, $array);
}
}
//Si hay archivos de legales

'/ficha_venta/legales';
$archivosLEGALESArray = [];
$array = [];
array_push($archivosLEGALESArray, $array);
}
}
//Veo si tiene Recibos de Cualquier Empresa

$reciboslaesperanza = RecibosLaEsperanza::withTrashed()
->select([
'recibos_la_esperanza.id',
'recibos_la_esperanza.id_cliente',
'usa.name as asesor',
'usr.name as responsable',
'recibos_la_esperanza.banco',
'recibos_la_esperanza.otros',
'recibos_la_esperanza.concepto',
'recibos_la_esperanza.recibos_valido_por',
'recibos_la_esperanza.fundamento',
'recibos_la_esperanza.total',
'recibos_la_esperanza.created_at',
'recibos_la_esperanza.deleted_at',
'recibos_la_esperanza.sucursales'
])
->join('users as
usa','usa.id','=','recibos_la_esperanza.id_usuario')
->join('users as
usr','usr.id','=','recibos_la_esperanza.id_responsable')
->where('recibos_la_esperanza.id_cliente',$cliente->id)
->get();
if(!empty($reciboslaesperanza)){
foreach($reciboslaesperanza as $recLA){
$recLA->total = json_decode($recLA->total);
$recLA->total = $recLA->total->importe;
switch($recLA->concepto){
case 1:
$recLA->concepto = 'Seña';
break;
case 2:
$recLA->concepto = 'Entrega';
break;
case 6:
$recLA->concepto = 'Planificación de Proyecto';
break;
case 3:
$recLA->concepto = 'Cuota';
break;
case 4:
$recLA->concepto = 'Saldo';
break;
case 5:
$recLA->concepto = 'Otros';
break;
}
//obtenemos datos de banco en recibo LA
if($recLA->banco) {
$recLA->banco = json_decode($recLA->banco);
/* if (array_key_exists('file', $recLA->banco) &&
$recLA->banco->file == "true") {
$recLA->banco->multiple = 1;
}
elseif (array_key_exists('details', $recLA->banco)) {
$countable = 0;
foreach ($recLA->banco->details as $row){
if ($row->file== "true"){
$countable++;
}
}
if($countable==1){
}
elseif($countable>1){
}
else{
}
}
else{
} */
}
//obtenemos datos de otro medio en recibo LA

if($recLA->otros) {
$recLA->otros = json_decode($recLA->otros);
if (array_key_exists('details', $recLA->otros)) {
$countable = 0;
foreach ($recLA->otros->details as $row){
$countable++;
}
}
if($countable==1){
$recLA->otros->multiple = 2;
}
}
else{
}
}
else{
}
}
}
}
$reciboseurocasa = RecibosEuroCasa::withTrashed()
->select([
'recibos_euro_casa.id',
'recibos_euro_casa.id_cliente',
'recibos_euro_casa.banco',
'recibos_euro_casa.otros',
'recibos_euro_casa.concepto',
'recibos_euro_casa.recibos_valido_por',
'recibos_euro_casa.fundamento',
'recibos_euro_casa.total',
'recibos_euro_casa.created_at',
'recibos_euro_casa.deleted_at',
'recibos_euro_casa.sucursales'
])
->join('users as
usa','usa.id','=','recibos_euro_casa.id_usuario')
->join('users as
usr','usr.id','=','recibos_euro_casa.id_responsable')
->where('recibos_euro_casa.id_cliente',$cliente->id)
->get();
if(!empty($reciboseurocasa)){
foreach($reciboseurocasa as $recEC){
$recEC->total = json_decode($recEC->total);
$recEC->total = $recEC->total->importe;
switch($recEC->concepto){
case 1:
$recEC->concepto = 'Seña';
break;
case 2:
$recEC->concepto = 'Entrega';
break;
case 6:
$recEC->concepto = 'Planificación de Proyecto';
break;
case 3:
$recEC->concepto = 'Cuota';
break;
case 4:
$recEC->concepto = 'Saldo';
break;
case 5:
$recEC->concepto = 'Otros';
break;
}
//obtenemos datos de banco en recibo EC
if($recEC->banco) {
$recEC->banco = json_decode($recEC->banco);
/* if (array_key_exists('file', $recEC->banco) &&
$recEC->banco->file == "true") {
$recEC->banco->multiple = 1;
}
elseif (array_key_exists('details', $recEC->banco)) {
$countable = 0;
foreach ($recEC->banco->details as $row){
$countable++;
}
}
if($countable==1){
}
}
else{
}
}
else{
} */
}
//obtenemos datos de otro medio en recibo EC

/* if($recEC->otros) {
$recEC->otros = json_decode($recEC->otros);
if (array_key_exists('details', $recEC->otros)) {
$countable = 0;
foreach ($recEC->otros->details as $row){
$countable++;
}
}
if($countable==1){
$recEC->otros->multiple = 2;
}
}
else{
}
}
else{
}
} */
}
}
$reciboswhitehouse = RecibosWhiteHouse::withTrashed()
->select([
'recibos_white_house.id',
'recibos_white_house.id_cliente',
'recibos_white_house.banco',
'recibos_white_house.otros',
'recibos_white_house.concepto',
'recibos_white_house.recibos_valido_por',
'recibos_white_house.fundamento',
'recibos_white_house.total',
'recibos_white_house.created_at',
'recibos_white_house.deleted_at',
'recibos_white_house.sucursales'
])
->join('users as
usa','usa.id','=','recibos_white_house.id_usuario')
->join('users as
usr','usr.id','=','recibos_white_house.id_responsable')
->where('recibos_white_house.id_cliente',$cliente->id)
->get();
if(!empty($reciboswhitehouse)){
foreach($reciboswhitehouse as $recWH){
$recWH->total = json_decode($recWH->total);
$recWH->total = $recWH->total->importe;
switch($recWH->concepto){
case 1:
$recWH->concepto = 'Seña';
break;
case 2:
$recWH->concepto = 'Entrega';
break;
case 6:
$recWH->concepto = 'Planificación de Proyecto';
break;
case 3:
$recWH->concepto = 'Cuota';
break;
case 4:
$recWH->concepto = 'Saldo';
break;
case 5:
$recWH->concepto = 'Otros';
break;
}
//obtenemos datos de banco en recibo WH
if($recWH->banco) {
$recWH->banco = json_decode($recWH->banco);
if (array_key_exists('file', $recWH->banco) && $recWH-
>banco->file == "true") {
$recWH->banco->multiple = 1;
}
elseif (array_key_exists('details', $recWH->banco)) {
$countable = 0;
foreach ($recWH->banco->details as $row){
$countable++;
}
}
if($countable==1){
}
}
else{
}
}
else{
}
}
//obtenemos datos de otro medio en recibo WH

if($recWH->otros) {
$recWH->otros = json_decode($recWH->otros);
if (array_key_exists('details', $recWH->otros)) {
$countable = 0;
foreach ($recWH->otros->details as $row){
$countable++;
}
}
if($countable==1){
$recWH->otros->multiple = 2;
}
}
else{
}
}
else{
}
}
}
}
$provincias = Provincia::orderBy('nombre_provincia', 'asc')

->lists('nombre_provincia', 'id');
/* Listas de Select en Forms */

$lista_empresas = Empresa::whereIn('id',
Config::get('constant.empresas_habilitadas'))->lists('nombre_empresa', 'id');
$productos = Producto::where('id_empresa', '=', $cliente-

>id_empresa)->orderBy('nombre', 'asc')->lists('nombre', 'id');
$status_proyectos = ProyectoStatus::lists('status', 'id');
$forma_pago = FormaPago::lists('forma_pago', 'id');
$modelo_cliente = Producto::where('id_empresa', $cliente-

>id_empresa)->lists('nombre','id')->toArray();
$modelosFiles = [];
$storage = Storage::disk('public');
if($files =
$storage->files('modelos/'.$cliente->nombre_empresa.'/Todos los modelos')){
$size = 0;
foreach($files as $file){
$size += ($storage->size($file) / 1024) / 1024;
}
array_push($modelosFiles,array('name' => 'Todos los modelos',
'size' => $size));
}
foreach($modelo_cliente as $modelo){
if($files = $storage->files('modelos/'.$cliente-
>nombre_empresa.'/'.$modelo)){
$size = 0;
$size += ($storage->size($file) /1024 ) /1024;
}
array_push($modelosFiles,array('name' => $modelo, 'size' =>
$size));
}
}
$modelo_cliente[666] = 'Sin modelo en específico';
$tareas = Tareas::where('id_cliente',$id)->where('leido',false)-
>orderBy('fecha')->get();
if(empty($cliente->financiacion)){
$cliente->financiacion = new Financiacion();
$cliente->financiacion->id_cliente = $cliente->id;
$cliente->financiacion->provincia = 28;
$cliente->financiacion->localidad_proyecto = 'Sin especificar';
$cliente->financiacion->save();
$barrios_cerrados = BarriosCerrados::lists('name');
} else {
if($cliente->financiacion->provincia != 28 && ($cliente-
>financiacion->provincia == 3 || $cliente->financiacion->provincia == 21 ||
$cliente->financiacion->provincia == 23 || $cliente->financiacion->provincia ==
24)){
$barrios_cerrados = BarriosCerrados::where('id_provincia',
$cliente->financiacion->provincia)->lists('name');
} else {
$barrios_cerrados = BarriosCerrados::lists('name');
}
}
if(!empty($cliente->financiacion->descripcion_vehiculo)){
$cliente->financiacion->descripcion_vehiculo =
json_decode($cliente->financiacion->descripcion_vehiculo);
$datos_vehiculo['marca'] = $cliente->financiacion-
>descripcion_vehiculo->marca;
$datos_vehiculo['modelo'] = $cliente->financiacion-
>descripcion_vehiculo->modelo;
$datos_vehiculo['ano_modelo'] = $cliente->financiacion-
>descripcion_vehiculo->ano_modelo;
$tiene_vehiculo =
ModelosVehiculos::select('id','id_marca','nombre_marca','nombre_modelo')
->where('nombre_marca',$cliente->financiacion-
>descripcion_vehiculo->marca)->get();
$datos_vehiculo['modelos'] = $tiene_vehiculo-
>lists('nombre_modelo','id');
/*$cliente->financiacion->descripcion_vehiculo =
json_decode($tiene_vehiculo);*/
$datos_vehiculo['id'] = $tiene_vehiculo->where('nombre_modelo',
$cliente->financiacion->descripcion_vehiculo->modelo)->pluck('id')->first();
$datos_vehiculo['id_marca'] =$tiene_vehiculo-
>where('nombre_marca',$cliente->financiacion->descripcion_vehiculo->marca)-
>pluck('id_marca')->first();
$cliente->financiacion->descripcion_vehiculo = $datos_vehiculo;
$fecha_diferencia = Carbon::now()->diffInDays($cliente-
>pluck('created_at'));
$campanas = ClientCampaign::select('campaign_id','source',
'medium', 'campaign_name', 'ad_group', 'ad_name', 'network','url')-
>where('client_id',$id)->whereNotNull('source')->get();
foreach($campanas as $campana){
if($campana->campaign_id == 3){
$cliente->messenger = $campana->url;
}
}
$subarea_cliente = ClientAreas::where('client_id', $cliente->id)-

>pluck('subarea_id');
$subareasPostVentas = Subarea::whereIn('id_area',[2,3])-
>lists('name','id');
$checkPostVenta = ChecklistPostVenta::select(
'checklist_postventa.check1 as check1',
'c1.name as check1_user',
'checklist_postventa.check1_time as check1_time',
'checklist_postventa.numAnexo as numAnexo',
'na.name as numAnexo_user',
'checklist_postventa.numAnexo_time as numAnexo_time',
'checklist_postventa.checkAdmin1 as checkAdmin1',
'ca1.name as checkAdmin1_user',
'checklist_postventa.checkAdmin1_time as checkAdmin1_time',
'checklist_postventa.check15_time as check15_time')
c1','checklist_postventa.check1_user','=','c1.id')
na','checklist_postventa.numAnexo_user','=','na.id')
ca1','checklist_postventa.checkAdmin1_user','=','ca1.id')
->where('checklist_postventa.id_cliente', $id)
->first();
if($checkPostVenta == null){
$checkPostVenta = 'Checklist Vacío';
}
$cliente_status =
ClienteStatus::getStatusListAvailable(Auth::user()->tipo, $cliente-
>id_status,Auth::user()->id);
$razon_cliente = RazonesController::obtenerListaArray($cliente-
>id_status);
$razon_cliente = $razon_cliente->toArray();
$razon_no_interesado = RazonesController::obtenerListaArray(3);
$razon_no_interesado = $razon_no_interesado->toArray();
$razon_a_plazo = RazonesController::obtenerListaArray(13);
$razon_a_plazo = $razon_a_plazo->toArray();
if (Gate::allows('reasign-clients')) {
if($user->tipo !=
Config::get('constant.user_types.post_ventas')){
$vendedores = $this-
>getTodosVendedoresyCantidadAtendidos();
$empresas = Empresa::select('nombre_empresa')-
>whereIn('id', [Auth::user()->empresa])->get();

$vendedor->totalClientes =
Cliente::AtendidosHoyPorVendedor($vendedor->id)->count();
}

$vendedor->groups = UserGroup::where('user_id',
$vendedor->id)->groupBy('group_id')->lists('group_id')->toArray();
>where('groups.primary', false)->lists('groups.id');
}
$vendedores = $vendedores->sortBy('totalClientes');
} else {
$vendedores =
User::join('user_areas','users.id','=','user_areas.user_id')-
>whereIn('user_areas.subarea_id', [6,17])->get();
foreach($vendedores as $vendedor){
$files = $avatars->allFiles($vendedor->id);
if(!empty($files)){
$vendedor->avatar = '/avatars/'.$files[0];
} else {
$vendedor->avatar =
}
}
$empresas = Empresa::select('nombre_empresa')-
>whereIn('id', [Auth::user()->empresa])->get();
$primary_groups = Area::all()->where('name', 'Post-

Ventas');
$secondary_groups = Subarea::whereIn('id_area', [2,3])-

>get();

$vendedor->groups = UserAreas::join('subareas',
'subareas.id', '=', 'user_areas.subarea_id')-
>join('areas','subareas.id_area','=','areas.id')->where('user_areas.user_id',
$vendedor->user_id)->groupBy('areas.id')->lists('areas.id','areas.name')-
>toArray();
$vendedor->secondary_group =
UserAreas::join('subareas', 'subareas.id', '=', 'user_areas.subarea_id')-
>where('user_areas.user_id', $vendedor->user_id)->groupBy('user_areas.subarea_id')-
>lists('user_areas.subarea_id','subareas.name')->toArray();
}
}
}
//ocultamos actividades de administradores para pruebas
$actividades = $cliente->activities->groupBy('tipo');
foreach($actividades as $actividad){
$actividad->subarea = ClientsActivitiesTypes::where('id',
$actividad[0]->getOriginal('tipo'))->pluck('subarea_id');
}
$eliminado = false;
if($cliente->deleted_at != null){
$eliminado = true;
if($user->tipo ==
Config::get('constant.user_types.asesor_comercial') || $user->tipo ==
Config::get('constant.user_types.call_center')){
return view('errors.accesodenegado',
compact('eliminado','id'));
}
}
$marcas= MarcasVehiculos::lists('nombre','id')->toArray();
//Instancio las alerta de Calibot

$calibot = [];
$solicitud_llamado = SolicitudLlamada::select([
'solicitud_llamada.id',
'solicitud_llamada.id_solicitante',
'solicitud_llamada.hora',
'solicitud_llamada.estado_cliente',
'solicitud_llamada.observacion_solicitante',
'solicitud_llamada.id_solicitante',
'solicitud_llamada.id_destinatario',
'us.name AS nombre_solicitante',
'ua.name as arquitecto',
'solicitud_llamada.estado_llamado',
'solicitud_llamada.observacion_llamado',
'solicitud_llamada.created_at',
'solicitud_llamada.visto_solicitante'
])
us','solicitud_llamada.id_solicitante','=','us.id')
ua','ua.id','=','solicitud_llamada.id_destinatario')
->orderBy('solicitud_llamada.hora', 'ASC')
->get();
if($solicitud_llamado){
foreach($solicitud_llamado as $soli){
calibotside
if($user->id == $soli->id_solicitante && $soli-
>estado_llamado == 'CONTACTADO'){
$calibotsession =
Session::get('calibotside.solLlamada');
if($cali['id'] == $cliente->id && !$soli-
Session::forget('calibotside.solLlamada');
Session::put('calibotside.solLlamada',
$calibotsession);
$soli->visto_solicitante = true;
$soli->save();
}
}
}
}
$fecha_llamado = Carbon::parse($soli->hora)->format('d/m/Y
H:i');
if($soli->id_solicitante == $user->id || $soli-
>id_destinatario == $user->id){
if(!$soli->estado_llamado){
$msg = "Tu solicitud de Llamado para el
$fecha_llamado hs. no tiene un estado aún.";
} else {
$msg = "Tu solicitud de Llamado para el
$fecha_llamado hs. se encuentra: <span class='badge'>$soli->estado_llamado</span>";
}
array_push($calibot,$msg);
}
}
}
$arquitectos_habilitados =
SolicitudLlamadaHabilitado::where('status' , 1)->lists('id_arquitecto')->toArray();
$arquitectos_habilitados_lucas =
User::select('users.name','users.id')-
>where('users.tipo',Config::get('constant.user_types.post_ventas'))
->where('user_areas.subarea_id',10)
->join('user_areas','user_areas.user_id','=','users.id')
-
>leftJoin('solicitud_llamada_habilitado','users.id','=','solicitud_llamada_habilita
do.id_arquitecto')
->where('solicitud_llamada_habilitado.status',1)
->get();
$arquitectos_habilitados_veri =
VerificacionArquitecturaHabilitado::where('status' , 1)->lists('id_arquitecto')-
>toArray();
$arquitectos_habilitados_veri_lucas =
User::select('users.name','users.id')-
>where('users.tipo',Config::get('constant.user_types.post_ventas'))
->where('user_areas.subarea_id',10)
->join('user_areas','user_areas.user_id','=','users.id')
-
>leftJoin('verificacion_arquitectura_habilitado','users.id','=','verificacion_arqui
tectura_habilitado.id_arquitecto')
->where('verificacion_arquitectura_habilitado.status',1)
->get();
if($user->tipo == Config::get('constant.user_types.post_ventas') ||
$user->id == 48 || $user->id == 457){
$historial_peticiones = HistorialPeticiones::select([
'historial_peticiones.id_peticion',
'p.asunto as asunto',
'us.name as nombre_usuario',
'historial_peticiones.id_estado as id_estado',
'p.created_at as fecha_creacion',
'historial_peticiones.updated_at as fecha_update',
'sa.name as areaEmisora',
'sa2.name as areaReceptora',
'us2.name as nameReceptor'
])
->where('historial_peticiones.id_cliente',$cliente->id)
->leftjoin('peticiones as
p','historial_peticiones.id_peticion','=','p.id')
us','historial_peticiones.id_usuario','=','us.id')
->join('subareas as sa','p.id_AreaEmisora','=','sa.id')
->leftjoin('subareas as
sa2','p.id_AreaReceptora','=','sa2.id')
us2','historial_peticiones.id_usuario_asignado','=','us2.id')
->get()
->toArray();
$group = array();
foreach ( $historial_peticiones as $value ) {

$group[$value['id_peticion']][] = $value;
}
$historial_peticiones=$group;
$peticiones = Peticiones::select([
'us.name as usuarioReceptor',
'peticiones.asunto',
'peticiones.mensaje',
'peticiones.created_at',
'peticiones.id',
'peticiones.id_UsuarioEmisor',
'peticiones.id_UsuarioReceptor',
'peticiones.id_EstadoPeticion',
'peticiones.id_AreaReceptora',
'sub.name as areaEmisora',
'sub2.name as areaReceptora'
])
us','peticiones.id_UsuarioReceptor','=','us.id')
sub','peticiones.id_AreaEmisora','=','sub.id')
sub2','peticiones.id_AreaReceptora','=','sub2.id')
->get()->toArray();
$archivosPeticiones = [];
$canUploadFiles = [];
foreach($peticiones as $peticion){
$disk = Storage::disk('s3');
$directory = 'clientes/'.$cliente->id.'/peticiones/'.
$peticion['id'];
$archivos = $disk->files($directory);
$archivosArray = [];
$array = [];
$explode = explode('/',$array['path']);
$array['extension'] = $disk->mimeType($file);
$array['size'] = $disk->size($file);
$array['last_modified'] = date(DATE_RFC822,$disk-
array_push($archivosArray,$array);
}
$archivosPeticiones[$peticion['id']] = $archivosArray;
if($user->id == 475 || $user->id == 132 || $user->id == 490
|| $user->id == 479 || $user->id == 48 || $peticion['id_UsuarioEmisor'] == $user-
>id || $peticion['id_UsuarioReceptor'] == $user->id){
$canUploadFiles[$peticion['id']] = true;
} else {
$canUploadFiles[$peticion['id']] = false;
}
}
$Status= [2=>"Asignado","Recibido","En Proceso","Pendiente otra

Area","Finalizado"];
$areaSupervisor = '';
if($user->id == 475 || $user->id == 132 || $user->id == 490 ||

$user->id == 479){
$areaSupervisor = UserAreas::where('user_id',$user->id)-
>lists('subarea_id')->toArray();
$userAsignables = UserAreas::select('us.id as id','us.name

as nombre')
->whereIn('subarea_id',$areaSupervisor)
us','user_areas.user_id','=','us.id')
->get()->lists('nombre','id');
$userAsignables->prepend("Seleccionar Usuario", 0);
}else if($user->id == 471){ //Habilitación de boton Reasignar

Petición
$areaSupervisor = 6;
as nombre')
->where('subarea_id',$areaSupervisor)

} elseif($user->postventa_sup){
$areaSupervisor = $user->postventa_user_area_sup;
as nombre')
->where('subarea_id',$areaSupervisor)
} else {
$userAsignables= [
0 => "Seleccionar Usuario"
];
}
$comentarios_peticiones = ComentarioPeticiones::select([
"comentario_peticiones.id",
"comentario_peticiones.id_peticion",
"comentario_peticiones.comentario",
"comentario_peticiones.created_at",
"comentario_peticiones.updated_at",
"us.name as nombre"
]) ->leftjoin('peticiones as
p','comentario_peticiones.id_peticion','=','p.id')
us','comentario_peticiones.id_usuario','=','us.id')
->where('p.id_cliente',$cliente->id)
->get()->toArray();
//Creo alerta de calibot
if(isset($checkPostVenta) && $checkPostVenta != 'Checklist

Vacío'){
if($checkPostVenta['check15']){
$msg = 'Recuerda que este cliente tiene un contrato de
contado con cláusula de garantías!!';
array_push($calibot,$msg);
}
}
if($proyectos){
if(isset($checkPostVenta) && $checkPostVenta != 'Checklist
Vacío') {
if ($proyectos->operacion && !
$checkPostVenta['check9']) {
if ($proyectos->operacion->fecha_contrato &&
$proyectos->operacion->dias_platea) {
$f_contrato = Carbon::createFromFormat('d/m/Y',
$proyectos->operacion->fecha_contrato);
$now = Carbon::now();
$difference = $now->diffInDays($f_contrato);
$quedan_dias = $proyectos->operacion-
>dias_platea - $difference;
switch ($quedan_dias) {
case ($quedan_dias == 1):
$msg = 'HOY SE VENCE EL PLAZO PARA
DECLARAR PLATEA';
array_push($calibot, $msg);
break;
case ($quedan_dias <= 0):
$msg = 'Declaración de platea
vencida!!';
break;
default:
$msg = "Quedan $quedan_dias días para
que el cliente declare platea";
break;
}
}
}
}
}
if($user->id == 48){
return view('pages.clientes.ver',
compact('user','archivosLEGALESArray','reuniones','reunion_comisiona','archivosDNIC
lientesVerArray','solicitud_llamado','archivosDNIArray','archivosDNISenaArray','arc
hivosSenaFormaPagoEfectivo','archivosSenaFormaPagoTransferencia','archivosSenaForma
PagoVehiculo','reuniones','comentarios_peticiones','userAsignables','areaSupervisor
','Status','archivosPeticiones','peticiones','historial_peticiones','marcas','vende
dores','empresas','cliente', 'productos', 'proyectos', 'origens', 'cliente_status',
'consultas','razon', 'status_proyectos',
'forma_pago','primary_groups','secondary_groups','tareas', 'modelo_cliente',
'fecha_diferencia',
'lista_empresas','locKUser','campanas','eliminado','subareasPostVentas','subareas',
'subarea_cliente','actividades','checkPostVenta','provincias','diffStatus','razon_c
liente','razon_no_interesado','razon_a_plazo','provincia_default','barrios_cerrados
','canUploadFiles','modelosFiles','competencias','origenes',
'reciboswhitehouse','reciboseurocasa','reciboslaesperanza','arquitectos_habilitados
','arquitectos_habilitados_lucas','arquitectos_habilitados_veri','arquitectos_habil
itados_veri_lucas','calibot'));
}
return view('pages.clientes.ver', compact('user',/*
'archivosLEGALESArray',
'archivosDNIClientesVerArray',*/'solicitud_llamado','reuniones','reunion_comisiona'
,/*'archivosDNIArray', 'archivosDNISenaArray',
'archivosSenaFormaPagoEfectivo','archivosSenaFormaPagoTransferencia','archivosSenaF
ormaPagoVehiculo',*/'reuniones','comentarios_peticiones','userAsignables','areaSupe
rvisor','Status','archivosPeticiones','peticiones','historial_peticiones','marcas',
'vendedores','empresas','cliente', 'productos', 'proyectos', 'origens',
'cliente_status', 'consultas',/* 'razon', */ 'status_proyectos',
'fecha_diferencia', 'lista_empresas',/* 'locKUser',
*/'campanas','eliminado','subareasPostVentas','subareas','subarea_cliente','activid
ades','checkPostVenta','provincias','diffStatus','razon_cliente','razon_no_interesa
do','razon_a_plazo','provincia_default','barrios_cerrados','canUploadFiles','modelo
sFiles','competencias','origenes',
itados_veri_lucas','calibot'));
} else {
return view('pages.clientes.ver', compact('user',/*
'archivosLEGALESArray',
'archivosDNIClientesVerArray',*/'solicitud_llamado','reuniones','reunion_comisiona'
,/* 'archivosDNIArray',
'archivosDNISenaArray','archivosSenaFormaPagoEfectivo','archivosSenaFormaPagoTransf
erencia','archivosSenaFormaPagoVehiculo',*/'reuniones','marcas',/* 'vendedores',
'empresas',*/'cliente', 'productos', 'proyectos', 'origens', 'cliente_status',
'consultas',/* 'razon', */ 'status_proyectos', 'forma_pago',/* 'primary_groups',
'secondary_groups',*/'tareas', 'modelo_cliente', 'fecha_diferencia',
'lista_empresas',/* 'locKUser',
*/'reuniones','campanas','eliminado','subareasPostVentas','subareas','subarea_clien
te','actividades','checkPostVenta','provincias','diffStatus','razon_cliente','razon
_no_interesado','razon_a_plazo','provincia_default','barrios_cerrados','origenes','
modelosFiles','competencias',
itados_veri_lucas'));
}
return view('pages.clientes.ver',
compact('reuniones','marcas','vendedores','empresas','solicitud_llamado','cliente',
'reuniones','reunion_comisiona', 'productos', 'proyectos', 'origens',
'cliente_status', 'consultas','razon', 'status_proyectos',
'fecha_diferencia',
'lista_empresas','reuniones','campanas','eliminado','subareasPostVentas','subareas'
,'subarea_cliente','actividades','checkPostVenta','provincias','diffStatus','razon_
cliente','razon_no_interesado','razon_a_plazo','provincia_default','barrios_cerrado
s','origenes','competencias','modelosFiles',
itados_veri_lucas'));
}
$datos = Cliente::select('users.name as vendedor',

'empresas.nombre_empresa as empresa', 'cliente_status.status as status')
->join('empresas', 'clientes.id_empresa', '=', 'empresas.id')
->where('clientes.id', $cliente->id)
->first();
return view('errors.accesodenegado', compact('datos'));

} else {
return view('errors.clienteinexistente',compact('id'));
}
/**
* Show the form for editing the specified resource.
*
* @param int $id
*/
public function edit($id) {
$cliente = Cliente::DatosDelCliente($id)->first();
if ($user->can('edit-cliente')) {
$paises = Paises::all()->lists('name', 'id');
$provincias = Provincia::orderBy('nombre_provincia', 'asc')
->lists('nombre_provincia', 'id');
$provincia_default = $user->provincia_id;
$empresas = Empresa::lists('nombre_empresa','id');
$groups = Group::all();
$asesor_group = UserGroup::where('user_id', $cliente->id_usuario)-
>lists('group_id');
$productos = Producto::where('id_empresa', $cliente->id_empresa)-

>orderBy('nombre', 'asc')->lists('nombre', 'id');
$producto_default = $user->producto_id;

$origen_default = $user->origen_id;
$campaigns = Campaign::lists('name', 'id');

$campaign_default = $user->campaign_id;
$forma_pagos = Planes::lists('forma_pago', 'id');

$pago_default = $user->pago_id;
$razon = Razon::lists('razon', 'id');
$logo = Empresa::select('imgurl')->where('id', Auth::user()->empresa)-

>pluck('imgurl');
if ($cliente->id_status ==
Config::get('constant.cliente_status.senado')) {
$cliente_status = ClienteStatus::lists('status', 'id');
} elseif ($cliente->id_status ==
Config::get('constant.cliente_status.vendido')) {
} else {
if (Auth::user()->tipo == 4) {
$cliente_status = ClienteStatus::whereIn('id',
Config::get('constant.status_habilitados_consultas_recepcion'))->lists('status',
'id');
} else {
$cliente_status = ClienteStatus::whereIn('id',
Config::get('constant.status_habilitados_consultas'))->lists('status', 'id');
}
}
$status_default = $user->status_id;
$financiacion = Financiacion::where('id_cliente', $cliente->id)-

>first();
return view('pages.clientes.editar', compact('provincias','paises',

'productos', 'origens', 'logo', 'forma_pagos', 'cliente_status', 'razon',
'producto_default', 'provincia_default', 'pago_default', 'status_default',
'origen_default', 'campaigns', 'campaign_default', 'cliente', 'current_phone',
'financiacion','empresas'));
}
}
public function restaurar(Request $request, $id){

$cliente = Cliente::where('id',$id)->withTrashed()->update(['deleted_at' =>
null]);
$consultas = Consultas::where('id_cliente',$id)->withTrashed()-
>update(['deleted_at' => null]);
if ($cliente) {
ClientsActivities::register(Auth::user()->id, $id,
ClientsActivities::MODIFICADO, 'Restaurado por');
$request->session()->flash('alert-success', 'Cliente restaurado con
éxito!');
return redirect()->route('clientes.show', [$id]);
} else {
$request->session()->flash('alert-warning', 'Ocurrio un Error.');
}
}
/**
* Update the specified resource in storage.
*
* @param \Illuminate\Http\Request $request
* @param int $id
*/
public function update(Request $request, $id) {
$cliente = Cliente::where('id', $id)->first();
$cliente->fill($request->all());
$financiacion = Financiacion::where('id_cliente', $cliente->id)->first();
if (empty($financiacion)) {
$financiacion = new Financiacion;
}
#$primera_consulta = Consultas::where('id_cliente',$cliente->id)-
>orderBy('created_at','desc')->first();
#$cliente->nombre_apellido = $request->nombre_apellido;
#$cliente->email = $request->email;
#$cliente->provincia = $request->provincia;
#$cliente->localidad = $request->localidad;
#$cliente->id_producto = $request->id_producto;
#$primera_consulta->id_producto = $request->id_producto;
/* Guardamos la financiacion */
$financiacion->update($request->all());
if ($request->localidad_proyecto == "0") {
$financiacion->localidad_proyecto = "No informado";
} else {
$financiacion->localidad_proyecto = $request->localidad_proyecto;
}
$financiacion->provincia = $request->provincia_proyecto;
$financiacion->posee_terreno = $request->has('posee_terreno');
$financiacion->posee_vehiculos = $request->has('posee_vehiculos');
$financiacion->posee_propiedades = $request->has('posee_propiedades');
$financiacion->id_cliente = $cliente->id;
$financiacion->fecha_estimada_inicio_proyecto = $request-
>fecha_estimada_inicio_proyecto;
if ($cliente->save() && $financiacion->save()) {

ClientsActivities::MODIFICADO, 'Modificado por');
$request->session()->flash('alert-success', 'Cliente actualizado!');
} else {
$request->session()->flash('alert-warning', 'Ocurrio un Error.');
}
}
/**
* Remove the specified resource from storage.
*
* @param int $id
*/
public function destroy(Request $request, $id) {
/* Comprobamos que el usuario logueado sea Recepcion */
if ($user->tipo == Config::get('constant.user_types.recepcion') || $user-
>tipo == Config::get('constant.user_types.supervisor') || $user->tipo ==
Config::get('constant.user_types.socio_gerente')) {
/* Obtenemos el cliente por el ID que recibimos via GET */
$cliente = Cliente::find($id);
/* Si el cliente Existe continuamos */

if ($id) {
/* Borramos las Consultas del Cliente */
$cliente->consultas()->delete();
/* Borramos el Cliente */
$cliente->delete();
/* Cargamos la actividad */
ClientsActivities::register($user->id, $id,
ClientsActivities::BORRADO);
/* retornamos un mensaje de confirmacion */

$request->session()->flash('alert-success', 'Cliente Eliminado
correctamente');
/* redirigimos segun el tipo de usuario */

if($user->tipo == Config::get('constant.user_types.socio_gerente'))
{
return redirect()->route('postventa.seguimiento_usuarios');
} else {
return redirect()->route('clientes.misclientes');
}
} else {
/* retornamos un mensaje de error */

$request->session()->flash('alert-warning', 'Cliente No Existe');
/* redirigimos a la pagina de mis clientes */

return redirect()->route('clientes.misclientes');
}
} else {
dd('no autorizado');
}
}
public function senados($id) {
$empresa = $id;
return view('pages.clientes.gerencia.senado', compact('empresa'));

}
public function vendidos($id) {
$empresa = $id;
return view('pages.clientes.gerencia.vendidos', compact('empresa'));

}
public function misclientes() {
//Si el usuario es Vendedor
if ($user->tipo == Config::get('constant.user_types.asesor_comercial')) {
return view('pages.clientes.vendedor.misclientes');
}
//si el usuario es Supervisor
return view('pages.clientes.supervisor.misclientes',
compact('clientes','primary_groups','vendedores',
'vendedores_LEC','secondary_groups'));
}
//Si el usuario es Gerente Socio
if ($user->tipo == Config::get('constant.user_types.socio_gerente')) {
$vendedores = User::ObtenerTodosLosUsuarios();
return view('pages.clientes.vendedor.misclientes',
compact('vendedores'));
}
//Si el usuario es recepcion


// $vendedor->groups = UserGroup::where('user_id', $vendedor->id)-
//$vendedor->secondary_group = UserGroup::join('groups',
>get();
}

return view('pages.clientes.recepcion.misclientes',
}
//Si el usuario es calidad
if($user->tipo == Config::get('constant.user_types.call_center')){
return view('pages.clientes.calidad.misclientes');
}
//Se el usuario es Post ventas

if($user->tipo == Config::get('constant.user_types.post_ventas')){
return view('pages.clientes.postventas.misclientes');
}
}
public function agenda_reuniones(){

return View::make('pages.agenda.calendario-reuniones');
}
public function visitasconcretadas(Request $request) {

if ($request->ajax()){
if($user->tipo == Config::get('constant.user_types.call_center') ){
'clientes.id',
'empresas.nombre_empresa',
'users.name as asignado_name',
'usersl.name as llamador_name',
'reuniones.fecha as fecha_visita',
'reuniones.donde'
])
->join('empresas','clientes.id_empresa','=','empresas.id')
->join('reuniones','clientes.id','=','reuniones.id_cliente')
->join('users as
usersl','reuniones.creado_por','=','usersl.id')
->where('reuniones.creado_por', $user->id);
if(isset($request->visitado))$clientes-
>whereIn('reuniones.visitado', $request->visitado);
if(!empty($request->id_empresa))$clientes->whereIn('empresas.id',
$request->id_empresa);
if(!empty($request->fecha))$clientes-
>whereBetween('reuniones.fecha', [Utils::startdate($request->fecha),
Utils::enddate($request->fecha)]);
if(!empty($request->created_at))$clientes-
>whereBetween('reuniones.created_at', [Utils::startdate($request->created_at),
Utils::enddate($request->created_at)]);
if(!empty($request->client_nombre))$clientes-
>where('clientes.nombre_apellido', 'like', '%'.$request->client_nombre.'%');
if(!empty($request->donde))$clientes->whereIn('reuniones.donde',
$request->donde);
}else if( $user->tipo == Config::get('constant.user_types.supervisor')
||
$user->tipo == Config::get('constant.user_types.socio_gerente') ||
$user->tipo == Config::get('constant.user_types.marketing') ||
$user->tipo == Config::get('constant.user_types.administrador') ||
$user->id == 527 ||
$user->tipo == Config::get('constant.user_types.rr_hh') ||
$user->can('asesor-can-view-all-citas')){
$clientes = Reuniones::select([
'reuniones.id as id_reunion',
'clientes.id',
'areas.tipo as grupo',
'reuniones.donde',
'provincias.nombre_provincia'
])->join('clientes','reuniones.id_cliente','=','clientes.id')
->join('users as
usersl','reuniones.creado_por','=','usersl.id')
->join('user_types as areas', 'usersl.tipo','=','areas.id')
-
>leftJoin('provincias','reuniones.id_provincia','=','provincias.id');
if(isset($request->visitado))$clientes-
>whereIn('reuniones.visitado', $request->visitado);
if(!empty($request->id_empresa))$clientes->whereIn('empresas.id',
$request->id_empresa);
if(!empty($request->areas))$clientes->whereIn('areas.id', $request-
>areas);
if(!empty($request->fecha_visita))$clientes-
>whereBetween('reuniones.fecha', [Utils::startdate($request->fecha_visita),
Utils::enddate($request->fecha_visita)]);
if(!empty($request->fecha_creacion))$clientes-
>whereBetween('reuniones.created_at', [Utils::startdate($request->fecha_creacion),
Utils::enddate($request->fecha_creacion)]);
if(!empty($request->asignado_a)){
if(count($request->asignado_a)== 1){
$clientes->where('users.id',$request->asignado_a);
} else {
$clientes->whereIn('users.id',$request->asignado_a);
}
}
if(!empty($request->created_by))$clientes->whereIn('usersl.id',
$request->created_by);
$request->donde);
if(!empty($request->provincia))$clientes->whereIn('provincias.id',
$request->provincia);
}else
return 'No tienes permisos para esta petición';
$provincias = Provincia::where('id','<>',28)-
>lists('nombre_provincia','id');
$areas = UserTypes::whereIn('id' , [3,4,5] )->lists('tipo','id');
$empresas = Empresa::whereIn('id',[1,2,5,8,9,11,14])-
>lists('nombre_empresa','id');
$list_users = User::whereIn('tipo',[2,3,4,5,7])->lists('name','id');
if($user->tipo == Config::get('constant.user_types.call_center')){
return view('pages.clientes.calidad.visitasconcretadas')-
>with(compact('empresas'));
}
else if($user->tipo == Config::get('constant.user_types.supervisor') ||
$user->tipo == Config::get('constant.user_types.socio_gerente') ||
$user->tipo == Config::get('constant.user_types.marketing') ||
$user->tipo == Config::get('constant.user_types.administrador') ||
$user->id == 527 ||
$user->tipo == Config::get('constant.user_types.rr_hh') ||
$user->can('asesor-can-view-all-citas')){
return view('pages.clientes.supervisor.visitasconcretadas')-
>with(compact('empresas', 'areas','list_users','provincias'));
}else{
abort(403);
}
}
public function sinatender() {

return view('pages.clientes.vendedor.sinatender');
}
public function verClientesporVendedor($id) {
$clientes = Cliente::PotablesInteresadosSenadosDelUsuario($id);
return view('pages.clientes.admin.lista', compact('clientes'));

}
public function todos() {
//Si el usuario es Gerente o recepcion
if ($user->tipo == 4) {



>get();
}
#dd($vendedores->where('id',171));
#exit();

return view('pages.clientes.recepcion.todos', compact('vendedores',

}
//si el usuario es Vendedor
elseif ($user->tipo == 3 ) {
return view('pages.clientes.vendedor.todos');
}
//si el usuario es Supervisor
elseif ($user->tipo == 2){
return
view('pages.clientes.supervisor.todos',compact('primary_groups','secondary_groups')
);
}
return view('pages.clientes.calidad.todos');
}elseif($user->tipo == 8){
$empresas =
Empresa::whereIn('empresas.id',Config::get('constant.empresas_habilitadas'))-
>lists('nombre_empresa', 'id');
$asesores = User::listUserslikeView()->lists('asesor','id')->toArray();
$subareas = Subarea::whereIn('id_area', [2,3])->lists('name','id');
$provincias = Provincia::lists('nombre_provincia', 'id');
$status = ClienteStatus::whereIn('id',
Config::get('constant.status_habilitados_consultas_post_venta'))-
>lists('status','id');
return View::make('pages.clientes.postventas.todos',
compact('empresas','asesores','subareas','provincias','status'));
} elseif($user->tipo == Config::get('constant.user_types.rr_hh') || $user-
>tipo == Config::get('constant.user_types.marketing')){
}
private function checkViewUser($user, $cliente) {
if ($this->isUserWithRestrictions($user)) {
if ($this->clientOnUser($user, $cliente)) {
return true;
}
if($this->userIsSupervisor($user)){
return true;
}
return false;
}
if ($this->isUserWithoutRestrictions($user)) {
return true;
}
return false;
}
private function getVendedoresyCantidadAtendidos() {
$vendedores = User::ObtenerVendedoresDeLaEmpresa(Auth::user()->empresa);

$vendedor->totalClientes = Cliente::AtendidosHoyPorVendedor($vendedor-
>id)->count();
}
return $vendedores;
}
private function getVendedoresyCantidadAtendidosEsperanza() {
$vendedores = User::ObtenerVendedoresDeLaEsperanza();

>id)->count();
}
return $vendedores;
}
private function getTodosVendedoresyCantidadAtendidos() {
$vendedores = User::ObtenerTodosLosVendedores();

>id)->count();
}
return $vendedores;
}
//traemos todos los vendedores de la económica con su cantidad de atendidos

private function getTodosVendedoresyCantidadAtendidosLEC() {
$vendedores = User::ObtenerTodosLosVendedoresLEC();

>id)->count();
}
return $vendedores;
}
private function getTodosVendedoresyCantidadAtendidosConRecepcion() {
$vendedores = User::ObtenerTodosLosVendedoresYRecepcion();

>id)->count();
}
return $vendedores;
}
public function repetidos() {
if ($user) {
$clientes = Cliente::select('*', 'id');
//return view('pages.clientes.recepcion.repetidos', compact('clientes',
'clientes_status'));
}
}
public function nointeresados() {



>get();
}
return view('pages.clientes.recepcion.nointeresados',
/**
if(Auth::user()->empresa ==
Config::get('constant.empresas.la_esperanza_cba')){
$vendedores = $this->getVendedoresyCantidadAtendidosEsperanza();

[1,7])->get();
compact('vendedores','empresas'));
}
else{
$vendedores = $this->getVendedoresyCantidadAtendidos();
$empresas = Empresa::select('nombre_empresa')->whereIn('id',
}
* * */
}
}
public function lesparececaro() {

return view('pages.clientes.recepcion.lesparececaro',
compact('vendedores', 'empresas'));
/**
if(Auth::user()->empresa ==
Config::get('constant.empresas.la_esperanza_cba')){
$vendedores = $this->getVendedoresyCantidadAtendidosEsperanza();

[1,7])->get();
}
else{
$vendedores = $this->getVendedoresyCantidadAtendidos();
$empresas = Empresa::select('nombre_empresa')->whereIn('id',
}
* * */
}
}
private function clientOnUser($user, $cliente) {
if (($cliente->id_usuario == $user->id && $user->tipo !=

Config::get('constant.user_types.call_center')) || $cliente->id_usuario == $user-
>id && $cliente->id_status != Config::get('constant.cliente_status.no_interesado'))
{
return true;
} else if(($cliente->id_status ==
Config::get('constant.cliente_status.senado') || $cliente->id_status ==
Config::get('constant.cliente_status.vendido')) && $user->tipo == 8){
//Si el clientes está señado o vendido y el usuario es tipo postventa
return true;
}
return false;
}
private function isUserWithRestrictions($user) {
if ($user->tipo == Config::get('constant.user_types.asesor_comercial') ||
$user->tipo == Config::get('constant.user_types.supervisor') || $user->tipo ==
Config::get('constant.user_types.call_center')) {
return true;
}
return false;
}
private function clientBelongsToUserCompany($user, $cliente) {

if ($cliente->id_empresa == $user->empresa) {
return true;
}
return false;
}
private function clientBelongsToUserGroup($user, $cliente) {
$supervisor_groups = UserGroup::select('user_groups.group_id')
->join('groups', 'user_groups.group_id', '=', 'groups.id')
->where('user_id', $user->id)
->where('groups.primary', true)
->get()
->pluck('group_id')
->toArray();
$vendedor_groups = UserGroup::select('user_groups.group_id')
->where('user_id', $cliente->id_usuario)
->where('groups.primary', true)
->get()
->pluck('group_id')
->toArray();
$coincide = false;
foreach($supervisor_groups as $supervisor_group){
if (in_array($supervisor_group, $vendedor_groups)) {
$coincide = true;
}
}
return $coincide;
private function userIsSupervisor($user) {

return true;
}
return false;
}
private function isUserWithoutRestrictions($user) {

if ($user->tipo == Config::get('constant.user_types.recepcion') || $user-
>tipo == Config::get('constant.user_types.socio_gerente') || $user->tipo ==
Config::get('constant.user_types.administrador') || $user->tipo ==
Config::get('constant.user_types.post_ventas') || $user->tipo ==
Config::get('constant.user_types.marketing') || $user->id == 527) {
return true;
}
return false;
}
public function ClientsNotLinked() {


>get();
}

return view('pages.clientes.recepcion.desvinculados',
}
//si el usuario es supervisor


>get();
}

return view('pages.clientes.supervisor.desvinculados',
}
else {
}
}
public function showTableClientsNotLinked() {
$clientes = Cliente::select(
'clientes.created_at',
'clientes.fecha_asignacion',
'clientes.nombre_apellido', 'clientes.telefono',
'cliente_status.status', 'users.name',
'clientes.id','r.fecha as freunion',
'r.visitado as reunionvisitado',
)
->join('empresas', 'clientes.id_empresa', '=', 'empresas.id')
->leftjoin('reuniones as r','r.id_cliente','=','clientes.id')
->whereIn('cliente_status.id', [1, 2, 4, 5, 6])
->whereNotNull('users.deleted_at');
}
public function reasign_unlinked() {
$vendedor = Input::get('vendedor');
$clientes = Input::get('clientes');
foreach($clientes as $c){
$asignacion = $this->reasign($c,$vendedor);
}
$act = $this->asigned_activity_mass($clientes, Auth::user()->id);
$clientes_editados = Cliente::whereIn('id', $clientes)->get();
foreach ($clientes_editados as $c) {
$last_consult = $c->consultas()->orderBy('created_at', 'DESC')-

>first();
$new_consult = $this->copy_consult($last_consult);
$c->consultas()->save($new_consult);
$tareas = Tareas::where('id_cliente', '=', $c->id)->get();

$tarea->id_usuario = $c->id;
$tarea->save();
}
}
$cantidadnueva = Cliente::where('id_usuario', $vendedor)

->whereBetween('clientes.fecha_asignacion',
[Carbon::today(), Carbon::now()])->count();
if ($asignacion != "error") {
return response()->json(['response' => 'true',
'cantidadnueva' => $cantidadnueva]);
}
return response()->json(['response' => 'false']);

}
private function copy_consult($last_consult) {
$new_consult = new Consultas();
$new_consult->id_usuario = $user->id;
$new_consult->id_origen = $last_consult->id_origen;
$new_consult->id_status = $last_consult->id_status;
$new_consult->id_producto = $last_consult->id_producto;
$new_consult->id_cliente = $last_consult->id_cliente;
$new_consult->id_razon = $last_consult->id_razon;
$lastuser = User::withTrashed()->where('id', $last_consult->id_usuario)-

>first();
$new_consult->comentario = 'Este cliente era de ' . $lastuser->name .

'>> RECOMENDACION: Decirle al cliente: Desde ahora en adelante yo
me voy a hacer cargo de su proyecto.
>> (RECORDAR darle un numero de contacto directo al cliente)';
return $new_consult;
}
public function clients_now() {

return view('pages.clientes.gerencia.hoy');
}
public function clients_now_table() {
$logged_user_id = Auth::user()->id;
$logged_user_groups = UserGroup::where('user_id', $logged_user_id)-

>lists('group_id')->toArray();
$clientes_hoy = Cliente::select([
'clientes.query_date as query_date',
'clientes.updated_at as updated_at',
'clientes.fecha_asignacion as fecha_asignacion',
'clientes.nombre_apellido as nombre_apellido',
'clientes.telefono as telefono',
'cliente_status.status as status',
'users.name as name',
'groups.name as group_name',
'clientes.id as id',
])

->join('user_groups', 'user_groups.user_id', '=', 'users.id')
->whereIn('user_groups.group_id', $logged_user_groups)
->where('fecha_asignacion', '>', $now->startOfDay())
return Datatables::of($clientes_hoy)->make(true);
}
public function clientes_potables_gral() {

return view('pages.clientes.gerencia.potables');
}
public function clients_potables_table() {

$clientes_potables = Cliente::select([
'clientes.updated_at as updated_at',
'clientes.fecha_asignacion as fecha_asignacion',
'clientes.id as id',
])

->where('clientes.status', '=', 2)
->whereIn('users.tipo', [2, 3])
->groupBy('clientes.id');;
return Datatables::of($clientes_potables)->make(true);
}
public function clientes_senados_gral() {

return view('pages.clientes.gerencia.senados');
}
public function clients_senados_table() {
$start = Carbon::now()->startOfMonth();
$end = Carbon::now()->endOfMonth();

$clientes_senados = Cliente::select([
'clientes.id as id'
])
->join('proyectos', 'clientes.id', '=', 'proyectos.id_cliente')
->whereBetween('proyectos.created_at', [$start, $end])
->where('proyectos.status', '=', 1)
return Datatables::of($clientes_senados)->make(true);
}
public function clientes_vendidos_gral() {

return view('pages.clientes.gerencia.vendidos');
}
public function clients_vendidos_table() {
$start = Carbon::now()->startOfMonth();
$end = Carbon::now()->endOfMonth();

$clientes_vendidos = Cliente::select([
'clientes.id as id'
])
->join('proyectos', 'clientes.id', '=', 'proyectos.id_cliente')
->whereBetween('proyectos.created_at', [$start, $end])
->where('proyectos.status', '=', 2)
return Datatables::of($clientes_vendidos)->make(true);
}
public function clientes_interaccion_alta() {

$vendedores = User::where('tipo', 3)->lists('name', 'id');
return view('pages.clientes.vendedor.interaccion-alta')->with(['vendedores'
=> $vendedores]);
}
public function clientes_interaccion_media() {

return view('pages.clientes.vendedor.interaccion-media')-
>with(['vendedores' => $vendedores]);
}
public function clientes_interaccion_baja() {

;
return view('pages.clientes.vendedor.interaccion-baja')->with(['vendedores'
=> $vendedores]);
}
public function create_activity($id_cliente = null, $created_by = null,

$qualified_by = null, $asigned_by = null) {
$actividad = Activity::create([
'id_cliente' => $id_cliente,
'created_by_id' => $created_by,
'qualified_by_id' => $qualified_by,
'asigned_by_id' => $asigned_by]);
return $actividad;
}
public function clients_calidad(){

return view('pages.clientes.calidad.misclientes');
}
public function clients_calidad_todos(){

//Si el usuario es supervisor
return view('pages.clientes.supervisor.todos', compact('vendedores',
}
else{
return view('pages.clientes.calidad.todos', compact('vendedores',
}
}
public function seguimientoAsignados(){

if (Auth::user()->hasGroup(Config::get('constant.groups.vendedor_b'))) {
return view('pages.clientes.vendedor.seguimientoAsignados');
}
}
public function clients_ventas_todos(){

$empresasFilter = Empresa::whereIn('id',[1,2,5,8,9,11])-
$list_users = User::whereIn('tipo',[2,3,5])->lists('name','id');
$status = ClienteStatus::lists('status','id');
return view('pages.clientes.supervisor.todos_ventas',
compact('vendedores', 'empresas', 'primary_groups',
'secondary_groups','empresasFilter','list_users','status'));
}
else{
return view('pages.clientes.calidad.todos', compact('vendedores',
}
}
public function setear_asignaciones(){
public function nueva_asignacion(Request $request){

$data = $request->all();
public function updateAssignment(){

return true;
}
public function todos_llamadores() {

if ($user->tipo == 4 || $user->tipo == 1) {



>get();
}
#exit();

return view('pages.clientes.recepcion.todosllamadores',
compact('vendedores', 'empresas', 'primary_groups', 'secondary_groups',
'razon','cliente_status','razon'));
}


>get();
}
#exit();

return view('pages.clientes.supervisor.todosllamadores',
compact('vendedores', 'empresas', 'primary_groups', 'secondary_groups',
'razon','cliente_status','razon'));
}
else {
//dd('error');
}
}
public function seguimiento_calidad() {

$vendedores = User::
leftJoin('user_areas','user_areas.user_id','=','users.id')
->whereIn('tipo',
[Config::get('constant.user_types.asesor_comercial'),Config::get('constant.user_typ
es.supervisor')])
->orWhere('user_areas.subarea_id',6)
->lists('users.name','users.id');
if($user->can('see_all_conversions')){
$filtradores =
User::where('tipo',Config::get('constant.user_types.call_center'))-
return view('pages.clientes.calidad.seguimiento',
compact('vendedores','filtradores'));
} else {
return view('pages.clientes.calidad.seguimiento',
compact('vendedores'));
}
}
public function update_asigned_activity($id_cliente, $id_user) {
$actividad = Activity::firstOrCreate(['id_cliente' => $id_cliente]);
$actividad->asigned_by_id = $id_user;
$actividad->save();
ClientsActivities::register(Auth::user()->id, $id_cliente,
return $actividad;
}
public function asigned_activity_mass($clientes, $id_user) {
foreach ($clientes as $cliente) {

$activity = Activity::firstOrNew(['id_cliente' => $cliente]);
$activity->asigned_by_id = $id_user;
$activity->save();
return true;
}
public function clientes_exportar()

{
if ($user->tipo == Config::get('constant.user_types.socio_gerente') ||
$user->tipo == Config::get('constant.user_types.marketing') || $user->tipo ==
Config::get('constant.user_types.administrador') || $user->id == 500 || $user->id
== 2624) {
$provincias = Provincia::lists('nombre_provincia', 'id');
$origenes = Campaign::lists('name', 'id');
$canales = Origen::lists('nombre', 'id');
$empresas = Empresa::lists('nombre_empresa', 'id');
$asesores = User::
whereIn('tipo' ,[1,2,3,4,5,7,8] )
->where(function($q){
$q->where('tipo','<>',1)
->orWhere('id',48);
})
->lists('name','id');
$estados =
ClienteStatus::whereIn('id',Config::get('constant.status_habilitados_toda_empresa')
)->lists('status','id');
$cargos = UserTypes::lists('tipo','id');
$nombre_campana = ClientCampaign::whereNotNull('campaign_name')-
>groupBy('campaign_name')->lists('campaign_name','campaign_name');
$nombre_anuncio = ClientCampaign::whereNotNull('ad_group')-
>groupBy('ad_group')->lists('ad_group','ad_group');
$urls = ClientCampaign::whereNotNull('url')->lists('url');
foreach($urls as $key => $url){
$explode = explode("?",$url);
$urlsLanding[] = $explode[0];
}
$urlsLandingSort = array_unique($urlsLanding);
sort($urlsLandingSort);
foreach($urlsLandingSort as $key => $value){

$arrayFinal[$value] = $value;
}
array_push($arrayFinal,'Seleccione una URL');
$asesoresBorrados = User::whereIn('tipo' ,[2,3,4,5,8] )-

>whereNotNull('deleted_at')->withTrashed()->lists('name','id');
return
view('pages.clientes.recepcion.exportar',compact('provincias','origenes','canales',
'empresas','asesores','asesoresBorrados','estados','cargos','nombre_campana','nombr
e_anuncio','arrayFinal'));
} elseif ($user->tipo == Config::get('constant.user_types.supervisor')){
$empresas = Empresa::lists('nombre_empresa', 'id');

$grupos = UserGroup::getUserGroups($user->id);
$asesores = User::listUserslikeViewSupervisor($grupos)-
$groups = Group::all()->lists('name','id');
return
view('pages.clientes.supervisor.clientes_por_asesor',compact('empresas','asesores',
'groups'));
} else {
}
public function clientes_explorar()

{
if ($user->tipo == Config::get('constant.user_types.supervisor')){
$empresas =
Empresa::whereIn('empresas.id',Config::get('constant.empresas_habilitadas'))-
>lists('nombre_empresa', 'id');
$cargos = UserTypes::whereIn('id',[3,5])->lists('tipo','id');
$grupos = UserGroup::getUserGroups($user->id);
$asesores = User::listUserslikeViewSupervisor($grupos)-
$groups = Group::whereIn('id',$grupos)->orWhere('primary',false)-
return
view('pages.clientes.supervisor.clientes_por_asesor',compact('empresas','asesores',
'groups','cargos'));
} else {
}
}
public function clientes_exportar_generate_excel(Request $request){
set_time_limit(0);
$url_previus = substr(URL::previous(),-20,20);
$time_start = time();
if($url_previus == 'seguimiento_usuarios'){
$clientes = Cliente::postventasTodos($request);
} else {
$clientes = Cliente::exportQuery($request);
}
$time_query = time() - $time_start ;
$filename = 'clientesPostVenta_'.time().'.csv';
} else {
$filename = 'clientes_'.time().'.csv';
}
$writer = WriterFactory::create(Type::CSV);
$writer->openToFile('excel/'.$filename);
$writer->addRow( ['Fecha Asignación','Fecha Actualización','Fecha
Creación','Fecha Seña','Fecha Venta','Fecha Contrato','Dias Contrato','Id.
Cliente','Nombre y Apellido','Provincia','Empresa','Asignado a', 'Vendido
por','Status','Subarea','Seña','Entrega','Total']);
} else {
$writer->addRow( ['Id','Fecha Creación','Fecha Consulta','Fecha
Asignación','Fecha Actualizacion','Fecha Construccion','Nombre y
Apellido','Provincia','Email','Teléfono', 'Horario de
Contacto','Origen','Canal','Nombre Campaña','Grupo
AD','URL','Empresa','Status','Razón' , 'Asesor' , 'Numero de
comentarios','Calificado por']);
}
$clientes->chunk(5000, function($rows) use ($writer)

{
$writer->addRows($rows->toArray());
},false);
$writer->close();
$time_excel = time() - $time_start ;
$this->clientes_exportar_delete_old_exports();
return response()
->json(['success' => true, 'url' => url('excel/'.
$filename) ,'time_query' => $time_query , 'time_excel' => $time_excel]);
public function clientes_exportar_generate_excel_for_postventas(Request

$request){
set_time_limit(0);
$clientes = Cliente::postventasTodos($request);

$filename = 'clientesPostVenta_'.time().'.csv';
$writer->addRow( ['Fecha Asignación','Fecha Actualización','Fecha

Creación','Fecha Seña','Fecha Venta','Fecha Contrato','Dias Contrato','Id.
Cliente','Nombre y Apellido','Provincia','Empresa','Asignado a', 'Vendido
por','Status','Subarea','Seña','Entrega','Total']);
$clientes->chunk(5000, function($rows) use ($writer)

{
},false);
$writer->close();
return response()
public function citas_exportar_generate_excel(Request $request){

set_time_limit(0);
//DB Query
'clientes.id',
'areas.tipo as grupo',
'reuniones.donde',
'provincias.nombre_provincia'
->join('users as usersl','reuniones.creado_por','=','usersl.id')
->join('user_types as areas', 'usersl.tipo','=','areas.id')
->leftJoin('provincias','reuniones.id_provincia','=','provincias.id');
if(isset($request->visitado))$clientes->whereIn('reuniones.visitado',
$request->visitado);
if(!empty($request->id_empresa))$clientes->whereIn('empresas.id', $request-
>id_empresa);
if(!empty($request->areas))$clientes->whereIn('areas.id', $request->areas);
if(!empty($request->fecha_visita))$clientes-
>whereBetween('reuniones.fecha', [Utils::startdate($request->fecha_visita),
Utils::enddate($request->fecha_visita)]);
if(!empty($request->fecha_creacion))$clientes-
>whereBetween('reuniones.created_at', [Utils::startdate($request->fecha_creacion),
Utils::enddate($request->fecha_creacion)]);
if(!empty($request->asignado_a)){
if(count($request->asignado_a)== 1){
$clientes->where('users.id',$request->asignado_a);
} else {
$clientes->whereIn('users.id',$request->asignado_a);
}
}
if(!empty($request->created_by)){
if(count($request->created_by) == 1){
$clientes->where('usersl.id',$request->created_by);
} else {
$clientes->whereIn('usersl.id',$request->created_by);
}
}
if(!empty($request->donde))$clientes->whereIn('reuniones.donde',$request-
>donde);
if(!empty($request->provincia))$clientes->whereIn('provincias.id',$request-
>provincia);
$time_query = time() - $time_start;

$filename = 'citas_'.time().'.csv';
$writer->addRow(['ID Reunion','ID Cliente','Fecha Creación', 'Fecha de
Visita', 'Nombre Cliente', 'Teléfono', 'Asignado A', 'Creado Por',
'Grupo','Empresa','Visitado', 'Donde', 'Provincia']);
$clientes->chunk(5000, function($rows) use ($writer){
foreach($rows as $row){
switch($row->visitado){
case '0':
$row->visitado = 'NO';
break;
case '1':
$row->visitado = 'SI';
break;
case '2':
$row->visitado = 'CANCELADO';
break;
}
}
},false);
$writer->close();
$time_excel = time() - $time_start;
return response()->json(['success'=>true,'url'=>url('excel/'.$filename),
'time_query'=>$time_query,'time_excel'=>$time_excel]);
}
public function clientes_exportar_para_issabel(Request $request){
set_time_limit(0);
$clientes = Cliente::exportQueryForIssabel($request);
$clientes = $clientes->get();
$filename = 'clientes_para_wapi_'.time().'.csv';
$rows = [];
foreach($clientes as $cliente){
$parcial = substr($cliente->telefono,0,3);
if($parcial == '549'){
$parcial = substr($cliente->telefono,3);
} else {
$parcial = $cliente->telefono;
}
$cliente = [
'nombre_apellido' => $cliente->nombre_apellido,
'telefono' => (int)$parcial
];
array_push($rows,$cliente);
}
$writer->addRows($rows);
/*$clientes->chunk(5000, function($rows) use ($writer)

{
$extract = $row->telefono;
$row->telefono = '99'.$extract;
},false);*/
$writer->close();
return response()
public function clientes_exportar_para_google(Request $request){

set_time_limit(0);
$clientes = Cliente::exportQueryForGoogle($request);
$filename = 'clientes_para_google_'.time().'.csv';
$writer->addRow(['Email','First Name','Last Name', 'Country', 'Zip',
'Phone']);
$rows = [];
} else {
$parcial = '549'.$cliente->telefono;
}
$cliente = [
'email' => !empty($cliente->email)?$cliente->email:'void',
'first_name' => $cliente->nombre_apellido,
'last_name' => $cliente->nombre_apellido,
'country' => 'AR',
'zip' => $cliente->cp,
'phone' => '+'.$parcial
];
}

{
},false);*/
$writer->close();
return response()
public function clientes_exportar_para_doppler(Request $request){

set_time_limit(0);
$clientes = Cliente::exportQueryForDoppler($request);
$filename = 'clientes_para_doppler_'.time().'.csv';
$writer->addRow(['email','nombre','apellido']);
$rows = [];
$cliente = [
'email' => !empty($cliente->email)?$cliente->email:'void',
'nombre' => $cliente->nombre_apellido,
'apellido' => $cliente->nombre_apellido
];
}

{
},false);*/
$writer->close();
return response()
/* public function clientes_exportar_para_wpp(Request $request){

set_time_limit(0);
$clientes = Cliente::exportQueryForWpp($request);
$filename = 'clientes_para_wpp_'.time().'.csv';
/* $writer->addRow(['email','nombre','apellido']); */
/* $rows = [];
$parcial = substr($cliente->telefono,3);
} else {
}
$cliente = [
'nombre_apellido' => $cliente->nombre_apellido.',',
'telefono' => $parcial,
'id' => $cliente->id,
];
}
$writer->addRows($rows); */

{
},false);*/
/* $writer->close();
return response()
} */
function clientes_exportar_delete_old_exports(){
//$time_compare = time() - 3600; //ARCHIVOS DE 1 HORA DE CREACION BORRARLOS

$time_compare = time() - 3600;
$path = '';
$files = Storage::disk('excel')->files($path);
$filename = basename($file, ".csv");
$name_parts = explode("_",$filename);
if(count($name_parts) == 2 && $name_parts[1] < $time_compare ){

Storage::disk('excel')->delete($file);
}
}
}
public function reasignar_masivo(Request $request){

if($request->ajax() && ($user->tipo == 1 || $user->tipo == 6 || $user->id

== 500 )){
//Mezclamos los parametros en el request

$request->merge($request->clientes);
//Traemos todos los clientes seleccionados desde la vista, que van a

ser reasignados
$c = Cliente::reasignQuery($request);
if($c->count() == 0){
return response()->json(['status'=>true, 'detalle'=>'No se realizo
ninguna asignacion, los filtros elegidos no devolvieron ningun cliente']);
};
if($c->count() > 1000){

return response()->json(['status'=>true, 'detalle'=>'No puedes
reasignar mas de 1000 clientes en una sola transaccion!']);
//Traemos solo los ids de los vendedores

$v = collect($request->usuarios)->pluck('id');
//consultamos cuantos asignados tiene cada vendedor

$vendedores = User::select([
'users.id',
DB::raw('(select count(*) from `clientes` where
`clientes`.`deleted_at` is null and `id_usuario` = users.id and `status` in (5)) as
nclientes'),
])->whereIn('id',$v)->get();
if($vendedores->count() == 0){
ninguna asignacion, no hay vendedores elegidos']);
};
Log::info('=====================================');
Log::info('INICIO DE REASIGNACION MASIVA MANUAL REALIZADA POR USUARIO
ID: '.Auth::user()->id.'');
foreach ($vendedores as $v) {

$vendedores_array[] = ['id' => $v->id, 'nclientes' => $v-
>nclientes];
}
$vendedores_collection = collect($vendedores_array);
$vendedores_collection = $vendedores_collection-
>sortByDesc('nclientes');
$vendedores_string = "";
foreach($vendedores_collection as $key => $value)
{ $vendedores_string .= '['.$value['id'].','.$value['nclientes'].']'; }
Log::info('Listado de vendedores: [id,nclientes] '.$vendedores_string);
$result = [];
$result_count = 0;
$result_count_excepciones = 0;
foreach ($c as $cliente) {

$vendedor_selected = null;
//Revisamos la ultima reunion con el cliente , si ya tuvo alguna

reunión salteamos su reasignación
$ultima_reunion = $cliente->lastreunion;
if(!is_null($ultima_reunion)){
if($ultima_reunion->visitado == 0 &&
(Carbon::parse($ultima_reunion->fecha) > Carbon::now())){
$result_count_excepciones ++;
continue;
}
}
if($cliente->status == Config::get('constant.cliente_status.cita'))
{
$cliente->status =
Config::get('constant.cliente_status.para_reciclar');
$cliente->save();
}
//obtenemos la lista de empleados correspondiente, la ordenamos y

obtenemos el empleado que tenga menos clientes asignados a la espera
$vendedores_collection = $vendedores_collection-
>sortByDesc('nclientes');
$vendedor_selected = $vendedores_collection->pop();
if($this->asignar($cliente->id,$vendedor_selected['id'])){
$result[$vendedor_selected['id']][] = $cliente->id ;
$result_count++;
$vendedores_collection->push(['id' => $vendedor_selected['id'],
'nclientes' => $vendedor_selected['nclientes'] + 1]);
}else{
$vendedores_collection->push(['id' => $vendedor_selected['id'],
'nclientes' => $vendedor_selected['nclientes']]);
}
Log::info('Se han reasignado '.$result_count.' clientes. Se han

excluido '.$result_count_excepciones.' clientes por reuniones.');
foreach($result as $id => $value){

$clients_ids = implode(',', $value);
$nclients = count($value);
Log::info('USER ID='.$id.' Se le asignaron '.$nclients.' Detalle:
['.$clients_ids.']');
}
return response()->json(['status'=>true, 'detalle'=>'Se han reasignado
'.$result_count.' clientes. Se han excluido '.$result_count_excepciones.' clientes
por reuniones.']);
}
return 'error';
public function restate_masivo(Request $request){

if($request->ajax() && ($user->tipo == 1 || $user->tipo == 6 || $user->id
== 500)){
//Mezclamos los parametros en el request
$request->merge($request->clientes);
//Traemos todos los clientes seleccionados desde la vista, que van a

ser reasignados
$clientes = Cliente::reasignQuery($request);
if($clientes->count() == 0){
ninguna asignacion, los filtros elegidos no devolvieron ningun cliente']);
};
if($clientes->count() > 1000){

return response()->json(['status'=>true, 'detalle'=>'No puedes
cambiar estados de más de 1000 clientes en una sola transaccion!']);
Log::info('=====================================');
Log::info('INICIO DE CAMBIO DE ESTADO MASIVO MANUAL REALIZADO POR
USUARIO ID: '.Auth::user()->id.'');
$count_clientes = 0;
$count_total = 0;
$c->status = $request->nuevo_status;
$c->id_razon = $request->nuevo_substatus;
if($c->save()){
$count_clientes++;
}
$count_total++;
}
Log::info('Se le cambio el estado a '.$count_clientes.' clientes de un
total de '.$count_total.'.');
Log::info('=====================================');
return response()->json(['status'=>true, 'detalle'=>'Se le cambió el

estado a '.$count_clientes.' clientes de un total de '.$count_total.'.']);
}
return 'error';
}
protected function asignar($cliente,$empleado) {

if(app('App\Http\Controllers\ClientesController')->reasign($cliente,
$empleado) == "error"){
Log::error('ERROR AL ASIGNAR cliente '.$cliente." A ".$empleado);
return false;
}else{
//$actividad = app('App\Http\Controllers\ClientesController')-
>update_asigned_activity($cliente, env('USER_API_ID'));
return true;
}
}
public function mis_clientes_status($status){

switch($user->tipo){
case 1:
return view('pages.clientes.misclientes_status',compact('status'));
break;
case 2:
if ($status != "a plazo"){
return
view('pages.clientes.misclientes_status',compact('status'));
}else{
}
break;
case 3:
return
}else{
}
break;
case 4:
break;
case 5:
return
}else{
}
break;
case 8:
break;
default:
break;
}
public function fast_view(){

if($user->tipo == 5){
return view('pages.clientes.fast');
} else {
}
}
public function fast_view_client(Request $request){

$id_cliente = $request['id_cliente'];
if($id_cliente){
return redirect()->route('clientes.show',$id_cliente);
}
}
public function autoasignar($id){

if(!empty($id)){
$user = Auth::user()->id;
if($this->reasign($id,$user)){
return redirect()->route('clientes.show',$id);
}
}
}
public function citas_de_hoy(Request $request){

//Si el usuario es Enzo tramonte o Romina Roque, Ivan Teruel, perfil
Administrador o Stefania Ceballos
if($user->id == 52 || $user->id == 500 || $user->id == 392 || $user->tipo
== 6 || $user->id == 527 || $user->id == 2626 || $user->id == 2647 || $user->id ==
2719 || $user->can('asesor-can-view-all-citas')){
if($request->ajax()){
'clientes.id',
'clientes.dni',
'clientes.voucher_num',
'clientes.email',
'users.id as id_user',
'reuniones.donde',
'reuniones.voucher_num as voucher_num_cita'
->join('users as
usersl','reuniones.creado_por','=','usersl.id');
if(!empty($request->empresa))$clientes->whereIn('empresas.id',
$request->empresa);
$request->donde);
if(!empty($request->client_tel))$clientes-
>where('clientes.telefono','like','%'.$request->client_tel.'%');
if(!empty($request->client_mail))$clientes-
>where('clientes.email','like','%'.$request->client_mail.'%');
if(!empty($request->client_dni))$clientes->where('clientes.dni',
$request->client_dni);
if(!empty($request->voucher_num))$clientes-
>where('clientes.voucher_num',$request->voucher_num);
if(!empty($request->voucher_cita))$clientes-
>where('reuniones.voucher_num',$request->voucher_cita);
$clientes->whereBetween('reuniones.fecha',[Carbon::now()-
>startOfDay(),Carbon::now()->endOfDay()]);
}
$empresas = Empresa::whereIn('id',[1,2,5,8,9,11])-
$list_users = User::whereIn('tipo',[2,3,4,5])->lists('name','id');
return view('pages.clientes.supervisor.visitashoy',
compact('empresas','list_users'));
} else {
}
}
// Agregamos función para código QR admin

public function qr_index(Request $request){
if($user->tipo == Config::get('constant.user_types.administrador')){
$empresas = Empresa::whereIn('id',[1,2,5,8,9,11])-
$list_users = User::whereIn('tipo',[2,3,4,5])->lists('name','id');
return view('pages.home.seguridad', compact('empresas','list_users'));
}else{
}
}
public function sendPost(Request $request){

$newPeticion = new Peticiones;
if($user->id == 457){
$areaEmisora = 3;
}else{
$areaEmisora = UserAreas::where('user_id',$user->id)->first()-
>subarea_id;
}
$newPeticion->id_AreaEmisora = $areaEmisora;
$newPeticion->id_UsuarioEmisor= $user->id;
$newPeticion->id_AreaReceptora= $request->areaReceptora;
$newPeticion->id_EstadoPeticion = 1;
$newPeticion->id_cliente = $request->id_cliente;
$newPeticion->asunto = $request->asunto;
$newPeticion->mensaje = $request->mensaje;
if($newPeticion->save()){
$historial_peticiones = new HistorialPeticiones;
$historial_peticiones->id_peticion = $newPeticion->id;
$historial_peticiones->id_usuario = $newPeticion->id_UsuarioEmisor;
$historial_peticiones->id_cliente = $newPeticion->id_cliente;
$historial_peticiones->id_estado = 1;
if($historial_peticiones->save()){
if($request) $request->session()->flash('alert-success', 'La
petición fue enviada con éxito!');
return redirect()->route('clientes.show',$request->id_cliente);
} else {
if($request) $request->session()->flash('alert-danger', 'Hubo un
problema al enviar la peticion');
}
}
}
public function peticiones(){

return view('pages.clientes.postventas.mispeticiones');
}
public function todas_peticiones(){

return view('pages.clientes.postventas.todaspeticiones',compact('user'));
}
public function senasventassinaprobar(){

$subareas = $user->subareas();
if(in_array('Contable',$subareas)){
return view('pages.clientes.contable.senas_ventas_sin_aprobar');
} else {
}
}
public function clasificar_automaticamente(Request $request){

$cliente = Cliente::findOrFail($request->id_cliente);
$usuario = Auth::user();
$ahora = Carbon::now();
if($request->hubo_contacto == 'true'){//Hubo contacto
if($request->hablo_proyecto == 'true'){//Pudiste hablar del proyecto
$cuando_construye = $request->cuando_construye;
$tiene_terreno = $request->got_terreno == 'true'?true:false;
$modelo = $request->choice_model;
$capital = $request->got_capital != 'No lo se'?true:false;
$como_paga = $request->how_pay;
$financiacion = Financiacion::where('id_cliente',$cliente->id)-
>first();
if($cuando_construye != 'No lo se'){
switch($cuando_construye){
case '1 - 3 meses':
$financiacion->fecha_estimada_inicio_proyecto =
Carbon::now()->addMonth();
break;
case '3 - 6 meses':
Carbon::now()->addMonths(3);
break;
case '+ de 6 meses':
Carbon::now()->addMonths(6);
break;
}
}
if($tiene_terreno){
$terreno = $request->where_terreno;
$financiacion->posee_terreno = true;
$financiacion->provincia = $terreno['provincia'];
$financiacion->localidad_proyecto = $terreno['localidad'];
if($terreno['barrio'] != ''){
$financiacion->barrio_cerrado = true;
$financiacion->barrio_cerrado_name = $terreno['barrio'];
}
if($terreno['losa'] == 'true'){
$financiacion->losa = true;
}
$financiacion->m_cuadrados = $terreno['mts'];
}
$id_producto = Producto::where('nombre',$modelo)-
>where('id_empresa',$cliente->id_empresa)->pluck('id');
$financiacion->id_producto = $id_producto;
if($capital){
switch($request->got_capital['name']){
case 'ambos':
$financiacion->monto_entrega = (int)str_replace('.','',
$request->got_capital['howMuch']);
$financiacion->entrega_type = $request-
>got_capital['moneyType'];
$financiacion->posee_vehiculos = true;
$ano_modelo = $request->got_capital['anio'];
$vehiculo =
ModelosVehiculos::select('nombre_marca','nombre_modelo',$ano_modelo)->where('id',
$request->got_capital['modelo'])->first()->toArray();
$array['marca'] =$vehiculo['nombre_marca'];
$array['modelo'] = $vehiculo['nombre_modelo'];
$array['ano_modelo']= $ano_modelo;
$array_encode = json_encode($array);
$valor_vehiculo = end($vehiculo);
$financiacion->valor_vehiculo = $valor_vehiculo;
$financiacion->descripcion_vehiculo = $array_encode;
$financiacion->monto_cuotas = (int)str_replace('.','',
$request->got_capital['howMuchQuotes']);
break;
case 'dinero':
$financiacion->monto_entrega = (int)str_replace('.','',
$request->got_capital['howMuch']);
$financiacion->entrega_type = $request-
>got_capital['moneyType'];
break;
case 'auto':
$financiacion->posee_vehiculos = true;
$ano_modelo = $request->got_capital['anio'];
$vehiculo =
ModelosVehiculos::select('nombre_marca','nombre_modelo',$ano_modelo)->where('id',
$request->got_capital['modelo'])->first()->toArray();
$array['marca'] =$vehiculo['nombre_marca'];
$array['modelo'] = $vehiculo['nombre_modelo'];
$array['ano_modelo']= $ano_modelo;
$array_encode = json_encode($array);
$valor_vehiculo = end($vehiculo);
$financiacion->valor_vehiculo = $valor_vehiculo;
$financiacion->descripcion_vehiculo = $array_encode;
break;
}
}
//Identifico el tipo de Cliente
//Tipo A
if(
(($financiacion->entrega_type == 'arg' && $financiacion-
>monto_entrega >= 300000) || ($financiacion->entrega_type == 'eeuu' &&
$financiacion->monto_entrega >= 2500) || $financiacion->posee_vehiculos) &&
($financiacion->posee_terreno) &&
($financiacion->monto_cuotas >= 2000)
){
$cliente->tipo_cliente =
Config::get('constant.cliente_type.A');
}
//Tipo B
elseif(
(($financiacion->entrega_type == 'arg' && $financiacion-
>monto_entrega >= 300000) || ($financiacion->entrega_type == 'eeuu' &&
$financiacion->monto_entrega >= 2500) || $financiacion->posee_vehiculos) &&
(!$financiacion->posee_terreno) &&
($financiacion->monto_cuotas >= 2000)
){
Config::get('constant.cliente_type.B');
}
//Tipo C
else {
Config::get('constant.cliente_type.C');
}
if(!empty($como_paga)){
switch($como_paga){
case 'Contado 100%':
$financiacion->forma_de_pago = 1;
break;
case 'Entrega / Contraentrega':
break;
case 'Financiado':
break;
case 'No lo sé':
break;
}
}
$financiacion->save();
if($request->interes_cita == 'true'){//Interesado en tener cita
if($request->se_pacto == 'true'){//Se pudo pactar
$cita = $request->agendacita;
$parsed_date = Carbon::parse($cita['cuandocita']);
$meeting = new Reuniones();

$meeting->id_cliente = $cliente->id;
$meeting->creado_por = $usuario->id;
$meeting->modificado_por = $usuario->id;
$meeting->visitado = 0;
$meeting->donde = $cita['dondecita'];
$meeting->fecha = $parsed_date;
$meeting->created_at = Carbon::now();
$meeting->updated_at = Carbon::now();
$meeting->save();
$cliente->status =
Config::get('constant.cliente_status.cita');
$new_s_stadistic = new StatusStadistics();
$new_s_stadistic->id_cliente = $cliente->id;
$new_s_stadistic->id_usuario = $usuario->id;
$new_s_stadistic->status = $cliente->status;
$new_s_stadistic->created_at = $ahora;
$new_s_stadistic->updated_at = $ahora;
$new_s_stadistic->save();
ClientsActivities::register($usuario->id,$cliente-
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Cita Creada');
Log::info('NUEVA CITA PACTADA POR '.$usuario->name.'!!!
Cliente Nro: '.$cliente->id);
}
elseif($request->se_pacto == 'limit'){//Se llego al limite de
citas
$cliente->status = $usuario->tipo ==
Config::get('constant.user_types.call_center')?
Config::get('constant.cliente_status.a_confirmar'):Config::get('constant.cliente_st
atus.pendiente');
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Cita a confirmar');
Log::info('CLIENTE PUESTO A CONFIRMAR POR '.$usuario-
>name.' (limite de citas alcanzado)!!! Cliente Nro: '.$cliente->id);
}
elseif($request->se_pacto == 'false'){//No se pudo pactar
$tarea = $request->agendatarea;
$tarea['cuandotarea'] =
Carbon::parse($tarea['cuandotarea']);
$recordatorio = new Tareas();
$recordatorio->nombre = $tarea['tengoque'];
$recordatorio->fecha = $tarea['cuandotarea'];
$recordatorio->id_usuario = $usuario->id;
$recordatorio->id_cliente = $cliente->id;
$recordatorio->created_at = $ahora;
$recordatorio->updated_at = $ahora;
$recordatorio->save();
$cliente->status = $usuario->tipo ==
Config::get('constant.user_types.call_center')?
Config::get('constant.cliente_status.a_confirmar'):Config::get('constant.cliente_st
atus.pendiente');
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Cita a confirmar');
Log::info('CLIENTE PUESTO A CONFIRMAR POR '.$usuario-
>name.'!!! Cliente Nro: '.$cliente->id);
}
} elseif($request->interes_cita == 'false'){//No interesado en
tener cita
if($request->interes_vendedor == 'true'){
$cliente->status =
Config::get('constant.cliente_status.filtrado');
//Asigno el dato a Ventas según sea tipo A o no
//Asigno el dato a vendedores que no sean de LE y LEC
/* if($cliente->tipo_cliente ==
Config::get('constant.cliente_type.A')){
//Jesus Gimenez, Evelyn Ozan, Lucas Arias, Christian
Rouanet
$vendedores = User::whereIn('id',[107,15,2532,2534])-
>get();
} else {
//Carla Acosta, Pablo Toranzo, Matias Hereñu, Marcos
Bengston
$vendedores = User::whereIn('id',[543,2529,2530,2531])-
>get();
} */
//perfil de vendedor para Javier Miglierini 2697, no recibe
datos filtrados, solo asignación manual.
/* $filtrados_particular =
array(41,301,2646,2719,2732,2751,2752);
$random_keys=array_rand($filtrados_particular,4);
$vendedores = User::whereIn('tipo',[2,3])
->where('suspendido','!=',1)
->where('id', $filtrados_particular[$random_keys[0]])
->get(); */
$vendedores = User::where('tipo',3)
->where('suspendido','!=',1)
->whereNotIn('id',
[500,107,15,41,464,434,392,2588,563,2595,559,518,52,457,2622,2697])
->whereNotIn('empresa', [1, 15, 6])
->get();
foreach($vendedores as $seller){
$cantClient = DB::table('clientes')-
>where('id_usuario',$seller->id)->whereBetween('fecha_asignacion',
[Carbon::today(), Carbon::now()])->count();
$seller->total = $cantClient;
}
$elegido = $vendedores->sortBy('total')->first();
//Si el elegido es Melisa Cisterna y el dato no es de

Córdoba, elegimos otro asesor.
if($elegido->id == 2588 && $cliente->provincia != 1){
$elegido = $vendedores->sortByDesc('total')->first();
}
//$glenda = User::where('id',518)->first();
$cliente->id_usuario = $elegido->id;
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Filtrado Por '.$usuario->name.'.
Asignado automáticamente a: '.$elegido->name);
Log::info('CLIENTE FILTRADO POR '.$usuario->name.'!!!
Asignado automáticamente a : '.$elegido->name.' Cliente Nro: '.$cliente->id);
} elseif($request->interes_vendedor == 'false'){//No hay
interes en charlar con un vendedor
if($request->clasifica_vendedor == 'true'){//Esta siendo
clasificado por un vendedor
$cliente->status = $request->estado_vendedor;
$nuevoEstado = ClienteStatus::where('id',$cliente-
>status)->pluck('status');
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,$nuevoEstado);
} else {
$cliente->status =
Config::get('constant.cliente_status.a_plazo');
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'A plazo ('.$request-
>why_no_fil.')');
Log::info('CLIENTE PUESTO A PLAZO POR '.$usuario-
switch($request->why_no_fil){
case 'Le parece caro':
$cliente->id_razon = 3;
break;
case 'Sólo quería info':
break;
case 'Quiere construir más adelante':
break;
case 'No tiene terreno':
break;
case 'Quiere 100% financiado':
break;
}
}
}
}
} elseif($request->hablo_proyecto == 'false'){//No pudiste hablar del
proyecto
switch($request->why_no_construye['why']){
case 'No le interesa':
$cliente->status =
Config::get('constant.cliente_status.no_interesado');
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'No Interesado');
Log::info('CLIENTE PUESTO NO INTERESADO POR '.$usuario-
break;
case 'Estaba ocupado':
$record_llamada = Carbon::parse($request-
>recordatorio_llamada);
$llamar = new AvisoLlamada();
$llamar->user_id = $usuario->id;
$llamar->client_id = $cliente->id;
$llamar->hora = $record_llamada;
$llamar->created_at = $ahora;
$llamar->updated_at = $ahora;
$llamar->save();
$cliente->status =
Config::get('constant.cliente_status.ocupado');
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Ocupado. Llamar a las '.$request-
>recordatorio_llamada.' hs.');
Log::info('CLIENTE OCUPADO PUESTO POR '.$usuario->name.'!!!
break;
case 'Ya compro con nosotros':
$cliente->status =
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Ya compró con nosotros');
Log::info('CLIENTE YA COMPRO CON NOSOTROS PUESTO POR '.
$usuario->name.'!!! Cliente Nro: '.$cliente->id);
break;
case 'Vio malos comentarios':
$cliente->status =
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Vió malos comentarios de la
empresa');
Log::info('CLIENTE VIO MALOS COMENTARIOS PUESTO POR '.
break;
case 'Ya compro con otra empresa':
$empresa = $request->why_no_construye['empresa'];
$cliente->status =
$empresa = Competencia::findOrFail($empresa);
$cliente->id_competencia = $empresa->id;
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Ya compro con '.$empresa->name);
Log::info('CLIENTE YA COMPRO CON '.$empresa->name.' PUESTO
POR '.$usuario->name.'!!! Cliente Nro: '.$cliente->id);
break;
case 'Decidió Const. Tradicional':
$cliente->status =
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Decidió Construcción
tradicional');
Log::info('CLIENTE DECIDE TRADICIONAL PUESTO POR '.
break;
default:
$cliente->status =
Config::get('constant.cliente_status.a_plazo');
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'A plazo ('.$request-
>why_no_fil.')');
Log::info('CLIENTE PUESTO A PLAZO POR '.$usuario->name.'!!!
switch($request->why_no_fil){
case 'Le parece caro':
break;
case 'Sólo quería info':
break;
case 'Quiere construir más adelante':
$cuantosMeses = (int)$request->cuantosMeses;
$cliente->fecha_tentativa = Carbon::now()-
>addMonths($cuantosMeses);
break;
case 'No tiene terreno':
break;
case 'Quiere 100% financiado':
break;
}
break;
}
}
} elseif($request->hubo_contacto == 'false'){//No hubo contacto
if($request->tiene_tel == 'true'){//Tiene telefono
if($request->bien_tel == 'true'){//Esta bien el tel
if($request->es_rango_horario == 'true'){//Esta llamando dentro
del rango horario
if(!empty($request->no_tiene_wa) && $request->no_tiene_wa
== 'true'){//No tiene whatsapp
$cliente->status =
Config::get('constant.cliente_status.sin_informacion');
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Sin atender (No Tiene Whatsapp)');
Log::info('CLIENTE SIN ATENDER PUESTO POR '.$usuario-
} elseif ($request->answer_wa == 'true'){//Respondio
whatsapp
$cliente->status =
Config::get('constant.cliente_status.sigue_gestion_WA');
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Sigue en Gestión por WhatsApp');
Log::info('CLIENTE SIGUE EN GESTION POR WA PUESTO POR
'.$usuario->name.'!!! Cliente Nro: '.$cliente->id);
} elseif($request->answer_wa == 'false'){//No respondio
whatsapp
$cliente->status =
Config::get('constant.cliente_status.espera_respuesta_WA');
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Espera Respuesta WhatsApp');
Log::info('CLIENTE EN ESPERA RESPUESTA WA PUESTO POR '.
}
} elseif($request->es_rango_horario == 'false'){// No está
llamando dentro del rango horario
$record_llamada = Carbon::parse($request-
>recordatorio_llamada);
$llamar = new AvisoLlamada();
$llamar->user_id = $usuario->id;
$llamar->client_id = $cliente->id;
$llamar->hora = $record_llamada;
$llamar->created_at = $ahora;
$llamar->updated_at = $ahora;
$llamar->save();
$cliente->status =
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Sin Atender (llamada fuera del
rango horario)');
Log::info('CLIENTE LLAMADO FUERA DEL RANGO HORARIO POR '.
}
} elseif($request->bien_tel == 'false'){//No está bien el tel
$cliente->status =
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Dato Erróneo');
$cliente->id_usuario = 518;
$cliente->fecha_asignacion = $ahora;
Log::info('CLIENTE DATO ERRONEO PUESTO POR '.$usuario->name.' Y
ASIGNADO AUTOMATICAMENTE!!! Cliente Nro: '.$cliente->id);
}
} elseif($request->tiene_tel == 'false'){//No tiene Telefono
if($request->enviaste_mail == 'true'){//Envio Email
$cliente->status =
Config::get('constant.cliente_status.mail_enviado');
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Mail Enviado');
Log::info('CLIENTE PUESTO A MAIL ENVIADO POR '.$usuario-
} elseif($request->enviaste_mail == 'false'){//No envio Mail
switch($request->tipomail){
case 'sin atender':
if($email =
MailController::sendSinAtenderEmail($cliente,$usuario->name)){
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Mail Enviado (sin atender)');
} else {
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Envio fallido de email (sin
atender)');
Log::info('No se pudo enviar el mail de SIN ATENDER
del cliente N° '.$cliente->id);
}
$cliente->status =
break;
}
}
}
} else {
return response()->json(['status'=> false]);
}
$cliente->updated_at = $ahora;
$cliente->save();
if(!empty($request->comentario)){
$comentario = new Consultas();
$comentario->id_cliente = $cliente->id;
$comentario->id_producto = $cliente->id_producto;
$comentario->id_status = $cliente->status;
$comentario->id_origen = $cliente->id_lugar;
$comentario->id_usuario = $usuario->id;
$comentario->comentario = $request->comentario;
$comentario->created_at = $ahora;
$comentario->updated_at = $ahora;
$comentario->id_razon = $cliente->id_razon?$cliente->id_razon:4;
$comentario->save();
}
return response()->json(['status'=> true]);
}
public function responde_WA(Request $request){

$cliente->status = Config::get('constant.cliente_status.sigue_gestion_WA');
if($cliente->save()){
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'Sigue Gestion por WhatsApp');
Log::info('CLIENTE RESPONDIO WA PUESTO POR '.$usuario->name.'!!!
$comentario = new Consultas();
$comentario->id_cliente = $cliente->id;
$comentario->id_producto = $cliente->id_producto;
$comentario->id_status = $cliente->status;
$comentario->id_origen = $cliente->id_lugar;
$comentario->id_usuario = $cliente->id_usuario;
$comentario->comentario = $request->comentario;
$comentario->created_at = $ahora;
$comentario->updated_at = $ahora;
$comentario->id_razon = $cliente->id_razon;
if($comentario->save()){
$lugar = Origen::where('id',$cliente->id_lugar)->withTrashed()-
>pluck('nombre');
$response = [
'fecha' => $ahora,
'lugar' => $lugar,
];
return response()->json(['status' => true, 'data' => $response]);
} else {
return response()->json(['status' => false]);
}
} else {
}
}
public function nunca_atendio(Request $request){

$cliente->status = Config::get('constant.cliente_status.a_plazo');
if($cliente->save()){
>id,ClientsActivities::CLASIFICACION_AUTOMATICA,'A plazo (no hubo contacto)');
Log::info('CLIENTE PUESTO A PLAZO NUNCA RESPONDIO WA '.$usuario-
return response()->json(['status'=> true]);
} else {
}
}
public function citas_today(Request $request){

'clientes.id',
'clientes.dni',
'clientes.email',
'reuniones.donde'
->where('reuniones.donde', 'fabrica')
->orderBy('reuniones.fecha')->orderBy('reuniones.visitado');
if(!empty($request->empresa))$clientes->whereIn('empresas.id', $request-
>empresa);
if(!empty($request->donde))$clientes->whereIn('reuniones.donde',$request-
>donde);
if(!empty($request->client_tel))$clientes-
>where('clientes.telefono','like','%'.$request->client_tel.'%');
if(!empty($request->client_mail))$clientes-
>where('clientes.email','like','%'.$request->client_mail.'%');
if(!empty($request->client_dni))$clientes->where('clientes.dni',$request-
>client_dni);
if(!empty($request->voucher_num))$clientes->where('clientes.voucher_num',
$request->voucher_num);
$clientes->whereBetween('reuniones.fecha',[Carbon::now()-
>startOfDay(),Carbon::now()->endOfDay()]);
return response()->json(['status' => true ,'clientes' => $clientes]);
}
public function citas_today_modal(Request $request){

$cliente = Reuniones::select([
'clientes.id',
'clientes.dni',
'clientes.email',
'reuniones.usuario_asignado',
'reuniones.donde'
->where('reuniones.id' , $request->id_reunion)
->get();
if ($cliente[0]->usuario_asignado){
$files = $avatars->allFiles($cliente[0]->usuario_asignado);
if(!empty($files)){
$cliente[0]->avatar = '/avatars/'.$files[0];
} else {
$cliente[0]->avatar =
}
}
return response()->json(['status' => true ,'cliente' => $cliente]);

}
public function confirmar_cita_qr($id_reunion_code){

if ($user->tipo == Config::get('constant.user_types.administrador') ||
$user->tipo == Config::get('constant.user_types.seguridad')){
$id_reunion = base64_decode($id_reunion_code);
$reunion = Reuniones::where('id',$id_reunion)->firstOrFail();
$client = Cliente::where('id',$reunion->id_cliente)->firstOrFail();
$creador = User::withTrashed()->where('id',$client->id_usuario)-
>firstOrFail();
$fecha_cita = ($reunion->fecha)->toDateString();
$fecha_hoy = (Carbon::now())->toDateString();
$dia_inicio = Carbon::now()->startOfDay();
$dia_fin = Carbon::now()->endOfDay();
$usuario_asignado = null;
$id_creador = null;
$useraux = 0;
$userdetalle = '';
//no es vendedor
if($creador->tipo != 3){
$usuario_asignado = $this->asignar_cita_automatica();
$id_creador = $usuario_asignado['id'];
$files = $avatars->allFiles($id_creador);
if(!empty($files)){
$usuario_asignado['avatar'] = '/avatars/'.$files[0];
} else {
$usuario_asignado['avatar'] =
}
}
//es vendedor
else{
if($creador->deleted_at){
//usuario eliminado
$useraux = 0;
$userdetalle = 'Asignado porque '.$creador->name.' esta
eliminado - ESPERANDO APROBACIÓN DEL VENDEDOR';
}else{
//obtenemos el presente
$declaracion = DeclaracionJurada::select('id')
->where('id_usuario' , $creador->id)
->whereBetween('declaraciones_juradas.created_at',
[$dia_inicio, $dia_fin])
->groupBy('declaraciones_juradas.id_usuario')
->count();
//obtenemos el disponible
$disponible = User::select('id')->where('id' , $creador->id)-
>where('users.estado',1)->count();
//obtenemos el activity
$activo = \Kim\Activity\Activity::usersBySeconds(35)->select([
'users.id',
'users.name',
'sessions.last_activity'
])
->join('users','users.id','=','sessions.user_id')
->where('users.id' , $creador->id)
->count();
if ($declaracion!=0 && $disponible!=0 && $activo!=0) {

$useraux = 1;
} else{
if($reunion->usuario_asignado) {
//obtenemos el presente del que dejaron a cargo
$declaracion_cargo = DeclaracionJurada::select('id')
->where('id_usuario' , $reunion->usuario_asignado)
->whereBetween('declaraciones_juradas.created_at',
[$dia_inicio, $dia_fin])
->count();
//obtenemos el disponible del que dejaron a cargo
$disponible_cargo = User::select('id')->where('id' ,
$reunion->usuario_asignado)->where('users.estado',1)->count();
//obtenemos el activity del que dejaron a cargo
$activo_cargo = \Kim\Activity\
Activity::usersBySeconds(35)->select([
'users.id',
'users.name',
])
->where('users.id' , $reunion->usuario_asignado)
->count();
if ($declaracion_cargo!=0 && $disponible_cargo!=0 &&

$activo_cargo!=0) {
$userdetalle = 'Asignado por el propio vendedor ('.
$creador->name.') - ESPERANDO APROBACIÓN DEL VENDEDOR';
$useraux = 2;
} else{
$usuario_cargo = User::where('id',$reunion-
>usuario_asignado)->firstOrFail()->toArray();
if ($declaracion_cargo==0){
$useraux = 0;
$userdetalle = 'Asignado porque responsable a
cargo '.$usuario_cargo['name'].' no esta presente - ESPERANDO APROBACIÓN DEL
VENDEDOR';
}elseif ($disponible_cargo==0){
$useraux = 0;
cargo '.$usuario_cargo['name'].' no esta disponible - ESPERANDO APROBACIÓN DEL
VENDEDOR';
}elseif ($activo_cargo==0){
$useraux = 0;
cargo '.$usuario_cargo['name'].' no esta logueado en el sistema - ESPERANDO
APROBACIÓN DEL VENDEDOR';
}
}
}else{
if ($declaracion==0){
$useraux = 0;
$userdetalle = 'Asignado porque '.$creador->name.'
no esta presente - ESPERANDO APROBACIÓN DEL VENDEDOR';
}elseif ($disponible==0){
$useraux = 0;
no esta disponible - ESPERANDO APROBACIÓN DEL VENDEDOR';
}elseif ($activo==0){
$useraux = 0;
no esta logueado en el sistema - ESPERANDO APROBACIÓN DEL VENDEDOR';
}
}
}
}
if($useraux==1){
//el vendedor esta disponible y presente ese dia
$usuario_asignado = $creador->toArray();
$id_creador = $creador->id;
if(!empty($files)){
} else {
$usuario_asignado['avatar'] = '/bower_components/admin-
}
}
elseif($useraux==2){
//el vendedor asigna quien recibe al cliente
$id_creador = $reunion->usuario_asignado;
$usuario_asignado = User::withTrashed()->where('id',
$id_creador)->firstOrFail()->toArray();
if(!empty($files)){
} else {
}
}else{
//el vendedor no esta por X motivo
if(!empty($files)){
} else {
}
}
}
if($fecha_cita == $fecha_hoy){
//notificamos al vendedor
if (!empty($id_creador)){
$this->addNotiCita($client->id, $id_creador, $reunion->id,
$useraux, $client->id_empresa);
}
if($reunion->visitado == 0){
$reunion->usuario_asignado = null;
if($useraux==1) {
ClientsActivities::register($id_creador, $reunion-
>id_cliente, ClientsActivities::ASIGNA_CITA_MISMO, null);
}
elseif($useraux==2){
>id_cliente, ClientsActivities::ASIGNA_CITA_MISMO, $userdetalle);
}
else{
if (!empty($id_creador)){
>id_cliente, ClientsActivities::ASIGNAR_CITA_ALEATORIO, $userdetalle);
}
}
if (!empty($id_creador)) {
return response()->json(['tipo' => 'cita', 'status' =>
'true', 'id_reu' => $reunion->id]);
}else{
return response()->json(['tipo'=>'cita', 'status' =>
'false', 'info' => 'No se encuentran vendedores disponibles, contacta con
recepción.']);
}
} else {
return response()->json(['tipo'=>'cita', 'status' =>
'false', 'info' => 'Ocurrio un problema para confirmar la cita.']);
}
}
elseif ($reunion->visitado == 1){
return response()->json(['tipo'=>'cita', 'status' => 'true',
'info' => 'Esta cita fue confirmada previamente.']);
}
else{
return response()->json(['tipo'=>'cita', 'status' => 'true',
'info' =>'No puedes confirmar una cita que se encuentra cancelada.']);
}
}else{
return response()->json(['tipo'=>'cita', 'status' => 'false',
'info' => 'Hoy no es la fecha de la cita.']);
}
}
else{
}
}
private function asignar_cita_automatica(){

$dia_inicio = Carbon::now()->startOfDay();
$dia_fin = Carbon::now()->endOfDay();
$mes_inicio = Carbon::now()->startOfMonth();
$mes_fin = Carbon::now()->endOfMonth();
$users = User::select([
'users.id as id',
'users.name as name'
])
->rightjoin('declaraciones_juradas',
'declaraciones_juradas.id_usuario', '=', 'users.id')
->whereBetween('declaraciones_juradas.created_at', [$dia_inicio,
$dia_fin])
->where('users.tipo',3)
->where('users.suspendido','!=',1)
->where('users.allow_supervisor',1)
->where('users.estado',1)
->orderBy('declaraciones_juradas.created_at','desc')
->get();
$ultimosQuinceVentas = \Kim\Activity\Activity::usersBySeconds(35)->select([
'users.id',
'users.name',
])
-
>where('users.tipo',Config::get('constant.user_types.asesor_comercial'))
->get()
->sortByDesc('last_activity');
foreach($users as $key => $usuario){

$exist = $ultimosQuinceVentas->where('name',$usuario->name)->isEmpty();
if($exist){
$users->forget($key);
}
}
$cita_cant = 0;
foreach ($users as $user){
$cita_cant = ClientsActivities::select('id')
->where('id_usuario',$user->id)
->where('tipo',29)
->whereBetween('clients_activities.created_at', [$mes_inicio,
$mes_fin])
->count();
$user->cantidad = $cita_cant;
}
$users = $users->toArray();
usort($users, function($a,$b){
if ($a['cantidad'] == $b['cantidad']) {
return 0;
}
return ($a['cantidad'] > $b['cantidad']) ? 1 : -1;
});
if($users){
$usuario_asignado = $users[0];
}else{
$usuario_asignado = false;
}
return $usuario_asignado;
}
private function addNotiCita($id_cliente, $id_usuario, $id_reunion, $useraux,

$id_empresa){
$cliente = Cliente::findOrFail($id_cliente);
$notiCita = NotiCita::where('id_usuario',$id_usuario)->first();
if(!empty($notiCita->ids)){
$notiCita->ids = json_decode($notiCita->ids);
$esta = false;
foreach($notiCita->ids->ids as $key => $client){
if($jclient->id == $cliente->id){
$esta = true;
}
}
if(!$esta){
$data_client = [
"id" => $cliente->id,
"id_reunion" => $id_reunion,
"id_empresa" => $id_empresa,
"useraux" => $useraux
];
array_push($notiCita->ids->ids,json_encode($data_client));
$notiCita->cant++;
$notiCita->ids = json_encode($notiCita->ids);
} else {
$notiCita->ids = json_encode($notiCita->ids);
}
Log::info('NOTICITA INSERTADO EN '.$id_usuario.' NOT NULL (CLIENTE:'.
$cliente->id.')');
} else {
$notiCita->cant++;
$data_client = [
"id" => $cliente->id,
"id_reunion" => $id_reunion,
"id_empresa" => $id_empresa,
"useraux" => $useraux
];
$data_final = [
"ids" => [json_encode($data_client)]
];
$notiCita->ids = json_encode($data_final);
Log::info('NOTICITA INSERTADO EN '.$id_usuario.' NULL (CLIENTE:'.
$cliente->id.')');
}
$notiCita->save();
}
public function check_cita_cantidad(Request $request){

$ahora = Carbon::now()->toDateString();
$unAñoAtras = Carbon::now()->startOfYear()->toDateString();
$reunion = Reuniones::where('id_cliente', $request['id_cliente'])->count();

$reunionesVisitadas = Reuniones::select('id_cliente', 'visitado')
->where('id_cliente', $request['id_cliente'])
->where('visitado', 1)
->whereBetween('fecha', [$unAñoAtras, $ahora])
->count();
return response()->json(['status' => 'true', "cant_citas"=>$reunion,

"cant_citas_visitadas"=>$reunionesVisitadas]);
}
public function presente_qr($id_user_code){

if ($user->tipo == Config::get('constant.user_types.administrador') ||
$user->tipo == Config::get('constant.user_types.seguridad')) {
$id_user = base64_decode($id_user_code);
$usuario = User::where('id' , $id_user)->firstOrFail();
$files = $avatars->allFiles($usuario->id);
if(!empty($files)){
$usuario->avatar = '/avatars/'.$files[0];
} else {
$usuario->avatar =
}
return response()->json(['tipo' => 'presente', 'usuario' => $usuario]);
}else{
}
}
public function update_noticita(Request $request){

$usuario =Auth::user();
$id_usuario = $usuario->id;
$respuesta = $request->respuesta;
$data = $this->descontarNotiCita();
$content = $data->getContent();
$array = json_decode($content, true);
$id_cliente = $array['id_cliente'];
$id_reunion = $array['id_reunion'];
$useraux = $array['useraux'];
$reunion = Reuniones::where('id',$id_reunion)->firstOrFail();
if ($respuesta=="true"){
if($useraux==1 || $useraux==2) {
$userdetalle = 'Cita Atendida por';
}
else{
$userdetalle = 'Cita Atendida por';
$cliente = Cliente::where('id' , $reunion->id_cliente)-
>firstOrFail();
$cliente->id_usuario = $id_usuario;
$cliente->save();
}
$reunion->usuario_asignado = $id_usuario;
$reunion->save();
ClientsActivities::register($id_usuario, $id_cliente,
ClientsActivities::ASIGNA_CITA_MISMO, $userdetalle);
$useres = User::where('id',$id_usuario)->firstOrFail();
$useres->estado = 0;
$useres->save();
return response()->json(['status'=>true, 'id_cliente' => $id_cliente]);

}else{
if ($request->variable && $request->variable == 1){
$userdetalle = 'Cita Rechazada Automáticamente porque el vendedor
no respondio en el tiempo estipulado';
}else{
$userdetalle = 'Cita Rechazada por';
}
ClientsActivities::register($id_usuario, $id_cliente,
ClientsActivities::ASIGNA_CITA_MISMO, $userdetalle);
//buscamos otro usuario
$useraux_new = 0;
$id_empresa = Cliente::where('id',$id_cliente)->pluck('id_empresa');
ClientsActivities::register($id_creador, $id_cliente,
ClientsActivities::ASIGNAR_CITA_ALEATORIO, null);
$this->addNotiCita($id_cliente, $id_creador, $id_reunion, $useraux_new,
$id_empresa);

}
}
public function descontarNotiCita(){

$usuario =Auth::user();
$notiCita = NotiCita::where('id_usuario',$usuario->id)->first();
if($notiCita){
if(!empty($notiCita->ids)){
$notiCita->ids = json_decode($notiCita->ids);
foreach($notiCita->ids->ids as $key => $client){
}
$notiCita->ids = null;
$notiCita->cant = 0;
if($notiCita->save()){
return response()->json(['status'=>true,
'id_cliente'=>$jclient->id, 'id_reunion'=>$jclient->id_reunion,
'useraux'=>$jclient->useraux]);
} else {
return response()->json(['status'=> false,'message'=>'Error
NotiVeri410. Infórmale al desarrollador.']);
}
} else {
}
} else {
}
}
}

Clientes Controller

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Clientes Controller

Uploaded by

Copyright:

Available Formats

<?

class ClientesController extends Controller {

public function clientes_base_datos() {

$primary_groups = Group::all()->where('primary', true);

$secondary_groups = Group::all()->where('primary', false);

$empresas = Empresa::select('nombre_empresa', 'id')->whereIn('id',

return view('pages.clientes.recepcion.base', compact('vendedores',

public function table_clientes_base() {

public function clientes_plan_ahorro() {

$primary_groups = Group::all()->where('primary', true);

$secondary_groups = Group::all()->where('primary', false);

foreach ($vendedores as $vendedor) {

$empresas = Empresa::select('nombre_empresa', 'id')->whereIn('id',

return view('pages.clientes.recepcion.ahorro', compact('vendedores',

public function table_clientes_plan_ahorro() {

public function clientes_a_plazo_recepcion() {

return view('pages.clientes.recepcion.plazo', compact('vendedores',

public function clientes_a_plazo_ventas() {

public function clientes_a_plazo_callcenter() {

protected function reasign_modal_vars(){

foreach ($vendedores_LEC as $vendedor) {

$empresas = Empresa::select('nombre_empresa', 'id')->whereIn('id',

public function table_clientes_a_plazo() {

public function table_clientes_a_plazo_callcenter() {

->join('cliente_status', 'clientes.status', '=',

public function table_clientes_a_plazo_ventas(Request $request) {

->join('cliente_status', 'clientes.status', '=',

public function table_clientes_a_plazo_ventas_filtrado(Request $request){

public function clientes_comprador_recepcion()

public function clientes_comprador_ventas()

public function clientes_comprador_callcenter()

public function table_clientes_comprador()

public function table_clientes_comprador_ventas()

public function table_clientes_comprador_callcenter()

public function massReasign() {

Log::info("Mass Reasign Job Begins");

public function reasign($client_id, $vendedor,Request $request=null) {

if($cliente->status != Config::get('constant.cliente_status.senado') &&

/* CREAMOS LA ESTADISTICA CORRESPONDIENTE SI EL ESTADO ES NUEVO O PARA

$tareas = Tareas::where('id_cliente', '=', $client_id)->get();

foreach ($tareas as $tarea) {

if($request) $request->session()->flash('alert-success', 'El cliente ha

if ($user->tipo == Config::get('constant.user_types.supervisor') || $user-

$paises = Paises::all()->lists('name', 'id');

$provincias = Provincia::orderBy('nombre_provincia', 'asc')-

$empresas = Empresa::orderBy('nombre_empresa', 'asc')->whereIn('id',

$productos = Producto::where('id_empresa', Auth::user()->empresa)-

$origens = Origen::lists('nombre', 'id');

$campaigns = Campaign::lists('name', 'id');

$forma_pagos = Planes::lists('forma_pago', 'id');

$razon = Razon::orderBy('order', 'asc')->lists('razon', 'id');

$logo = Empresa::select('imgurl')->where('id', Auth::user()->empresa)-

foreach ($vendedores as $vendedor) {

$primary_groups = Group::all()->where('primary', true);

foreach ($vendedores as $vendedor) {

$cliente = new Cliente($request->all());

$consulta = New Consultas();

if(isset($request->jsonresponse) && $request->jsonresponse){

/* Guardamos datos del usuario que lo agrego */

$reasing = $this->reasign($cliente->id, $next_user->id,$request);

$financiacion->monto_entrega = $request->monto_entrega ? $request-

$financiacion->entrega_type = $request->entrega_type ? $request-