public async Task <IActionResult> Create([Required] string NombreCultivos, string IntroduccionCultivos,
string CuerpoCultivos, string RecomendacionesCultivos, int IdTipoCultivo, int IdRegiones)
{
if (ModelState.IsValid)
{
//var user = await _context.GetUserAsync(User);
var region = new Cultivo();
{
//region.UserId = await _context.GetUserIdAsync(user);
//region.UserId = await _context.GetUserIdAsync(user);
region.NombreCultivos = NombreCultivos;
region.IntroduccionCultivos = IntroduccionCultivos;
region.CuerpoCultivos = CuerpoCultivos;
region.RecomendacionesCultivos = RecomendacionesCultivos;
region.IdTipoCultivo = IdTipoCultivo;
region.IdRegiones = IdRegiones;
}
if (region != null)
{
_context.Add(region);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Costa)));
}
}
return(View());
}
private void Button_Clicked(object sender, EventArgs e)
{
Cultivo cultivo = new Cultivo();
cultivo.id_cultivo = "0";
Navigation.PushAsync(new RegistrarCultivo(asociado, cultivo));
}
// select id
public Cultivo Select(int id)
{
Cultivo obj = null;
System.Data.IDbConnection objConexao;
System.Data.IDbCommand objCommand;
System.Data.IDataReader objDataReader;
objConexao = Mapped.Connection();
objCommand = Mapped.Command("SELECT * FROM cul_cultivo WHERE cul_id = ?cul_id", objConexao);
objCommand.Parameters.Add(Mapped.Parameter("?cul_id", id));
objDataReader = objCommand.ExecuteReader();
while (objDataReader.Read())
{
obj = new Cultivo();
obj.Nome = Convert.ToString(objDataReader["cul_nome"]);
obj.Tipo.Id = Convert.ToInt32(objDataReader["tic_id"]);
}
objDataReader.Close();
objConexao.Close();
objCommand.Dispose();
objConexao.Dispose();
objDataReader.Dispose();
return(obj);
}
public async Task <ApiResponse> update(string token, string id_cultivo, string id_asociado, string nombre, string id_niame, DateTime fecha_inicio_siembra, DateTime fecha_fin_siembra, float hectareas_sembradas, float kg_espera_cosechar, float costo_total_siembra, Boolean estado)
{
Cultivo cultivo = new Cultivo()
{
id_cultivo = id_cultivo,
id_asociado = id_asociado,
nombre = nombre,
niameIdNiame = id_niame,
fecha_inicio_siembra = fecha_inicio_siembra,
fecha_fin_siembra = fecha_fin_siembra,
hectareas_sembradas = hectareas_sembradas,
kg_espera_cosechar = kg_espera_cosechar,
costo_total_siembra = costo_total_siembra,
estado = estado
};
HttpClient client = await get();
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
var response = await client.PutAsync(url + "/UpdateSiembra/" + cultivo.id_cultivo, new StringContent(JsonConvert.SerializeObject(cultivo), Encoding.UTF8, "application/json"));
ApiResponse apiResponse = new ApiResponse();
apiResponse.code = response.StatusCode.ToString();
apiResponse.message = await response.Content.ReadAsStringAsync();
return(apiResponse);
}
public void sembrar_Cultivo(Cultivo cultivo)
{
bool disponible = false;
foreach (Robots temp in granjaSeleccionada.getRobots())
{
if (temp.Estado == true)
{
if (cultivo.Estado == false)
{
temp.Cant_Semillas = 0;
temp.Estado = false;
disponible = true;
break;
}
else
{
Console.WriteLine("El cultivo ", cultivo.Tipo, " tiene semillas.");
disponible = true;
break;
}
}
}
if (disponible == false)
{
Console.WriteLine("No hay robots libres.");
}
}
public async Task <IActionResult> Edit(int id, [Bind("IdCultivo,IdTipoCultivos,IdRegiones,NombreCultivos,IntroduccionCultivos,CuerpoCultivos,Recomendaciones")] Cultivo cultivo)
{
if (id != cultivo.IdCultivo)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(cultivo);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CultivoExists(cultivo.IdCultivo))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(cultivo));
}
protected void btnCadastrar_Click(object sender, EventArgs e)
{
string mensagem;
Cultivo cul = new Cultivo();
cul.Nome = txtNome.Text;
TipoCultivo tip = new TipoCultivo();
tip.Id = Convert.ToInt32(ddlTipo.SelectedValue);
cul.Tipo = tip;
if (CultivoDB.Insert(cul))
{
mensagem = "Cadastrado com sucesso!";
txtNome.Text = "";
txtNome.Focus();
}
else
{
mensagem = "Erro!";
}
Response.Write("<script language='javascript'>alert('" + mensagem + "');</script>");
}
public Task <RegistrarCultivoResponse> Handle(RegistrarCultivoRequest request, CancellationToken cancellationToken)
{
var cultivo = new Cultivo(request.Nombre, request.FechaSiembra);
_palmAppUnitOfWork.CultivoRepository.Add(cultivo);
_palmAppUnitOfWork.Commit();
return(Task.FromResult(new RegistrarCultivoResponse(cultivo.Id)));
}
public Cultivo(Cultivo otroCultivo)
{
semilla = otroCultivo.semilla;
tiempoCrecer = otroCultivo.tiempoCrecer;
litrosPorMinuto = otroCultivo.litrosPorMinuto;
sprite = otroCultivo.sprite;
cultivoPrefab = otroCultivo.cultivoPrefab;
}
private Cultivo Mapear(CultivoInputModel cultivoInput)
{
var cultivo = new Cultivo
{
CultivoId = cultivoInput.CultivoId,
Nombre = cultivoInput.Nombre
};
return(cultivo);
}
public async Task <IActionResult> Create([Bind("IdCultivo,IdTipoCultivos,IdRegiones,NombreCultivos,IntroduccionCultivos,CuerpoCultivos,Recomendaciones")] Cultivo cultivo)
{
if (ModelState.IsValid)
{
_context.Add(cultivo);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(cultivo));
}
public ActionResult <CultivoViewModel> put(CultivoInputModel cultivoInput)
{
Cultivo cultivo = Mapear(cultivoInput);
var response = _cultivoService.Modificar(cultivo.CultivoId, cultivo);
if (response.Error)
{
return(BadRequest(response.Mensaje));
}
return(Ok(response.cultivo));
}
/// <summary>
/// Initializes a new instance of the <see cref="UnidadCultivoDatosHidricos"/> class.
/// </summary>
/// <param name="idUnidadCultivo">The IdUnidadCultivo<see cref="string"/>.</param>
/// <param name="fecha">The idTemporada<see cref="string"/>.</param>
public UnidadCultivoDatosHidricos(string idUnidadCultivo, DateTime fecha)
{
string idTemporada = DB.TemporadaDeFecha(idUnidadCultivo, fecha);
if ((temporada = DB.Temporada(idTemporada)) == null)
{
throw new Exception($"Imposible cargar datos de la temporada {idTemporada}.");
}
if ((unidadCultivo = DB.UnidadCultivo(idUnidadCultivo)) == null)
{
throw new Exception($"Imposible cargar datos del cultivo {idUnidadCultivo}.");
}
pUnidadCultivoExtensionM2 = DB.UnidadCultivoExtensionM2(idUnidadCultivo, idTemporada);
if ((UnidadCultivoCultivoEtapasList = DB.UnidadCultivoCultivoEtapasList(idUnidadCultivo, idTemporada)).Count == 0)
{
throw new Exception($"Imposible cargar las etapas para la unidad de cultivo {idUnidadCultivo}.");
}
if ((unidadCultivoCultivo = DB.UnidadCultivoCultivo(idUnidadCultivo, idTemporada)) == null)
{
throw new Exception("Imposible datos del cultivo en la temporada indicada.");
}
lTiposEstres = DB.ListaTipoEstres();
lTipoEstresUmbralList = DB.ListaEstresUmbral();
if ((lDatosClimaticos = DB.DatosClimaticosList(FechaSiembra(), FechaFinalDeEstudio(), unidadCultivo.IdEstacion)) == null)
{
throw new Exception($"Imposible cargar datos climáticos para la estación {unidadCultivo.IdEstacion} en el intervalo de fechas de {FechaSiembra()} a {FechaFinalDeEstudio()}");
}
cultivo = DB.Cultivo(unidadCultivoCultivo.IdCultivo);
estacion = DB.Estacion(unidadCultivo.IdEstacion);
regante = (Regante)DB.Regante(unidadCultivoCultivo.IdRegante);
if ((ListaUcSuelo = DB.UnidadCultivoSueloList(idTemporada, idUnidadCultivo)) == null)
{
throw new Exception("No se ha definido suelo para la unidad de Cultivo:" + idUnidadCultivo);
}
riegoTipo = DB.RiegoTipo(unidadCultivoCultivo.IdTipoRiego);
DateTime fechaSiembra = FechaSiembra();
DateTime fechaFinal = FechaFinalDeEstudio();;
lDatosRiego = DB.RiegosList(idUnidadCultivo, fechaSiembra, fechaFinal);
lUnidadCultivoDatosExtas = DB.ParcelasDatosExtrasList(idUnidadCultivo, fechaSiembra, fechaFinal);
}
public GestionarCosecha(LoginResponseDto aso, Cultivo culti)
{
InitializeComponent();
asociado = aso;
cultivo = culti;
llenaLista();
cosecha_lv.RefreshCommand = new Command(() =>
{
llenaLista();
cosecha_lv.IsRefreshing = false;
});
}
public bool analizarCultivo(Cultivo c)
{
int temp;
temp = c.GetTemperatura();
if (temp > 25)
{
return(true);
}
else
{
return(false);
}
}
public ListaDiasControl(LoginResponseDto aso, Cultivo culti)
{
InitializeComponent();
asociado = aso;
cultivo = culti;
llenaLista();
diaControl_lv.RefreshCommand = new Command(() =>
{
llenaLista();
diaControl_lv.IsRefreshing = false;
});
}
public void regarCultivos(Cultivo c, bool flag)
{
int temp;
temp = c.GetTemperatura();
if (flag == true)
{
c.SetTemperatura(temp - 2);
Console.WriteLine("Cultivo regado exitosamente.");
}
else
{
Console.WriteLine("No es necesario regar el cultivo.\ntemperatura actual de: " + temp);
}
}
public GuardarCultivoResponse Guardar(Cultivo cultivo)
{
try{
/*var cultivoBuscado = _context.Cultivos.Find(cultivo.NumeroCedula);
* if(cultivoBuscado != null){
* return new GuardarCultivoResponse("Error el cultivo ya se encuentra registrado");
* }*/
_context.Cultivos.Add(cultivo);
_context.SaveChanges();
return(new GuardarCultivoResponse(cultivo));
}catch (Exception e) {
return(new GuardarCultivoResponse($"Error de la aplicacion: {e.Message}"));
}
}
public GuardarCultivoResponse Modificar(int id, Cultivo cultivo)
{
try{
var cultivoBuscado = _context.Cultivos.Find(id);
if (cultivoBuscado == null)
{
return(new GuardarCultivoResponse("Error el cultivo no se encuentra registrado"));
}
cultivoBuscado.Nombre = cultivo.Nombre;
_context.Cultivos.Update(cultivoBuscado);
_context.SaveChanges();
return(new GuardarCultivoResponse(cultivo));
}catch (Exception e) {
return(new GuardarCultivoResponse($"Error de la aplicacion: {e.Message}"));
}
}
public RegistrarCultivo(LoginResponseDto aso, Cultivo cultivo)
{
InitializeComponent();
asociado = aso;
cultivo1 = cultivo;
llenaLista();
if (cultivo.id_cultivo != "0")
{
llenarDatosCultivo();
}
else
{
btnRegistrar.IsVisible = false;
btnCosechar.IsVisible = false;
}
}
static void Main(string[] args)
{
RepositorioCultivo Datos = new RepositorioCultivo();
List <Seccion> Secciones = Datos.Secciones;
ProximoTornado objTornado = new ProximoTornado();
objTornado.ejecutarDomo(90, false, Datos, Secciones);
Seccion enDomo = Secciones.FirstOrDefault(s => s.enDomo = true) as Seccion;
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>();
}
// insert
public static bool Insert(Cultivo cultivo)
{
System.Data.IDbConnection objConexao;
System.Data.IDbCommand objCommand;
try
{
string sql = "INSERT INTO cul_cultivo(cul_nome, tic_id) VALUES(?cul_nome, ?tic_id)";
objConexao = Mapped.Connection();
objCommand = Mapped.Command(sql, objConexao);
objCommand.Parameters.Add(Mapped.Parameter("?cul_nome", cultivo.Nome));
objCommand.Parameters.Add(Mapped.Parameter("?tic_id", cultivo.Tipo.Id));
objCommand.ExecuteNonQuery();
objConexao.Close();
objCommand.Dispose();
objConexao.Dispose();
return(true);
}
catch (Exception e)
{
return(false);
}
}
public void Cultivar(RECURSOS recurso)
{
int value = -1;
Agricultura agri = manager.GetComponent <Agricultura>();
for (int i = 0; i < agri.semillas.Length; i++)
{
if (agri.semillas[i].semilla == recurso)
{
value = i;
break;
}
}
if (value == -1)
{
return;
}
cultivo = new Cultivo(agri.semillas[value]);
renderCultivo.sortingOrder = manager.SetSortingLayer(transform.position.y) + 1;
renderCultivo.sprite = cultivo.sprite[0];
}
// update
public bool Update(Cultivo cultivo)
{
System.Data.IDbConnection objConexao;
System.Data.IDbCommand objCommand;
string sql = "UPDATE cul_cultivo SET cul_nome = ?cul_nome, tic_id = ?tic_id WHERE cul_id = ?cul_id";
try
{
objConexao = Mapped.Connection();
objCommand = Mapped.Command(sql, objConexao);
objCommand.Parameters.Add(Mapped.Parameter("?cul_nome", cultivo.Nome));
objCommand.Parameters.Add(Mapped.Parameter("?cul_id", cultivo.Id));
objCommand.Parameters.Add(Mapped.Parameter("?tic_id", cultivo.Tipo.Id));
objCommand.ExecuteNonQuery();
objConexao.Close();
objCommand.Dispose();
objConexao.Dispose();
return(true);
}catch (Exception e)
{
return(false);
}
}
public void sembrarCultivos()
{
Cultivo a = new Cultivo();
Robot r = new Robot();
Console.WriteLine("==============================================");
Console.WriteLine("¿De que será su parcela?:");
Console.WriteLine("==============================================");
a.SetTipoCultivo(Console.ReadLine());
a.SetTemperatura(tempAct);
Random id = new Random();
int x;
x = id.Next(1000, 9999);
a.SetIdCultivo(Convert.ToString(x));
a.SetEstadoProtegido(false);
cultivos.Add(a);
r.SetIdRobot(Convert.ToString(x));
robots.Add(r);
Console.WriteLine("==============================================");
Console.WriteLine("Parcela creada exitosamente");
Console.WriteLine("==============================================");
}
public async Task <IActionResult> Create(Cultivo cultivo)
{
if (ModelState.IsValid)
{
string wwwRootPath = _hostEnvironment.WebRootPath;
string fileName = Path.GetFileNameWithoutExtension(cultivo.ImageFile.FileName);
string extension = Path.GetExtension(cultivo.ImageFile.FileName);
//guarda el nombre de la imagen (ImageName)
cultivo.ImageName = fileName = fileName + DateTime.Now.ToString("yymmssfff") + extension;
string path = Path.Combine(wwwRootPath + "/img/cultivo", fileName);
using (var fileStream = new FileStream(path, FileMode.Create))
{
await cultivo.ImageFile.CopyToAsync(fileStream);
}
_context.Add(cultivo);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(cultivo));
}
private QueimaControlada ObterHistorico(int id, BancoDeDados banco = null, string tid = null, bool simplificado = false)
{
QueimaControlada caracterizacao = new QueimaControlada();
int hst = 0;
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
#region Queima Controlada
Comando comando = bancoDeDados.CriarComando(@"select c.id, c.empreendimento_id, c.tid
from {0}hst_crt_queima_contr c where c.queima_controlada_id = :id and c.tid = :tid" , EsquemaBanco);
comando.AdicionarParametroEntrada("id", id, DbType.Int32);
comando.AdicionarParametroEntrada("tid", DbType.String, 36, tid);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
if (reader.Read())
{
hst = Convert.ToInt32(reader["id"]);
caracterizacao.Id = id;
caracterizacao.EmpreendimentoId = Convert.ToInt32(reader["empreendimento_id"]);
caracterizacao.Tid = reader["tid"].ToString();
}
reader.Close();
}
#endregion
if (caracterizacao.Id <= 0 || simplificado)
{
return(caracterizacao);
}
#region Queimas Controladas
comando = bancoDeDados.CriarComando(@"select c.id, c.queima_contr_queima_id, c.identificacao, c.area_croqui,
c.area_requerida, c.tid from {0}hst_crt_queima_contr_queima c where c.id_hst = :id" , EsquemaBanco);
comando.AdicionarParametroEntrada("id", hst, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
QueimaControladaQueima queima = null;
while (reader.Read())
{
hst = Convert.ToInt32(reader["id"]);
queima = new QueimaControladaQueima();
queima.Id = Convert.ToInt32(reader["queima_contr_queima_id"]);
queima.Tid = reader["tid"].ToString();
queima.Identificacao = reader["identificacao"].ToString();
queima.AreaCroqui = reader.GetValue <decimal>("area_croqui");
queima.AreaRequerida = reader["area_requerida"].ToString();
#region Cultivos
comando = bancoDeDados.CriarComando(@"select c.queima_tipo_cultivo_id, c.tipo_cultivo_id, c.tipo_cultivo_texto,
c.nome_finalidade, c.tid from {0}hst_crt_queima_contr_tipo_cult c
where c.id_hst = :id" , EsquemaBanco);
comando.AdicionarParametroEntrada("id", hst, DbType.Int32);
using (IDataReader readerAux = bancoDeDados.ExecutarReader(comando))
{
Cultivo cultivo = null;
while (readerAux.Read())
{
cultivo = new Cultivo();
cultivo.Id = Convert.ToInt32(readerAux["queima_tipo_cultivo_id"]);
cultivo.CultivoTipo = Convert.ToInt32(readerAux["tipo_cultivo_id"]);
cultivo.CultivoTipoTexto = readerAux["tipo_cultivo_texto"].ToString();
cultivo.Tid = readerAux["tid"].ToString();
if (readerAux["nome_finalidade"] != null && !Convert.IsDBNull(readerAux["nome_finalidade"]))
{
cultivo.FinalidadeNome = readerAux["nome_finalidade"].ToString();
}
queima.Cultivos.Add(cultivo);
}
readerAux.Close();
}
#endregion
caracterizacao.QueimasControladas.Add(queima);
}
reader.Close();
}
#endregion
}
return(caracterizacao);
}
private Aquicultura ObterHistorico(int id, BancoDeDados banco = null, string tid = null, bool simplificado = false)
{
Aquicultura caracterizacao = new Aquicultura();
int hst = 0;
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
Comando comando = bancoDeDados.CriarComando(@"select c.id, c.empreendimento, c.tid from {0}hst_crt_aquicultura c where c.caracterizacao = :id and c.tid = :tid", EsquemaBanco);
comando.AdicionarParametroEntrada("id", id, DbType.Int32);
comando.AdicionarParametroEntrada("tid", DbType.String, 36, tid);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
if (reader.Read())
{
hst = Convert.ToInt32(reader["id"]);
caracterizacao.Id = id;
caracterizacao.EmpreendimentoId = Convert.ToInt32(reader["empreendimento"]);
caracterizacao.Tid = reader["tid"].ToString();
}
reader.Close();
}
if (caracterizacao.Id <= 0 || simplificado)
{
return(caracterizacao);
}
#region Aquiculturas
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
comando = bancoDeDados.CriarComando(@"select c.aquicultura_id id, c.atividade_id, c.area_inundada, c.num_viveiros_escavados, c.num_unid_cultivo, c.area_cultivo, c.geometria_coord_atv_x, c.geometria_coord_atv_y,
c.geometria_id, c.geometria_tipo, c.tid from {0}hst_crt_aquicultura_aquic c where c.id_hst = :id_hst" , EsquemaBanco);
comando.AdicionarParametroEntrada("id_hst", hst, DbType.Int32);
AquiculturaAquicult aquicultura = null;
while (reader.Read())
{
aquicultura = new AquiculturaAquicult();
aquicultura.Id = Convert.ToInt32(reader["id"]);
aquicultura.Atividade = Convert.ToInt32(reader["atividade_id"]);
aquicultura.AreaInundadaTotal = reader["area_inundada"].ToString();
aquicultura.NumViveiros = reader["num_viveiros_escavados"].ToString();
aquicultura.NumUnidadeCultivos = reader["num_unid_cultivo"].ToString();
aquicultura.AreaCultivo = reader["area_cultivo"].ToString();
aquicultura.CoordenadaAtividade.Id = Convert.ToInt32(reader["geometria_id"]);
aquicultura.CoordenadaAtividade.Tipo = Convert.ToInt32(reader["geometria_tipo"]);
if (reader["geometria_coord_atv_x"] != null && !Convert.IsDBNull(reader["geometria_coord_atv_x"]))
{
aquicultura.CoordenadaAtividade.CoordX = Convert.ToDecimal(reader["geometria_coord_atv_x"]);
}
if (reader["geometria_coord_atv_y"] != null && !Convert.IsDBNull(reader["geometria_coord_atv_y"]))
{
aquicultura.CoordenadaAtividade.CoordY = Convert.ToDecimal(reader["geometria_coord_atv_y"]);
}
#region Cultivos
comando = bancoDeDados.CriarComando(@"select c.cultivo id, c.identificador, c.volume, c.unidade, c.quantidade, m.tid
from {0}hst_crt_aquicultura_cultivos c where c.id_hst = :id order by c.identificador" , EsquemaBanco);
comando.AdicionarParametroEntrada("id", hst, DbType.Int32);
Cultivo cultivo = null;
using (IDataReader readerAux = bancoDeDados.ExecutarReader(comando))
{
while (readerAux.Read())
{
cultivo = new Cultivo();
cultivo.Id = Convert.ToInt32(readerAux["id"]);
cultivo.Identificador = readerAux["identificador"].ToString();
cultivo.Volume = readerAux["volume"].ToString();
aquicultura.Cultivos.Add(cultivo);
}
readerAux.Close();
}
#endregion
caracterizacao.AquiculturasAquicult.Add(aquicultura);
}
reader.Close();
}
#endregion
}
return(caracterizacao);
}
public GuardarCultivoResponse(Cultivo cultivo1)
{
Error = false;
cultivo = cultivo1;
}
public CultivoViewModel(Cultivo cultivo)
{
CultivoId = cultivo.CultivoId;
Nombre = cultivo.Nombre;
}
