public List<Ambiente> ListaAmbientes()
{
try
{
List<Ambiente> lisb = bd.Ambiente.ToList();
//bd.compromisosxcuota.ToList();
List<Ambiente> lisbcrm = new List<Ambiente>();
if (lisb.Count.Equals(0))
{
return lisbcrm;
}
else
{
foreach (var item in lisb)
{
Ambiente entb = new Ambiente();
entb.Id = item.Id;
entb.Ambiente1 = item.Ambiente1;
lisbcrm.Add(entb);
}
return lisbcrm;
}
}
catch (Exception)
{
throw;
}
}
public MosquitoMacho(Ambiente amb, Celula posInicial)
: base(EstagioMosquito.Adulto, posInicial, amb)
{
rd = RandomExtensions.GetInstance();
ciclosEspera = 0;
acasalou = false;
}
public MosquitoFemea(Ambiente amb, Celula posInicial)
: base(EstagioMosquito.Adulto, posInicial, amb)
{
rd = RandomExtensions.GetInstance();
this.qtdAcasalamento = this.ciclosEspera = 0;
this.Acasalou = this.depositouOvos = false;
}
public Celula(int i, int j, int numero, Ambiente amb)
{
agentes = new List<Agente>();
this.i = i;
this.j = j;
this.numero = numero;
this.amb = amb;
}
//Construtores
public Pessoa(Ambiente amb, Celula posicaoInicial)
: base(amb, posicaoInicial)
{
rd = RandomExtensions.GetInstance();
historico = new Stack<TipoDengue>();
EstaContaminado = EstaDoente = false;
EstaVivo = true;
}
public void InicializarObjetosEnvolvidos()
{
this.AmbienteEnvolvido = new Ambiente();
this.AmbienteEnvolvido.Titulo = "Portal Administrativo (Homologação)";
this.AmbienteEnvolvido.Habilitado = Valor.Ativo;
this.AmbienteEnvolvido.Restrito = Valor.Ativo; // Acesso não autenticado.
AcessoController.Manter(this.AmbienteEnvolvido, "usuario.teste", null);
}
public AgenteDeSaude(Ambiente amb, Celula inicioCobertura, Celula fimCobertura)
: base(amb, inicioCobertura)
{
this.InicioCobertura = inicioCobertura;
this.FimCobertura = fimCobertura;
this.alvo = FimCobertura;
this.indoParaDireita = true;
this.EstaDetetizando = false;
this.ciclosLimpando = this.quantidadeDeCiclosNecessarias = 0;
}
public static Ambiente CrearEntidad(IDataReader lector)
{
var aux = new Ambiente();
aux.Id = lector.GetString(0);
aux.IdTipoAmbiente = lector.GetString(1);
aux.Descripcion = lector.GetString(2);
aux.Ubicacion = lector.GetString(3);
aux.Condicion = lector.GetString(6);
aux.Estado = lector.GetString(7);
return aux;
}
public static bool Registro(Ambiente ent)
{
bool r;
if (AmbienteAD.Existe(ent.Id))
{
r = true;
AmbienteAD.Modificar(ent);
}
else
{
r = false;
AmbienteAD.Agregar(ent);
}
return r;
}
public void testAmbienteJason () {
Ambiente ambiente = new Ambiente ();
ambiente.id = 0;
ambiente.nome = "nome";
ambiente.peDireito = 2f;
ambiente.area = 2f;
ambiente.acusticoAberto = 2f;
ambiente.acusticoFechado = 2f;
ambiente.termoAberto = 2f;
ambiente.termoFechado = 2f;
ambiente.acusticoAbertoComRes = "test";
ambiente.acusticoFechadoComRes = "test";
ambiente.termoAbertoComRes = "test";
ambiente.termoFechadoComRes = "test";
ambiente.vistoria = new Vistoria () {id = 3};
print (ambiente.GetJson ());
}
public int InsertAmbiente(Ambiente p)
{
try
{
bd.Ambiente.Add(p);
bd.SaveChanges();
return 1;
}
catch (DbUpdateException)
{
return 0;
}
catch (Exception)
{
return 2;
throw;
}
}
public void InsertTest()
{
AmbienteDAL target = new AmbienteDAL();
Ambiente ambiente = new Ambiente();
ambiente.IdAmbiente = 999;
ambiente.Descricao = "Ambiente Teste";
ambiente.DataCadastro = DateTime.Now;
ambiente.Mostra = true;
target.Insert(ambiente);
Ambiente ambienteTest = target.Obter("IdAmbiente = " + ambiente.IdAmbiente);
Assert.AreEqual(ambiente.IdAmbiente, ambienteTest.IdAmbiente);
Assert.AreEqual(ambiente.Descricao, ambienteTest.Descricao);
Assert.AreNotEqual(ambiente.DataCadastro, ambienteTest.DataCadastro);
Assert.AreEqual(ambiente.Mostra, ambienteTest.Mostra);
}
public static List<Ambiente> Buscar(Ambiente ent)
{
var lista = new List<Ambiente>();
using (var cn = Conexion.ConexionDBSqlServer())
{
SqlCommand cmd = new SqlCommand("SPU_BUSCAR_Ambiente", cn);
cmd.CommandType = CommandType.StoredProcedure;
cn.Open();
cmd.Parameters.AddWithValue("@AmbienteDescripcion",ent.Descripcion);
var r = cmd.ExecuteReader();
while (r.Read())
{
lista.Add(CrearEntidad(r));
}
cn.Close();
}
return lista;
}
public static bool Agregar(Ambiente ent)
{
var r = 0;
using (var cn = Conexion.ConexionDBSqlServer())
{
SqlCommand cmd = new SqlCommand("SPU_INSERTAR_Ambiente",cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@IdTipoAmbiente",ent.IdTipoAmbiente);
cmd.Parameters.AddWithValue("@Descripcion",ent.Descripcion);
cmd.Parameters.AddWithValue("@Ubicacion",ent.Ubicacion);
cmd.Parameters.AddWithValue("@Capacidad",ent.Capacidad);
cmd.Parameters.AddWithValue("@Area",ent.Area);
cmd.Parameters.AddWithValue("@Condicion",ent.Condicion);
cn.Open();
r = cmd.ExecuteNonQuery();
cn.Close();
}
return r > 0;
}
private void InsertOrUpdate()
{
if (ModoCreate)
{
if (TxtClave.Text.Trim().Length == 0)
{
return;
}
objeto = new UnidadMedida();
objeto.UnidadMedidaId = TxtClave.Text.Trim();
objeto.Nombre = TxtNombre.Text.Trim();
objeto.UnidadSat = TxtUnidadSat.Text.Trim();
if (unidadMedidaController.InsertOne(objeto))
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[3]);
}
else
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[-1]);
}
Close();
}
else
{
objeto.Nombre = TxtNombre.Text.Trim();
objeto.UnidadSat = TxtUnidadSat.Text.Trim();
if (unidadMedidaController.Update(objeto))
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[3]);
}
else
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[-1]);
}
Close();
}
}
private void ActualizaConfig()
{
if (puntoConfig != null)
{
puntoConfig.TasaDescuento = NTasaDesc.Value / 100;
puntoConfig.DiasReset = (int)NdiasReset.Value;
if (puntoConfigController.Update(puntoConfig))
{
Ambiente.Mensaje("Proceso concluido con éxito");
Close();
}
else
{
Ambiente.Mensaje("Algo salió mal con este modulo");
}
}
else
{
Ambiente.Mensaje("No hay configuración por defecto para este modulo");
Close();
}
}
private void Malla_CellEndEdit(object sender, DataGridViewCellEventArgs e)
{
if (Malla.CurrentCell.Value == null)
{
return;
}
if (Malla.CurrentCell.ColumnIndex == 3)
{
//Cantidad
try
{
ActualizaCantidad(int.Parse(Malla.CurrentCell.Value.ToString()), e.RowIndex);
ReCargaGrid();
}
catch (Exception ex)
{
Ambiente.Mensaje(ex.Message);
}
}
}
private void Agregar()
{
if (Ambiente.Pregunta("REALMENTE NO ES NECESARIO CREAR CIERRES MANUALES. \n El sistema generá automaticamente los cambios y arranques de periodos automaticamente. \n CREAR DE TODAS FORMAS"))
{
if (Ambiente.Pregunta("Aseguresé que conoce las implicaciones de generar periodos manualmente. CONTINUAR"))
{
cierreInventario = new CierreInventario();
cierreInventario.FechaInicial = DpFinicial.Value;
cierreInventario.FechaFinal = DpFinicial.Value;
cierreInventario.FechaProgramacion = DpFechaEjecucion.Value;
cierreInventario.Etapa1Generada = false;
cierreInventario.Etapa2Generada = false;
cierreInventario.CreatedAt = DateTime.Now;
cierreInventario.CreatedBy = Ambiente.LoggedUser.UsuarioId;
if (cierreInventarioController.InsertOne(cierreInventario))
{
Ambiente.Mensaje("Proceso completado");
}
}
}
}
private void LlenaDatosProducto()
{
TxtProductoId.Text = producto.ProductoId;
TxtPrecioCompra.Text = producto.PrecioCompra.ToString();
TxtPrecioCaja.Text = producto.PrecioCaja.ToString();
TxtDescripcion.Text = producto.Descripcion;
TxtU1.Text = producto.Utilidad1.ToString();
TxtU2.Text = producto.Utilidad2.ToString();
TxtU3.Text = producto.Utilidad3.ToString();
TxtU4.Text = producto.Utilidad4.ToString();
TxtPrecio1.Text = producto.Precio1.ToString();
TxtPrecio2.Text = producto.Precio2.ToString();
TxtPrecio3.Text = producto.Precio3.ToString();
TxtPrecio4.Text = producto.Precio4.ToString();
CargaListaImpuestos(producto);
CargaGridImpuestos();
TxtPrecioS1.Text = Ambiente.GetPrecioSalida(TxtPrecio1.Text, impuestos);
TxtPrecioS2.Text = Ambiente.GetPrecioSalida(TxtPrecio2.Text, impuestos);
TxtPrecioS3.Text = Ambiente.GetPrecioSalida(TxtPrecio3.Text, impuestos);
TxtPrecioS4.Text = Ambiente.GetPrecioSalida(TxtPrecio4.Text, impuestos);
PbxImagen.Image = GetImg(producto.RutaImg);
}
public ActionResult Obtener(string id)
{
try
{
ObservacionRepository or = new ObservacionRepository();
List <Observacion> observaciones = or.Listar(String.Empty);
AmbienteView av = new AmbienteView();
av.Mensaje = "";
av.Observaciones = observaciones;
AmbienteRepository ar = new AmbienteRepository();
Ambiente a = ar.Obtener(int.Parse(id));
a.Correos = ar.ListarCorreos(a.Id);
av.Ambiente = a;
return(View("Obtener", av));
}
catch (Exception ex)
{
return(View("Mensaje", new AmbienteView {
Mensaje = ex.Message
}));
}
}
private void Decrementa(int rowIndex)
{
try
{
if (partidas.Count > 0)
{
if (partidas[rowIndex].Cantidad >= 2)
{
partidas[rowIndex].Cantidad--;
CalculaTotales();
}
else
{
Ambiente.Mensaje("Operación denegada");
}
}
}
catch (Exception ex)
{
Ambiente.Mensaje(ex.Message);
}
}
public static void InicializaProdiedades()
{
try
{
Ambiente.Empresa = new EmpresaController().SelectTopOne();
Ambiente.reporteController = new ReporteController();
Ambiente.ImageList = new System.Windows.Forms.ImageList();
Ambiente.ImageList.TransparentColor = Color.Blue;
Ambiente.ImageList.ColorDepth = ColorDepth.Depth24Bit;
Ambiente.ImageList.ImageSize = new Size(16, 16);
Ambiente.ImageList.Images.Add("reports16", Properties.Resources.reports);
Ambiente.ImageList.Images.Add("folder16", Properties.Resources.Folder);
Ambiente.ImageList.Images.Add("openfolder16", Properties.Resources.FolderOpen);
Ambiente.ServerImgAccesible = Ambiente.PingHost(Ambiente.Empresa.IpServer);
}
catch (Exception e)
{
Ambiente.Mensaje(e.ToString());
}
}
public IEnumerable <ClientePessoaFisica> GetListaPessoaFisica()
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(Ambiente.GetBaseAppURI());
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = client.GetAsync(stringBaseUri).Result;
if (response.IsSuccessStatusCode)
{
var listaPessoas = response.Content.ReadAsStringAsync();
var dados = JsonConvert.DeserializeObject <List <ClientePessoaFisica> >(listaPessoas.Result);
return(dados);
}
else
{
Mensagens.Erro("Ocorreu um erro ao listar os clientes!");
return(null);
}
}
}
internal static void ProductosConPrecio()
{
try
{
report = new StiReport();
report.Load(@"C:\Dympos\Formatos\ProductoXprecio.mrt");
report.Compile();
report["creador"] = Ambiente.LoggedUser.UsuarioId;
report.RegBusinessObject("productos", productoController.SelectAll());
report.Dictionary.Synchronize();
//report.Render();
// report.Design();
//report.Save(@"C:\Dympos\Formatos\ProductoXprecio.mrt");
report.Show();
}
catch (Exception e)
{
Ambiente.Mensaje(e.Message);
}
}
public static void OQueRolouNaParada(Exception e, int NumeroMagico)
{
switch (NumeroMagico)
{
case 1:
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.WriteLine("\n##########################################################");
Console.WriteLine("[POP-MONGO] Erro ao tentar se conectar com o RabbitMQ");
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
Console.WriteLine("[ ERROR: ] " + e.Message);
Console.WriteLine("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
Console.WriteLine("[POP-MONGO] Dados da conexão listados a seguir:\n");
Console.WriteLine("[POP-MONGO] Host: " + Ambiente.getRabbitHost());
Console.WriteLine("[POP-MONGO] Topico: " + Ambiente.getRabbitTopic());
Console.WriteLine("[POP-MONGO] Chave de Rota: " + Ambiente.getRabbitKey());
Console.WriteLine("[POP-MONGO] Canal: " + Ambiente.getRabbitChannelName());
Console.WriteLine("##########################################################");
Console.ResetColor();
break;
case 2:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n#############################################");
Console.WriteLine("Erro ao tentar salvar no MongoDB");
Console.WriteLine("#############################################");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(e.Message + "\n");
Console.ResetColor();
break;
default:
Console.ForegroundColor = System.ConsoleColor.Red;
Console.WriteLine("\n################################################\n");
Console.WriteLine("ERRO NAO ESPECIFICADO");
Console.WriteLine("\n################################################\n");
Console.ResetColor();
break;
}
}
public ActionResult CadastrarAmbiente(AmbienteViewModel Ambienteviewmodel)
{
Ambiente model = null;
try
{
//Tratar a lista de recursos selecionados
string[] arrayRecurso = new string[1] {
""
};
if (Ambienteviewmodel.HiddenListaRecurso != null)
{
arrayRecurso = Ambienteviewmodel.HiddenListaRecurso.Split(';');
//var teste = arrayRecurso.ToList();
}
if (Ambienteviewmodel.IdAmbiente != null)
{
Ambienteviewmodel.IdAmbiente = null;
}
model = AmbienteViewModel.MapToModel(Ambienteviewmodel);
//this.speDominioService.InserirAmbienteRecurso(model, arrayRecurso);
BL.Ambiente.InserirAmbienteRecurso(model, arrayRecurso);
TempData["Sucesso"] = true;
TempData["SucessoMessage"] = "Cadastro de Ambiente realizado com sucesso.";
}
catch (Exception ex)
{
TempData["Error"] = true;
TempData["ErrorMessage"] = (ex.GetType().Name == "CustomException") ? ex.Message : "Erro ao cadastrar Ambiente.";
Logging.getInstance().Error(TempData["ErrorMessage"].ToString(), ex);
}
return(RedirectToAction("Index"));
}
public Ambiente UpdateAmbiente(Ambiente Ambiente)
{
var foundAmbiente = appDbContext.Ambienti.FirstOrDefault(e => e.Id == Ambiente.Id);
if (foundAmbiente != null)
{
foundAmbiente.billingcenter = Ambiente.billingcenter;
foundAmbiente.codicefiscale = Ambiente.codicefiscale;
foundAmbiente.ColUri = Ambiente.ColUri;
foundAmbiente.contractid = Ambiente.contractid;
foundAmbiente.contracttype = Ambiente.contracttype;
foundAmbiente.Contratto = Ambiente.Contratto;
foundAmbiente.ContrattoCOL = Ambiente.ContrattoCOL;
foundAmbiente.ContrattoMOL = Ambiente.ContrattoMOL;
foundAmbiente.costcenter = Ambiente.costcenter;
foundAmbiente.customer = Ambiente.customer;
foundAmbiente.customerid = Ambiente.customerid;
foundAmbiente.Description = Ambiente.Description;
foundAmbiente.idsender = Ambiente.idsender;
foundAmbiente.IsPil = Ambiente.IsPil;
foundAmbiente.LolUri = Ambiente.LolUri;
foundAmbiente.MolUri = Ambiente.MolUri;
foundAmbiente.partitaiva = Ambiente.partitaiva;
foundAmbiente.Password = Ambiente.Password;
foundAmbiente.RolUri = Ambiente.RolUri;
foundAmbiente.sendersystem = Ambiente.sendersystem;
foundAmbiente.smuser = Ambiente.smuser;
foundAmbiente.Username = Ambiente.Username;
foundAmbiente.usertype = Ambiente.usertype;
foundAmbiente.VolUri = Ambiente.VolUri;
appDbContext.SaveChanges();
return(foundAmbiente);
}
return(null);
}
private Ambiente SetAmbiente(Environment environment)
{
Ambiente result = null;
switch (environment)
{
case Environment.BTS1023:
break;
case Environment.Collaudo:
result = new Ambiente
{
MolUri = "http://10.60.19.13/RaccomandataMarket/MOLService.svc",
customerid = "3908983576",
smuser = "******",
ContrattoMOL = "40000015982",
PostaEvoConnectionString = "data source=10.60.19.22\\TPCESQLINST02;initial catalog=PostaEvo;persist security info=True;user id=pasquale;password=pasquale;MultipleActiveResultSets=True;App=EntityFramework;"
};
break;
case Environment.Certificazione:
break;
case Environment.Staging:
break;
case Environment.Bts2016:
break;
case Environment.Produzione:
break;
default:
break;
}
return(result);
}
public Destinatario(Ambiente ambiente, Modelo modelo, string telefone, string email, Endereco endereco,
TipoDestinatario tipoDestinatario, string inscricaoEstadual = null, bool isIsentoICMS = false,
string documento = null, string nomeRazao = null)
{
Documento = documento;
NomeRazao = ambiente == Ambiente.Homologacao
? "NF-E EMITIDA EM AMBIENTE DE HOMOLOGACAO - SEM VALOR FISCAL"
: nomeRazao ?? "CONSUMIDOR NÃO IDENTIFICADO";
IsIsentoICMS = isIsentoICMS;
TipoDestinatario = tipoDestinatario;
if (Documento != null)
{
Email = email;
if (modelo == Modelo.Modelo65)
{
IndicadorInscricaoEstadual = 9;
InscricaoEstadual = null;
}
else
{
if (IsIsentoICMS)
{
IndicadorInscricaoEstadual = 2;
}
else
{
IndicadorInscricaoEstadual = 1;
}
InscricaoEstadual = inscricaoEstadual;
}
Telefone = telefone;
Endereco = endereco;
}
}
private void ActualizaCantidad(int cant, int rowIndex)
{
try
{
if ((rowIndex <= partidas.Count - 1) && cant > 0)
{
partidas[rowIndex].Cantidad = cant;
Malla.Rows[rowIndex].Cells[2].Value = cant;
CalculaTotales();
}
else
{
partidas[rowIndex].Cantidad = 1;
Malla.Rows[rowIndex].Cells[2].Value = 1;
CalculaTotales();
Ambiente.Mensaje("Operación denegada, solo cantidades positivas");
}
}
catch (Exception ex)
{
Ambiente.Mensaje(ex.Message);
}
}
public List <Lote> GetLotes(string productoId, int compraId)
{
try
{
using (var db = new DymContext())
{
var lotes = db.Lote.Where(x => x.ProductoId.Equals(productoId.Trim()) && x.CompraId == compraId).ToList();
if (lotes.Count > 0)
{
return(lotes);
}
else
{
return(null);
}
}
}
catch (Exception ex)
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[-1] + "@" + GetType().Name + "\n" + ex.ToString());
}
return(null);
}
private void Decrementa(int rowIndex)
{
try
{
if (partidas.Count > 0)
{
if (partidas[rowIndex].Cantidad > 1)
{
partidas[rowIndex].Cantidad--;
Malla.Rows[rowIndex].Cells[2].Value = partidas[rowIndex].Cantidad;
CalculaTotales();
}
else
{
Ambiente.Mensaje("Operación denegada, solo cantidades positivas");
}
}
}
catch (Exception ex)
{
Ambiente.Mensaje(ex.Message);
}
}
private void BorrarCampo()
{
if (migrationTable == null)
{
return;
}
if (Malla.RowCount == 0)
{
return;
}
if (Ambiente.Pregunta("Realmente quiere borrar el campo " + Malla.Rows[Malla.CurrentCell.RowIndex].Cells[2].Value.ToString()))
{
if (Ambiente.Pregunta("Si eliminas " + Malla.Rows[Malla.CurrentCell.RowIndex].Cells[2].Value.ToString() + " puede ocasionar problemas ¿CONTINUAR?"))
{
if (migrationFieldController.Delete((int)Malla.Rows[Malla.CurrentCell.RowIndex].Cells[0].Value))
{
CargaGrid();
Ambiente.Mensaje("Proceso completado");
}
}
}
}
public bool InsertOne(Venta o)
{
try
{
using (var db = new DymContext())
{
db.Add(o);
if (db.SaveChanges() > 0)
{
return(true);
}
else
{
return(false);
}
}
}
catch (Exception ex)
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[-1] + "@" + GetType().Name + "\n" + ex.ToString());
}
return(false);
}
public List <Venta> SelectFacturas(DateTime fini, DateTime ffin, bool solosintimbrar = false)
{
try
{
ffin = ffin.AddDays(1);
using (var db = new DymContext())
{
if (solosintimbrar)
{
return(db.Venta.Where(x => x.UuId == null && x.TipoDocId.Equals("FAC") && x.EstadoDocId.Equals("CON")).ToList());
}
else
{
return(db.Venta.Where(x => x.UuId != null && x.FechaTimbrado >= fini && x.FechaTimbrado <= ffin && x.TipoDocId.Equals("FAC") && x.EstadoDocId.Equals("CON")).ToList());
}
}
}
catch (Exception ex)
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[-1] + "@" + GetType().Name + "\n" + ex.ToString());
}
return(null);
}
public bool UpdateOne(Venta o)
{
try
{
using (var db = new DymContext())
{
db.Entry(o).State = EntityState.Modified;
if (db.SaveChanges() > 0)
{
return(true);
}
else
{
return(false);
}
}
}
catch (Exception ex)
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[-1] + "@" + GetType().Name + "\n" + ex.ToString());
}
return(false);
}
private void InsertOrUpdate()
{
if (ModoCreate)
{
if (TxtClave.Text.Trim().Length == 0)
{
return;
}
objeto = new Presentacion();
objeto.PresentacionId = TxtClave.Text.Trim();
objeto.Nombre = TxtNombre.Text.Trim();
if (presentacionController.InsertOne(objeto))
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[3]);
}
else
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[-1]);
}
Close();
}
else
{
objeto.Nombre = TxtNombre.Text.Trim();
if (presentacionController.Update(objeto))
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[3]);
}
else
{
Ambiente.Mensaje(Ambiente.CatalgoMensajes[-1]);
}
Close();
}
}
public int SalvarNotaFiscalPendente(NotaFiscal notaFiscal, string v, Ambiente ambiente)
{
var NotaFiscalEntity = new NotaFiscalEntity();
if (notaFiscal.Destinatario != null && notaFiscal.Destinatario.Endereco != null)
{
NotaFiscalEntity.UfDestinatario = notaFiscal.Destinatario.Endereco.UF;
}
else
{
NotaFiscalEntity.UfDestinatario = notaFiscal.Emitente.Endereco.UF;
}
NotaFiscalEntity.Destinatario = notaFiscal.Destinatario == null
? "CONSUMIDOR NÃO IDENTIFICADO"
: notaFiscal.Destinatario.NomeRazao;
NotaFiscalEntity.DocumentoDestinatario =
notaFiscal.Destinatario == null ? null : notaFiscal.Destinatario.Documento;
NotaFiscalEntity.Status = (int)notaFiscal.Identificacao.Status;
NotaFiscalEntity.Chave = notaFiscal.Identificacao.Chave;
NotaFiscalEntity.DataEmissao = notaFiscal.Identificacao.DataHoraEmissao;
NotaFiscalEntity.Modelo = notaFiscal.Identificacao.Modelo == Modelo.Modelo55 ? "55" : "65";
NotaFiscalEntity.Serie = notaFiscal.Identificacao.Serie.ToString();
NotaFiscalEntity.TipoEmissao = notaFiscal.Identificacao.TipoEmissao.ToString();
NotaFiscalEntity.ValorDesconto = notaFiscal.TotalNFe.IcmsTotal.ValorTotalDesconto;
NotaFiscalEntity.ValorDespesas = notaFiscal.TotalNFe.IcmsTotal.ValorDespesasAcessorias;
NotaFiscalEntity.ValorFrete = notaFiscal.TotalNFe.IcmsTotal.ValorTotalFrete;
NotaFiscalEntity.ValorICMS = notaFiscal.TotalNFe.IcmsTotal.ValorTotalIcms;
NotaFiscalEntity.ValorProdutos = notaFiscal.ValorTotalProdutos;
NotaFiscalEntity.ValorSeguro = notaFiscal.TotalNFe.IcmsTotal.ValorTotalSeguro;
NotaFiscalEntity.ValorTotal = notaFiscal.TotalNFe.IcmsTotal.ValorTotalNFe;
NotaFiscalEntity.Ambiente = ambiente == Ambiente.Homologacao ? 2 : 1;
NotaFiscalEntity.Numero = notaFiscal.Identificacao.Numero;
NotaFiscalEntity.IsProducao = ambiente == Ambiente.Producao;
return(Salvar(NotaFiscalEntity));
}
private void CargarDatos()
{
if (venta != null)
{
TxtCliente.Text = venta.ClienteId;
TxtUsoCFDI.Text = venta.UsoCfdi;
TxtFormaPago.Text = venta.FormaPago1;
TxtMetodoPago.Text = venta.MetodoPago;
Malla.Rows.Clear();
Malla.Rows.Add();
Malla.Rows[Malla.RowCount - 1].Cells[0].Value = venta.NoRef;
Malla.Rows[Malla.RowCount - 1].Cells[1].Value = venta.EstadoDocId;
Malla.Rows[Malla.RowCount - 1].Cells[2].Value = venta.DatosCliente;
}
else
{
TxtCliente.Text = "";
TxtUsoCFDI.Text = "";
TxtFormaPago.Text = "";
TxtMetodoPago.Text = "";
Malla.Rows.Clear();
Ambiente.Mensaje("El ticket no existe");
}
}
public void RecuperaIdRichiesta()
{
Ambiente ambiente = null;
ambiente = new Ambiente
{
customerid = "nello.citta.npce",
costcenter = "UNF",
billingcenter = "IdCdF",
idsender = "999988",
sendersystem = "H2H",
smuser = "******",
contracttype = "PosteWeb",
usertype = "B",
LolUri = "http://10.10.5.101/LOLGC/LolService.svc",
Username = "******",
Password = "******"
};
var operation = new RecuperaIdRichiestaLol(ambiente);
var idRichiesta = operation.Execute();
}
private void GenerarAnioCompleto()
{
var mactual = DateTime.Now.ToString("MMMM").ToUpper();
var mfinal = (DateTime.Now.AddMonths(12 - DateTime.Now.Month)).ToString("MMMM").ToUpper();
if (Ambiente.Pregunta("Se generarán los cierres de inventarios de " + mactual + " hasta " + mfinal))
{
for (int i = DateTime.Now.Month; i <= DateTime.Now.AddMonths(12 - DateTime.Now.Month).Month; i++)
{
cierreInventario = new CierreInventario();
cierreInventario.FechaInicial = new DateTime(DateTime.Now.Year, i, 1);
cierreInventario.FechaFinal = cierreInventario.FechaInicial.AddMonths(1).AddDays(-1);
cierreInventario.FechaProgramacion = cierreInventario.FechaFinal.AddDays(1);
cierreInventario.Etapa1Generada = false;
cierreInventario.Etapa2Generada = false;
cierreInventario.CreatedAt = DateTime.Now;
cierreInventario.CreatedBy = Ambiente.LoggedUser.UsuarioId;
cierreInventario.EstacionId = Ambiente.Estacion.EstacionId;
cierreInventarioController.InsertOne(cierreInventario);
}
CargaMalla();
Ambiente.Mensaje("Proceso concluido");
}
}
public Ambient (string ambName)
{
name = ambName;
ambient = new Ambiente ();
ambient.vistoria = StaticData.vistoriaAtual;
ambient.nome = name;
ambient.peDireito = 0;
ambient.area = 0;
ambient.acusticoAbertoComRes = "Res";
ambient.acusticoFechadoComRes = "Res";
dimensionsInformation = new DimensionsInformation ();
accousticInformation = new AccousticInformation ();
ceramicInformation = new CeramicInformation (name);
ceramicWallsInformation = new CeramicWallsInformation (name);
eletricsInformation = new EletricsInformation (name);
hidraulicsInformation = new HidraulicsInformation (name);
framesInformation = new FramesInformation (name);
paintingCeilingInformation = new PaintingCeilingInformation (name);
paintingWallInformation = new PaintingWallInformation (name);
woodenFloorInformation = new WoodenFloorInformation (name);
sillsInformation = new SillsInformation (name);
peitorisInformation = new PeitorisInformation (name);
tentosBaguetesInformation = new TentosBaguetesInformation (name);
functionalWallInformation = new FunctionalWallInformation (name);
functionalCeilingInformation = new FunctionalCeilingInformation (name);
if (!CheckSpaceManager.instance.initialized) {
if (StaticData.OnlineVistoria) {
LoadAllNet ();
} else {
CheckSpaceManager.instance.StartCoroutine (LoadAllLocal ());
}
}
}
private void AgregarLote()
{
if (NCantidad.Value <= restante && TxtNoLote.Text.Trim().Length > 0)
{
lote = new Lote();
lote.NoLote = TxtNoLote.Text.Trim();
lote.CompraId = compraId;
lote.ProductoId = TxtProductoId.Text.Trim();
lote.StockInicial = NCantidad.Value;
lote.StockRestante = NCantidad.Value;
lote.Caducidad = DpFechaCaducidad.Value;
lote.CreatedBy = Ambiente.LoggedUser.UsuarioId;
lote.CreatedAt = DateTime.Now;
lotes.Add(lote);
restante -= NCantidad.Value;
TxtRestante.Text = restante.ToString();
CargaGrid();
}
else
{
Ambiente.Mensaje("Operación denegada");
}
}
private void BtnAceptar_Click(object sender, EventArgs e)
{
if ((int)CboCategorias.SelectedValue <= 0)
{
Ambiente.Mensaje("Informe todos los campos");
return;
}
if (TxtDescripcion.Text.Equals(""))
{
Ambiente.Mensaje("Informe todos los campos");
return;
}
if (TxtReporteId.Text.Equals(""))
{
Ambiente.Mensaje("Informe todos los campos");
return;
}
CategoriaId = int.Parse(CboCategorias.SelectedValue.ToString());
Descrip = TxtDescripcion.Text.Trim();
ReporteId = TxtReporteId.Text.Trim();
Sistema = ChkSistema.Checked;
DialogResult = DialogResult.OK;
}
private void AtualizarDescricao()
{
try
{
string texto = string.Empty;
int idRequisicao = 0;
int idAmbiente = 0;
if ((lvRequisicoes.Items.Count > 0 && lvRequisicoes.SelectedItems.Count > 0) && cbAmbiente.Items.Count > 0)
{
int.TryParse(lvRequisicoes.SelectedItems[0].Text, out idRequisicao);
int.TryParse(cbAmbiente.SelectedValue.ToString(), out idAmbiente);
}
if (idRequisicao > 0)
{
Requisicao req = ReqRepo.ObterRequisicao(idRequisicao);
texto = req.Descricao;
}
if (idAmbiente > 0)
{
Ambiente amb = AmbiRepo.ObterAmbiente(idAmbiente);
if (texto.Contains("@ambiente"))
{
texto = texto.Replace("@ambiente", amb.Nome);
}
if (texto.Contains("@instancias"))
{
texto = texto.Replace("@instancias", amb.Instancias);
}
}
txtDescricao.Text = texto;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "ERRO", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void LoadAllNet ()
{
ambient = CheckSpaceManager.instance.FindOnlineAmbient (name);
LoadOnlineServices ();
FillIndicadoresNet (ceramicInformation, Servicos.REVESTIMENTO_PISO.ToString ());
FillIndicadoresNet (ceramicWallsInformation, Servicos.REVESTIMENTO_PAREDE.ToString ());
FillIndicadoresNet (eletricsInformation, Servicos.ELETRICA.ToString ());
FillIndicadoresNet (framesInformation, Servicos.ESQUADRIAS.ToString ());
FillIndicadoresNet (hidraulicsInformation, Servicos.HIDRAULICA.ToString ());
FillIndicadoresNet (paintingCeilingInformation, Servicos.PINTURA_TETO.ToString ());
FillIndicadoresNet (paintingWallInformation, Servicos.PINTURA_PAREDE.ToString ());
FillIndicadoresNet (sillsInformation, Servicos.SOLEIRAS.ToString ());
FillIndicadoresNet (peitorisInformation, Servicos.PEITORIS.ToString ());
FillIndicadoresNet (tentosBaguetesInformation, Servicos.TENTOS_BAGUETES.ToString ());
FillIndicadoresNet (woodenFloorInformation, Servicos.PISO_MADEIRA.ToString ());
FillIndicadoresNet (functionalCeilingInformation, Servicos.FUNCIONAL_TETO.ToString ());
FillIndicadoresNet (functionalWallInformation, Servicos.FUNCIONAL_PAREDE.ToString ());
FillImageIndicadoresNet (ceramicInformation, Servicos.REVESTIMENTO_PISO.ToString ());
FillImageIndicadoresNet (ceramicWallsInformation, Servicos.REVESTIMENTO_PAREDE.ToString ());
FillImageIndicadoresNet (eletricsInformation, Servicos.ELETRICA.ToString ());
FillImageIndicadoresNet (framesInformation, Servicos.ESQUADRIAS.ToString ());
FillImageIndicadoresNet (hidraulicsInformation, Servicos.HIDRAULICA.ToString ());
FillImageIndicadoresNet (paintingCeilingInformation, Servicos.PINTURA_TETO.ToString ());
FillImageIndicadoresNet (paintingWallInformation, Servicos.PINTURA_PAREDE.ToString ());
FillImageIndicadoresNet (sillsInformation, Servicos.SOLEIRAS.ToString ());
FillImageIndicadoresNet (peitorisInformation, Servicos.PEITORIS.ToString ());
FillImageIndicadoresNet (tentosBaguetesInformation, Servicos.TENTOS_BAGUETES.ToString ());
FillImageIndicadoresNet (woodenFloorInformation, Servicos.PISO_MADEIRA.ToString ());
FillImageIndicadoresNet (functionalCeilingInformation, Servicos.FUNCIONAL_TETO.ToString ());
FillImageIndicadoresNet (functionalWallInformation, Servicos.FUNCIONAL_PAREDE.ToString ());
}
public IEnumerator LoadAllLocal ()
{
List<Ambiente> ambientes = CheckSpaceManager.instance.FilterAmbients (ambient.nome);
if (ambientes.Count > 0) {
ambient = ambientes [0];
} else
yield break;
List<Servico> servicos = CheckSpaceManager.instance.FilterServicos (ambient.nome);
foreach (var item in servicos) {
if (item.nome == Servicos.ELETRICA.ToString ())
eletricsInformation.service = item;
else if (item.nome == Servicos.ESQUADRIAS.ToString ())
framesInformation.service = item;
else if (item.nome == Servicos.FUNCIONAL_PAREDE.ToString ())
functionalWallInformation.service = item;
else if (item.nome == Servicos.FUNCIONAL_TETO.ToString ())
functionalCeilingInformation.service = item;
else if (item.nome == Servicos.HIDRAULICA.ToString ())
hidraulicsInformation.service = item;
else if (item.nome == Servicos.PEITORIS.ToString ())
peitorisInformation.service = item;
else if (item.nome == Servicos.PINTURA_PAREDE.ToString ())
paintingWallInformation.service = item;
else if (item.nome == Servicos.PINTURA_TETO.ToString ())
paintingCeilingInformation.service = item;
else if (item.nome == Servicos.PISO_MADEIRA.ToString ())
woodenFloorInformation.service = item;
else if (item.nome == Servicos.REVESTIMENTO_PAREDE.ToString ())
ceramicWallsInformation.service = item;
else if (item.nome == Servicos.REVESTIMENTO_PISO.ToString ())
ceramicInformation.service = item;
else if (item.nome == Servicos.SOLEIRAS.ToString ())
sillsInformation.service = item;
else if (item.nome == Servicos.TENTOS_BAGUETES.ToString ())
tentosBaguetesInformation.service = item;
yield return new WaitForEndOfFrame ();
}
System.DateTime time = System.DateTime.Now;
List<Indicador> ceramicIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.REVESTIMENTO_PISO.ToString (), name);
if (ceramicIndicators != null && ceramicIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < ceramicInformation.indicatorsList.Count; i++) {
for (int j = 0; j < ceramicInformation.indicatorsList [i].Count; j++) {
ceramicInformation.indicatorsList [i] [j] = ceramicIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> ceramicImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.REVESTIMENTO_PISO.ToString (), name);
if (ceramicImageIndicators != null && ceramicImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < ceramicInformation.evidencias.Count; i++) {
for (int j = 0; j < ceramicInformation.evidencias [i].Count; j++) {
ceramicInformation.evidencias [i] [j] = ceramicImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> ceramicWallIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.REVESTIMENTO_PAREDE.ToString (), name);
if (ceramicWallIndicators != null && ceramicWallIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < ceramicWallsInformation.indicatorsList.Count; i++) {
for (int j = 0; j < ceramicWallsInformation.indicatorsList [i].Count; j++) {
ceramicWallsInformation.indicatorsList [i] [j] = ceramicWallIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> ceramicWallImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.REVESTIMENTO_PAREDE.ToString (), name);
if (ceramicWallImageIndicators != null && ceramicWallImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < ceramicWallsInformation.evidencias.Count; i++) {
for (int j = 0; j < ceramicWallsInformation.evidencias [i].Count; j++) {
ceramicWallsInformation.evidencias [i] [j] = ceramicWallImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> eletricsIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.ELETRICA.ToString (), name);
if (eletricsIndicators != null && eletricsIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < eletricsInformation.indicatorsList.Count; i++) {
for (int j = 0; j < eletricsInformation.indicatorsList [i].Count; j++) {
eletricsInformation.indicatorsList [i] [j] = eletricsIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> eletricsImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.ELETRICA.ToString (), name);
if (eletricsImageIndicators != null && eletricsImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < eletricsInformation.evidencias.Count; i++) {
for (int j = 0; j < eletricsInformation.evidencias [i].Count; j++) {
eletricsInformation.evidencias [i] [j] = eletricsImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> framesIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.ESQUADRIAS.ToString (), name);
if (framesIndicators != null && framesIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < framesInformation.indicatorsList.Count; i++) {
for (int j = 0; j < framesInformation.indicatorsList [i].Count; j++) {
framesInformation.indicatorsList [i] [j] = framesIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> framesImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.ESQUADRIAS.ToString (), name);
if (framesImageIndicators != null && framesImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < framesInformation.evidencias.Count; i++) {
for (int j = 0; j < framesInformation.evidencias [i].Count; j++) {
framesInformation.evidencias [i] [j] = framesImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> hidraulicsIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.HIDRAULICA.ToString (), name);
if (hidraulicsIndicators != null && hidraulicsIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < hidraulicsInformation.indicatorsList.Count; i++) {
for (int j = 0; j < hidraulicsInformation.indicatorsList [i].Count; j++) {
hidraulicsInformation.indicatorsList [i] [j] = hidraulicsIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> hidraulicsImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.HIDRAULICA.ToString (), name);
if (hidraulicsImageIndicators != null && hidraulicsImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < hidraulicsInformation.evidencias.Count; i++) {
for (int j = 0; j < hidraulicsInformation.evidencias [i].Count; j++) {
hidraulicsInformation.evidencias [i] [j] = hidraulicsImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> paintingCeilingIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.PINTURA_TETO.ToString (), name);
if (paintingCeilingIndicators != null && paintingCeilingIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < paintingCeilingInformation.indicatorsList.Count; i++) {
for (int j = 0; j < paintingCeilingInformation.indicatorsList [i].Count; j++) {
paintingCeilingInformation.indicatorsList [i] [j] = paintingCeilingIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> paintingImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.PINTURA_TETO.ToString (), name);
if (paintingImageIndicators != null && paintingImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < paintingCeilingInformation.evidencias.Count; i++) {
for (int j = 0; j < paintingCeilingInformation.evidencias [i].Count; j++) {
paintingCeilingInformation.evidencias [i] [j] = paintingImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> paintingWallIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.PINTURA_PAREDE.ToString (), name);
if (paintingWallIndicators != null && paintingWallIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < paintingWallInformation.indicatorsList.Count; i++) {
for (int j = 0; j < paintingWallInformation.indicatorsList [i].Count; j++) {
paintingWallInformation.indicatorsList [i] [j] = paintingWallIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> paintingWallImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.PINTURA_PAREDE.ToString (), name);
if (paintingWallImageIndicators != null && paintingWallImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < paintingWallInformation.evidencias.Count; i++) {
for (int j = 0; j < paintingWallInformation.evidencias [i].Count; j++) {
paintingWallInformation.evidencias [i] [j] = paintingWallImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> sillsIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.SOLEIRAS.ToString (), name);
if (sillsIndicators != null && sillsIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < sillsInformation.indicatorsList.Count; i++) {
for (int j = 0; j < sillsInformation.indicatorsList [i].Count; j++) {
sillsInformation.indicatorsList [i] [j] = sillsIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> sillsImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.SOLEIRAS.ToString (), name);
if (sillsImageIndicators != null && sillsImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < sillsInformation.evidencias.Count; i++) {
for (int j = 0; j < sillsInformation.evidencias [i].Count; j++) {
sillsInformation.evidencias [i] [j] = sillsImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> peitorisIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.PEITORIS.ToString (), name);
if (peitorisIndicators != null && peitorisIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < peitorisInformation.indicatorsList.Count; i++) {
for (int j = 0; j < peitorisInformation.indicatorsList [i].Count; j++) {
peitorisInformation.indicatorsList [i] [j] = peitorisIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> peitorisImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.PEITORIS.ToString (), name);
if (peitorisImageIndicators != null && peitorisImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < peitorisInformation.evidencias.Count; i++) {
for (int j = 0; j < peitorisInformation.evidencias [i].Count; j++) {
peitorisInformation.evidencias [i] [j] = peitorisImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> tentosBaguetesIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.TENTOS_BAGUETES.ToString (), name);
if (tentosBaguetesIndicators != null && tentosBaguetesIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < tentosBaguetesInformation.indicatorsList.Count; i++) {
for (int j = 0; j < tentosBaguetesInformation.indicatorsList [i].Count; j++) {
tentosBaguetesInformation.indicatorsList [i] [j] = tentosBaguetesIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> tentosBaguetesImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.TENTOS_BAGUETES.ToString (), name);
if (tentosBaguetesImageIndicators != null && tentosBaguetesImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < tentosBaguetesInformation.evidencias.Count; i++) {
for (int j = 0; j < tentosBaguetesInformation.evidencias [i].Count; j++) {
tentosBaguetesInformation.evidencias [i] [j] = tentosBaguetesImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> woodenFloorIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.PISO_MADEIRA.ToString (), name);
if (woodenFloorIndicators != null && woodenFloorIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < woodenFloorInformation.indicatorsList.Count; i++) {
for (int j = 0; j < woodenFloorInformation.indicatorsList [i].Count; j++) {
woodenFloorInformation.indicatorsList [i] [j] = woodenFloorIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> woodenFloorImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.PISO_MADEIRA.ToString (), name);
if (woodenFloorImageIndicators != null && woodenFloorImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < woodenFloorInformation.evidencias.Count; i++) {
for (int j = 0; j < woodenFloorInformation.evidencias [i].Count; j++) {
woodenFloorInformation.evidencias [i] [j] = woodenFloorImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> funcionalTetoIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.FUNCIONAL_TETO.ToString (), name);
if (funcionalTetoIndicators != null && funcionalTetoIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < functionalCeilingInformation.indicatorsList.Count; i++) {
for (int j = 0; j < functionalCeilingInformation.indicatorsList [i].Count; j++) {
functionalCeilingInformation.indicatorsList [i] [j] = funcionalTetoIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> funcionalTetoImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.FUNCIONAL_TETO.ToString (), name);
if (funcionalTetoImageIndicators != null && funcionalTetoImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < functionalCeilingInformation.evidencias.Count; i++) {
for (int j = 0; j < functionalCeilingInformation.evidencias [i].Count; j++) {
functionalCeilingInformation.evidencias [i] [j] = funcionalTetoImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<Indicador> funcionalWallIndicators = CheckSpaceManager.instance.FilterIndicator (Servicos.FUNCIONAL_PAREDE.ToString (), name);
if (funcionalWallIndicators != null && funcionalWallIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < functionalWallInformation.indicatorsList.Count; i++) {
for (int j = 0; j < functionalWallInformation.indicatorsList [i].Count; j++) {
functionalWallInformation.indicatorsList [i] [j] = funcionalWallIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
List<ImagemIndicador> funcionalWallImageIndicators = CheckSpaceManager.instance.FilterImageIndicator (Servicos.FUNCIONAL_PAREDE.ToString (), name);
if (funcionalWallImageIndicators != null && funcionalWallImageIndicators.Count > 0) {
int count = 0;
for (int i = 0; i < functionalWallInformation.evidencias.Count; i++) {
for (int j = 0; j < functionalWallInformation.evidencias [i].Count; j++) {
functionalWallInformation.evidencias [i] [j] = funcionalWallImageIndicators [count];
count++;
}
yield return new WaitForEndOfFrame ();
}
}
}
public Agente(Ambiente amb, Celula posInicial)
{
this.ambiente = amb;
this.posicaoAtual = posInicial;
}
public int UpdateAmbiente(Ambiente b)
{
return cl.UpdateAmbiente(b);
}
public int InsertAmbiente(Ambiente b)
{
return cl.InsertAmbiente(b);
}
public World()
{
InitializeComponent();
amb = new Ambiente(App.Default.TamanhoMundo, 0, 0, 0, 0);
}
public int UpdateAmbiente(Ambiente ambiente)
{
try
{
var ctx = bd.Ambiente.First(inm => inm.Id == ambiente.Id);
ctx.Ambiente1 = ambiente.Ambiente1;
bd.SaveChanges();
return 1;
}
catch (Exception ex)
{
return 0;
throw;
}
}
public static List<Ambiente> Buscar(Ambiente ent)
{
return AmbienteAD.Buscar(ent);
}
public AssinaturaAPI(Ambiente ambiente)
{
_ambiente = ambiente;
}
public void UpdateTest()
{
AmbienteDAL target = new AmbienteDAL();
Ambiente ambiente = new Ambiente();
ambiente.IdAmbiente = 999;
ambiente.Descricao = "Ambiente Teste Unitário - UPDATED";
ambiente.DataCadastro = DateTime.Now;
ambiente.Mostra = false;
target.Update(ambiente);
Ambiente ambienteTest = target.Obter("IdAmbiente = " + ambiente.IdAmbiente);
Assert.AreEqual(ambiente.IdAmbiente, ambienteTest.IdAmbiente);
Assert.AreEqual(ambiente.Descricao, ambienteTest.Descricao);
Assert.AreNotEqual(ambiente.DataCadastro, ambienteTest.DataCadastro);
Assert.AreEqual(ambiente.Mostra, ambienteTest.Mostra);
}
public Mosquito(EstagioMosquito e, Celula posicaoInicial, Ambiente amb)
: base(amb, posicaoInicial)
{
this.Estagio = e;
this.EstaVivo = true;
}
public void DeleteTest()
{
AmbienteDAL target = new AmbienteDAL();
Ambiente ambiente = new Ambiente();
ambiente.IdAmbiente = 999;
target.Delete(ambiente);
//Assert.(ambiente, target.Obter("IdAmbiente = 101"));
}