public OrdenPago()
{
this.Bancos = new List <Banco>();
this.Sucursales = new List <Sucursal>();
this.Monedas = new List <ListaGenerica>();
this.Estados = new List <ListaGenerica>();
Monedas.Add(new ListaGenerica {
codigo = "S", descripcion = "SOLES"
});
Monedas.Add(new ListaGenerica {
codigo = "D", descripcion = "DOLARES"
});
Estados.Add(new ListaGenerica {
codigo = "P", descripcion = "PAGADA"
});
Estados.Add(new ListaGenerica {
codigo = "D", descripcion = "DECLINADA"
});
Estados.Add(new ListaGenerica {
codigo = "F", descripcion = "FALLIDA"
});
Estados.Add(new ListaGenerica {
codigo = "A", descripcion = "ANULADA"
});
}
private void LoadedCmd_Execute(bool isNFe)
{
if (DestinatarioParaSalvar == null)
{
DestinatarioParaSalvar = new DestinatarioModel()
{
IsNFe = isNFe
};
}
else
{
DestinatarioParaSalvar.IsNFe = isNFe;
}
var estados = _estadoService.GetEstados();
foreach (var estado in estados)
{
Estados.Add(estado);
}
var emitenteUf = _emissorService.GetEmissor().Endereco.UF;
DestinatarioParaSalvar.Endereco.UF = emitenteUf;
UfSelecionadoCmd_Execute();
}
private void LerEstados()
{
int op;
Console.WriteLine("Insira o(s) estado(s): ");
do
{
var estado = new Estado();
Console.WriteLine("Escreva o nome do estado:");
estado.Nome = Console.ReadLine();
Console.WriteLine("Esse estado é inicial? 1- Sim 0- Não");
estado.Inicial =
Convert.ToBoolean(int.Parse(Console.ReadLine() ?? throw new InvalidOperationException()));
Console.WriteLine("Esse estado é final? 1- Sim 0- Não");
estado.Final =
Convert.ToBoolean(int.Parse(Console.ReadLine() ?? throw new InvalidOperationException()));
Estados.Add(estado);
var e = Estados.FirstOrDefault(e => e.Nome == estado.Nome);
if (e != default)
{
Console.WriteLine($"O estado {e.Nome} ja existe");
}
Console.WriteLine("Deseja continuar inserindo? 1- Sim 0- Não");
op = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("\n\n" + MostrarEstados());
} while (op == 1);
}
private async Task PreencherEstados()
{
var estados = await _battutaService.ObterEstados(PaisSelecionado.Codigo);
Estados.Clear();
foreach (var estado in estados)
{
Estados.Add(estado);
}
}
public virtual void AgregarVersionEstado(DocumentoVersionEstado versionEstado)
{
Estados.ToList <DocumentoVersionEstado>().ForEach(delegate(DocumentoVersionEstado verEstado)
{
if (verEstado.Estado.Equals(versionEstado.Estado) && verEstado.Fecha.Equals(versionEstado.Fecha))
{
throw new ApplicationException(string.Format("El estado {0} ya existe en la versión para la fecha {1}",
versionEstado.Estado, versionEstado.FechaToString));
}
});
versionEstado.Version = this;
Estados.Add(versionEstado);
}
private void TransportadoraWindowLoadedCmd_Execute()
{
var estados = _estadoService.GetEstados();
foreach (var estado in estados)
{
Estados.Add(estado);
}
var emitenteUf = _emissorService.GetEmissor().Endereco.UF;
TransportadoraParaSalvar.Endereco.UF = emitenteUf;
UfSelecionadoCmd_Execute();
}
public string AgregarEstado(Estado e)
{
string msg = "";
if (!Estados.Contains(e))
{
Estados.Add(e);
msg = "Ok";
}
else
{
msg = "Estado existente";
}
return(msg);
}
public void AgregarEstado(Estado estado)
{
foreach (var transicion in estado.Transiciones)
{
if (AlfabetoAutomatico)
{
Alfabeto.Add(transicion.Key);
}
else if (!Alfabeto.Contains(transicion.Key))
{
throw new TransitionNotInAlphabetException();
}
}
Estados.Add(estado);
estado.AutomataPadre = this;
}
public FiltroRanking GetFiltroRankingSimulado(int idSimulado)
{
try
{
using (MiniProfiler.Current.Step("Obter modal simulado online"))
{
var filtroRanking = new FiltroRanking();
var especialidades = new Especialidades();
var estados = new Estados();
var filiais = new Filiais();
var ranking = _rankingSimuladoRepository.GetRankingParcial(idSimulado);
foreach (var item in ranking)
{
especialidades.Add(new Especialidade {
Descricao = item.txtEspecialidade
});
var hasSigla = item.txtUnidade.Any(x => x.Equals('('));
estados.Add(new Estado
{
Sigla = hasSigla ? item.txtUnidade.Substring(item.txtUnidade.IndexOf('(')).Replace("(", "").Replace(")", "") : item.txtUnidade,
ID = (int)item.intStateID
});
filiais.Add(new Filial
{
Nome = item.txtUnidade == "MEDREADER" ? "MEDREADER" : item.txtUnidade,
EstadoID = (int)item.intStateID
});
}
var estadoEAD = -1;
filtroRanking.Especialidades.AddRange(especialidades.GroupBy(e => new { e.Descricao }).Select(g => g.First()).ToList());
filtroRanking.Estados.AddRange(estados.GroupBy(e => new { e.Sigla, e.ID }).Select(g => g.First()).ToList());
filtroRanking.Unidades.AddRange(filiais.Where(e => e.EstadoID != estadoEAD).GroupBy(e => new { e.Nome, e.ID, e.EstadoID }).Select(g => g.First()).ToList());
return(filtroRanking);
//}
}
}
catch
{
throw;
}
}
public void GenerarTransiciones()
{
//El estado incial es el FIRST de la raíz
Estados.Add(new Estado(Raiz.First));
//Se plantean todos los caracteres que se van a analizar, o sea se muestra el valor de todas las hojas sin repetirse
foreach (var nodoHoja in Hojas)
{
if (!TablaTransiciones.ContainsKey(nodoHoja.ItemExpresion) && nodoHoja.ItemExpresion != "#")
{
TablaTransiciones.Add(nodoHoja.ItemExpresion, new List <Estado>());
}
}
//Como hay una lista de estados, se hace el procedimiento por cada estado de la lista y se le aplica a cada "columna/caracter/Hoja"
for (int i = 0; i < Estados.Count; i++)
{
//Por cada "columna/caracter/Hoja", se hace...
foreach (var columna in TablaTransiciones)
{
//Variable que sirve para llevar el control si algún "nodo" del estado que se está evaluando coincide
var match = false;
//Por cada "nodo" del estado que se evalúa actualmente
foreach (var nodoEstado in Estados[i].ListaNodos)
{
//si algún nodo coincide con la "columna/caracter/Hoja"...
if (nodoEstado.ItemExpresion == columna.Key)
{
//se marca que sí coincide y...
match = true;
//se manda a traer los FOLLOW de ese nodo que se analiza.
//Luego para que no hayan datos repetidos en el estado que se está creando, se hace que....
//Por cada nodo del FOLLOW se verifica si ya se ingresó previamente al nuevo estado
foreach (var nodoFollow in Hojas[nodoEstado.NumNodo - 1].Follow)
{
if (columna.Value.Count == i)
{
columna.Value.Add(new Estado(-1));
}
if (!columna.Value[i].ListaNodos.Contains(nodoFollow))
{
columna.Value[i].ListaNodos.Add(nodoFollow);
}
}
var existe = false;
for (int j = 0; j < Estados.Count; j++)
{
var contador = 0;
foreach (var itemEstado in Estados[j].ListaNodos)
{
if (itemEstado.NumNodo != columna.Value[i].ListaNodos[contador].NumNodo)
{
existe = false;
}
else
{
existe = true;
contador++;
}
if (existe == false)
{
break;
}
}
if (existe == true)
{
columna.Value[i].Nombre = Estados[j].Nombre;
break;
}
}
if (existe == false)
{
var estado = new Estado(Estados.Count);
estado.ListaNodos = columna.Value[i].ListaNodos;
VerificarAceptacion(ref estado);
Estados.Add(estado);
columna.Value[i].Nombre = estado.Nombre;
}
}
}
if (match == false)
{
var estadoAux = new Estado(-1);
estadoAux.Nombre = "-";
columna.Value.Add(estadoAux);
}
}
}
}
public ReactiveCadastroContratoViewModel(IReactiveRepository repository, DispatcherScheduler dispatcherScheduler)
: base(repository, dispatcherScheduler)
{
// NOTE: Inicialização dos campos
// Carrega os contratos do banco
Repository.GetAll <Contrato>()
.Busy(this)
.Subscribe(contratos =>
{
foreach (var contrato in contratos)
{
ContratosSalvos.Add(contrato);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega as naturalidades do banco de maneira assíncrona
Repository.GetAll <Naturalidade>()
.Busy(this)
.Subscribe(naturalidades =>
{
foreach (var naturalidade in naturalidades)
{
Naturalidades.Add(naturalidade);
}
NaturalidadeSelecionada = Naturalidades.First();
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
Repository.GetAll <EstadoCivil>()
.Busy(this)
.Subscribe(estadosCivis =>
{
foreach (var estadoCivil in estadosCivis)
{
EstadosCivis.Add(estadoCivil);
}
EstadoCivilSelecionado = EstadosCivis.First();
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega os estados do banco de maneira assíncrona
Repository.GetAll <Estado>()
.Busy(this)
.Subscribe(estados =>
{
foreach (var estado in estados)
{
Estados.Add(estado);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega os bairros do banco de maneira assíncrona
Repository.GetAll <Bairro>()
.Busy(this)
.Subscribe(bairros =>
{
foreach (var bairro in bairros)
{
Bairros.Add(bairro);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega os cidades do banco de maneira assíncrona
Repository.GetAll <Cidade>()
.Busy(this)
.Subscribe(cidades =>
{
foreach (var cidade in cidades)
{
Cidades.Add(cidade);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega as secretarias do banco de maneira assíncrona
Repository.GetAll <Secretaria>()
.Busy(this)
.Subscribe(secretarias =>
{
foreach (var secretaria in secretarias)
{
Secretarias.Add(secretaria);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// Carrega as jornadas do banco de maneira assíncrona
Repository.GetAll <Jornada>()
.Busy(this)
.Subscribe(jornadas =>
{
foreach (var jornada in jornadas)
{
Jornadas.Add(jornada);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
// NOTE: Validação dos campos.
// Para cada campo abaixo é criado um fluxo que verifica se o campo está preenchido. Caso não esteja
// uma notificação de erro será propagada. O fluxo é acionado de maneira reativa, através da interação
// do usuário na aplicação.
var nomeHasErrors = this.WhenAnyValue(s => s.Nome, texto => string.IsNullOrEmpty(texto));
ObservarErroCampoObrigatorio(nomeHasErrors, nameof(Nome));
var cpfHasErros = this.WhenAnyValue(s => s.Cpf, texto => string.IsNullOrEmpty(texto));
ObservarErroCampoObrigatorio(cpfHasErros, nameof(Cpf));
var rgHasErros = this.WhenAnyValue(s => s.Rg, texto => string.IsNullOrEmpty(texto));
ObservarErroCampoObrigatorio(rgHasErros, nameof(Rg));
var orgExpHasErros = this.WhenAnyValue(s => s.OrgExp, texto => string.IsNullOrEmpty(texto));
ObservarErroCampoObrigatorio(orgExpHasErros, nameof(OrgExp));
var enderecoHasErros = this.WhenAnyValue(s => s.Endereco, texto => string.IsNullOrEmpty(texto));
ObservarErroCampoObrigatorio(enderecoHasErros, nameof(Endereco));
var estadoCivilHasErros = this.WhenAny(s => s.EstadoCivilSelecionado, e => e.Value is null);
var naturalidadeHasErros = this.WhenAny(s => s.NaturalidadeSelecionada, e => e.Value is null);
var estadoHasErros = this.WhenAny(s => s.EstadoSelecionado, e => e.Value is null);
var bairroHasErros = this.WhenAny(s => s.BairroSelecionado, e => e.Value is null);
var cidadeHasErros = this.WhenAny(s => s.CidadeSelecionada, e => e.Value is null);
var secretariaHasErros = this.WhenAny(s => s.SecretariaSelecionada, e => e.Value is null);
var orgaoHasErros = this.WhenAny(s => s.OrgaoSelecionado, e => e.Value is null);
var deparmentoHasErros = this.WhenAny(s => s.DepartamentoSelecionado, e => e.Value is null);
var dotacaoHasErros = this.WhenAny(s => s.DotacaoSelecionado, e => e.Value is null);
var descricaoVinculoHasErros = this.WhenAny(s => s.DescricaoVinculoSelecionado, e => e.Value is null);
var cargoHasErros = this.WhenAny(s => s.CargoSelecionado, e => e.Value is null);
var jornadaHasErros = this.WhenAny(s => s.JornadaSelecionada, e => e.Value is null);
// Criamos um fluxo que é a combinação de todos os fluxos de validação acima.
// Caso algum fluxo apresente o valor verdadeiro, isto é, caso algum fluxo notifique uma mensagem de erro,
// este fluxo irá propagar uma notificação que fará com que o comando abaixo não possa ser executado.
var salvarCanExecute = Observable.CombineLatest(
this.WhenAnyValue(s => s.IsBusy),
nomeHasErrors,
cpfHasErros,
rgHasErros,
orgExpHasErros,
estadoCivilHasErros,
naturalidadeHasErros,
estadoHasErros,
enderecoHasErros,
bairroHasErros,
cidadeHasErros,
secretariaHasErros,
orgaoHasErros,
deparmentoHasErros,
dotacaoHasErros,
descricaoVinculoHasErros,
cargoHasErros,
jornadaHasErros)
.Select(observables => !observables.Any(r => r == true));
SalvarCommand = ReactiveCommand.Create(SalvarExecute, salvarCanExecute);
// Regras de negócio
// Ao selecionar uma nova secretaria carregamos dados referentes a esta secretaria
this.WhenAnyValue(s => s.SecretariaSelecionada)
.Subscribe(newSecretaria =>
{
if (newSecretaria != null)
{
Repository.Get <DescricaoVinculo>(e => e.SecretariaId == newSecretaria.SecretariaId)
.Busy(this)
.Subscribe(descricaoVinculos =>
{
foreach (var descricaoVinculo in descricaoVinculos)
{
DescricaoVinculos.Add(descricaoVinculo);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
Repository.Get <Orgao>(e => e.SecretariaId == newSecretaria.SecretariaId)
.Busy(this)
.Subscribe(orgaos =>
{
foreach (var orgao in orgaos)
{
Orgaos.Add(orgao);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
Repository.Get <Departamento>(e => e.SecretariaId == newSecretaria.SecretariaId)
.Busy(this)
.Subscribe(departamentos =>
{
foreach (var departamento in departamentos)
{
Departamentos.Add(departamento);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
Repository.Get <Dotacao>(e => e.SecretariaId == newSecretaria.SecretariaId)
.Busy(this)
.Subscribe(dotacoes =>
{
foreach (var dotacao in dotacoes)
{
Dotacoes.Add(dotacao);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
Repository.Get <Cargo>(e => e.SecretariaId == newSecretaria.SecretariaId)
.Busy(this)
.Subscribe(cargos =>
{
foreach (var cargo in cargos)
{
Cargos.Add(cargo);
}
},
ex =>
{
System.Windows.Forms.MessageBox.Show(ex.Message, "Erro");
});
}
});
}
// Isso é um construtor, presente em qualquer linguagem de programação.
// Todo o código escrito aqui será chamado SOMENTE UMA VEZ durante a inicialização da janela
public CadastroContratoViewModel() : base(new Repository())
{
// Carregamos todos os Contratos gravados no banco de dados. isso é similar a um "SELECT * FROM Contrato";
var contratos = Repository.GetAll <Contrato>();
// Populamos o combobox com os contatos recuperados
foreach (var contrato in contratos)
{
ContratosSalvos.Add(contrato);
}
// Carregamos todas as Naturalidades gravados no banco de dados. isso é similar a um "SELECT * FROM Naturalidade";
var naturalidades = Repository.GetAll <Naturalidade>();
// Populamos o combobox com as naturalidades recuperados
foreach (var naturalidade in naturalidades)
{
Naturalidades.Add(naturalidade);
}
// Carregamos todas os estados civis gravados no banco de dados. isso é similar a um "SELECT * FROM EstadoCivil";
var estadosCivis = Repository.GetAll <EstadoCivil>();
// Populamos o combobox com os estadosCivis recuperados
foreach (var estadoCivil in estadosCivis)
{
EstadosCivis.Add(estadoCivil);
}
// Aqui definimos que inicialmente o estado civil selecionado será o primeiro elemento do combobox
EstadoCivilSelecionado = EstadosCivis.First();
// Carregamos todas os Estados gravados no banco de dados. isso é similar a um "SELECT * FROM Estado";
var estados = Repository.GetAll <Estado>();
// Populamos o combobox com os estados recuperados
foreach (var estado in estados)
{
Estados.Add(estado);
}
// Carregamos todas os Bairros gravados no banco de dados. isso é similar a um "SELECT * FROM Bairro";
var bairros = Repository.GetAll <Bairro>();
// Populamos o combobox com os bairros recuperados
foreach (var bairro in bairros)
{
Bairros.Add(bairro);
}
// Carregamos todas as Cidades gravados no banco de dados. isso é similar a um "SELECT * FROM Cidade";
var cidades = Repository.GetAll <Cidade>();
// Populamos o combobox com as cidades recuperados
foreach (var cidade in cidades)
{
Cidades.Add(cidade);
}
// Carregamos todas as Secretarias gravados no banco de dados. isso é similar a um "SELECT * FROM Secretaria";
var secretarias = Repository.GetAll <Secretaria>();
// Populamos o combobox com as secretarias recuperados
foreach (var secretaria in secretarias)
{
Secretarias.Add(secretaria);
}
// Carregamos todas as Jornadas gravados no banco de dados. isso é similar a um "SELECT * FROM Jornada";
var jornadas = Repository.GetAll <Jornada>();
// Populamos o combobox com as jornadas recuperados
foreach (var jornada in jornadas)
{
Jornadas.Add(jornada);
}
// Criamos um comando para o botão de Salvar. O método "SalvarExecute" será chamado sempre que o usuário acionar o botão
SalvarCommand = new DelegateCommand(SalvarExecute);
// Criamos uma rotina que será executada sempre que a secretaria selecionada mudar.
// Diferente dos demais códigos escritos no construtor, esse código pode ser chamado mais de uma vez.
this.WhenAnyValue(s => s.SecretariaSelecionada)
.Subscribe(newSecretaria =>
{
// Atenção: O código de todo esse bloco será executado sempre que uma nova secretaria for selecionada.
// "newSecretaria" representa a nova secretaria selecionada pelo usuário.
// Caso a nova secretaria selecionada não seja null, isto é, não seja uma secretária inválida
if (newSecretaria != null)
{
// Carregamos todas as descrições associadas a nova secretaria selecionada. isso é similar a um "SELECT * FROM DescricaoVinculo WHERE SecretariaId = @newSecretariaId";
var descricaoVinculos = Repository.Get <DescricaoVinculo>(e => e.SecretariaId == newSecretaria.SecretariaId);
// Populamos o combobox com as descricaoVinculos recuperados
foreach (var descricaoVinculo in descricaoVinculos)
{
DescricaoVinculos.Add(descricaoVinculo);
}
// Carregamos todos os orgãos associados a nova secretaria selecionada. isso é similar a um "SELECT * FROM Orgao WHERE SecretariaId = @newSecretariaId";
var orgaos = Repository.Get <Orgao>(e => e.SecretariaId == newSecretaria.SecretariaId);
// Populamos o combobox com os orgaos recuperados
foreach (var orgao in orgaos)
{
Orgaos.Add(orgao);
}
// Carregamos todos os departamentos associados a nova secretaria selecionada. isso é similar a um "SELECT * FROM Departamento WHERE SecretariaId = @newSecretariaId";
var departamentos = Repository.Get <Departamento>(e => e.SecretariaId == newSecretaria.SecretariaId);
// Populamos o combobox com os departamentos recuperados
foreach (var departamento in departamentos)
{
Departamentos.Add(departamento);
}
// Carregamos todos as dotações associadas a nova secretaria selecionada. isso é similar a um "SELECT * FROM Dotacao WHERE SecretariaId = @newSecretariaId";
var dotacoes = Repository.Get <Dotacao>(e => e.SecretariaId == newSecretaria.SecretariaId);
// Populamos o combobox com os departamentos recuperados
foreach (var dotacao in dotacoes)
{
Dotacoes.Add(dotacao);
}
// Carregamos todos os Cargos associados a nova secretaria selecionada. isso é similar a um "SELECT * FROM Cargo WHERE SecretariaId = @newSecretariaId";
var cargos = Repository.Get <Cargo>(e => e.SecretariaId == newSecretaria.SecretariaId);
// Populamos o combobox com os cargos recuperados
foreach (var cargo in cargos)
{
Cargos.Add(cargo);
}
}
});
}