001: /*
002: * Created on 29/09/2004
003: *
004: * Swing Components - visit http://sf.net/projects/gfd
005: *
006: * Copyright (C) 2004 Igor Regis da Silva Simões
007: *
008: * This program is free software; you can redistribute it and/or
009: * modify it under the terms of the GNU General Public License
010: * as published by the Free Software Foundation; either version 2
011: * of the License, or (at your option) any later version.
012: *
013: * This program is distributed in the hope that it will be useful,
014: * but WITHOUT ANY WARRANTY; without even the implied warranty of
015: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
016: * GNU General Public License for more details.
017: *
018: * You should have received a copy of the GNU General Public License
019: * along with this program; if not, write to the Free Software
020: * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
021: *
022: */
023: package br.com.gfp.db;
024:
025: import java.io.BufferedReader;
026: import java.io.File;
027: import java.io.FileReader;
028: import java.io.IOException;
029: import java.io.InputStream;
030: import java.io.InputStreamReader;
031: import java.net.URL;
032: import java.sql.SQLException;
033: import java.util.ArrayList;
034: import java.util.Calendar;
035: import java.util.Date;
036: import java.util.Enumeration;
037: import java.util.Locale;
038:
039: import javax.xml.parsers.DocumentBuilder;
040: import javax.xml.parsers.DocumentBuilderFactory;
041: import javax.xml.parsers.ParserConfigurationException;
042:
043: import org.w3c.dom.Document;
044: import org.w3c.dom.NamedNodeMap;
045: import org.w3c.dom.Node;
046: import org.w3c.dom.NodeList;
047: import org.xml.sax.SAXException;
048:
049: import br.com.gfp.dao.AccountSavingDAO;
050: import br.com.gfp.dao.AccountTypeDAO;
051: import br.com.gfp.dao.AssetsDAO;
052: import br.com.gfp.dao.BankDAO;
053: import br.com.gfp.dao.CheckingAccountDAO;
054: import br.com.gfp.dao.ContactDAO;
055: import br.com.gfp.dao.CreditCardDAO;
056: import br.com.gfp.dao.GFPController;
057: import br.com.gfp.dao.IncomePredictionDAO;
058: import br.com.gfp.dao.TransactionDAO;
059: import br.com.gfp.dao.TransactionTypeDAO;
060: import br.com.gfp.data.AccountSaving;
061: import br.com.gfp.data.AccountType;
062: import br.com.gfp.data.Assets;
063: import br.com.gfp.data.Bank;
064: import br.com.gfp.data.CheckingAccount;
065: import br.com.gfp.data.Contact;
066: import br.com.gfp.data.CreditCard;
067: import br.com.gfp.data.Transaction;
068: import br.com.gfp.data.TransactionType;
069: import br.com.gfp.features.AtualizaRendimentoAplicacao;
070: import br.com.gfp.features.CalcularValorFaturaCartao;
071: import br.com.gfp.features.PreverGastosEReceitas;
072: import br.com.gfp.features.PreverMovimentoAplicacao;
073: import br.com.gfp.features.PreverRendimentosAplicacao;
074: import br.com.gfp.internationalization.TipoDeLancamentosMessages;
075: import br.com.gfp.util.GFPProperties;
076: import br.com.gfp.util.SimpleLog;
077: import br.com.gfpshare.controllers.AcessoController;
078: import br.com.gfpshare.db.DAO;
079: import br.com.gfpshare.db.DataBaseManager;
080: import br.com.gfpshare.db.SQLCondition;
081: import br.com.gfpshare.db.SQLCondition.Condicao;
082: import br.com.gfpshare.plugin.core.DynamicClassLoader;
083: import br.com.gfpshare.security.Acesso;
084:
085: /**
086: * @author Igor Regis da Silva Simoes
087: */
088: public final class DBInicializador {
089: /**
090: * Classe controladora das previsões de aplicações
091: */
092: private static PreverMovimentoAplicacao controladorDePrevisaoDeRendimentos = null;
093:
094: private static AtualizaRendimentoAplicacao atualizaRendimentoAplicacao = null;
095:
096: private static CalcularValorFaturaCartao calcularValorFaturaCartao = null;
097:
098: private static PreverGastosEReceitas preverGastosEReceitas = null;
099:
100: /**
101: * Inicializa o banco de dados, criando as tabelas e inserindo os dados básicos Aqui também criamos o banco de
102: * dados. É normal uma exceção ser lançada aqui, caso o banco já exista. Isso vai ocorrer sempre que for aberto um
103: * arquivo que já possui lançamentos
104: *
105: * @throws IOException
106: * @throws SQLException
107: */
108: public static void inicializarBancoDeDados() throws IOException,
109: SQLException {
110: DataBaseManager dbManager = DataBaseManager
111: .getDataBaseManager(
112: System
113: .getProperty(GFPProperties.ARQUIVO_CONFIG_BANCO_DE_DADOS),
114: System
115: .getProperty(GFPProperties.DIRETORIO_BANCO_DE_DADOS));
116:
117: // Carregamos o arquivo que contém os DDL (Data Definition Language) para criação do banco de dados
118: File ddlSQL = new File(System
119: .getProperty(GFPProperties.DIRETORIO_BANCO_DE_DADOS)
120: + File.separator + "ddl.sql");
121: BufferedReader reader = new BufferedReader(new FileReader(
122: ddlSQL));
123: String ddl = "", temp = null;
124: do {
125: ddl += (temp = reader.readLine()) == null ? "" : temp;
126: } while (temp != null);
127:
128: try {
129: // Criamos o banco de dados. É normal uma exceção ser lançada aqui, caso o banco já exista.
130: // Isso vai ocorrer sempre que for aberto um arquivo que já possui lançamentos
131: dbManager.executarAtualizacao(ddl, null);
132: } catch (SQLException sqle) {
133: ((SimpleLog) GFPController.getGFPController().getContexto()
134: .get(GFPController.LOG))
135: .log("Excecao capturada e relancada! "
136: + sqle.getLocalizedMessage());
137: throw sqle;
138: } finally {
139: // Fazemos a migração da banco de dados caso seja necessário
140: String versaoAtualDB = dbManager
141: .getPropriedade(DataBaseManager.VERSAO_DB);
142: versaoAtualDB = versaoAtualDB == null ? "1" : versaoAtualDB;
143: dbManager.setVersaoDB(new MigradorDB().migrarDB(
144: "br.com.gfp.db.migration.MigrarDB", Integer
145: .parseInt(versaoAtualDB)));
146:
147: initListeners();
148: }
149: insertTipoDeConta();
150: insertBanks(dbManager);
151: insertTipoLancamentos();
152: insertAcessos();
153: }
154:
155: /**
156: * Insert a predefined list of banks to GFP data base
157: * according to user country
158: * @param dbManager
159: * @throws IOException
160: * @throws SQLException
161: */
162: private static void insertBanks(DataBaseManager dbManager)
163: throws IOException, SQLException {
164: InputStream is = DynamicClassLoader.getClassLoader()
165: .getResourceAsStream(
166: "db/banks/banks_"
167: + Locale.getDefault().getLanguage()
168: + "_"
169: + Locale.getDefault().getCountry()
170: + ".sql");
171: if (is == null)
172: return;
173: BufferedReader reader = new BufferedReader(
174: new InputStreamReader(is, "ISO-8859-1"));
175: String ddl = "", temp = null;
176: do {
177: ddl += (temp = reader.readLine()) == null ? "" : temp;
178: } while (temp != null);
179:
180: if (ddl.trim().equals(""))
181: return;
182: dbManager.executarAtualizacao(ddl, null);
183: }
184:
185: /**
186: * Este método realizad as mesmas operações que o método inicializarDB, só que para os plugins instalados.
187: *
188: * @throws IOException Caso não seja possível fazer a leitura dos arquivos ddls dos plugins
189: * @throws SQLException Caso de erro ao abrir o DBManager (muito dificil dar esse erro).
190: */
191: public static void inicializarDBDosPlugins() throws IOException,
192: SQLException {
193: DataBaseManager dbManager = DataBaseManager
194: .getDataBaseManager(
195: System
196: .getProperty(GFPProperties.ARQUIVO_CONFIG_BANCO_DE_DADOS),
197: System
198: .getProperty(GFPProperties.DIRETORIO_BANCO_DE_DADOS));
199: Enumeration ddls = DynamicClassLoader
200: .getSystemResourcesEndingWith("ddl.sql");
201:
202: while (ddls.hasMoreElements()) {
203: URL ddlUrl = (URL) ddls.nextElement();
204: String file = ddlUrl.getFile();
205: String pluginName = file.substring(file.indexOf("plugins")
206: + "plugins".length() + 1);
207: pluginName = pluginName.substring(0, pluginName
208: .indexOf('/'));
209:
210: ((SimpleLog) GFPController.getGFPController().getContexto()
211: .get(GFPController.LOG))
212: .log("Inicializando DB do Plugin: " + pluginName);
213:
214: BufferedReader leitor = new BufferedReader(
215: new InputStreamReader(ddlUrl.openStream()));
216: String ddl = "", temp = null;
217:
218: do {
219: temp = leitor.readLine();
220: if (temp != null)
221: ddl += temp;
222:
223: } while (temp != null);
224:
225: try {
226: // Criamos o banco de dados. É normal uma exceção ser lançada aqui, caso o banco já exista.
227: // Isso vai ocorrer sempre que for aberto um arquivo que já possui lançamentos
228: dbManager.executarAtualizacao(ddl, null);
229: } catch (SQLException sqle) {
230: ((SimpleLog) GFPController.getGFPController()
231: .getContexto().get(GFPController.LOG))
232: .log("Erro ao inicializar DB do plugin "
233: + pluginName);
234: ((SimpleLog) GFPController.getGFPController()
235: .getContexto().get(GFPController.LOG)).log(sqle
236: .getLocalizedMessage());
237: }
238: }
239: }
240:
241: /**
242: * Retorna o objeto que irá controlar as aplicações
243: */
244: private static void initListeners() {
245: TransactionDAO<Transaction> lancamentoController = new TransactionDAO<Transaction>();
246:
247: if (calcularValorFaturaCartao == null) {
248: try {
249: calcularValorFaturaCartao = new CalcularValorFaturaCartao();
250: } catch (Exception e) {
251: ((SimpleLog) GFPController.getGFPController()
252: .getContexto().get(GFPController.LOG))
253: .log("Erro ao inicializar calculo de fatura de cartao!");
254: ((SimpleLog) GFPController.getGFPController()
255: .getContexto().get(GFPController.LOG)).log(e
256: .getLocalizedMessage());
257: ((SimpleLog) GFPController.getGFPController()
258: .getContexto().get(GFPController.LOG)).log(e);
259: }
260: // Inicalizamos o controle de Perevisão das aplicações.
261: lancamentoController
262: .addControllerListener(calcularValorFaturaCartao);
263: }
264:
265: if (atualizaRendimentoAplicacao == null) {
266: try {
267: atualizaRendimentoAplicacao = new AtualizaRendimentoAplicacao();
268: } catch (Exception e) {
269: ((SimpleLog) GFPController.getGFPController()
270: .getContexto().get(GFPController.LOG))
271: .log("Erro ao inicializar atualizacao rendimento aplicacao!");
272: ((SimpleLog) GFPController.getGFPController()
273: .getContexto().get(GFPController.LOG)).log(e
274: .getLocalizedMessage());
275: ((SimpleLog) GFPController.getGFPController()
276: .getContexto().get(GFPController.LOG)).log(e);
277: }
278:
279: // Inicalizamos o controle das alterações que podem afetar as apliações
280: // sejam lançamentos ou previsões de rendimento
281: lancamentoController
282: .addControllerListener(atualizaRendimentoAplicacao);
283:
284: new IncomePredictionDAO()
285: .addControllerListener(atualizaRendimentoAplicacao);
286: }
287:
288: if (preverGastosEReceitas == null) {
289: try {
290: preverGastosEReceitas = new PreverGastosEReceitas();
291: } catch (Exception e) {
292: ((SimpleLog) GFPController.getGFPController()
293: .getContexto().get(GFPController.LOG))
294: .log("Erro ao inicializar previsao de gastos e receitas!");
295: ((SimpleLog) GFPController.getGFPController()
296: .getContexto().get(GFPController.LOG)).log(e
297: .getLocalizedMessage());
298: ((SimpleLog) GFPController.getGFPController()
299: .getContexto().get(GFPController.LOG)).log(e);
300: }
301:
302: // Inicalizamos o controle das alterações que podem afetar as previsões
303: // sobre lançamentos futuros
304: lancamentoController
305: .addControllerListener(preverGastosEReceitas);
306: }
307:
308: try {
309: preverGastosEReceitas.limparPrevisoesAteDiaAtual();
310: } catch (SQLException e) {
311: ((SimpleLog) GFPController.getGFPController().getContexto()
312: .get(GFPController.LOG))
313: .log("Erro ao limpar previsoes de gastos e receitas!");
314: ((SimpleLog) GFPController.getGFPController().getContexto()
315: .get(GFPController.LOG)).log(e
316: .getLocalizedMessage());
317: ((SimpleLog) GFPController.getGFPController().getContexto()
318: .get(GFPController.LOG)).log(e);
319: }
320:
321: if (controladorDePrevisaoDeRendimentos == null) {
322: try {
323: controladorDePrevisaoDeRendimentos = new PreverMovimentoAplicacao();
324: } catch (Exception e) {
325: ((SimpleLog) GFPController.getGFPController()
326: .getContexto().get(GFPController.LOG))
327: .log("Erro ao inicializar previsao movimento aplicacao!");
328: ((SimpleLog) GFPController.getGFPController()
329: .getContexto().get(GFPController.LOG)).log(e
330: .getLocalizedMessage());
331: ((SimpleLog) GFPController.getGFPController()
332: .getContexto().get(GFPController.LOG)).log(e);
333: }
334:
335: // Inicalizamos o controle de Perevisão das aplicações.
336: lancamentoController
337: .addControllerListener(controladorDePrevisaoDeRendimentos);
338: }
339:
340: try {
341: new PreverRendimentosAplicacao()
342: .verSeVaiPreverMovimento(null);
343: } catch (Exception e) {
344: ((SimpleLog) GFPController.getGFPController().getContexto()
345: .get(GFPController.LOG))
346: .log("Erro ao prever movimento de aplicacao na virada do mes!");
347: ((SimpleLog) GFPController.getGFPController().getContexto()
348: .get(GFPController.LOG)).log(e
349: .getLocalizedMessage());
350: ((SimpleLog) GFPController.getGFPController().getContexto()
351: .get(GFPController.LOG)).log(e);
352: }
353:
354: try {
355: updateBensValue();
356: } catch (SQLException e) {
357: ((SimpleLog) GFPController.getGFPController().getContexto()
358: .get(GFPController.LOG))
359: .log("Erro ao realizar depreciacao dos bens!");
360: ((SimpleLog) GFPController.getGFPController().getContexto()
361: .get(GFPController.LOG)).log(e
362: .getLocalizedMessage());
363: ((SimpleLog) GFPController.getGFPController().getContexto()
364: .get(GFPController.LOG)).log(e);
365: }
366: }
367:
368: /**
369: * Atualiza os valores dos bens, considerando a depreciação
370: *
371: * @throws SQLException
372: */
373: private static void updateBensValue() throws SQLException {
374: AssetsDAO assetsDAO = new AssetsDAO();
375: Assets parametro = new Assets();
376: parametro.addCondicaoExtra(new SQLCondition<Object>(
377: "DataVenda", Condicao.IS_NULL));
378: ArrayList<Assets> bens = assetsDAO.getAllBy(parametro);
379: for (Assets assets : bens)
380: assetsDAO.atualizar(assets);
381: }
382:
383: /**
384: * Insere todos os tipos de lancamentos iniciais a serem usados pela aplicação a partir de um arquivo xml
385: *
386: * @throws SQLException
387: */
388: private static void insertTipoLancamentos() throws SQLException {
389: try {
390: Enumeration enu = DynamicClassLoader.getClassLoader()
391: .getResources("/xml/db/TiposDeLancamentos.xml");
392: while (enu.hasMoreElements()) // for each xml file...
393: {
394: DocumentBuilderFactory factory = DocumentBuilderFactory
395: .newInstance();
396: factory.setValidating(true);
397: factory.setNamespaceAware(true);
398:
399: URL url = (URL) enu.nextElement();
400:
401: DocumentBuilder builder = factory.newDocumentBuilder();
402: Document document = builder.parse(url.openStream(), url
403: .toString()); // We load/parse the file
404:
405: // Insert all fiels in xml file
406: insertTipoLancamentos(null, document.getLastChild()
407: .getChildNodes());
408: }
409: } catch (ParserConfigurationException e) {
410: ((SimpleLog) GFPController.getGFPController().getContexto()
411: .get(GFPController.LOG))
412: .log("Erro ao realizar parsing do xml: /xml/db/TiposDeLancamentos.xml");
413: ((SimpleLog) GFPController.getGFPController().getContexto()
414: .get(GFPController.LOG)).log(e
415: .getLocalizedMessage());
416: ((SimpleLog) GFPController.getGFPController().getContexto()
417: .get(GFPController.LOG)).log(e);
418: } catch (SAXException e) {
419: ((SimpleLog) GFPController.getGFPController().getContexto()
420: .get(GFPController.LOG))
421: .log("Erro ao realizar parsing do xml: /xml/db/TiposDeLancamentos.xml");
422: ((SimpleLog) GFPController.getGFPController().getContexto()
423: .get(GFPController.LOG)).log(e
424: .getLocalizedMessage());
425: ((SimpleLog) GFPController.getGFPController().getContexto()
426: .get(GFPController.LOG)).log(e);
427: } catch (IOException e) {
428: ((SimpleLog) GFPController.getGFPController().getContexto()
429: .get(GFPController.LOG))
430: .log("Erro ao ler arquivo xml: /xml/db/TiposDeLancamentos.xml");
431: ((SimpleLog) GFPController.getGFPController().getContexto()
432: .get(GFPController.LOG)).log(e
433: .getLocalizedMessage());
434: ((SimpleLog) GFPController.getGFPController().getContexto()
435: .get(GFPController.LOG)).log(e);
436: }
437: }
438:
439: /**
440: * Metodo que adiciona as itens na tabela do banco de dados de forma recursiva, baseado no NodeList passado e
441: * considerando o parent. Caso o parent esteja null então o tipo de lançamento não terá supertipo
442: *
443: * @param parent Supertipo de um Tipo de lançamento - pode ser null
444: * @param listaDeTipos Lista de todos os tipos em um mesmo nível
445: * @throws SQLException
446: */
447: private static void insertTipoLancamentos(String parent,
448: NodeList listaDeTipos) throws SQLException {
449: TransactionTypeDAO ctrlTipoLancamento = new TransactionTypeDAO();
450: TransactionType transactionType = new TransactionType();
451:
452: // for each registry type
453: for (int i = 0; i < listaDeTipos.getLength(); i++) {
454: Node n = null;
455: if ((n = listaDeTipos.item(i)).getNodeName().equals("Tipo"))// if its name is Tipo
456: {
457: NamedNodeMap atributos = n.getAttributes();
458: Node atributo = null;
459:
460: String nome = TipoDeLancamentosMessages.getMessages()
461: .getString(
462: atributos.getNamedItem("Nome")
463: .getNodeValue().trim())
464: .replaceAll("_USER_",
465: System.getProperty("user.name"));
466: transactionType.setNome(nome);
467:
468: if ((atributo = atributos
469: .getNamedItem("RealizarPrevisao")) != null) {
470: transactionType.setRealizarPrevisao(Boolean
471: .valueOf(atributo.getNodeValue().trim()));
472: } else
473: transactionType.setRealizarPrevisao(Boolean
474: .valueOf(false));
475:
476: if ((atributo = atributos.getNamedItem("DadoDeSistema")) != null) {
477: transactionType.setEhDeSistema(Boolean
478: .valueOf(atributo.getNodeValue().trim()));
479: } else
480: transactionType.setEhDeSistema(Boolean
481: .valueOf("false"));
482:
483: if ((atributo = atributos.getNamedItem("Descricao")) != null) {
484: String descricao = TipoDeLancamentosMessages
485: .getMessages().getString(
486: atributo.getNodeValue().trim())
487: .replaceAll("_USER_",
488: System.getProperty("user.name"));
489: transactionType.setDescricao(descricao);
490: } else
491: transactionType.setDescricao(null);
492:
493: if (parent != null)// If it has a parent then we must include it
494: transactionType
495: .setSuperTipo(ctrlTipoLancamento.getBy(
496: new TransactionType(parent))
497: .getId());
498: else
499: transactionType.setSuperTipo(null);
500:
501: try {
502: // Let's check if this registry allready exist, if a error occur, we will add it as a new registry
503: ctrlTipoLancamento.getBy(transactionType);
504: } catch (SQLException e) {
505: ctrlTipoLancamento.adicionarNovo(transactionType);
506: }
507:
508: // For each item we try to add its childNodes
509: insertTipoLancamentos(TipoDeLancamentosMessages
510: .getMessages().getString(
511: atributos.getNamedItem("Nome")
512: .getNodeValue().trim()), n
513: .getChildNodes());
514: }
515: }
516: }
517:
518: /**
519: * Insere todos os tipos de conta usados por default pelo GFP
520: *
521: * @throws SQLException
522: */
523: private static void insertTipoDeConta() throws SQLException {
524: DAO<AccountType> tipoDeContaController = new AccountTypeDAO();
525: AccountType aplicacaoTipo = new AccountType("aplicacao");
526: tipoDeContaController.adicionarNovo(aplicacaoTipo);
527:
528: AccountType contaCorrenteTipo = new AccountType("contaCorrente");
529: tipoDeContaController.adicionarNovo(contaCorrenteTipo);
530:
531: AccountType cartaoCreditoTipo = new AccountType("cartaoCredito");
532: tipoDeContaController.adicionarNovo(cartaoCreditoTipo);
533:
534: Bank bank = new Bank();
535: bank.setCodigo("0000");
536: bank.setNome("Banco do sistema");
537: bank.setEhDeSistema(Boolean.TRUE);
538: DAO<Bank> bancoController = new BankDAO();
539: bancoController.adicionarNovo(bank);
540: bank = bancoController.getBy(bank);
541:
542: Contact contact = new Contact();
543: contact.setNome("Entidade do sistema");
544: contact.setEhDeSistema(Boolean.TRUE);
545: DAO<Contact> entidadeController = new ContactDAO();
546: entidadeController.adicionarNovo(contact);
547: contact = entidadeController.getBy(contact);
548:
549: CreditCard creditCard = new CreditCard();
550: creditCard.setBanco(bank.getId());
551: creditCard.setDataAbertura(new Date());
552: creditCard.setDiasParaPagamento(Integer.valueOf("1"));
553: creditCard.setDataFechamento(new Date());
554: creditCard.setDataPagamento(Integer.valueOf("1"));
555: Calendar c = Calendar.getInstance();
556: c.add(Calendar.YEAR, 100);
557: creditCard.setDataValidade(c.getTime());
558: creditCard.setDescricao("cartao do sistema");
559: creditCard.setJurosFinanciamento(Double.valueOf("0.0"));
560: creditCard.setJurosRotativo(Double.valueOf("0.0"));
561: creditCard.setLimite(Double.valueOf("0.0"));
562: creditCard.setNumeroCartao("00000000");
563: creditCard.setOperadora(contact.getId());
564: creditCard.setEhDeSistema(Boolean.TRUE);
565: DAO<CreditCard> cartaoCreditoController = new CreditCardDAO();
566: cartaoCreditoController.adicionarNovo(creditCard);
567:
568: AccountSaving accountSaving = new AccountSaving();
569: accountSaving.setBanco(bank.getId());
570: accountSaving.setDataAbertura(new Date());
571: accountSaving.setDescricao("AccoutSaving do sistema");
572: accountSaving.setNumeroAgencia("00000");
573: accountSaving.setNumeroConta("00000000");
574: accountSaving.setTipoRendimento(Integer.valueOf("-1"));
575: accountSaving.setValorMinimoMovimentacao(Double.valueOf("0.0"));
576: accountSaving.setEhDeSistema(Boolean.TRUE);
577: DAO<AccountSaving> aplicacaoController = new AccountSavingDAO();
578: aplicacaoController.adicionarNovo(accountSaving);
579:
580: CheckingAccount checkingAccount = new CheckingAccount();
581: checkingAccount.setBanco(bank.getId());
582: checkingAccount.setDataAbertura(new Date());
583: checkingAccount.setDescricao("Account do sistema");
584: checkingAccount.setNumeroAgencia("00000");
585: checkingAccount.setNumeroConta("00000000");
586: checkingAccount.setEhDeSistema(Boolean.TRUE);
587: DAO<CheckingAccount> contaCorrenteController = new CheckingAccountDAO();
588: contaCorrenteController.adicionarNovo(checkingAccount);
589: }
590:
591: /**
592: * Insere todas as regras de acesso do sistema
593: *
594: * @throws SQLException
595: */
596: private static void insertAcessos() throws SQLException {
597: DAO<Acesso> acessoController = new AcessoController();
598: Acesso acesso = new Acesso();
599: Integer indice = null;
600:
601: acesso.setNome("Salvar arquivo de controle de finanças");
602: acesso.setSuperTipo(null);
603: acessoController.adicionarNovo(acesso);
604:
605: acesso.setNome("Tela Lançamentos");
606: acesso.setSuperTipo(null);
607: acessoController.adicionarNovo(acesso);
608:
609: indice = acessoController.getBy(new Acesso("Tela Lançamentos"))
610: .getId();
611:
612: acesso.setNome("Adicionar novo lançamento");
613: acesso.setSuperTipo(indice);
614: acessoController.adicionarNovo(acesso);
615:
616: acesso.setNome("Salvar lançamentos");
617: acesso.setSuperTipo(indice);
618: acessoController.adicionarNovo(acesso);
619:
620: acesso.setNome("Excluir lançamentos");
621: acesso.setSuperTipo(indice);
622: acessoController.adicionarNovo(acesso);
623:
624: acesso.setNome("Tela Tipo de Lançamentos");
625: acesso.setSuperTipo(null);
626: acessoController.adicionarNovo(acesso);
627:
628: indice = acessoController.getBy(
629: new Acesso("Tela Tipo de Lançamentos")).getId();
630:
631: acesso.setNome("Adicionar novo tipo de lançamento");
632: acesso.setSuperTipo(indice);
633: acessoController.adicionarNovo(acesso);
634:
635: acesso.setNome("Salvar tipos de lançamento");
636: acesso.setSuperTipo(indice);
637: acessoController.adicionarNovo(acesso);
638:
639: acesso.setNome("Excluir tipos de lançamentos");
640: acesso.setSuperTipo(indice);
641: acessoController.adicionarNovo(acesso);
642:
643: acesso.setNome("Tela Account Corrente");
644: acesso.setSuperTipo(null);
645: acessoController.adicionarNovo(acesso);
646:
647: indice = acessoController.getBy(
648: new Acesso("Tela Account Corrente")).getId();
649:
650: acesso.setNome("Adicionar nova conta corrente");
651: acesso.setSuperTipo(indice);
652: acessoController.adicionarNovo(acesso);
653:
654: acesso.setNome("Salvar contas corrente");
655: acesso.setSuperTipo(indice);
656: acessoController.adicionarNovo(acesso);
657:
658: acesso.setNome("Excluir contas corrente");
659: acesso.setSuperTipo(indice);
660: acessoController.adicionarNovo(acesso);
661:
662: acesso.setNome("Tela Aplicações");
663: acesso.setSuperTipo(null);
664: acessoController.adicionarNovo(acesso);
665:
666: indice = acessoController.getBy(new Acesso("Tela Aplicações"))
667: .getId();
668:
669: acesso.setNome("Adicionar nova aplicação");
670: acesso.setSuperTipo(indice);
671: acessoController.adicionarNovo(acesso);
672:
673: acesso.setNome("Salvar aplicações");
674: acesso.setSuperTipo(indice);
675: acessoController.adicionarNovo(acesso);
676:
677: acesso.setNome("Excluir aplicações");
678: acesso.setSuperTipo(indice);
679: acessoController.adicionarNovo(acesso);
680:
681: acesso.setNome("Configurar Aplicações");
682: acesso.setSuperTipo(indice);
683: acessoController.adicionarNovo(acesso);
684:
685: acesso.setNome("Tela Bancos");
686: acesso.setSuperTipo(null);
687: acessoController.adicionarNovo(acesso);
688:
689: indice = acessoController.getBy(new Acesso("Tela Bancos"))
690: .getId();
691:
692: acesso.setNome("Adicionar novo banco");
693: acesso.setSuperTipo(indice);
694: acessoController.adicionarNovo(acesso);
695:
696: acesso.setNome("Salvar bancos");
697: acesso.setSuperTipo(indice);
698: acessoController.adicionarNovo(acesso);
699:
700: acesso.setNome("Excluir bancos");
701: acesso.setSuperTipo(indice);
702: acessoController.adicionarNovo(acesso);
703:
704: acesso.setNome("Tela Bens");
705: acesso.setSuperTipo(null);
706: acessoController.adicionarNovo(acesso);
707:
708: indice = acessoController.getBy(new Acesso("Tela Bens"))
709: .getId();
710:
711: acesso.setNome("Adicionar novo bem");
712: acesso.setSuperTipo(indice);
713: acessoController.adicionarNovo(acesso);
714:
715: acesso.setNome("Salvar bens");
716: acesso.setSuperTipo(indice);
717: acessoController.adicionarNovo(acesso);
718:
719: acesso.setNome("Excluir bens");
720: acesso.setSuperTipo(indice);
721: acessoController.adicionarNovo(acesso);
722:
723: acesso.setNome("Tela Entidades");
724: acesso.setSuperTipo(null);
725: acessoController.adicionarNovo(acesso);
726:
727: indice = acessoController.getBy(new Acesso("Tela Entidades"))
728: .getId();
729:
730: acesso.setNome("Adicionar nova entidade");
731: acesso.setSuperTipo(indice);
732: acessoController.adicionarNovo(acesso);
733:
734: acesso.setNome("Salvar entidades");
735: acesso.setSuperTipo(indice);
736: acessoController.adicionarNovo(acesso);
737:
738: acesso.setNome("Excluir entidades");
739: acesso.setSuperTipo(indice);
740: acessoController.adicionarNovo(acesso);
741: }
742: }
|