Example #1
0
        private static void StoreParameter(Device d, Device.Parameter param, SqlConnection connection)
        {
            try
            {
                var command = new SqlCommand("sp_set_device_parameter", connection)
                {
                    CommandType = CommandType.StoredProcedure
                };

                var retur_value = command.Parameters.Add("RETURN_VALUE", SqlDbType.Int);
                retur_value.Direction = ParameterDirection.ReturnValue;

                command.Parameters.AddWithValue("@p1_device_id", d.Id_short);
                command.Parameters.AddWithValue("@p2_parameter", param.Nombre);
                command.Parameters.AddWithValue("@p3_value", param.Valor);
                command.Parameters.AddWithValue("@p4_consumer", param.Consumidor);
                command.Parameters.AddWithValue("@p5_data_type", param.TipoDato);
                command.Parameters.AddWithValue("@p6_valor_inicial", param.ValorInicial);
                command.Parameters.AddWithValue("@p7_editable", 0);

                var rows = command.ExecuteNonQuery();

                STrace.Debug(typeof(DevicesSql).FullName, String.Format("URBETRACK: set_parameter({0},{1}) rows:{2}", param.Nombre, param.Valor, rows));
            }
            catch (Exception e)
            {
                e.Data.Add("Parameter:", param.Nombre);
                throw;
            }
        }
Example #2
0
        public static Dictionary <int, Device> RetrieveDevices()
        {
            using (var connection = new SqlConnection(ConnectionString))
            {
                var devices = new Dictionary <int, Device>();
                connection.Open();
                var command = new SqlCommand("SELECT * FROM fleet01_devices", connection);
                var reader  = command.ExecuteReader();
                var c       = 0;
                while (reader.Read())
                {
                    var d = new Device(TransactionUser)
                    {
                        Id_short = Convert.ToInt16(reader.GetInt32(reader.GetOrdinal("id_parenti08"))),
                        Base     = reader.IsDBNull(reader.GetOrdinal("parenti02_descri"))
                                                        ? "(sin vehiculo)"
                                                        : reader.GetString(reader.GetOrdinal("parenti02_descri")),
                        Vehicle = reader.IsDBNull(reader.GetOrdinal("parenti03_interno"))
                                                                ? "(sin vehiculo)"
                                                                : reader.GetString(reader.GetOrdinal("parenti03_interno")),
                        LegacyCode     = reader.GetString(reader.GetOrdinal("parenti08_codigo")),
                        Imei           = reader.GetString(reader.GetOrdinal("parenti08_imei")),
                        FirmaRequerida = reader.IsDBNull(reader.GetOrdinal("parenti24_firma"))
                                                                        ? ""
                                                                        : reader.GetString(reader.GetOrdinal("parenti24_firma")),
                        FirmwareId =
                            reader.IsDBNull(reader.GetOrdinal("rela_parenti24"))
                                                                ? 0
                                                                : Convert.ToInt32(
                                reader.GetInt32(reader.GetOrdinal("rela_parenti24")))
                    };

                    STrace.Debug(typeof(DevicesSql).FullName, String.Format("DB.DEVICES: agregando Device[{0}] IMEI={1}", d.LogId, d.Imei));
                    devices.Add(d.Id_short, d);
                    c++;
                    if (c % 100 == 0)
                    {
                        STrace.Debug(typeof(DevicesSql).FullName, String.Format("DB.DEVICES: {0} dispositivos recuperados.", c));
                    }
                }
                reader.Close();
                c = 0;

                if (Config.Torino.DisableParameters)
                {
                    STrace.Debug(typeof(DevicesSql).FullName, "DB.DEVICES: parametros deshabilitados.");
                    return(devices);
                }

                var cmd = new SqlCommand("SELECT * FROM fleet02_parameters", connection);

                var total = CountQuery(connection, cmd);
                STrace.Debug(typeof(DevicesSql).FullName, String.Format("DB.DEVICES: parametrizando {0} dispositivos, total de parametros {1}", devices.Count, total));
                if (InitializeProgress != null)
                {
                    InitializeProgress(total, c);
                }
                reader = cmd.ExecuteReader();
                while (reader.Read())
                {
                    c++;
                    var dev_id = reader.GetInt32(reader.GetOrdinal("device_id"));
                    if (!devices.ContainsKey(dev_id))
                    {
                        continue;
                    }
                    var dev = devices[dev_id];
                    var p   = new Device.Parameter
                    {
                        Consumidor   = reader.GetString(reader.GetOrdinal("parenti31_consumidor"))[0],
                        TipoDato     = reader.GetString(reader.GetOrdinal("parenti31_tipo_dato")),
                        Nombre       = reader.GetString(reader.GetOrdinal("parenti31_nombre")),
                        Revision     = reader.GetInt32(reader.GetOrdinal("parenti30_revision")),
                        Valor        = reader.GetString(reader.GetOrdinal("parenti30_valor")),
                        ValorInicial = reader.GetString(reader.GetOrdinal("parenti31_valor_inicial"))
                    };
                    if (!dev.Parameters.ContainsKey(p.Nombre))
                    {
                        dev.Parameters.Add(p.Nombre, p);
                    }
                    else if (p.Revision > dev.Parameters[p.Nombre].Revision)
                    {
                        dev.Parameters[p.Nombre] = p;
                    }

                    if (total > 24 && c % (total / 25) == 0)
                    {
                        if (InitializeProgress != null)
                        {
                            InitializeProgress(total, c);
                        }
                    }
                    if (c % 10000 == 0)
                    {
                        STrace.Debug(typeof(DevicesSql).FullName, String.Format("DB.DEVICES: {0} parametros cargados.", c));
                    }
                }
                if (InitializeProgress != null)
                {
                    InitializeProgress(0, 0);
                }
                return(devices);
            }
        }
Example #3
0
        public static Device DeviceUpdate(object sender, Device d)
        {
            try
            {
                if (d.UpdateRequired)
                {
                    using (var connection = new SqlConnection(ConnectionString))
                    {
                        connection.Open();
                        foreach (var param in d.Parameters.Values)
                        {
                            if (!param.UpdateRequired)
                            {
                                continue;
                            }
                            StoreParameter(d, param, connection);
                            param.UpdateRequired = false;
                        }
                        d.UpdateRequired = false;
                    }
                }

                using (var connection = new SqlConnection(ConnectionString))
                {
                    var cmd = string.Format("SELECT * FROM fleet01_devices WHERE id_parenti08 = {0}", d.Id_short);

                    var command = new SqlCommand(cmd, connection);
                    connection.Open();
                    var reader = command.ExecuteReader();
                    if (reader.Read())
                    {
                        var rd = new Device(TransactionUser)
                        {
                            Id_short = Convert.ToInt16(reader.GetInt32(reader.GetOrdinal("id_parenti08"))),
                            Base     = reader.IsDBNull(reader.GetOrdinal("parenti02_descri"))
                                                                ? "(sin vehiculo)"
                                                                : reader.GetString(reader.GetOrdinal("parenti02_descri")),
                            Vehicle = reader.IsDBNull(reader.GetOrdinal("parenti03_interno"))
                                                                        ? "(sin vehiculo)"
                                                                        : reader.GetString(reader.GetOrdinal("parenti03_interno")),
                            LegacyCode     = reader.GetString(reader.GetOrdinal("parenti08_codigo")),
                            Imei           = reader.GetString(reader.GetOrdinal("parenti08_imei")),
                            FirmaRequerida = reader.IsDBNull(reader.GetOrdinal("parenti24_firma"))
                                                                                ? ""
                                                                                : reader.GetString(reader.GetOrdinal("parenti24_firma")),
                            FirmwareId =
                                reader.IsDBNull(reader.GetOrdinal("rela_parenti24"))
                                                                        ? 0
                                                                        : Convert.ToInt32(
                                    reader.GetInt32(reader.GetOrdinal("rela_parenti24")))
                        };
                        reader.Close();
                        var pcmd = new SqlCommand(String.Format("SELECT * FROM fleet02_parameters where device_id = {0};", d.Id_short), connection);
                        reader = pcmd.ExecuteReader();

                        while (reader.Read())
                        {
                            var p = new Device.Parameter
                            {
                                Consumidor   = reader.GetString(reader.GetOrdinal("parenti31_consumidor"))[0],
                                TipoDato     = reader.GetString(reader.GetOrdinal("parenti31_tipo_dato")),
                                Nombre       = reader.GetString(reader.GetOrdinal("parenti31_nombre")),
                                Revision     = reader.GetInt32(reader.GetOrdinal("parenti30_revision")),
                                Valor        = reader.GetString(reader.GetOrdinal("parenti30_valor")),
                                ValorInicial = reader.GetString(reader.GetOrdinal("parenti31_valor_inicial"))
                            };
                            rd.Parameters.Add(p.Nombre, p);
                        }
                        reader.Close();

                        return(rd);
                    }
                }
            }
            catch (Exception e)
            {
                STrace.Exception(typeof(DevicesSql).FullName, e);
            }
            return(null);
        }
Example #4
0
        private void CommanderProc()
        {
            try
            {
                while (_running)
                {
                    var myData = Thread.GetNamedDataSlot("device");

                    String commandText;

                    try
                    {
                        commandText = Cmd.PeekLabel();
                    }
                    catch (ExceptionMessageQueueInvalid)
                    {
                        STrace.Debug(GetType().FullName, "COMMANDER: ExceptionMessageQueueInvalid");
                        Thread.Sleep(1000);
                        continue;
                    }

                    if (String.IsNullOrEmpty(commandText))
                    {
                        if (Cmd.HaveMessages)
                        {
                            STrace.Debug(GetType().FullName, "COMMANDER: String.IsNullOrEmpty(commandText)");
                            Cmd.JustPop();
                        }
                        Thread.Sleep(250);
                        continue;
                    }

                    commandText = Cmd.JustPop();

                    STrace.Debug(GetType().FullName, String.Format("COMMANDER: CMD[{0}]", commandText));

                    // parseo el comando
                    var cmdParts = commandText.Split(":".ToCharArray());

                    try
                    {
                        if (cmdParts.GetLength(0) < 2)
                        {
                            if (commandText.StartsWith("CLOSE"))
                            {
                                STrace.Debug(GetType().FullName, "COMMANDER: cerrando commander.");

                                return;
                            }

                            continue;
                        }

                        var args = cmdParts[1].Split(";".ToCharArray());
                        var argc = args.GetLength(0);

                        //  resumo en 3 variables.
                        var command   = cmdParts[0];
                        var pointCode = Convert.ToInt32(args[0]);
                        var iPoint    = FindById(pointCode);

                        #region Comandos de IPowerBoot

                        // Request Soft Reboot RRS:(NodeCode);
                        if (command.StartsWith("RSR"))
                        {
                            iPoint.Reboot();
                            continue;
                        }

                        #endregion Comandos de IPowerBoot

                        #region Comandos de IWorkflow

                        // Set Workflow State SWS:(NodeCode);(State);
                        if (command.StartsWith("SWS"))
                        {
                            iPoint.AutoEvento(MessageIdentifier.UnsuportedCmd, 1);
                            continue;
                        }

                        #endregion Comandos de IWorkflow

                        #region Comandos de IShortMessage

                        // Submit Canned Message SCM:(NodeCode);(Code);(ReCode1,ReCode2,ReCodeN);
                        if (command.StartsWith("SCM") && argc == 4)
                        {
                            var code      = Convert.ToInt16(args[1]);
                            var responses = new List <int>();

                            if (!String.IsNullOrEmpty(args[2]))
                            {
                                responses.AddRange(args[2].Split(",".ToCharArray()).Select(i => Convert.ToInt32(i)));
                            }

                            iPoint.SendMessage(code, "", 345345, args[2]);

                            continue;
                        }

                        // Submit Text Message STM:(NodeCode);(Text);(ReCode1,ReCode2,ReCodeN);
                        if (command.StartsWith("STM") && argc == 4)
                        {
                            var textMessage = args[1];
                            iPoint.SendMessage(99, textMessage, 345345, args[2]);
                            continue;
                        }

                        // Delete Canned Message DCM:(NodeCode);(Code);(Rev);
                        if (command.StartsWith("DCM") && argc == 4)
                        {
                            iPoint.DeleteAllMessages();
                            continue;
                        }

                        /*/// Update Canned Message
                         * /// UCM:(NodeCode);(Code);(Text);(Rev);
                         * if (Command.StartsWith("UCM") && argc == 5 && iPoint is IShortMessage)
                         * {
                         *      var code = Convert.ToInt32(args[1]);
                         *      var text_message = args[2];
                         *      var rev = Convert.ToInt32(args[3]);
                         *      (iPoint as IShortMessage).SetCannedMessage(code, text_message, rev);
                         *      return 1;
                         * }
                         *
                         * /// Update Canned Response
                         * /// UCR:(NodeCode);(Code);(Text);(Rev);
                         * if (Command.StartsWith("UCR") && argc == 5 && iPoint is IShortMessage)
                         * {
                         *      var code = Convert.ToInt32(args[1]);
                         *      var text_message = args[2];
                         *      var rev = Convert.ToInt32(args[3]);
                         *      (iPoint as IShortMessage).SetCannedResponse(code, text_message, rev);
                         *      return 1;
                         * }*/

                        #endregion Comandos de IShortMessage

                        #region Comandos de IProvisioned

                        /*/// Update System Parameter
                         * /// UCR:(NodeCode);(Parameter);(NewValue);(Rev);
                         * if (Command.StartsWith("USP") && argc == 4 && iPoint is IProvisioned)
                         * {
                         * var parameter = args[1];
                         * var value = args[2];
                         * var rev = Convert.ToInt32(args[3]);
                         * (iPoint as IProvisioned).SetParameter(parameter, value, rev);
                         * return 1;
                         * }*/

                        #endregion Comandos de IProvisioned

                        var alreadyUpdated = false;

                        if (commandText.StartsWith("@"))
                        {
                            commandText    = commandText.Substring(1);
                            alreadyUpdated = true;
                        }

                        if (commandText.StartsWith("CONFIGURE:"))
                        {
                            var data  = commandText.Split(":".ToCharArray());
                            var devid = Convert.ToUInt16(data[1]);
                            var d     = FindById(devid);
                            if (d == null)
                            {
                                STrace.Debug(GetType().FullName, String.Format("DEVICE[{0}]: no se configura por que no esta en el mapa.", devid));
                            }
                            else
                            {
                                STrace.Debug(GetType().FullName, String.Format("COMMANDER: Configurando dispositivo a {0}", devid));
                                if (!alreadyUpdated)
                                {
                                    d.UpdateFrom(DeviceUpdate(this, d));
                                }
                                d.Configure();
                            }
                        }
                        else if (commandText.StartsWith("SBLC:"))
                        {
                            var partes = commandText.Split(":".ToCharArray());
                            var data   = partes[1].Split(";".ToCharArray());
                            var devid  = Convert.ToUInt16(data[0]);
                            if (data.GetLength(0) >= 2)
                            {
                                var action = Convert.ToByte(data[1][0]);
                                var d      = FindById(devid);
                                STrace.Debug(GetType().FullName, String.Format("COMMANDER: Configuracion accion de bootloader DEVICE[{0}] action={1}", d.LogId, action));
                                d.SetBootloaderAction(action);
                            }
                        }
                        else if (commandText.StartsWith("MSG:"))
                        {
                            var partes    = commandText.Split(":".ToCharArray());
                            var data      = partes[1].Split(";".ToCharArray());
                            var devid     = Convert.ToUInt16(data[0]);
                            var code      = Convert.ToInt16(data[1]);
                            var texto     = "";
                            var sessionid = 0;
                            var rfilter   = "";

                            // MSG:766;29;;7532;25,26
                            if (data.GetLength(0) >= 3)
                            {
                                texto = data[2];
                            }
                            if (data.GetLength(0) >= 4)
                            {
                                sessionid = Convert.ToInt32(data[3]);
                            }
                            if (data.GetLength(0) >= 5)
                            {
                                rfilter = data[4];
                            }
                            var d = FindById(devid);
                            STrace.Debug(GetType().FullName, String.Format("COMMANDER: Enviando mensaje DEVICE[{0}] code={1} text={2}", d.LogId, code, texto));
                            d.SendMessage(code, texto, sessionid, rfilter);
                        }
                        else if (commandText.StartsWith("DCM:"))
                        {
                            var partes = commandText.Split(":".ToCharArray());
                            var devid  = Convert.ToUInt16(partes[1]);
                            var d      = FindById(devid);
                            STrace.Debug(GetType().FullName, String.Format("COMMANDER: Borrando tabla de mensajes en DEVICE[{0}]", d.LogId));
                            d.DeleteAllMessages();
                        }
                        else if (commandText.StartsWith("SETPS:"))
                        {
                            var data  = commandText.Split(":".ToCharArray());
                            var devid = Convert.ToUInt16(data[1]);
                            var param = data[2];
                            var value = data[3];
                            var d     = FindById(devid);
                            STrace.Debug(GetType().FullName, String.Format("COMMANDER: Enviando parametro {0} a {1} valor={2}", param, devid, value));
                            var p = new Device.Parameter
                            {
                                Nombre   = param,
                                Revision = d.GetServerParameterInt("known_config_revision", 0),
                                Valor    = value
                            };
                            d.SendParameter(p);
                        }
                        else if (commandText.StartsWith("FULLQTREE:"))
                        {
                            var data  = commandText.Split(":".ToCharArray());
                            var devid = Convert.ToUInt16(data[1]);
                            var d     = FindById(devid);
                            STrace.Debug(GetType().FullName, String.Format("COMMANDER: Enviando QTree Completo a {0}", devid));
                            if (!alreadyUpdated)
                            {
                                d.UpdateFrom(DeviceUpdate(this, d));
                            }
                            d.UpdateQtree(QuadTree, 0);
                        }
                        else if (commandText.StartsWith("QTREE:"))
                        {
                            var data  = commandText.Split(":".ToCharArray());
                            var devid = Convert.ToUInt16(data[1]);
                            var d     = FindById(devid);

                            if (d == null)
                            {
                                STrace.Debug(GetType().FullName, String.Format("Node not find: {0}", devid));
                            }
                            else
                            {
                                STrace.Debug(GetType().FullName, String.Format("COMMANDER: Enviando QTree a dispositivo id='{0}'", devid));

                                if (!alreadyUpdated)
                                {
                                    d.UpdateFrom(DeviceUpdate(this, d));
                                }

                                d.UpdateQtree(QuadTree);
                            }
                        }
                        else if (commandText.StartsWith("RSH:"))
                        {
                            var daio = commandText.Split(":".ToCharArray());
                            var data = daio[1].Split(";".ToCharArray());
                            if (data.GetLength(0) >= 2)
                            {
                                var devid       = Convert.ToUInt16(data[0]);
                                var commandLine = data[1];
                                var d           = FindById(devid);
                                d.RemoteShell(commandLine);
                            }
                        }
                        else if (commandText.StartsWith("REBOOT:"))
                        {
                            var data  = commandText.Split(":".ToCharArray());
                            var devid = Convert.ToUInt16(data[1]);
                            var d     = FindById(devid);
                            d.Reboot();
                        }
                        else if (commandText.StartsWith("FOTA:"))
                        {
                            var data  = commandText.Split(":".ToCharArray());
                            var devid = Convert.ToUInt16(data[1]);
                            var d     = FindById(devid);
                            if (!alreadyUpdated)
                            {
                                d.UpdateFrom(DeviceUpdate(this, d));
                            }
                            if (d.FirmwareId != 0)
                            {
                                var sut = d.ut as ServerTU;
                                if (sut == null)
                                {
                                    throw new NullReferenceException("COMMANDER: El dispositivo id=" + devid +
                                                                     " no tiene usario de transaccion para FOTA.");
                                }
                                if (FirmwareRequest != null)
                                {
                                    var firmwareName = FirmwareRequest(this, d.FirmwareId);
                                    STrace.Debug(GetType().FullName, String.Format("COMMANDER: Iniciando fota para el dispositivo id='{0}' file='{1}'", devid, firmwareName));
                                    d.FlashOverTheAir(firmwareName);
                                }
                                else
                                {
                                    STrace.Debug(GetType().FullName, String.Format("COMMANDER: NO ESTA INSTALADO EL HANDLER DE OBTENCION DE FIRMWARE"));
                                }
                            }
                            else
                            {
                                STrace.Debug(GetType().FullName, String.Format("COMMANDER: El dispositivo {0} no tiene firmware asignado.", devid));
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        STrace.Exception(GetType().FullName, e);
                    }
                    finally
                    {
                        Thread.SetData(myData, null);
                    }
                }
            }
            catch (ThreadAbortException)
            {
            }
        }