public void CalibrarPotenciaPotencia(ParqueEolico parqueEolico, bool isTempoReal)
{
try
{
if (isTempoReal)
{
this.criarCaminhoDeDiscoCalibrador(Path.GetFullPath(CALIBRADOR_TR_DIRECTORY_NAME));
this.criarPastaDeTrabalhoCalibrador(CALIBRADOR_TR_DIRECTORY_NAME + PASTA_TRABALHO, parqueEolico, "TR");
var process = Process.Start(CALIBRADOR_TR_EXE);
process.WaitForExit();
FactoryController.getInstance().PrevisorController.montarEstruturaParaPrevisao(parqueEolico.SiglaPrevEOL, PrevisorController.PREVISAO_TIPO.TEMPO_REAL);
this.copiarPesosOtimos(parqueEolico, PrevisorController.PREVISAO_TIPO.TEMPO_REAL);
this.criarAtualizarArquivoParquesCalibrados(parqueEolico, PrevisorController.PREVISAO_TIPO.TEMPO_REAL);
}
else
{
this.criarCaminhoDeDiscoCalibrador(Path.GetFullPath(CALIBRADOR_PP_DIRECTORY_NAME));
this.criarPastaDeTrabalhoCalibrador(CALIBRADOR_PP_DIRECTORY_NAME + PASTA_TRABALHO, parqueEolico, "PP");
var process = Process.Start(CALIBRADOR_PP_EXE);
process.WaitForExit();
FactoryController.getInstance().PrevisorController.montarEstruturaParaPrevisao(parqueEolico.SiglaPrevEOL, PrevisorController.PREVISAO_TIPO.POTENCIA_POTENCIA);
this.copiarPesosOtimos(parqueEolico, PrevisorController.PREVISAO_TIPO.POTENCIA_POTENCIA);
this.criarAtualizarArquivoParquesCalibrados(parqueEolico, PrevisorController.PREVISAO_TIPO.POTENCIA_POTENCIA);
}
FactoryDAO.getInstance().ParqueEolicoDAO.atualizarParqueFoiCalibrado(parqueEolico);
}
catch (Exception e)
{
throw new Exception("Ops, ocorreu um erro na calibração dos dados.");
}
}
public void PreverVentoPotencia(EntradaVentoPotencia parque)
{
try
{
Dictionary <String, Object> dicPotenciaMedia = FactoryDAO.getInstance().PotenciaMediaHoraMesDAO.
carregarArquivoPotenciaMedia(Path.GetFullPath(Util.Util.POTENCIA_MEDIA_DIRECTORY_NAME), parque.ParqueEolico.Nome);
List <List <EntradaVentoPotencia> > dados = FactoryDAO.getInstance().
PrevisorDAO.GetDadosPrevisaoPotenciaVento(parque.ParqueEolico, dicPotenciaMedia);
gerarArquivosDeEntrada(Path.GetFullPath(PREVISOR_VP_DIRECTORY_NAME) +
"\\" + parque.ParqueEolico.SiglaPrevEOL + "\\Entradas", dados);
this.atualizarParquePastaTrabalho(parque.ParqueEolico.SiglaPrevEOL, PREVISOR_VP_DIRECTORY_NAME);
this.atualizarCaminhoDoExecutavelDoPrevisor(Path.GetFullPath(PREVISOR_VP_DIRECTORY_NAME));
this.executarPrevisor(PREVISOR_VP_EXE);
}
catch (FileNotFoundException e)
{
MessageBox.Show(e.Message, Constants.WARNNING_CAPTION);
}
catch (Exception ex)
{
throw ex;
}
}
public void UpdateFactoryByIdTest()
{
Factory factory = CreateFactory();
FactoryDAO dao = new FactoryDAO();
bool insert = dao.InsertFactory(factory);
Base basPom = new Base();
basPom.Planet = "Mars";
BaseDAO baseDAO = new BaseDAO();
baseDAO.InsertBase(basPom);
factory.BaseId = bas.BaseId;
factory.CargoCount = 40;
factory.Type = "služby";
dao.UpdateFactoryById(factory);
Factory factoryPom = dao.GetFactoryById(factory.FacotryId);
Assert.IsTrue(factoryPom.BaseId == bas.BaseId && factoryPom.CargoCount == 40 && factoryPom.Type == "služby");
dao.RemoveFactoryById(factory.FacotryId);
baseDAO.RemoveBaseById(basPom.BaseId);
}
static void Main()
{
IFactoryDAO factory = new FactoryDAO
{
UserID = "sa",
Password = "******",
DataSource = @"BOSS\MSSQLENTERPRISE",
InitialCatalog = "geikoDbUsers"
};
IUserDAO ud = new FactoryUserDAO {
factory = factory
};
IContactDAO cd = new FactoryContactDAO {
factory = factory
};
IUserServises servises = new UserServises {
UserDAO = ud, ContactDAO = cd
};
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new FormMain(servises));
}
internal void realizarPrevisao(ParqueEolico parque, string tipo)
{
String tag = parque.SiglaGETOT;
String initialDate = "06/08/2014 13:00:00";
String currentDateTime = "06/08/2014 13:00:00";
TimeSpan span = new TimeSpan(3, 0, 0);
string format = "dd/MM/yyyy HH:mm:ss";
//Get current date
DateTime time2 = DateTime.Now;
currentDateTime = time2.ToString(format);
//Get past date from desired time interval
DateTime time1 = time2.Subtract(span);
initialDate = time1.ToString(format);
MyPiFileUtil fileReader = new MyPiFileUtil();
if (tipo.Equals("PP"))
{
this.atualizarParquePastaTrabalho(parque.SiglaPrevEOL, PREVISOR_PP_DIRECTORY_NAME);
this.atualizarCaminhoDoExecutavelDoPrevisor(Path.GetFullPath(PREVISOR_PP_DIRECTORY_NAME));
//Abrir PI
MyPiController controller = new MyPiController(tag, initialDate, currentDateTime);
controller.run();
ArrayList integralizedPowerList = fileReader.readPotRequestFile(tag, PREVISOR_PP_NUMERO_ENTRADAS);
String path = PREVISOR_PP_DIRECTORY_NAME + "/" + parque.SiglaPrevEOL + PASTA_ENTRADAS;
//Escrever arquivo com entradas para previsão
fileReader.writeFile(integralizedPowerList, tag, path);
this.executarPrevisor(PREVISOR_PP_EXE);
}
else if (tipo.Equals("TR"))
{
this.atualizarParquePastaTrabalho(parque.SiglaPrevEOL, PREVISOR_TR_DIRECTORY_NAME);
this.atualizarCaminhoDoExecutavelDoPrevisor(Path.GetFullPath(PREVISOR_TR_DIRECTORY_NAME));
//Abrir PI
MyPiController controller = new MyPiController(tag, initialDate, currentDateTime);
controller.run();
ArrayList integralizedPowerList = fileReader.readPotRequestFile(tag, PREVISOR_TR_NUMERO_ENTRADAS);
String path = PREVISOR_TR_DIRECTORY_NAME + "/" + parque.SiglaPrevEOL + PASTA_ENTRADAS;
//Escrever arquivo com entradas para previsão
fileReader.writeFile(integralizedPowerList, tag, path);
//executar previsão
this.executarPrevisor(PREVISOR_TR_EXE);
}
FactoryDAO.getInstance().ParqueEolicoDAO.atualizarParqueFoiPrevisto(parque);
}
public static FactoryDAO getInstance()
{
if (instance == null)
{
instance = new FactoryDAO();
}
return(instance);
}
public void InsertFactoryTest()
{
Factory factory = CreateFactory();
FactoryDAO dao = new FactoryDAO();
bool insert = dao.InsertFactory(factory);
Assert.IsTrue(insert);
dao.RemoveFactoryById(factory.FacotryId);
}
/// <summary>
/// Método cria todos os Daos Necessários para o FacedeOrcamento
/// </summary>
private void CriaDAOS()
{
_daoOrca = FactoryDAO.CriaDAOOrcamento();
_daoItem = FactoryDAO.CriaDAOItemOrcamento();
_daoCliente = FactoryDAO.CriaDAOCliente();
_daoProduto = FactoryDAO.CriaDAOProduto();
_daoSerie = FactoryDAO.CriaDaoSerieMaquina();
_daoOS = FactoryDAO.CriaDaoOS();
}
public void gerarArquivoTreinamentoVentoPotencia(ParqueEolico parqueEolico, DateTime dataInicial, DateTime dataFinal, String intervalo)
{
DirectoryInfo directoryInfoCalibrador = Util.Util.GetOrCreateIfNotExistsDiretoriosCalibracao(CALIBRADOR_VP_DIRECTORY_NAME + "/" + parqueEolico.SiglaPrevEOL);
DirectoryInfo directoryInfoPotenciaMedia = Util.Util.GetOrCreateIfNotExistsDiretorioPotenciaMedia();
FactoryDAO.getInstance().PotenciaMediaHoraMesDAO.gerarArquivosPotenciaMedia(parqueEolico, directoryInfoPotenciaMedia.FullName, intervalo);
FactoryDAO.getInstance().CPTECDAO.gerarArquivoTreinamentoVentoPotencia(parqueEolico, directoryInfoCalibrador.FullName + Util.Util.getEntradaPath(),
directoryInfoPotenciaMedia.FullName, dataInicial, dataFinal, intervalo);
this.criarAtualizarArquivoParquesCalibrados(parqueEolico, PrevisorController.PREVISAO_TIPO.VENTO_POTENCIA);
}
public void GetFactoriesTest()
{
Factory factory = CreateFactory();
FactoryDAO dao = new FactoryDAO();
bool insert = dao.InsertFactory(factory);
List <Factory> factoryPom = dao.GetFactories();
Assert.IsTrue(factoryPom.Count == 1);
}
public void RemoveFactoryByIdTest()
{
Factory factory = CreateFactory();
FactoryDAO dao = new FactoryDAO();
bool insert = dao.InsertFactory(factory);
dao.RemoveFactoryById(factory.FacotryId);
Factory factoryPom = dao.GetFactoryById(factory.FacotryId);
Assert.IsNull(factoryPom);
}
public void GetFactoryByIdTest()
{
Factory factory = CreateFactory();
FactoryDAO dao = new FactoryDAO();
bool insert = dao.InsertFactory(factory);
Factory factoryPom = dao.GetFactoryById(factory.FacotryId);
Assert.IsTrue(factory.FacotryId == factoryPom.FacotryId && factory.BaseId == factoryPom.BaseId);
dao.RemoveFactoryById(factory.FacotryId);
}
internal List <EntradaVentoPotencia> GetInputPrevisaoVentoPotencia()
{
List <EntradaVentoPotencia> ret = new List <EntradaVentoPotencia>();
List <ParqueEolico> parquesEolicos = (List <ParqueEolico>)FactoryController.getInstance().ParqueEolicoController.getParquesCalibrados("VP");
for (int i = 0; i < parquesEolicos.Count; i++)
{
EntradaVentoPotencia inVP = FactoryDAO.getInstance().PrevisorDAO.GetDadosPrevisaoPotenciaVentoVisualizar(parquesEolicos[i]);
if (inVP != null)
{
ret.Add(inVP);
}
}
return(ret);
}
public void Save(User user)
{
List <string> texts = new List <string>()
{
user.Name, user.Lastname, user.Login, user.Password
};
if (fieldsInvalid(texts))
{
throw new Exception("No field can be blank!");
}
if (LoginCheck(user.Login))
{
throw new Exception("Login already exists!");
}
FactoryDAO.getUserDAO().Save(user);
}
public void GetFactoriesByTypeTest()
{
Factory factory = CreateFactory();
FactoryDAO dao = new FactoryDAO();
bool insert = dao.InsertFactory(factory);
int firstId = factory.FacotryId;
factory.Type = "služby";
dao.InsertFactory(factory);
List <Factory> factoryPom = dao.GetFactoriesByType("zboží");
Assert.IsTrue(factoryPom.Count == 1);
dao.RemoveFactoryById(factory.FacotryId);
dao.RemoveFactoryById(firstId);
}
public void calibrarVentoPotencia(ParqueEolico parqueEolico)
{
try
{
this.criarCaminhoDeDiscoCalibrador(Path.GetFullPath(CALIBRADOR_VP_DIRECTORY_NAME));
this.criarPastaDeTrabalhoCalibrador(CALIBRADOR_VP_DIRECTORY_NAME + PASTA_TRABALHO, parqueEolico, "VP");
var process = Process.Start(CALIBRADOR_VP_EXE);
process.WaitForExit();
FactoryDAO.getInstance().ParqueEolicoDAO.atualizarParqueFoiCalibrado(parqueEolico);
FactoryController.getInstance().PrevisorController.montarEstruturaParaPrevisao(parqueEolico.SiglaPrevEOL, PrevisorController.PREVISAO_TIPO.VENTO_POTENCIA);
this.copiarPesosOtimos(parqueEolico, PrevisorController.PREVISAO_TIPO.VENTO_POTENCIA);
}
catch (Exception ex)
{
throw new Exception("Ops, ocorreu um erro durante a calibração dos dados.");
}
}
public void gerarArquivosTreinamentoPotenciaPotencia(ParqueEolico parqueEolico, int numeroDeEntradas,
DateTime dataInicial, DateTime dataFinal, String intervalo, bool isTempoReal)
{
String parque = parqueEolico.Nome.Replace(' ', '_');
String nomeArquivo = "";
try
{
List <ParqueEolicoImportacaoPrevEOL> listaCompleta = FactoryDAO.getInstance().PrevEOLDAO.GetList(parqueEolico,
dataInicial, dataFinal, intervalo);
DirectoryInfo directoryInfo;
if (isTempoReal)
{
directoryInfo = Util.Util.GetOrCreateIfNotExistsDiretoriosCalibracao(CALIBRADOR_TR_DIRECTORY_NAME + "/" + parqueEolico.SiglaPrevEOL);
}
else
{
directoryInfo = Util.Util.GetOrCreateIfNotExistsDiretoriosCalibracao(CALIBRADOR_PP_DIRECTORY_NAME + "/" + parqueEolico.SiglaPrevEOL);
}
if (intervalo.Equals(Util.Util.DEZ_MINUTOS))
{
nomeArquivo = parque + "_10_min_full_" + (2 + numeroDeEntradas) + "_36.txt";
this.gerarArquivoPotenciaPotenciaCompleto(directoryInfo.FullName + Util.Util.getEntradaPath(),
numeroDeEntradas, nomeArquivo, 1, 36, listaCompleta);
this.gerarArquivosPotenciaPotenciaDiarios10min(directoryInfo.FullName + Util.Util.getEntradaPath(),
numeroDeEntradas, nomeArquivo, parque);
}
else if (intervalo.Equals(Util.Util.TRINTA_MINUTOS))
{
nomeArquivo = parque + "_30_min_full_" + (2 + numeroDeEntradas) + "_48.txt";
this.gerarArquivoPotenciaPotenciaCompleto(directoryInfo.FullName + Util.Util.getEntradaPath(),
numeroDeEntradas, nomeArquivo, 5, 48, listaCompleta);
this.gerarArquivosPotenciaPotenciaDiarios30min(directoryInfo.FullName + Util.Util.getEntradaPath(),
numeroDeEntradas, nomeArquivo, parque);
}
}
catch (Exception e)
{
Console.WriteLine("ERROR: " + e.Message);
}
}
public Boolean excluirCargo(Cargo objCargo)
{
//Validação de existência do cargo utilizado por algum usuário
FuncionarioDAO objFuncionarioDAO = FactoryDAO.criarFuncionarioDAO();
if (!objFuncionarioDAO.possuiFuncionarioPorCargo(objCargo))
{
db = ServidorSingleton.obterServidor().OpenClient();
try
{
IObjectSet leitor = db.QueryByExample(objCargo);
if (leitor.HasNext())
{
db.Delete((Cargo)leitor.Next());
db.Commit();
return(true);
}
else
{
return(false);
}
}
catch
{
db.Rollback();
return(false);
}
finally
{
db.Close();
db.Dispose();
}
}
else
{
return(false);
}
}
public void cadastrarPedido(SolicitacaoMateriais objSolicitacao, string materiaisFornecedores)
{
PedidoDAO objPedidoDAO = FactoryDAO.criarPedidoDAO();
Collection <Materiais> objMateriaisColecao = new Collection <Materiais>();
//Obtem cada item e seu fornecedor
string[] arrLinhas = materiaisFornecedores.Split('§');
for (int i = 0; i < arrLinhas.Length; i++)
{
//Obtem o fornecedor e item
string[] arrItemFornecedor = arrLinhas[i].Split('|');
Materiais objMateriais = FactoryClasses.criarMateriais();
objMateriais.Codigo = Convert.ToInt32(arrItemFornecedor[0]);
Fornecedor objFornecedor = FactoryClasses.criarFornecedor();
objFornecedor.Codigo = Convert.ToInt32(arrItemFornecedor[1]);
objMateriais.Fornecedor = objFornecedor;
objMateriaisColecao.Add(objMateriais);
}
objSolicitacao.Materiais = objMateriaisColecao;
objPedidoDAO.cadastrarPedido(objSolicitacao);
}
public void GetFactoriesByPlanetTest()
{
Factory factory = CreateFactory();
FactoryDAO dao = new FactoryDAO();
bool insert = dao.InsertFactory(factory);
int firstId = factory.FacotryId;
Base basPom = new Base();
basPom.Planet = "Mars";
BaseDAO baseDAO = new BaseDAO();
baseDAO.InsertBase(basPom);
factory.BaseId = basPom.BaseId;
dao.InsertFactory(factory);
List <Factory> factoryPom = dao.GetFactoriesByPlanet("Země");
Assert.IsTrue(factoryPom.Count == 1);
dao.RemoveFactoryById(factory.FacotryId);
dao.RemoveFactoryById(firstId);
baseDAO.RemoveBaseById(basPom.BaseId);
}
public List <ParqueEolicoImportacaoCPTEC> getDadosImportados(int idParqueEolico, int limit)
{
return(FactoryDAO.getInstance().CPTECDAO.SelectDataImported(idParqueEolico, limit));
}
public void importarArquivoNovo(string caminho, int idParqueEolico)
{
FactoryDAO.getInstance().CPTECDAO.importarArquivoNovo(caminho, idParqueEolico);
}
public AccountUiFacade(string DaoType)
{
dao = FactoryDAO <IAccount> .getDao(DaoType);
}
public EngenheiroCampoBll()
{
objEngenheiroCampoDAO = FactoryDAO.criarEngenheiroCampoDAO();
}
public GestorObraBll()
{
objGestorDAO = FactoryDAO.criarGestorObraDAO();
}
private void importPrevEOLFile_Button_Click(object sender, RoutedEventArgs e)
{
try
{
this.feedbackMessage.Visibility = Visibility.Hidden;
if (files.Length > 0)
{
int qtdArquivos = files.Length;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += (o, ea) =>
{
try
{
int progressoPorAquivo = 100 / files.Length;
int count = 0;
foreach (FileInfo file in this.files)
{
count++;
this.Dispatcher.Invoke(new Action(() => { this.txtProgressValue.Text = "Importando arquivo " + count + "/" + qtdArquivos + "."; }));
for (int i = 0; i < this.listaParquesEolicos.Count; i++)
{
string sigla = this.listaParquesEolicos[i].SiglaPrevEOL;
if (file.Name.IndexOf(sigla, StringComparison.OrdinalIgnoreCase) != -1)
{
// Arquivos de 30 minutos
if (file.Name.IndexOf(Util.Util.TRINTA_MINUTOS, StringComparison.OrdinalIgnoreCase) != -1)
{
FactoryDAO.getInstance().PrevEOLDAO.importarArquivoPrevEOL(file.FullName, this.listaParquesEolicos[i].Id, Util.Util.TRINTA_MINUTOS);
}
// Arquivos de 10 minutos
else if (file.Name.IndexOf(Util.Util.DEZ_MINUTOS, StringComparison.OrdinalIgnoreCase) != -1)
{
FactoryDAO.getInstance().PrevEOLDAO.importarArquivoPrevEOL(file.FullName, this.listaParquesEolicos[i].Id, Util.Util.DEZ_MINUTOS);
}
else
{
break;
}
file.CopyTo(CAMINHO_FILES + CAMINHO_SAIDA_IMPORTACAO + "\\" + file.Name, true);
File.Delete(file.FullName);
break;
}
}
this.Dispatcher.Invoke(new Action(() =>
{
//this.processBar.Value += progressoPorAquivo;
this.LoadFiles();
}));
}
this.Dispatcher.Invoke(new Action(() => { this.feedbackMessage.Visibility = Visibility.Visible; }));
}
catch (Exception ex)
{
this.Dispatcher.Invoke(new Action(() => { this.ShowInfoMessage(ex.Message); }));
}
};
worker.RunWorkerCompleted += (param, args) =>
{
if (args.Error != null)
{
MessageBox.Show(args.Error.ToString());
}
this.Dispatcher.Invoke(new Action(() =>
{
HideProgressBar();
}));
};
this.Dispatcher.Invoke(new Action(() =>
{
ShowProgressBar();
}));
worker.RunWorkerAsync();
}
}
catch (Exception ex)
{
this.ShowInfoMessage(ex.Message);
}
}
public void cadastrarPedido(SolicitacaoMateriais objSolicitacao)
{
//Atualiza a solicitação no db
SolicitacaoMateriaisDAO objSolicitacaoDAO = FactoryDAO.criarSolicitacaoMateriaisDAO();
if (objSolicitacaoDAO.atualizarSolicitacao(objSolicitacao))
{
SolicitacaoMateriais objSolicitacaoProt = FactoryClasses.criarSolicitacaoMateriais();
objSolicitacaoProt.Codigo = objSolicitacao.Codigo;
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitor = db.QueryByExample(objSolicitacaoProt);
if (leitor.HasNext())
{
objSolicitacaoProt = null;
objSolicitacaoProt = (SolicitacaoMateriais)leitor.Next();
}
leitor = null;
Collection <Pedido> objPedidoColecao = new Collection <Pedido>();
foreach (Materiais material in objSolicitacaoProt.Materiais)
{
Pedido objPedido = FactoryClasses.criarPedido();
objPedido.SolicitacaoMateriais = objSolicitacaoProt;
Collection <Materiais> objMateriaisColecao = new Collection <Materiais>();
objMateriaisColecao.Add(material);
objPedido.Materiais = objMateriaisColecao;
objPedido.Codigo = obtemNovoId();
db = ServidorSingleton.obterServidor().OpenClient();
db.Store(objPedido);
db.Commit();
}
//Le os pedidos
Pedido objPedidoProt = FactoryClasses.criarPedido();
objPedidoProt.SolicitacaoMateriais = objSolicitacaoProt;
db = ServidorSingleton.obterServidor().OpenClient();
IObjectSet leitorPedidoCache = db.QueryByExample(objPedidoProt);
int codFornecedor = 0;
int contador = 0;
int codPedido = 0;
while (leitorPedidoCache.HasNext())
{
Pedido objPedidoLer = (Pedido)leitorPedidoCache.Next();
if (contador == 0)
{
codFornecedor = objPedidoLer.Materiais[0].Fornecedor.Codigo;
}
else
{
if (codFornecedor == objPedidoLer.Materiais[0].Fornecedor.Codigo)
{
//Retira os itens deste pedido e coloca no anterior
Collection <Materiais> objMateriaisColecaoTmp = new Collection <Materiais>();
foreach (Materiais item in objPedidoLer.Materiais)
{
objMateriaisColecaoTmp.Add(item);
}
//exclui o pedido atual
db.Delete(objPedidoLer);
//Carrega o anterior em cache
Pedido p = FactoryClasses.criarPedido();
p.Codigo = codPedido;
IObjectSet leitorPedido2 = db.QueryByExample(p);
if (leitorPedido2.HasNext())
{
p = null;
p = (Pedido)leitorPedido2.Next();
//Atualiza o pedido anterior com os dados do pedido que foi apagado
foreach (Materiais item in p.Materiais)
{
objMateriaisColecaoTmp.Add(item);
}
p.Materiais = objMateriaisColecaoTmp;
db.Store(p);
db.Commit();
}
leitorPedido2 = null;
}
}
codFornecedor = objPedidoLer.Materiais[0].Fornecedor.Codigo;
codPedido = objPedidoLer.Codigo;
contador++;
}
leitorPedidoCache = null;
db.Close();
db.Dispose();
}
}
public AnalistaFaturamentoBll()
{
objAnalistaFatDAO = FactoryDAO.criarAnalistaFaturamentoDAO();
}
public FornecedorBll()
{
objFornecedorDAO = FactoryDAO.criarFornecedorDAO();
}
public AnalistaFinanceiroBll()
{
objAnalistaFinanceiroDAO = FactoryDAO.criarAnalistaFinanceiroDAO();
}
