public async Task <IActionResult> Create(Clima clima)
{
if (ModelState.IsValid)
{
//guarda la imagen en wwwroot/image
string wwwRootPath = _hostEnvironment.WebRootPath;
string fileName = Path.GetFileNameWithoutExtension(clima.ImageFile.FileName);
string extension = Path.GetExtension(clima.ImageFile.FileName);
//guarda el nombre de la imagen (ImageName)
clima.ImageName = fileName = fileName + DateTime.Now.ToString("yymmssfff") + extension;
string path = Path.Combine(wwwRootPath + "/img/climas", fileName);
using (var fileStream = new FileStream(path, FileMode.Create))
{
await clima.ImageFile.CopyToAsync(fileStream);
}
_context.Add(clima);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(clima));
}
public async Task <IActionResult> Get(string cidade)
{
var climaDoBanco = repositorio.BuscarClima(cidade);
if (climaDoBanco is null)
{
var climaService = new ClimaServico();
var temperatura = climaService.BuscarTemperatura(cidade);
var clima = new Clima
{
Atual = 22, //(int)temperatura.Main.Temp,
Minimo = 20, //(int)temperatura.Main.Temp_min,
Maximo = 28, //(int)temperatura.Main.Temp_max
Horario = DateTime.Now,
Cidade = cidade
};
repositorio.Adicionar(clima);
if (await repositorio.Salvar())
{
return(Ok(clima));
}
}
return(Ok(climaDoBanco));
}
public async Task <IActionResult> Edit(int id, [Bind("IdClima,NombreClima,CaracteristicasClima,ImageName")] Clima clima)
{
if (id != clima.IdClima)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(clima);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClimaExists(clima.IdClima))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(clima));
}
private int GuardarClima(Clima clima)
{
StringBuilder sb = new StringBuilder();
sb.Append(" SELECT * FROM dbo.Clima ");
if (clima.Id > 0)
{
sb.Append(" WHERE id = " + clima.Id);
}
using (IDbConnection conn = Connection.GetConnection(_config.ConnectionString))
{
if (!conn.State.Equals(ConnectionState.Open))
{
conn.Open();
}
var result = conn.QueryFirstOrDefault <Clima>(sb.ToString());
if (result == null) //El clima no existe en la base de datos
{
sb.Clear();
sb.Append(" INSERT INTO dbo.Clima (id, descripcion) ");
sb.Append(" VALUES (@id, @descripcion) ");
var rowsAffected = conn.Execute(sb.ToString(), new { id = clima.Id, descripcion = clima.Descripcion });
return(rowsAffected);
}
}
return(0);
}
public Clima GetClima(Sucursal sucursal)
{
Clima clima = new Clima();
try
{
ServiceHelper <WeatherRequest> serviceHelper = new ServiceHelper <WeatherRequest>();
var result = serviceHelper.MakeRequest(string.Format("{0}/weather?q={1}&appid={2}", END_POINT_WEATHHER, sucursal.Region.Descripcion, APPID),
null,
"GET"
);
if (result != null)
{
clima.Descripcion = result.weather[0].description;
clima.Id = result.weather[0].id;
clima.Main = result.weather[0].main;
}
}
catch (Exception e)
{
clima.Id = 9999;
clima.Main = "No se puede obtener informacion";
clima.Descripcion = "No se puede obtener informacion";
}
return(clima);
}
public void mdtUpsClima(ref string mensaje, Clima objClima)
{
// Se pasa la condicion a la consulta del procedimiento almacenado
try
{
List <SqlParameter> parametros = new List <SqlParameter>()
{
new SqlParameter()
{
ParameterName = "@grados", SqlDbType = SqlDbType.VarChar, Value = objClima.grados
},
new SqlParameter()
{
ParameterName = "@IdCiudad", SqlDbType = SqlDbType.Int, Value = objClima.IdCiudad
},
new SqlParameter()
{
ParameterName = "@IdEstado", SqlDbType = SqlDbType.Int, Value = objClima.IdEstado
},
new SqlParameter()
{
ParameterName = "@IdClima", SqlDbType = SqlDbType.Int, Value = objClima.IdClima
}
};
cDataBase.ejecutarSPParametros("[clima].[UpsClima]", parametros);
}
catch (Exception ex)
{
mensaje = "Error en la consulta: " + ex.Message;
}
}
public async Task <IActionResult> PutClima(int id, Clima clima)
{
if (id != clima.Id)
{
return(BadRequest());
}
_context.Entry(clima).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClimaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//Se usa para calcular los dias de tomenta usando la formula de perimetro maximo presentada en el enunciado
public void CalcularTormentas()
{
Clima pronosticoMaximoPerimetro = Pronostico.OrderByDescending(x => x.getTriangulo().getPerimetro()).FirstOrDefault();
double perimetroMaximo = pronosticoMaximoPerimetro.getTriangulo().getPerimetro();
Pronostico.Where(x => x.getTriangulo().getPerimetro() == perimetroMaximo).ToList().ForEach(x => x.setEstado("Tormenta"));
}
public async Task <ActionResult <Clima> > PostClima(Clima clima)
{
_context.Clima.Add(clima);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetClima", new { id = clima.Id }, clima));
}
private int GuardarSucursalClima(Clima clima, Sucursal sucursal)
{
try
{
StringBuilder sb = new StringBuilder();
GuardarClima(clima);
sb.Append(" INSERT INTO dbo.Sucursal_Clima (id_sucursal, id_clima, fecha) ");
sb.Append(" VALUES (@idSucursal, @idClima, @fecha) ");
using (IDbConnection conn = Connection.GetConnection(_config.ConnectionString))
{
if (!conn.State.Equals(ConnectionState.Open))
{
conn.Open();
}
var rowsAffected = conn.Execute(sb.ToString(), new { idSucursal = sucursal.Id, idClima = clima.Id, fecha = DateTime.Now.ToString() });
return(rowsAffected);
}
}
catch (Exception ex)
{
throw ex;
}
}
public static Clima BuscarClima(int idCidade)
{
try
{
StringBuilder urlApi = new StringBuilder();
string response = string.Empty;
urlApi.Append("http://api.openweathermap.org/data/2.5/weather?id=");
urlApi.AppendFormat("{0}", idCidade);
urlApi.Append("&appid=2bac87e0cb16557bff7d4ebcbaa89d2f&lang=pt&units=metric");
HttpWebRequest request = WebRequest.Create(urlApi.ToString()) as HttpWebRequest;
using (HttpWebResponse httpWebResponse = request.GetResponse() as HttpWebResponse)
{
StreamReader reader = new StreamReader(httpWebResponse.GetResponseStream());
response = reader.ReadToEnd();
}
Clima responseDeserializado = JsonConvert.DeserializeObject <Clima>(response);
return(responseDeserializado);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <Clima> ObterTemperaturaPorLocalizacao(decimal latitude, decimal longitude)
{
var _client = new RestClient(_openWeatherConfig.Url);
var _request = new RestRequest(Method.GET);
var clima = new Clima();
_request.Resource = $"/data/2.5/weather";
_request.AddParameter("lat", latitude);
_request.AddParameter("lon", longitude);
_request.AddParameter("appid", _openWeatherConfig.AppId);
_request.AddParameter("units", "metric");
try
{
var response = await _client.ExecuteAsync(_request);
if (response.IsSuccessful)
{
clima = JsonConvert.DeserializeObject <Clima>(response.Content);
}
else
{
clima.Erro = JsonConvert.DeserializeObject <Erro>(response.Content);
}
}
catch (Exception ex)
{
}
return(clima);
}
public static async Task <Clima> ConsultarClima(string ciudad)
{
var conexion = $"http://api.openweathermap.org/data/2.5/weather?q={ciudad}&appid={Key}";
using (var cliente = new HttpClient())
{
var peticion = await cliente.GetAsync(conexion);
if (peticion != null)
{
var json = peticion.Content.ReadAsStringAsync().Result;
var datos = (JContainer)JsonConvert.DeserializeObject(json);
if (datos["weather"] != null)
{
var clima = new Clima();
clima.Titulo = (string)datos["name"];
clima.Temperatura = ((float)datos["main"]["temp"] - 273.15).ToString("N2") + " °C";
clima.Viento = (string)datos["wind"]["speed"] + " mph";
clima.Humedad = (string)datos["main"]["humidity"] + " %";
clima.Visibilidad = (string)datos["weather"][0]["main"];
var fechaBase = new DateTime(1970, 1, 1, 0, 0, 0, 0);
var amanecer = fechaBase.AddSeconds((double)datos["sys"]["sunrise"]);
var ocaso = fechaBase.AddSeconds((double)datos["sys"]["sunset"]);
clima.Amanecer = amanecer.ToString() + " UTC";
clima.Ocaso = ocaso.ToString() + " UTC";
return(clima);
}
}
}
return(default(Clima));
}
public static async Task <Clima> ConsultarClima(string ciudad)
{
var conexion = $"http://api.openweathermap.org/data/2.5/weather?q={ciudad}&appid={Key}";
using (var cliente = new HttpClient())
{
var peticion = await cliente.GetAsync(conexion);
if (peticion != null)
{
var json = peticion.Content.ReadAsString.Async().Result;
var datos = (JContainer)JsonConvert.DeserializeObject(json);
if (datos["weather"] != null)
{
var clima = new Clima();
clima.Titulo = (string)datos["name"];
clima.Temperatura = ((float)datos["main"]["temp"] - 273.15).ToString("N2") + "C°";
clima.Viento = (string)datos["wind"]["speed"] + "mph";
clima.Humedad = (string)datos["main"]["humidity"] + "%";
clima.Visibilidad = (string)datos["weather"][0]["main"];
return(clima);
}
}
}
return(default(Clima));
}
static void Main(string[] args)
{
RepositorioCultivo Datos = new RepositorioCultivo();
List <Seccion> Secciones = Datos.Secciones;
ProximoTornado objTornado = new ProximoTornado();
Clima objClima = new Clima();
objTornado.ejecutarDomo(90, false, Datos, Secciones);
Seccion enDomo = Secciones.FirstOrDefault(s => s.enDomo = true) as Seccion;
DisplayCultivos objDisplay = new DisplayCultivos();
objDisplay.displayColor("Frutales", "Rojo", Datos, Secciones);
objDisplay.tiempoMaduracionOrdenado("Cereales", Datos, Secciones);
objDisplay.maxMantenimiento("Ornamentales", Datos, Secciones);
objClima.MonitorearClima(); //Desea monitorear el clima?
//Seccion frutales = Secciones.First(s=> s.Tipo =="Frutales") as Seccion ;
//List<String> frutos = frutales.Cultivos.Select(c => c.Fruto).ToList();
//Cultivo FrutoAmarillo = frutales.Cultivos.Last( c => c.Color == "Amarillo"); //Ultimo frutales Amarillo
//Seccion Hortalizas = Secciones.FirstOrDefault(s=> s.Tipo =="Hortalizas") as Seccion ;
//List<Cultivo> HortalizasNaranjas = Hortalizas.Cultivos.Where(c=> c.Color == "Naranja").ToList<Cultivo>();
}
public void Seleccion(RepositorioCultivo Datos, List <Seccion> Secciones)
{
MenuUsuario objUsu = new MenuUsuario();
ProximoTornado objTornado = new ProximoTornado();
Clima objClima = new Clima();
TemperaturaAmbiente objTemperatura = new TemperaturaAmbiente();
TareasRobot objRobot = new TareasRobot();
DisplayCultivos objDisplay = new DisplayCultivos();
int choice;
do
{
choice = objUsu.MenuPrincipal();
switch (choice)
{
case 1:
Console.WriteLine("Nombre de la seccion que desea buscar");
string seccionDeseada = Console.ReadLine();
Console.WriteLine("Color a buscar");
string colorDeseado = Console.ReadLine();
objDisplay.displayColor(seccionDeseada, colorDeseado, Datos, Secciones);
break;
case 2:
Console.WriteLine("Nombre de la seccion que desea buscar");
string seccionDeseada1 = Console.ReadLine();
objDisplay.tiempoMaduracionOrdenado(seccionDeseada1, Datos, Secciones);
Console.WriteLine();
break;
case 3:
Console.WriteLine("Nombre de la seccion que desea buscar");
string seccionDeseada2 = Console.ReadLine();
objDisplay.maxMantenimiento(seccionDeseada2, Datos, Secciones);
Console.WriteLine();
break;
case 4:
objClima.MonitorearClima();
Console.WriteLine();
break;
case 5:
objTemperatura.MonitorearTemperatura();
Console.WriteLine();
break;
case 6:
objTornado.ejecutarRobotEmergencia(Datos, Secciones);
Console.WriteLine();
break;
case 7:
objTornado.ejecutarSacarDomo(Datos, Secciones);
break;
}
}while(choice != -1);
}
public Clima Get(int id)
{
using (UOWClimaSistemaSolar unitOfWork = new UOWClimaSistemaSolar())
{
Clima oClima = unitOfWork.ClimaRepository.Retrieve(id);
return(oClima);
}
}
public static void Salvar(this Clima clima)
{
var client = new AmazonDynamoDBClient();
var context = new DynamoDBContext(client);
var x = context.SaveAsync(clima);
x.Wait();
}
public DetalheCidadeViewModel(Clima clima)
{
IdCidade = clima.id;
NomeCidade = clima.name;
Temperatura = string.Concat(clima.main.temp.ToString("F0"), " °C");
DescricaoTempo = clima.weather.FirstOrDefault().description;
TemperaturaMinima = string.Concat(clima.main.temp_min.ToString("F0"), " °C");;
TemperaturaMaxima = string.Concat(clima.main.temp_max.ToString("F0"), " °C");;
}
public async Task <IActionResult> Create([Bind("IdClima,NombreClima")] Clima clima)
{
if (ModelState.IsValid)
{
_context.Add(clima);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(clima));
}
public IActionResult GetClima(float latitud, float longitud)
{
try
{
Clima clima = WeatherHelper.GetClima(latitud, longitud);
return(Ok(clima));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public IActionResult GetClima(string nombreRegion)
{
try
{
Clima clima = WeatherHelper.GetClima(nombreRegion);
return(Ok(clima));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public static DataTable DownloadClima()
{
string urlClima = @"http://api.openweathermap.org/data/2.5/forecast/daily?q=49095780&mode=json&units=metric&cnt=16";
var syncClient = new WebClient();
var content = syncClient.DownloadString(urlClima);
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(WeatherData));
using (var ms = new MemoryStream(Encoding.Unicode.GetBytes(content)))
{
var weatherData = (WeatherData)serializer.ReadObject(ms);
Clima objClima = new Clima();
foreach (var item in weatherData.list)
{
objClima.dt = item.dt.ToString();
objClima.temp_dia = Convert.ToDecimal(item.temp.day.ToString());
objClima.temp_tarde = Convert.ToDecimal(item.temp.eve.ToString());
objClima.temp_noite = Convert.ToDecimal(item.temp.night.ToString());
int data = Convert.ToInt32(item.dt.ToString());
var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
objClima.data = epoch.AddSeconds((int)data);
objClima.velocidade_vento = Convert.ToDecimal(item.speed.ToString());
objClima.nuvens = Convert.ToInt32(item.clouds.ToString());
if (!string.IsNullOrEmpty(item.rain.ToString()))
{
objClima.chuva = (int)(Math.Round(Convert.ToDecimal(item.rain.ToString()), MidpointRounding.ToEven));
}
else
{
objClima.chuva = 0;
}
foreach (var desc in item.weather)
{
objClima.nuvens_descricao = desc.main.ToString();
objClima.descricao = desc.description.ToString();
objClima.icone = desc.icon.ToString();
WebFilmesAD.ClimaAD.InserirClima(objClima);
}
}
}
return(ObterClima());
}
public static Int32 InserirClima(Clima objClima)
{
DBUtil bd = new DBUtil();
String sql = @"
delete dbo.Clima where dt = @dt;
INSERT INTO dbo.Clima
(dt
,data
,temp_dia
,temp_tarde
,temp_noite
,nuvens_descricao
,descricao
,icone
,velocidade_vento
,nuvens
,chuva)
VALUES
(@dt
,@data
,@temp_dia
,@temp_tarde
,@temp_noite
,@nuvens_descricao
,@descricao
,@icone
,@velocidade_vento
,@nuvens
,@chuva)
";
bd.AdicionarParametro("@dt", System.Data.DbType.AnsiString, objClima.dt);
bd.AdicionarParametro("@data", System.Data.DbType.DateTime, objClima.data);
bd.AdicionarParametro("@temp_dia", System.Data.DbType.Decimal, objClima.temp_dia);
bd.AdicionarParametro("@temp_tarde", System.Data.DbType.Decimal, objClima.temp_tarde);
bd.AdicionarParametro("@temp_noite", System.Data.DbType.Decimal, objClima.temp_noite);
bd.AdicionarParametro("@nuvens_descricao", System.Data.DbType.AnsiString, objClima.nuvens_descricao);
bd.AdicionarParametro("@descricao", System.Data.DbType.AnsiString, objClima.descricao);
bd.AdicionarParametro("@icone", System.Data.DbType.AnsiString, objClima.icone);
bd.AdicionarParametro("@velocidade_vento", System.Data.DbType.Decimal, objClima.velocidade_vento);
bd.AdicionarParametro("@nuvens", System.Data.DbType.Int32, objClima.nuvens);
bd.AdicionarParametro("@chuva", System.Data.DbType.Int32, objClima.chuva);
//return bd.Inserir<SqlConnection>(sql);
return(bd.Gravar(sql));
}
public static Clima ToModelClima(this JsonElement climaJson)
{
var clima = new Clima();
clima.Cidade = climaJson.GetProperty("name").ToString();
clima.DataColeta = climaJson.GetProperty("dt").GetInt64().ToDateTime();
clima.Temperatura = climaJson.GetProperty("main").GetProperty("temp").GetDecimal();
clima.Pressao = climaJson.GetProperty("main").GetProperty("pressure").GetInt32();
clima.Umidade = climaJson.GetProperty("main").GetProperty("humidity").GetInt32();
clima.Visibilidade = climaJson.GetProperty("visibility").GetInt32();
clima.VelocidadeVento = climaJson.GetProperty("wind").GetProperty("speed").GetDecimal();
clima.DirecaoVento = climaJson.GetProperty("wind").GetProperty("deg").GetDecimal();
clima.NascerDoSol = climaJson.GetProperty("sys").GetProperty("sunrise").GetInt64().ToDateTime();
clima.PorDoSol = climaJson.GetProperty("sys").GetProperty("sunset").GetInt64().ToDateTime();
//var dt = climaJson.GetProperty("dt").GetInt64().ToDateTime();
//Console.WriteLine($"data tostring {dt.ToString()} local {dt.ToLocalTime().ToString()} utc {dt.ToUniversalTime().ToString()}");
return(clima);
}
public static void Arrays()
{
Notas = new int[6];
Notas[0] = 1245;
// Notas[-1] = 123;//esto falla
Notas[6] = 123; // esto tambien falla.
// Arreglo de una dimension
Frutas[] HolaFrutas = new Frutas[10];
DateTime[] tiempos = new DateTime[100];
Notas = new int[8];
// Arreglo Multidimensional
Clima[,,,,] matriz = new Clima[6, 4, 2, 2, 5];
// Jagged Array
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[5];
jaggedArray[0][1] = 2;
jaggedArray[1] = new int[10];
jaggedArray[1][1] = 30000;
}
public List <Sucursal> GetSucursal(int idSucursal)
{
StringBuilder sb = new StringBuilder();
List <Sucursal> list = new List <Sucursal>();
sb.Append(" SELECT s.id, s.descripcion, r.id, r.descripcion, s.latitud, s.longitud ");
sb.Append(" FROM dbo.Sucursal s INNER JOIN dbo.Region r ON r.id = s.id_region ");
if (idSucursal > 0)
{
sb.Append(" WHERE s.id = " + idSucursal);
}
using (IDbConnection conn = Connection.GetConnection(_config.ConnectionString))
{
conn.Open();
list = conn.Query <Sucursal, Region, Sucursal>(sb.ToString(), (sucursal, region) =>
{
sucursal.Region = region;
return(sucursal);
}).AsList();
foreach (var item in list)
{
if (item.Coordenadas.Empty())
{
Clima clima = GetClima(item);
item.Climas = new List <Clima>();
item.Climas.Add(clima);
GuardarSucursalClima(clima, item);
}
else
{
Clima clima = GetClima(item.Coordenadas);
item.Climas.AsList().Add(clima);
GuardarSucursalClima(clima, item);
}
}
}
return(list);
}
public async void getWeather()
{
HttpResponseMessage msj = await client.GetAsync(new Uri(URL));
String XML = msj.ToString();
XDocument doc = XDocument.Parse(XML);
XElement results = doc.Root.Element("results");
XElement chanel = results.Element("channel");
XElement atmosphere = chanel.Element("yweather:atmosphere");
XElement item = chanel.Element("item");
String temperatura = item.Element("yweather:condition").Attribute("temp").Value;
String pronostico = item.Element("yweather:condition").Attribute("text").Value;
String humedad = atmosphere.Attribute("humidity").Value;
String presion = atmosphere.Attribute("pressure").Value;
Clima clima = new Clima()
{
Presion = presion, Humedad = humedad, Pronostico = pronostico, Temperatura = temperatura
};
w.putWeather(clima);
}
/// <summary>
/// Metodo para Eliminar el clima
/// </summary>
/// <param name="strErrMsg">Mensaje de error</param>
/// <returns>Retorna si el proceso fue exitoso o no</returns>
public bool mdtDelClima(ref string mensaje, Clima objClima)
{
bool booResult = false;
clsDTOclima dbClima = new clsDTOclima();
try
{
dbClima.mdtDelClima(ref mensaje, objClima);
if (mensaje != string.Empty)
{
booResult = false;
}
else
{
booResult = true;
mensaje = "Exito! registro eliminado satisfactoriamente";
}
}
catch (Exception ex)
{
mensaje = "Error en la eliminacion: " + ex.Message;
}
return(booResult);
}
public IHttpActionResult GetFiveDays()
{
using (WebClient wc = new WebClient())
{
/*Guardo en la variable json el JSON que me devuelve la URL de accuweather*/
var json = wc.DownloadString("http://dataservice.accuweather.com/forecasts/v1/daily/5day/7894?4eq974m8yEZNwRONLMCGs9Kzx9MkUOwV&apikey=4eq974m8yEZNwRONLMCGs9Kzx9MkUOwV&language=es-ar&details=false&metric=true");
/*Dias tiene la informacion de 5 dias con sus respectivas mediciones deserealizado*/
dias = JsonConvert.DeserializeObject <RootObject>(json).DailyForecasts;
}
List <Clima> climas = new List <Clima>();
/* Creo un foreach que me devuelve la informacion necesaria del clima para cada dia
* fecha, temperaturas y el icono (que está asociado a un estado del tiempo)
* */
foreach (var dia in dias)
{
Clima nuevoClima = new Clima(dia.Date, dia.Temperature.Minimum.Value,
dia.Day.Icon,
dia.Night.Icon);
climas.Add(nuevoClima);
continue;
}
return(Ok(climas));
}
