public void SetPosition(DtoPosition paramPosition)
        {
            IMongoDatabase database = MongoClient.GetDatabase("RadarFamily");
            IMongoCollection <DtoPosition> position = database.GetCollection <DtoPosition>("HistoricoPosicao");

            DtoPosition pos = new DtoPosition();

            pos._id = paramPosition._id;
            pos.IdUnidadeRastreada = paramPosition.IdUnidadeRastreada;
            pos.Name            = paramPosition.Name;
            pos.DateEvent       = paramPosition.DateEvent;
            pos.DateAtualizacao = paramPosition.DateAtualizacao;
            pos.Address         = paramPosition.Address;
            pos.Latitude        = paramPosition.Latitude;
            pos.Longitude       = paramPosition.Longitude;
            pos.IdRegra         = paramPosition.IdRegra;
            pos.Avatar          = paramPosition.Avatar;
            try
            {
                position.ReplaceOne(x => x._id == pos._id, pos, UpdateOptions);
            }
            catch (NullReferenceException)
            {
                position.InsertOne(pos);
            }
        }
Ejemplo n.º 2
0
 /// <summary>
 ///     Adding or Updating Position in a database
 /// </summary>
 /// <param name="position">Business Object Position</param>
 /// <returns>True if succeeded and false otherwise</returns>
 public async Task <bool> SavePosition(DtoPosition position)
 {
     try
     {
         using (var data = Context)
         {
             var p =
                 await
                     (from item in data.Position where position.Id == item.id select item).FirstOrDefaultAsync();
             // Updating Position
             if (p != null)
             {
                 p.name        = position.Name;
                 p.description = position.Description;
             }
             // Adding new Position
             else
             {
                 if (await(from item in data.Position where position.Name == item.name select item).AnyAsync())
                 {
                     return(false);
                 }
                 data.Position.Add(PositionConverter.DtoToDataAccess(position));
             }
             await data.SaveChangesAsync();
         }
         return(true);
     }
     catch (Exception)
     {
         return(false);
     }
 }
        public IActionResult SetLastPosition([FromBody] DtoPosition paramPosition)
        {
            DtoPosition pos = new DtoPosition();

            pos = _positionService.SetLastPosition(paramPosition);
            _positionService.SetPosition(pos);

            return(Json(pos));
        }
        public void Remove(DtoPosition position)
        {
            Position oldPosition = GetPosition(CtxDB, CurrentOrganizationId, position.Id);

            // CtxDB.Positions.Remove(oldPosition);
            oldPosition.DeletedDate        = DateTime.UtcNow;
            CtxDB.Entry(oldPosition).State = EntityState.Modified;
            CtxDB.SaveChanges();
        }
Ejemplo n.º 5
0
 /// <summary>
 ///     Conversion from DTO to View Model Method
 /// </summary>
 /// <param name="position">DTO Position</param>
 /// <returns>View Model Position</returns>
 public static Position DtoToViewModel(DtoPosition position)
 {
     return(new Position
     {
         Id = position.Id,
         Name = position.Name,
         Description = position.Description
     });
 }
 /// <summary>
 ///     Conversion from dto to Data Access Method
 /// </summary>
 /// <param name="position">dto Position</param>
 /// <returns>Data Access Position</returns>
 public static Position DtoToDataAccess(DtoPosition position)
 {
     return(new Position
     {
         id = position.Id,
         name = position.Name,
         description = position.Description
     });
 }
        public void Update(DtoPosition position, List <Position> Positions = null)
        {
            Position oldPosition = GetPosition(CtxDB, CurrentOrganizationId, position.Id);

            oldPosition.SubjectId        = position.SubjectId;
            oldPosition.RoleType         = position.Type;
            oldPosition.GroupId          = position.GroupId;
            oldPosition.LastModifiedDate = DateTime.UtcNow;

            CtxDB.Entry(oldPosition).State = EntityState.Modified;
            CtxDB.SaveChanges();
        }
        public void Insert(DtoPosition position)
        {
            Position newPosition = new Position
            {
                SubjectId      = position.SubjectId,
                RoleType       = position.Type,
                GroupId        = position.GroupId,
                OrganizationId = CurrentOrganizationId,
                CreatedDate    = DateTime.UtcNow
            };

            CtxDB.Positions.Add(newPosition);
            CtxDB.SaveChanges();
        }
Ejemplo n.º 9
0
        private async void getListLastPosition(Int32 IdAdmin)
        {
            Items = new ObservableCollection <DtoPosition>();
            Items.Clear();

            try
            {
                using (var client = new HttpClient())
                {
                    string uri = "http://207.180.246.227:8095/admin/Position/GetLastPosition?paramIdAdmin=" + IdAdmin;

                    HttpResponseMessage retorno = await client.GetAsync(uri);

                    var resultString = await retorno.Content.ReadAsStringAsync();

                    if (retorno.StatusCode == System.Net.HttpStatusCode.BadRequest)
                    {
                        await Application.Current.MainPage.DisplayAlert("Erro", "Ocorreu um erro ao retonar as posições", "Ok");

                        return;
                    }
                    if (resultString != "[]")
                    {
                        foreach (DtoPosition item in JsonConvert.DeserializeObject <List <DtoPosition> >(resultString))
                        {
                            DtoPosition position = new DtoPosition()
                            {
                                Name            = item.Name,
                                DateEvent       = item.DateEvent,
                                DateAtualizacao = item.DateAtualizacao,
                                Avatar          = item.Avatar,
                                Address         = item.Address,
                                LatLong         = item.LatLong,
                                Latitude        = item.Latitude,
                                Longitude       = item.Longitude
                            };
                            Items.Add(position);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
        public DtoPosition SetLastPosition(DtoPosition paramPosition)
        {
            try
            {
                DtoPosition pos = null;
                using (SqlConnection con = new SqlConnection(GetConnectionString()))
                {
                    SqlCommand cmd = new SqlCommand("[dbo].[pr_setLastPosition]", con)
                    {
                        CommandType = CommandType.StoredProcedure
                    };

                    SqlDataReader sqlDataReader = null;

                    cmd.Parameters.AddWithValue("@prmIdUnidadeRastreada", paramPosition.IdUnidadeRastreada);
                    cmd.Parameters.AddWithValue("@prmName", paramPosition.Name);
                    cmd.Parameters.AddWithValue("@prmDateEvent", paramPosition.DateEvent);
                    cmd.Parameters.AddWithValue("@prmAddress", paramPosition.Address);
                    cmd.Parameters.AddWithValue("@prmLatitude", paramPosition.Latitude);
                    cmd.Parameters.AddWithValue("@prmLongitude", paramPosition.Longitude);
                    cmd.Parameters.AddWithValue("@prmIdRegra", paramPosition.IdRegra);

                    con.Open();
                    sqlDataReader = cmd.ExecuteReader();

                    if (sqlDataReader.Read())
                    {
                        pos = new DtoPosition();
                        if (!sqlDataReader.IsDBNull(0))
                        {
                            pos._id = sqlDataReader.GetInt64(0);
                        }
                        if (!sqlDataReader.IsDBNull(1))
                        {
                            pos.IdUnidadeRastreada = sqlDataReader.GetInt32(1);
                        }
                        if (!sqlDataReader.IsDBNull(2))
                        {
                            pos.Name = sqlDataReader.GetString(2);
                        }
                        if (!sqlDataReader.IsDBNull(3))
                        {
                            pos.DateEvent = sqlDataReader.GetDateTime(3);
                        }
                        if (!sqlDataReader.IsDBNull(4))
                        {
                            pos.DateAtualizacao = sqlDataReader.GetDateTime(4);
                        }
                        if (!sqlDataReader.IsDBNull(5))
                        {
                            pos.Address = sqlDataReader.GetString(5);
                        }
                        if (!sqlDataReader.IsDBNull(6))
                        {
                            pos.Latitude = sqlDataReader.GetDouble(6);
                        }
                        if (!sqlDataReader.IsDBNull(7))
                        {
                            pos.Longitude = sqlDataReader.GetDouble(7);
                        }
                        if (!sqlDataReader.IsDBNull(8))
                        {
                            pos.IdRegra = sqlDataReader.GetInt32(8);
                        }
                        if (!sqlDataReader.IsDBNull(9))
                        {
                            pos.Avatar = sqlDataReader.GetString(9);
                        }
                    }

                    con.Close();
                }

                return(pos);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
        public List <DtoPosition> GetLastPosition(Int32 paramIdUnidadeRastreada)
        {
            try
            {
                List <DtoPosition> listPos = new List <DtoPosition>();

                using (SqlConnection con = new SqlConnection(GetConnectionString()))
                {
                    SqlCommand cmd = new SqlCommand("[dbo].[pr_getLastPosition]", con)
                    {
                        CommandType = CommandType.StoredProcedure
                    };

                    SqlDataReader sqlDataReader = null;

                    cmd.Parameters.AddWithValue("@prmIdUnidadeRastreada", paramIdUnidadeRastreada);

                    con.Open();
                    sqlDataReader = cmd.ExecuteReader();

                    while (sqlDataReader.Read())
                    {
                        DtoPosition item = new DtoPosition();
                        if (!sqlDataReader.IsDBNull(0))
                        {
                            item._id = sqlDataReader.GetInt64(0);
                        }
                        if (!sqlDataReader.IsDBNull(1))
                        {
                            item.IdUnidadeRastreada = sqlDataReader.GetInt32(1);
                        }
                        if (!sqlDataReader.IsDBNull(2))
                        {
                            item.Address = sqlDataReader.GetString(2);
                        }
                        if (!sqlDataReader.IsDBNull(3))
                        {
                            item.Latitude = sqlDataReader.GetDouble(3);
                        }
                        if (!sqlDataReader.IsDBNull(4))
                        {
                            item.Longitude = sqlDataReader.GetDouble(4);
                        }
                        if (!sqlDataReader.IsDBNull(5))
                        {
                            item.DateEvent = sqlDataReader.GetDateTime(5);
                        }
                        if (!sqlDataReader.IsDBNull(6))
                        {
                            item.DateAtualizacao = sqlDataReader.GetDateTime(6);
                        }
                        if (!sqlDataReader.IsDBNull(7))
                        {
                            item.Name = sqlDataReader.GetString(7);
                        }
                        if (!sqlDataReader.IsDBNull(8))
                        {
                            item.Avatar = sqlDataReader.GetString(8);
                        }

                        listPos.Add(item);
                    }

                    return(listPos);
                }
            }
            catch (Exception Ex)
            {
                throw new Exception(Ex.Message);
            }
        }
Ejemplo n.º 12
0
        public async void SetPosition()
        {
            if (Application.Current.Properties.ContainsKey("IdUnidadeRastreada"))
            {
                Int32 IdUnidadeRastreada = (Int32)Application.Current.Properties["IdUnidadeRastreada"];
                Int32 Tolerancia         = (Int32)Application.Current.Properties["CalculoDistancia"];

                try
                {
                    if (Application.Current.Properties["IdUnidadeRastreada"] != null && (Boolean)Application.Current.Properties["IsAdmin"] == false)
                    {
                        //Posição atual
                        Dictionary <Coordenates, Velocity> loc = new Dictionary <Coordenates, Velocity>();
                        Coordenates geoLoc = new Coordenates();

                        loc = await GetCurrentPositionAsync();

                        if (loc != null)
                        {
                            Double?speed = 0;

                            foreach (KeyValuePair <Coordenates, Velocity> dadosGeo in loc)
                            {
                                geoLoc.lat = dadosGeo.Key.lat;
                                geoLoc.lng = dadosGeo.Key.lng;

                                speed = dadosGeo.Value.speed;
                            }

                            String address = null;

                            await Task.Run(async() =>
                            {
                                //Reverser GeoCode para endereço
                                address = await GetAddressByReverseGeoCode(geoLoc.lat, geoLoc.lng);
                            });


                            //Posição anterior
                            DtoPosition lastPos = new DtoPosition();
                            lastPos = GetLastPosition(IdUnidadeRastreada).Result.FirstOrDefault();

                            Boolean gravaPosicao = true;

                            //Cálculo de distância

                            if (lastPos != null)
                            {
                                Coordenates lastLatLong = new Coordenates();
                                lastLatLong.lat = lastPos.Latitude;
                                lastLatLong.lng = lastPos.Longitude;

                                Double distance = await GetCalculateDistance(IdUnidadeRastreada, lastLatLong, geoLoc);

                                if (distance > Tolerancia || lastPos.DateEvent.Day != DateTime.Today.Day)
                                {
                                    gravaPosicao = true;
                                }
                                else
                                {
                                    gravaPosicao = false;
                                }
                            }

                            var level = Battery.ChargeLevel;

                            if (gravaPosicao)
                            {
                                using (var client = new HttpClient())
                                {
                                    var positionRequest = new DtoPosition
                                    {
                                        _id = null,
                                        IdUnidadeRastreada = (Int32)Application.Current.Properties["IdUnidadeRastreada"],
                                        Name         = Application.Current.Properties["Name"].ToString(),
                                        DateEvent    = DateTime.Now,
                                        Address      = address,
                                        Latitude     = geoLoc.lat,
                                        Longitude    = geoLoc.lng,
                                        IdRegra      = null,
                                        Avatar       = Application.Current.Properties["Avatar"].ToString(),
                                        LevelBattery = level,
                                        Velocity     = (double)speed
                                    };

                                    var jsonRequest = JsonConvert.SerializeObject(positionRequest);
                                    var httpContent = new StringContent(jsonRequest, Encoding.UTF8, "application/json");

                                    string uri = "http://207.180.246.227:8095/admin/Position/SetLastPosition";

                                    var retorno = await client.PostAsync(uri, httpContent);

                                    var resultString = await retorno.Content.ReadAsStringAsync();

                                    DtoPosition pos = new DtoPosition();
                                    pos = JsonConvert.DeserializeObject <DtoPosition>(resultString);

                                    if (retorno.StatusCode == System.Net.HttpStatusCode.BadRequest)
                                    {
                                        //throw new Exception("Ocorrer um erro ao enviar posição!");
                                    }

                                    #region ViolacaoRegra

                                    RuleService rule    = new RuleService();
                                    Boolean     HasRule = await rule.HasViolationRule(pos.IdUnidadeRastreada, pos.Latitude, pos.Longitude, pos._id);

                                    #endregion


                                    //DtoPosition position = new DtoPosition();
                                    //position = JsonConvert.DeserializeObject<DtoPosition>(resultString);
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception("Ocorreu um erro ao enviar posição. Erro: " + ex.Message);
                }

                await Application.Current.SavePropertiesAsync();
            }
        }
        private async void MontaUltimaPosicao()
        {
            Int32 IdAdmin = (int)Application.Current.Properties["IdUser"];

            List <DtoPosition> itens = new List <DtoPosition>();

            try
            {
                using (var client = new HttpClient())
                {
                    string uri = "http://207.180.246.227:8095/admin/Position/GetLastPosition?paramIdAdmin=" + IdAdmin;

                    HttpResponseMessage retorno = await client.GetAsync(uri);

                    var resultString = await retorno.Content.ReadAsStringAsync();

                    if (retorno.StatusCode == System.Net.HttpStatusCode.BadRequest)
                    {
                        await DisplayAlert("Erro", "Ocorreu um erro ao retonar as posições", "Ok");

                        return;
                    }
                    if (resultString != "[]")
                    {
                        PositionService pos = new PositionService();

                        List <DtoPosition> listPosition = new List <DtoPosition>();

                        foreach (var item in JsonConvert.DeserializeObject <List <DtoPosition> >(resultString))
                        {
                            DtoPosition position = new DtoPosition()
                            {
                                Name            = item.Name,
                                DateEvent       = item.DateEvent,
                                DateAtualizacao = item.DateAtualizacao,
                                Avatar          = item.Avatar,
                                Address         = item.Address,
                                LatLong         = item.LatLong,
                                Latitude        = item.Latitude,
                                Longitude       = item.Longitude
                            };
                            listPosition.Add(position);
                        }

                        lvPosition.ItemsSource = listPosition;

                        //var polyline = new Polyline();

                        //foreach (DtoPosition x in lvPosition.DataSource.Items)
                        //{

                        //    polyline.Positions.Add(new Position(x.Latitude, x.Longitude));

                        //    polyline.StrokeColor = Color.Red;
                        //    polyline.StrokeWidth = 5f;
                        //    polyline.Tag = "POLYLINE"; // Can set any object

                        //    polyline.IsClickable = false;
                        //    polyline.Clicked += (s, e) =>
                        //    {
                        //        // handle click polyline
                        //    };


                        //    Pin pin = new Pin()
                        //    {
                        //        Icon = BitmapDescriptorFactory.FromBundle(x.Avatar),
                        //        Type = PinType.Place,
                        //        Label = x.Name,
                        //        Address = x.Address,
                        //        Position = new Position(x.Latitude, x.Longitude),
                        //        ZIndex = 5,
                        //    };

                        //    MyMap.Pins.Add(pin);
                        //}

                        //MyMap.Polylines.Add(polyline);
                        Dictionary <Coordenates, Velocity> geo = new Dictionary <Coordenates, Velocity>();

                        Coordenates geoLoc = new Coordenates();

                        geo = await pos.GetCurrentPositionAsync();

                        foreach (KeyValuePair <Coordenates, Velocity> dadosGeo in geo)
                        {
                            geoLoc.lat = dadosGeo.Key.lat;
                            geoLoc.lng = dadosGeo.Key.lng;
                        }

                        MyMap.MoveToRegion(MapSpan.FromCenterAndRadius(new Position(geoLoc.lat, geoLoc.lng), Distance.FromKilometers(1)));


                        //waitActivityIndicator.IsVisible = false;
                        //waitActivityIndicator.IsRunning = false;
                    }
                    else
                    {
                        //waitActivityIndicator.IsVisible = false;
                        //waitActivityIndicator.IsRunning = false;
                    }
                }
            }
            catch (Exception ex)
            {
                await DisplayAlert("Erro", ex.Message, "Erro ao listar Matérias...");

                return;
            }
        }