Esempio n. 1
0
        private void SendQuestionPatenteToGarmin(string msgText, ViajeDistribucion distribucion)
        {
            var message = MessageSender.CreateSubmitTextMessage(distribucion.Vehiculo.Dispositivo, new MessageSaver(DaoFactory));

            message.AddMessageText(msgText).AddTextMessageId((uint)distribucion.Id + 100);
            message.Send();
        }
Esempio n. 2
0
        private void SendMessageToGarmin(string msgText, ViajeDistribucion distribucion)
        {
            var message = MessageSender.CreateSubmitTextMessage(distribucion.Vehiculo.Dispositivo, new MessageSaver(DaoFactory));

            message.AddMessageText(msgText).AddTextMessageId((uint)distribucion.Id + 200);
            message.Send();
            Logger.InfoFormat("Se notifico servicio {0} al vehiculo {1} [{2}]", distribucion.Codigo, distribucion.Vehiculo.Patente, msgText);

            var destinations = distribucion.Detalles.Where(d => d.PuntoEntrega != null &&
                                                           d.ReferenciaGeografica != null &&
                                                           Math.Abs(d.ReferenciaGeografica.Latitude) < 90 &&
                                                           Math.Abs(d.ReferenciaGeografica.Longitude) < 180)
                               .Select(d => new Destination(d.Id, new GPSPoint(DateTime.UtcNow,
                                                                               (float)d.ReferenciaGeografica.Latitude,
                                                                               (float)d.ReferenciaGeografica.Longitude),
                                                            d.Descripcion,
                                                            d.PuntoEntrega.Descripcion,
                                                            d.ReferenciaGeografica.Direccion.Descripcion))
                               .ToArray();

            var msg = MessageSender.CreateUnloadRoute(distribucion.Vehiculo.Dispositivo, new MessageSaver(DaoFactory))
                      .AddRouteId(distribucion.Id)
                      .AddDestinations(destinations);

            msg.Send();
        }
Esempio n. 3
0
        // POST: api/Messages
        public IHttpActionResult Post([FromBody] List <CustomMessage> messages)
        {
            try
            {
                var deviceId = GetDeviceId(Request);
                if (deviceId == null)
                {
                    return(Unauthorized());
                }

                if (messages == null)
                {
                    return(BadRequest());
                }

                var mensajes = new List <LogMensaje>();
                foreach (var message in messages)
                {
                    var logMensaje = new LogMensaje
                    {
                        Fecha    = message.DateTime,
                        Texto    = message.Description,
                        Latitud  = message.Latitude,
                        Longitud = message.Longitude
                    };
                    bool esMensajeOculto = false;
                    if (!String.IsNullOrEmpty(message.codigomensaje) &&
                        message.codigomensaje.StartsWith("R"))
                    {
                        message.codigomensaje = message.codigomensaje.Substring(1, message.codigomensaje.Length - 1);
                        TicketRechazo.MotivoRechazo rechazoEnum = (TicketRechazo.MotivoRechazo) int.Parse(message.codigomensaje.ToString());
                        switch (rechazoEnum)
                        {
                        case TicketRechazo.MotivoRechazo.MalFacturado:
                        case TicketRechazo.MotivoRechazo.MalPedido:
                        case TicketRechazo.MotivoRechazo.NoEncontroDomicilio:
                        case TicketRechazo.MotivoRechazo.NoPedido:
                        case TicketRechazo.MotivoRechazo.Cerrado:
                        case TicketRechazo.MotivoRechazo.CaminoIntransitable:
                        case TicketRechazo.MotivoRechazo.FaltaSinCargo:
                        case TicketRechazo.MotivoRechazo.FueraDeHorario:
                        case TicketRechazo.MotivoRechazo.FueraDeZona:
                        case TicketRechazo.MotivoRechazo.ProductoNoApto:
                        case TicketRechazo.MotivoRechazo.SinDinero:
                        {
                            esMensajeOculto = true;
                            var messageLog = DaoFactory.LogMensajeDAO.FindById(message.Id);

                            Dispositivo device = DaoFactory.DispositivoDAO.FindByImei(deviceId);
                            if (device == null)
                            {
                                continue;
                            }

                            var employee = DaoFactory.EmpleadoDAO.FindEmpleadoByDevice(device);
                            if (employee == null)
                            {
                                continue;
                            }

                            var idRechazo = Convert.ToInt32(messageLog.Texto.Split(':')[0].Split(' ').Last());
                            var rechazo   = DaoFactory.TicketRechazoDAO.FindById(idRechazo);

                            if (rechazo != null)
                            {
                                try
                                {
                                    if (rechazo.UltimoEstado == TicketRechazo.Estado.Notificado1 ||
                                        rechazo.UltimoEstado == TicketRechazo.Estado.Notificado2 ||
                                        rechazo.UltimoEstado == TicketRechazo.Estado.Notificado3)
                                    {
                                        IMessageSaver saver       = new MessageSaver(DaoFactory);
                                        var           messagetEXT = MessageSender.CreateSubmitTextMessage(device, saver);
                                        string        usuario     = "";
                                        try
                                        {
                                            rechazo.ChangeEstado(Logictracker.Types.BusinessObjects.Rechazos.TicketRechazo.Estado.Alertado, "Confirma atención", employee);
                                            DaoFactory.TicketRechazoDAO.SaveOrUpdate(rechazo);

                                            //El usuario tomo existosamente el rechazo
                                            foreach (var item in rechazo.Detalle)
                                            {
                                                if (item.Estado == TicketRechazo.Estado.Alertado)
                                                {
                                                    usuario = item.Empleado.Entidad.Descripcion;
                                                    break;
                                                }
                                            }
                                            messagetEXT.AddMessageText("INFORME DE RECHAZO NRO " + idRechazo + " SE CONFIRMA LA ASISTENCIA PARA: " + usuario);
                                            messagetEXT.Send();
                                        }
                                        catch (Exception ex)
                                        {
                                            messagetEXT.AddMessageText("INFORME DE RECHAZO NRO " + idRechazo + " HA OCURRIDO UN ERROR, POR FAVOR INTENTE NUEVAMENTE ASISTIR EL RECHAZO");
                                            messagetEXT.Send();
                                            throw ex;
                                        }
                                    }
                                    else
                                    {
                                        //El usuario ya fue alertado
                                        IMessageSaver saver       = new MessageSaver(DaoFactory);
                                        var           messagetEXT = MessageSender.CreateSubmitTextMessage(device, saver);
                                        string        usuario     = "";
                                        foreach (var item in rechazo.Detalle)
                                        {
                                            if (item.Estado == TicketRechazo.Estado.Alertado)
                                            {
                                                usuario = item.Empleado.Entidad.Descripcion;
                                                break;
                                            }
                                        }
                                        messagetEXT.AddMessageText("INFORME DE RECHAZO NRO " + idRechazo + " EL RECHAZO YA FUE TOMADO POR: " + usuario);
                                        messagetEXT.Send();
                                    }
                                }
                                catch (Exception ex)
                                {
                                    if (!ex.Message.ToString().Contains("Cambio de estado invalido"))
                                    {
                                        throw ex;
                                    }
                                }
                            }
                            break;
                        }

                        default:
                        {
                            TicketRechazo.Estado rechazoEstadoEnum = (TicketRechazo.Estado) int.Parse(message.codigomensaje.ToString());
                            switch (rechazoEstadoEnum)
                            {
                            case TicketRechazo.Estado.RespuestaExitosa:
                            {
                                esMensajeOculto = true;
                                var device = DaoFactory.DispositivoDAO.FindByImei(deviceId);
                                if (device == null)
                                {
                                    continue;
                                }
                                var employee = DaoFactory.EmpleadoDAO.FindEmpleadoByDevice(device);
                                if (employee == null)
                                {
                                    continue;
                                }
                                var rechazo = DaoFactory.TicketRechazoDAO.FindById(message.Id);

                                if (rechazo != null &&
                                    message.Id > 0)
                                {
                                    try
                                    {
                                        if (rechazo.UltimoEstado != TicketRechazo.Estado.RespuestaExitosa)
                                        {
                                            rechazo.ChangeEstado(Logictracker.Types.BusinessObjects.Rechazos.TicketRechazo.Estado.RespuestaExitosa, message.Description, employee);
                                            DaoFactory.TicketRechazoDAO.SaveOrUpdate(rechazo);
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        if (!ex.Message.ToString().Contains("Cambio de estado invalido"))
                                        {
                                            throw ex;
                                        }
                                    }
                                }
                                break;
                            }

                            case TicketRechazo.Estado.RespuestaConRechazo:
                            {
                                esMensajeOculto = true;

                                var device = DaoFactory.DispositivoDAO.FindByImei(deviceId);
                                if (device == null)
                                {
                                    continue;
                                }
                                var employee = DaoFactory.EmpleadoDAO.FindEmpleadoByDevice(device);
                                if (employee == null)
                                {
                                    continue;
                                }
                                var rechazo = DaoFactory.TicketRechazoDAO.FindById(message.Id);
                                if (rechazo != null &&
                                    rechazo.Id != 0)
                                {
                                    try
                                    {
                                        if (rechazo.UltimoEstado != TicketRechazo.Estado.RespuestaConRechazo)
                                        {
                                            rechazo.ChangeEstado(Logictracker.Types.BusinessObjects.Rechazos.TicketRechazo.Estado.RespuestaConRechazo, message.Description, employee);
                                            DaoFactory.TicketRechazoDAO.SaveOrUpdate(rechazo);
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        if (!ex.Message.ToString().Contains("Cambio de estado invalido"))
                                        {
                                            throw ex;
                                        }
                                    }
                                }
                                break;
                            }

                            default:
                                break;
                            }
                            break;
                        }
                        }
                    }
                    if (!esMensajeOculto)
                    {
                        mensajes.Add(logMensaje);
                    }
                }


                var value = RouteService.SendMessagesMobile(deviceId, mensajes);

                return(CreatedAtRoute("DefaultApi", null, value));
            }
            catch (Exception error)
            {
                LogicTracker.App.Web.Api.Providers.LogWritter.writeLog(error);
                return(BadRequest());
            }
        }
Esempio n. 4
0
        public void ProcessArchivo(LogicLinkFile archivo)
        {
            archivo.Status = LogicLinkFile.Estados.Procesando;
            DaoFactory.LogicLinkFileDAO.SaveOrUpdate(archivo);

            using (var transaction = SmartTransaction.BeginTransaction())
            {
                try
                {
                    STrace.Trace(Component, "Procesando con Estrategia: " + archivo.Strategy);
                    var rutas               = 0;
                    var entregas            = 0;
                    var clientes            = 0;
                    var asignaciones        = 0;
                    var result              = string.Empty;
                    var observaciones       = string.Empty;
                    ViajeDistribucion viaje = null;

                    switch (archivo.Strategy)
                    {
                    case LogicLinkFile.Estrategias.DistribucionFemsa:
                        DistribucionFemsa.Parse(archivo, out rutas, out entregas);
                        _update = true;
                        result  = string.Format("Archivo procesado exitosamente. Rutas: {0} - Entregas: {1}", rutas, entregas);
                        break;

                    case LogicLinkFile.Estrategias.DistribucionQuilmes:
                        DistribucionQuilmes.Parse(archivo, out rutas, out entregas, out observaciones);
                        _update = true;
                        result  = string.Format("Archivo procesado exitosamente. Rutas: {0} - Entregas: {1}", rutas, entregas);
                        if (observaciones != string.Empty)
                        {
                            result = result + " (" + observaciones + ")";
                        }
                        break;

                    case LogicLinkFile.Estrategias.DistribucionMusimundo:
                        DistribucionMusimundo.Parse(archivo, out rutas, out entregas, out observaciones);
                        _update = true;
                        result  = string.Format("Archivo procesado exitosamente. Rutas: {0} - Entregas: {1}", rutas, entregas);
                        if (observaciones != string.Empty)
                        {
                            result = result + " (" + observaciones + ")";
                        }
                        break;

                    case LogicLinkFile.Estrategias.DistribucionBrinks:
                        //DistribucionBrinks.Parse(archivo, out rutas, out entregas);
                        break;

                    case LogicLinkFile.Estrategias.DistribucionSos:
                        viaje  = DistribucionSos.Parse(archivo, out rutas, out entregas);
                        result = string.Format("Archivo procesado exitosamente. Rutas: {0} - Entregas: {1}", rutas, entregas);
                        break;

                    case LogicLinkFile.Estrategias.DistribucionReginaldLee:
                        DistribucionReginaldLee.Parse(archivo, out rutas, out entregas);
                        _update = true;
                        result  = string.Format("Archivo procesado exitosamente. Rutas: {0} - Entregas: {1}", rutas, entregas);
                        break;

                    case LogicLinkFile.Estrategias.DistribucionCCU:
                        var extension = GetFileName(archivo.FilePath);
                        switch (extension)
                        {
                        case "Rutas.xlsx":
                            DistribucionCCU.ParseRutas(archivo, out rutas, out entregas, out observaciones);
                            _update = true;
                            result  = string.Format("Archivo procesado exitosamente. Rutas: {0} - Entregas: {1}", rutas, entregas);
                            break;

                        case "Clientes.xlsx":
                            DistribucionCCU.ParseClientes(archivo, out clientes);
                            result = string.Format("Archivo procesado exitosamente. Clientes: {0}", clientes);
                            break;

                        case "Asigno.xlsx":
                            DistribucionCCU.ParseAsignaciones(archivo, out asignaciones, out observaciones);
                            result = string.Format("Archivo procesado exitosamente. Asignaciones: {0}", asignaciones);
                            break;

                        default:
                            result = string.Format("Extensión '" + extension + "' no válida.");
                            break;
                        }
                        break;

                    case LogicLinkFile.Estrategias.PedidosPetrobras:
                        var pedidos = 0;
                        PedidosPetrobras.Parse(archivo, out pedidos, out observaciones);
                        result = string.Format("Archivo procesado exitosamente. Pedidos: {0}", pedidos);
                        if (observaciones != string.Empty)
                        {
                            result = result + " (" + observaciones + ")";
                        }
                        break;

                    case LogicLinkFile.Estrategias.AsignacionClienteEmpleado:
                        var asignados = 0;
                        AsignacionClienteEmpleado.Parse(archivo, out asignados, out observaciones);
                        result = string.Format("Archivo procesado exitosamente. Asignados: {0}", asignados);
                        if (observaciones != string.Empty)
                        {
                            result = result + " (" + observaciones + ")";
                        }
                        break;

                    case LogicLinkFile.Estrategias.AsignacionCodigoViaje:
                        var viajes = 0;
                        AsignacionCodigoViaje.Parse(archivo, out viajes, out observaciones);
                        result = string.Format("Archivo procesado exitosamente. Viajes: {0}", viajes);
                        if (observaciones != string.Empty)
                        {
                            result = result + " (" + observaciones + ")";
                        }
                        break;
                    }

                    archivo.Status        = LogicLinkFile.Estados.Procesado;
                    archivo.DateProcessed = DateTime.UtcNow;
                    archivo.Result        = result;
                    DaoFactory.LogicLinkFileDAO.SaveOrUpdate(archivo);

                    transaction.Commit();

                    if (archivo.Strategy == LogicLinkFile.Estrategias.DistribucionSos)
                    {
                        if (viaje != null)
                        {
                            foreach (var detalle in viaje.Detalles)
                            {
                                if (detalle.PuntoEntrega != null && detalle.PuntoEntrega.ReferenciaGeografica != null)
                                {
                                    _update = true;
                                }
                            }

                            if (viaje.Vehiculo != null && viaje.Estado == ViajeDistribucion.Estados.Pendiente)
                            {
                                var tieneViajeEnCurso = DaoFactory.ViajeDistribucionDAO.FindEnCurso(viaje.Vehiculo) != null;
                                if (!tieneViajeEnCurso)
                                {
                                    //var ciclo = new CicloLogisticoDistribucion(viaje, DaoFactory,
                                    //    new MessageSaver(DaoFactory));
                                    //var evento = new InitEvent(DateTime.UtcNow);
                                    //ciclo.ProcessEvent(evento);
                                }
                                if (viaje.Vehiculo.Dispositivo != null)
                                {
                                    var msg   = new StringBuilder();
                                    var desde = viaje.Detalles[1].ReferenciaGeografica;
                                    var hasta = viaje.Detalles[2].ReferenciaGeografica;
                                    msg.Append("Viaje: " + viaje.Codigo);
                                    msg.Append("<br>Desde: " + GeocoderHelper.GetDescripcionEsquinaMasCercana(desde.Latitude, desde.Longitude));
                                    msg.Append("<br>Hasta: " + GeocoderHelper.GetDescripcionEsquinaMasCercana(hasta.Latitude, hasta.Longitude));

                                    var message = MessageSender.CreateSubmitTextMessage(viaje.Vehiculo.Dispositivo, new MessageSaver(DaoFactory));
                                    message.AddMessageText(msg.ToString());
                                    message.Send();

                                    //STrace.Trace(Component, "Ruta Aceptada: " + MessageCode.RutaAceptada.ToString());
                                    //STrace.Trace(Component, "Ruta Rechazada: " + MessageCode.RutaRechazada.ToString());

                                    //var msgText = "Acepta la asignacion del servicio <br><b>" + viaje.Codigo + "</b>?";
                                    //var replies = new[] { Convert.ToUInt32(MessageCode.RutaAceptada.ToString()),
                                    //                      Convert.ToUInt32(MessageCode.RutaRechazada.ToString()) };
                                    //message = MessageSender.CreateSubmitCannedResponsesTextMessage(viaje.Vehiculo.Dispositivo, new MessageSaver(DaoFactory));
                                    //message.AddMessageText(msgText)
                                    //       .AddTextMessageId(Convert.ToUInt32(viaje.Id))
                                    //       .AddCannedResponses(replies)
                                    //       .AddAckEvent(MessageCode.GarminCannedMessageReceived.GetMessageCode());

                                    //message.Send();
                                }
                            }
                        }
                    }

                    STrace.Trace(Component, result);
                }
                catch (Exception ex)
                {
                    AddError(ex);
                    transaction.Rollback();
                    ClearData();

                    archivo.Status = LogicLinkFile.Estados.Cancelado;
                    var result = "Archivo procesado erroneamente. Exception: " + ex.Message;
                    archivo.Result = result;
                    DaoFactory.LogicLinkFileDAO.SaveOrUpdate(archivo);

                    STrace.Trace(Component, result);
                }
                finally
                {
                    ClearData();
                }
            }
        }