public List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /** Table Cash Money columns. */
    List<String> cashMoneyColumns = new ArrayList<String>();

    cashMoneyColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_CASH_TRANSACTION_ID_COLUMN_NAME);
    cashMoneyColumns.add(CashMoneyWalletDatabaseConstants.CASH_MONEY_WALLET_KEY_BROKER_COLUMN_NAME);
    cashMoneyColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_PUBLIC_KEY_CUSTOMER_COLUMN_NAME);
    cashMoneyColumns.add(CashMoneyWalletDatabaseConstants.CASH_MONEY_PUBLIC_KEY_BROKER_COLUMN_NAME);
    cashMoneyColumns.add(CashMoneyWalletDatabaseConstants.CASH_MONEY_BALANCE_TYPE_COLUMN_NAME);
    cashMoneyColumns.add(CashMoneyWalletDatabaseConstants.CASH_MONEY_TRANSACTION_TYPE_COLUMN_NAME);
    cashMoneyColumns.add(CashMoneyWalletDatabaseConstants.CASH_MONEY_AMOUNT_COLUMN_NAME);
    cashMoneyColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_CASH_CURRENCY_TYPE_COLUMN_NAME);
    cashMoneyColumns.add(CashMoneyWalletDatabaseConstants.CASH_MONEY_CASH_REFERENCE_COLUMN_NAME);
    cashMoneyColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_RUNNING_BOOK_BALANCE_COLUMN_NAME);
    cashMoneyColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_RUNNING_AVAILABLE_BALANCE_COLUMN_NAME);
    cashMoneyColumns.add(CashMoneyWalletDatabaseConstants.CASH_MONEY_TIMESTAMP_COLUMN_NAME);
    cashMoneyColumns.add(CashMoneyWalletDatabaseConstants.CASH_MONEY_MEMO_COLUMN_NAME);
    cashMoneyColumns.add(CashMoneyWalletDatabaseConstants.CASH_MONEY_STATUS_COLUMN_NAME);
    /** Table Cash Money addition. */
    DeveloperDatabaseTable cashMoneyTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            CashMoneyWalletDatabaseConstants.CASH_MONEY_TABLE_NAME, cashMoneyColumns);
    tables.add(cashMoneyTable);

    /** Table Cash Money Total Balances columns. */
    List<String> cashMoneyTotalBalancesColumns = new ArrayList<String>();

    cashMoneyTotalBalancesColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_TOTAL_BALANCES_WALLET_KEY_BROKER_COLUMN_NAME);
    cashMoneyTotalBalancesColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_TOTAL_BALANCES_PUBLIC_KEY_BROKER_COLUMN_NAME);
    cashMoneyTotalBalancesColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_TOTAL_BALANCES_CASH_CURRENCY_TYPE_COLUMN_NAME);
    cashMoneyTotalBalancesColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_TOTAL_BALANCES_NAME_COLUMN_NAME);
    cashMoneyTotalBalancesColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_TOTAL_BALANCES_DESCRIPTION_COLUMN_NAME);
    cashMoneyTotalBalancesColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_TOTAL_BALANCES_AVAILABLE_BALANCE_COLUMN_NAME);
    cashMoneyTotalBalancesColumns.add(
        CashMoneyWalletDatabaseConstants.CASH_MONEY_TOTAL_BALANCES_BOOK_BALANCE_COLUMN_NAME);
    /** Table Cash Money Total Balances addition. */
    DeveloperDatabaseTable cashMoneyTotalBalancesTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            CashMoneyWalletDatabaseConstants.CASH_MONEY_TOTAL_BALANCES_TABLE_NAME,
            cashMoneyTotalBalancesColumns);
    tables.add(cashMoneyTotalBalancesTable);

    return tables;
  }
  public List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {

    List<DeveloperDatabaseTable> tables = new ArrayList<>();

    /** Table Wallet Contacts columns. */
    List<String> walletContactsColumns = new ArrayList<>();

    walletContactsColumns.add(
        WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACTS_CONTACT_ID_COLUMN_NAME);
    walletContactsColumns.add(
        WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACTS_ACTOR_PUBLIC_KEY_COLUMN_NAME);
    walletContactsColumns.add(
        WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACTS_ACTOR_TYPE_COLUMN_NAME);
    walletContactsColumns.add(
        WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACTS_ACTOR_ALIAS_COLUMN_NAME);
    walletContactsColumns.add(
        WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACTS_ACTOR_FIRST_NAME_COLUMN_NAME);
    walletContactsColumns.add(
        WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACTS_ACTOR_LAST_NAME_COLUMN_NAME);
    walletContactsColumns.add(
        WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACTS_WALLET_PUBLIC_KEY_COLUMN_NAME);
    walletContactsColumns.add(
        WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACTS_COMPATIBILITY_COLUMN_NAME);
    /** Table Wallet Contacts addition. */
    DeveloperDatabaseTable walletContactsTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACTS_TABLE_NAME,
            walletContactsColumns);
    tables.add(walletContactsTable);

    /** Table Wallet Contact Addresses columns. */
    List<String> walletContactAddressesColumns = new ArrayList<>();

    walletContactAddressesColumns.add(
        WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACT_ADDRESSES_CONTACT_ID_COLUMN_NAME);
    walletContactAddressesColumns.add(
        WalletContactsMiddlewareDatabaseConstants
            .WALLET_CONTACT_ADDRESSES_CRYPTO_ADDRESS_COLUMN_NAME);
    walletContactAddressesColumns.add(
        WalletContactsMiddlewareDatabaseConstants
            .WALLET_CONTACT_ADDRESSES_CRYPTO_CURRENCY_COLUMN_NAME);
    walletContactAddressesColumns.add(
        WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACT_ADDRESSES_NETWORK_TYPE);

    /** Table Wallet Contact Addresses addition. */
    DeveloperDatabaseTable walletContactAddressesTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            WalletContactsMiddlewareDatabaseConstants.WALLET_CONTACT_ADDRESSES_TABLE_NAME,
            walletContactAddressesColumns);
    tables.add(walletContactAddressesTable);

    return tables;
  }
 public List<DeveloperDatabaseTableRecord> getDatabaseTableContent(
     DeveloperObjectFactory developerObjectFactory,
     DeveloperDatabaseTable developerDatabaseTable) {
   /** Will get the records for the given table */
   List<DeveloperDatabaseTableRecord> returnedRecords =
       new ArrayList<DeveloperDatabaseTableRecord>();
   /** I load the passed table name from the SQLite database. */
   DatabaseTable selectedTable = database.getTable(developerDatabaseTable.getName());
   try {
     selectedTable.loadToMemory();
     List<DatabaseTableRecord> records = selectedTable.getRecords();
     for (DatabaseTableRecord row : records) {
       List<String> developerRow = new ArrayList<String>();
       /** for each row in the table list */
       for (DatabaseRecord field : row.getValues()) {
         /** I get each row and save them into a List<String> */
         developerRow.add(field.getValue());
       }
       /** I create the Developer Database record */
       returnedRecords.add(
           developerObjectFactory.getNewDeveloperDatabaseTableRecord(developerRow));
     }
     /** return the list of DeveloperRecords for the passed table. */
   } catch (CantLoadTableToMemoryException cantLoadTableToMemory) {
     /** if there was an error, I will returned an empty list. */
     database.closeDatabase();
     return returnedRecords;
   } catch (Exception e) {
     database.closeDatabase();
     return returnedRecords;
   }
   database.closeDatabase();
   return returnedRecords;
 }
  public List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /** Table Asset User columns. */
    List<String> ArtistUserColumns = new ArrayList<String>();

    ArtistUserColumns.add(ArtistIdentityDatabaseConstants.ARTIST_IDENTITY_PUBLIC_KEY_COLUMN_NAME);
    ArtistUserColumns.add(
        ArtistIdentityDatabaseConstants.ARTIST_IDENTITY_DEVICE_USER_PUBLIC_KEY_COLUMN_NAME);
    ArtistUserColumns.add(ArtistIdentityDatabaseConstants.ARTIST_IDENTITY_ALIAS_COLUMN_NAME);
    ArtistUserColumns.add(
        ArtistIdentityDatabaseConstants.ARTIST_IDENTITY_EXTERNAL_USER_NAME_COLUMN_NAME);
    ArtistUserColumns.add(
        ArtistIdentityDatabaseConstants.ARTIST_IDENTITY_EXTERNAL_ACCESS_TOKEN_COLUMN_NAME);
    ArtistUserColumns.add(
        ArtistIdentityDatabaseConstants.ARTIST_IDENTITY_EXTERNAL_PLATFORM_COLUMN_NAME);
    ArtistUserColumns.add(
        ArtistIdentityDatabaseConstants.ARTIST_IDENTITY_EXPOSURE_LEVEL_COLUMN_NAME);
    ArtistUserColumns.add(
        ArtistIdentityDatabaseConstants.ARTIST_IDENTITY_ACEEPTS_CONNECTIONS_TYPE_COLUMN_NAME);
    /** Table Asset User addition. */
    DeveloperDatabaseTable assetUserTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            ArtistIdentityDatabaseConstants.ARTIST_IDENTITY_TABLE_NAME, ArtistUserColumns);
    tables.add(assetUserTable);

    return tables;
  }
  public final List<DeveloperDatabaseTableRecord> getDatabaseTableContent(
      final DeveloperObjectFactory developerObjectFactory,
      final DeveloperDatabaseTable developerDatabaseTable) {

    final List<DeveloperDatabaseTableRecord> returnedRecords = new ArrayList<>();

    final DatabaseTable selectedTable = database.getTable(developerDatabaseTable.getName());

    try {

      selectedTable.loadToMemory();
      final List<DatabaseTableRecord> records = selectedTable.getRecords();

      for (final DatabaseTableRecord row : records) {

        final List<String> developerRow = new ArrayList<>();

        for (DatabaseRecord field : row.getValues()) developerRow.add(field.getValue());

        returnedRecords.add(
            developerObjectFactory.getNewDeveloperDatabaseTableRecord(developerRow));
      }

    } catch (CantLoadTableToMemoryException cantLoadTableToMemory) {

      return returnedRecords;
    } catch (Exception e) {
      return returnedRecords;
    }
    return returnedRecords;
  }
 public List<DeveloperDatabase> getDatabaseList(DeveloperObjectFactory developerObjectFactory) {
   /** I only have one database on my plugin. I will return its name. */
   List<DeveloperDatabase> databases = new ArrayList<DeveloperDatabase>();
   databases.add(
       developerObjectFactory.getNewDeveloperDatabase("Cash Money", this.pluginId.toString()));
   return databases;
 }
  public List<DeveloperDatabase> getDatabaseList(
      final DeveloperObjectFactory developerObjectFactory) {

    List<DeveloperDatabase> databases = new ArrayList<>();

    databases.add(
        developerObjectFactory.getNewDeveloperDatabase(
            "Actor Network Service",
            FanActorNetworkServiceDatabaseConstants.FAN_ACTOR_NETWORK_SERVICE_DATABASE_NAME));

    databases.add(
        developerObjectFactory.getNewDeveloperDatabase(
            "Network Service Template",
            CommunicationNetworkServiceDatabaseConstants.DATA_BASE_NAME));

    return databases;
  }
 public List<DeveloperDatabase> getDatabaseList(DeveloperObjectFactory developerObjectFactory) {
   /** I only have one database on my plugin. I will return its name. */
   List<DeveloperDatabase> databases = new ArrayList<>();
   databases.add(
       developerObjectFactory.getNewDeveloperDatabase(
           ArtistIdentityDatabaseConstants.ARTIST_IDENTITY_DB_NAME, this.pluginId.toString()));
   return databases;
 }
 public List<DeveloperDatabase> getDatabaseList(DeveloperObjectFactory developerObjectFactory) {
   /** I only have one database on my plugin. I will return its name. */
   List<DeveloperDatabase> databases = new ArrayList<DeveloperDatabase>();
   databases.add(
       developerObjectFactory.getNewDeveloperDatabase(
           AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_DATABASE,
           this.pluginId.toString()));
   return databases;
 }
 public List<DeveloperDatabase> getDatabaseList(DeveloperObjectFactory developerObjectFactory) {
   /** I only have one database on my plugin. I will return its name. */
   List<DeveloperDatabase> databases = new ArrayList<DeveloperDatabase>();
   databases.add(
       developerObjectFactory.getNewDeveloperDatabase(
           CustomerBrokerSaleNegotiationDatabaseConstants.DATABASE_NAME,
           this.pluginId.toString()));
   return databases;
 }
 public List<DeveloperDatabase> getDatabaseList(DeveloperObjectFactory developerObjectFactory) {
   /** I only have one database on my plugin. I will return its name. */
   List<DeveloperDatabase> databases = new ArrayList<DeveloperDatabase>();
   databases.add(
       developerObjectFactory.getNewDeveloperDatabase(
           AssetIssuingTransactionDatabaseConstants.DIGITAL_ASSET_TRANSACTION_DATABASE,
           this.pluginId.toString()));
   return databases;
 }
  public List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /** Table Wallets columns. */
    List<String> walletsColumns = new ArrayList<String>();

    walletsColumns.add(CashMoneyWalletDatabaseConstants.WALLETS_WALLET_PUBLIC_KEY_COLUMN_NAME);
    walletsColumns.add(CashMoneyWalletDatabaseConstants.WALLETS_AVAILABLE_BALANCE_COLUMN_NAME);
    walletsColumns.add(CashMoneyWalletDatabaseConstants.WALLETS_BOOK_BALANCE_COLUMN_NAME);
    walletsColumns.add(CashMoneyWalletDatabaseConstants.WALLETS_CURRENCY_COLUMN_NAME);
    walletsColumns.add(
        CashMoneyWalletDatabaseConstants.WALLETS_TIMESTAMP_WALLET_CREATION_COLUMN_NAME);
    /** Table Wallets addition. */
    DeveloperDatabaseTable walletsTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            CashMoneyWalletDatabaseConstants.WALLETS_TABLE_NAME, walletsColumns);
    tables.add(walletsTable);

    /** Table Transactions columns. */
    List<String> transactionsColumns = new ArrayList<String>();

    transactionsColumns.add(
        CashMoneyWalletDatabaseConstants.TRANSACTIONS_TRANSACTION_ID_COLUMN_NAME);
    transactionsColumns.add(
        CashMoneyWalletDatabaseConstants.TRANSACTIONS_WALLET_PUBLIC_KEY_COLUMN_NAME);
    transactionsColumns.add(
        CashMoneyWalletDatabaseConstants.TRANSACTIONS_ACTOR_PUBLIC_KEY_COLUMN_NAME);
    transactionsColumns.add(
        CashMoneyWalletDatabaseConstants.TRANSACTIONS_PLUGIN_PUBLIC_KEY_COLUMN_NAME);
    transactionsColumns.add(
        CashMoneyWalletDatabaseConstants.TRANSACTIONS_TRANSACTION_TYPE_COLUMN_NAME);
    transactionsColumns.add(CashMoneyWalletDatabaseConstants.TRANSACTIONS_BALANCE_TYPE_COLUMN_NAME);
    transactionsColumns.add(CashMoneyWalletDatabaseConstants.TRANSACTIONS_AMOUNT_COLUMN_NAME);
    transactionsColumns.add(CashMoneyWalletDatabaseConstants.TRANSACTIONS_MEMO_COLUMN_NAME);
    transactionsColumns.add(CashMoneyWalletDatabaseConstants.TRANSACTIONS_TIMESTAMP_COLUMN_NAME);
    /** Table Transactions addition. */
    DeveloperDatabaseTable transactionsTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            CashMoneyWalletDatabaseConstants.TRANSACTIONS_TABLE_NAME, transactionsColumns);
    tables.add(transactionsTable);

    return tables;
  }
 public List<DeveloperDatabase> getDatabaseList(DeveloperObjectFactory developerObjectFactory) {
   /**
    * We have one database for each walletId, so we will return all their names. Remember that a
    * database name in this plug-in is the internal wallet id.
    */
   List<DeveloperDatabase> databases = new ArrayList<DeveloperDatabase>();
   for (String databaseName : this.walletsIssuer)
     databases.add(developerObjectFactory.getNewDeveloperDatabase(databaseName, this.pluginId));
   return databases;
 }
  public List<DeveloperDatabase> getDatabaseList(DeveloperObjectFactory developerObjectFactory) {
    /** I only have one database on my plugin. I will return its name. */
    List<DeveloperDatabase> databases = new ArrayList<DeveloperDatabase>();
    databases.add(
        developerObjectFactory.getNewDeveloperDatabase(
            StockTransactionsCashMoneyDestockDatabaseConstants.CASH_MONEY_DESTOCK_DATABASE_NAME,
            StockTransactionsCashMoneyDestockDatabaseConstants.CASH_MONEY_DESTOCK_DATABASE_NAME));

    return databases;
  }
  public List<DeveloperDatabase> getDatabaseList(DeveloperObjectFactory developerObjectFactory) {

    List<DeveloperDatabase> databases = new ArrayList<>();

    databases.add(
        developerObjectFactory.getNewDeveloperDatabase(
            "Wallet Contacts", this.pluginId.toString()));

    return databases;
  }
  public List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /** Table Contract Customer Broker Cash Money Sale columns. */
    List<String> contractCustomerBrokerCashMoneySaleColumns = new ArrayList<String>();

    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_CONTRACT_ID_COLUMN_NAME);
    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_CUSTOMER_PUBLIC_KEY_COLUMN_NAME);
    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_BROKER_PUBLIC_KEY_COLUMN_NAME);
    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_PAYMENT_CURRENCY_COLUMN_NAME);
    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_MERCHANDISE_CURRENCY_COLUMN_NAME);
    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_REFERENCE_PRICE_COLUMN_NAME);
    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_REFERENCE_CURRENCY_COLUMN_NAME);
    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_PAYMENT_AMOUNT_COLUMN_NAME);
    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_MERCHANDISE_AMOUNT_COLUMN_NAME);
    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_PAYMENT_EXPIRATION_DATE_COLUMN_NAME);
    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_MERCHANDISE_DELIVERY_EXPIRATION_DATE_COLUMN_NAME);
    contractCustomerBrokerCashMoneySaleColumns.add(
        CustomerBrokerCashMoneySaleContractDatabaseConstants
            .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_STATUS_COLUMN_NAME);
    /** Table Contract Customer Broker Cash Money Sale addition. */
    DeveloperDatabaseTable contractCustomerBrokerCashMoneySaleTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            CustomerBrokerCashMoneySaleContractDatabaseConstants
                .CONTRACT_CUSTOMER_BROKER_CASH_MONEY_SALE_TABLE_NAME,
            contractCustomerBrokerCashMoneySaleColumns);
    tables.add(contractCustomerBrokerCashMoneySaleTable);

    return tables;
  }
  public List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /** Table Project columns. */
    List<String> projectColumns = new ArrayList<String>();

    /** Table Asset Factory addition. */
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants
            .CASH_MONEY_DESTOCK_TRANSACTION_ID_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants
            .CASH_MONEY_DESTOCK_PUBLIC_KEY_ACTOR_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants
            .CASH_MONEY_DESTOCK_FIAT_CURRENCY_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants
            .CASH_MONEY_DESTOCK_CBP_WALLET_PUBLIC_KEY_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants
            .CASH_MONEY_DESTOCK_CSH_WALLET_PUBLIC_KEY_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants
            .CASH_MONEY_DESTOCK_CASH_REFERENCE_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants.CASH_MONEY_DESTOCK_CONCEPT_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants.CASH_MONEY_DESTOCK_MEMO_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants.CASH_MONEY_DESTOCK_AMOUNT_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants
            .CASH_MONEY_DESTOCK_TIMESTAMP_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants
            .CASH_MONEY_DESTOCK_TRANSACTION_STATUS_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants
            .CASH_MONEY_DESTOCK_PRICE_REFERENCE_COLUMN_NAME);
    projectColumns.add(
        StockTransactionsCashMoneyDestockDatabaseConstants
            .CASH_MONEY_DESTOCK_ORIGIN_TRANSACTION_COLUMN_NAME);

    DeveloperDatabaseTable bankMoneyRestockTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            StockTransactionsCashMoneyDestockDatabaseConstants.CASH_MONEY_DESTOCK_TABLE_NAME,
            projectColumns);
    tables.add(bankMoneyRestockTable);

    return tables;
  }
  public final List<DeveloperDatabase> getDatabaseList(
      final DeveloperObjectFactory developerObjectFactory) {

    List<DeveloperDatabase> databases = new ArrayList<>();

    databases.add(
        developerObjectFactory.getNewDeveloperDatabase(
            NegotiationTransmissionNetworkServiceDatabaseConstants.DATA_BASE_NAME,
            this.pluginId.toString()));

    return databases;
  }
  public List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /** Table agents columns. */
    List<String> agentsColumns = new ArrayList<String>();

    agentsColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENTS_ID_COLUMN_NAME);
    agentsColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENTS_NAME_COLUMN_NAME);
    agentsColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENTS_DESCRIPTION_COLUMN_NAME);
    agentsColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENTS_OWNER_PUBLICKEY_COLUMN_NAME);
    agentsColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENTS_START_TIME_COLUMN_NAME);
    agentsColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENTS_DURATION_COLUMN_NAME);
    agentsColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENTS_ELAPSED_COLUMN_NAME);
    agentsColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENTS_STATE_COLUMN_NAME);
    agentsColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENTS_PROTOCOL_STATUS_COLUMN_NAME);
    agentsColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENTS_LAST_UPDATE_COLUMN_NAME);
    /** Table agents addition. */
    DeveloperDatabaseTable agentsTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            TimeOutNotifierAgentDatabaseConstants.AGENTS_TABLE_NAME, agentsColumns);
    tables.add(agentsTable);

    /** Table agent_owner columns. */
    List<String> agent_ownerColumns = new ArrayList<String>();

    agent_ownerColumns.add(
        TimeOutNotifierAgentDatabaseConstants.AGENT_OWNER_OWNER_PUBLICKEY_COLUMN_NAME);
    agent_ownerColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENT_OWNER_NAME_COLUMN_NAME);
    agent_ownerColumns.add(TimeOutNotifierAgentDatabaseConstants.AGENT_OWNER_TYPE_COLUMN_NAME);
    /** Table agent_owner addition. */
    DeveloperDatabaseTable agent_ownerTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            TimeOutNotifierAgentDatabaseConstants.AGENT_OWNER_TABLE_NAME, agent_ownerColumns);
    tables.add(agent_ownerTable);

    return tables;
  }
  public List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {

    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    List<String> projectColumns = new ArrayList<String>();

    try {

      projectColumns.add(
          WalletNavigationStructureMiddlewareDatabaseConstants
              .WALLET_NAVIGATION_STRUCTURE_PUBLIC_KEY);
      projectColumns.add(
          WalletNavigationStructureMiddlewareDatabaseConstants
              .WALLET_NAVIGATION_STRUCTURE_ACTIVITY);
      projectColumns.add(
          WalletNavigationStructureMiddlewareDatabaseConstants
              .WALLET_NAVIGATION_STRUCTURE_START_ACTIVITY);
      projectColumns.add(
          WalletNavigationStructureMiddlewareDatabaseConstants
              .WALLET_NAVIGATION_STRUCTURE_LAST_ACTIVITY);

      DeveloperDatabaseTable projectTable =
          developerObjectFactory.getNewDeveloperDatabaseTable(
              WalletNavigationStructureMiddlewareDatabaseConstants
                  .WALLET_NAVIGATION_STRUCTURE_TABLE_NAME,
              projectColumns);
      tables.add(projectTable);

    } catch (Exception exception) {

      FermatException fermatException =
          new CantDeliverDatabaseException(
              CantDeliverDatabaseException.DEFAULT_MESSAGE,
              FermatException.wrapException(exception),
              "WalletId: " + pluginId.toString(),
              "Check the cause");
      this.errorManager.reportUnexpectedPluginException(
          Plugins.BITDUBAI_WALLET_NAVIGATION_STRUCTURE_MIDDLEWARE,
          UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
          fermatException);
    }

    return tables;
  }
  public List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /** extraUserTable columns */
    List<String> extraUserTableColumns = new ArrayList<String>();
    extraUserTableColumns.add(ExtraUserDatabaseConstants.EXTRA_USER_TABLE_ID_COLUMN_NAME);
    extraUserTableColumns.add(ExtraUserDatabaseConstants.EXTRA_USER_TABLE_NAME_COLUMN_NAME);
    extraUserTableColumns.add(ExtraUserDatabaseConstants.EXTRA_USER_TABLE_TIME_STAMP_COLUMN_NAME);

    /** extraUser table */
    DeveloperDatabaseTable extraUserTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            ExtraUserDatabaseConstants.EXTRA_USER_TABLE_NAME, extraUserTableColumns);
    tables.add(extraUserTable);

    return tables;
  }
  public List<DeveloperDatabase> getDatabaseList(DeveloperObjectFactory developerObjectFactory) {

    List<DeveloperDatabase> databases = new ArrayList<DeveloperDatabase>();
    try {

      databases.add(
          developerObjectFactory.getNewDeveloperDatabase(
              "Wallet Navigation Structure", this.pluginId.toString()));

    } catch (Exception exception) {
      this.errorManager.reportUnexpectedPluginException(
          Plugins.BITDUBAI_WALLET_NAVIGATION_STRUCTURE_MIDDLEWARE,
          UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
          exception);
    }

    return databases;
  }
  public static List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /*
     * We only have one table in each database, let's complete it
     */
    List<String> assetWalletIssuerColumns = new ArrayList<>();
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_TABLE_ID_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ASSET_PUBLIC_KEY_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ASSET_CRYPTO_ADDRESS_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_AMOUNT_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_VERIFICATION_ID_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ADDRESS_FROM_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ADDRESS_TO_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ACTOR_FROM_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ACTOR_TO_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ACTOR_FROM_TYPE_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ACTOR_TO_TYPE_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_TYPE_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_BALANCE_TYPE_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_TIME_STAMP_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_MEMO_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_TRANSACTION_HASH_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_RUNNING_AVAILABLE_BALANCE_COLUMN_NAME);
    assetWalletIssuerColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_RUNNING_BOOK_BALANCE_COLUMN_NAME);

    /** assetIssuerWalletColumns table */
    DeveloperDatabaseTable cryptoTransactionsTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_TABLE_NAME, assetWalletIssuerColumns);
    tables.add(cryptoTransactionsTable);

    /** Added new table AssetIssuerWalletTotalBalances */
    List<String> assetIssuerWalletTotalBalancesColumns = new ArrayList<>();
    assetIssuerWalletTotalBalancesColumns.add(
        AssetUserWalletDatabaseConstant
            .ASSET_WALLET_USER_BALANCE_TABLE_ASSET_PUBLIC_KEY_COLUMN_NAME);
    assetIssuerWalletTotalBalancesColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_BALANCE_TABLE_NAME_COLUMN_NAME);
    assetIssuerWalletTotalBalancesColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_BALANCE_TABLE_DESCRIPTION_COLUMN_NAME);
    assetIssuerWalletTotalBalancesColumns.add(
        AssetUserWalletDatabaseConstant
            .ASSET_WALLET_USER_BALANCE_TABLE_AVAILABLE_BALANCE_COLUMN_NAME);
    assetIssuerWalletTotalBalancesColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_BALANCE_TABLE_BOOK_BALANCE_COLUMN_NAME);
    assetIssuerWalletTotalBalancesColumns.add(
        AssetUserWalletDatabaseConstant
            .ASSET_WALLET_USER_BALANCE_TABLE_QUANTITY_AVAILABLE_BALANCE_COLUMN_NAME);
    assetIssuerWalletTotalBalancesColumns.add(
        AssetUserWalletDatabaseConstant
            .ASSET_WALLET_USER_BALANCE_TABLE_QUANTITY_BOOK_BALANCE_COLUMN_NAME);

    /** AssetIssuerWalletTotalBalanceColumns table */
    DeveloperDatabaseTable assetIssuerWalletWalletTotalBalances =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_BALANCE_TABLE_NAME,
            assetIssuerWalletTotalBalancesColumns);
    tables.add(assetIssuerWalletWalletTotalBalances);

    /** Added new table AssetIssuerWalletTotalBalances */
    List<String> metadataLockColumns = new ArrayList<>();
    metadataLockColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_METADATA_LOCK_METADATA_ID_COLUMN_NAME);
    metadataLockColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_METADATA_LOCK_GENESIS_TX_COLUMN_NAME);
    metadataLockColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_METADATA_LOCK_STATUS_COLUMN_NAME);
    /** AssetIssuerWalletTotalBalanceColumns table */
    DeveloperDatabaseTable metadataLockTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_METADATA_LOCK_TABLE_NAME,
            metadataLockColumns);
    tables.add(metadataLockTable);

    List<String> addressesColumns = new ArrayList<>();
    addressesColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ADDRESSES_ID_COLUMN_NAME);
    addressesColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ADDRESSES_ASSET_PUBLICKEY_COLUMN_NAME);
    addressesColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ADDRESSES_CRYPTO_ADDRESS_COLUMN_NAME);
    addressesColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ADDRESSES_CRYPTO_CURRENCY_COLUMN_NAME);
    addressesColumns.add(
        AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ADDRESSES_AVAILABLE_COLUMN_NAME);

    DeveloperDatabaseTable addressesTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetUserWalletDatabaseConstant.ASSET_WALLET_USER_ADDRESSES_TABLE_NAME,
            addressesColumns);
    tables.add(addressesTable);
    return tables;
  }
  public final List<DeveloperDatabaseTable> getDatabaseTableList(
      final DeveloperObjectFactory developerObjectFactory) {

    List<DeveloperDatabaseTable> tables = new ArrayList<>();

    /** Table incoming messages columns. */
    List<String> incomingMessagesColumns = new ArrayList<>();

    incomingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants.INCOMING_MESSAGES_ID_COLUMN_NAME);
    incomingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .INCOMING_MESSAGES_SENDER_ID_COLUMN_NAME);
    incomingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .INCOMING_MESSAGES_RECEIVER_ID_COLUMN_NAME);
    incomingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .INCOMING_MESSAGES_TEXT_CONTENT_COLUMN_NAME);
    incomingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants.INCOMING_MESSAGES_TYPE_COLUMN_NAME);
    incomingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .INCOMING_MESSAGES_SHIPPING_TIMESTAMP_COLUMN_NAME);
    incomingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .INCOMING_MESSAGES_DELIVERY_TIMESTAMP_COLUMN_NAME);
    incomingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .INCOMING_MESSAGES_STATUS_COLUMN_NAME);
    /** Table incoming messages addition. */
    DeveloperDatabaseTable incomingMessagesTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            NegotiationTransmissionNetworkServiceDatabaseConstants.INCOMING_MESSAGES_TABLE_NAME,
            incomingMessagesColumns);
    tables.add(incomingMessagesTable);

    /** Table outgoing messages columns. */
    List<String> outgoingMessagesColumns = new ArrayList<>();

    outgoingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_ID_COLUMN_NAME);
    outgoingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .OUTGOING_MESSAGES_SENDER_ID_COLUMN_NAME);
    outgoingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .OUTGOING_MESSAGES_RECEIVER_ID_COLUMN_NAME);
    outgoingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .OUTGOING_MESSAGES_TEXT_CONTENT_COLUMN_NAME);
    outgoingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_TYPE_COLUMN_NAME);
    outgoingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .OUTGOING_MESSAGES_SHIPPING_TIMESTAMP_COLUMN_NAME);
    outgoingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .OUTGOING_MESSAGES_DELIVERY_TIMESTAMP_COLUMN_NAME);
    outgoingMessagesColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .OUTGOING_MESSAGES_STATUS_COLUMN_NAME);
    /** Table outgoing messages addition. */
    DeveloperDatabaseTable outgoingMessagesTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            NegotiationTransmissionNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_TABLE_NAME,
            outgoingMessagesColumns);
    tables.add(outgoingMessagesTable);

    /** Table Negotiation Transmission Network Service columns. */
    List<String> negotiationTransmissionNetworkServiceColumns = new ArrayList<String>();

    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_TRANSMISSION_ID_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_TRANSACTION_ID_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_NEGOTIATION_ID_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_NEGOTIATION_STATUS_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_NEGOTIATION_TRANSACTION_TYPE_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_PUBLIC_KEY_ACTOR_SEND_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_ACTOR_SEND_TYPE_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_PUBLIC_KEY_ACTOR_RECEIVE_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_ACTOR_RECEIVE_TYPE_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_TRANSMISSION_TYPE_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_TRANSMISSION_STATE_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_NEGOTIATION_TYPE_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_NEGOTIATION_XML_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_PENDING_FLAG_COLUMN_NAME);
    negotiationTransmissionNetworkServiceColumns.add(
        NegotiationTransmissionNetworkServiceDatabaseConstants
            .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_TIMESTAMP_COLUMN_NAME);
    /** Table Negotiation Transmission Network Service addition. */
    DeveloperDatabaseTable negotiationTransmissionNetworkServiceTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            NegotiationTransmissionNetworkServiceDatabaseConstants
                .NEGOTIATION_TRANSMISSION_NETWORK_SERVICE_TABLE_NAME,
            negotiationTransmissionNetworkServiceColumns);
    tables.add(negotiationTransmissionNetworkServiceTable);

    return tables;
  }
  public List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /** Table Negotiations Sale columns. */
    List<String> negotiationsSaleColumns = new ArrayList<String>();

    negotiationsSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants
            .NEGOTIATIONS_SALE_NEGOTIATION_ID_COLUMN_NAME);
    negotiationsSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants
            .NEGOTIATIONS_SALE_CRYPTO_CUSTOMER_PUBLIC_KEY_COLUMN_NAME);
    negotiationsSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants
            .NEGOTIATIONS_SALE_CRYPTO_BROKER_PUBLIC_KEY_COLUMN_NAME);
    negotiationsSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants
            .NEGOTIATIONS_SALE_START_DATE_TIME_COLUMN_NAME);
    negotiationsSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants
            .NEGOTIATIONS_SALE_EXPIRATION_DATE_TIME_COLUMN_NAME);
    negotiationsSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.NEGOTIATIONS_SALE_STATUS_COLUMN_NAME);
    negotiationsSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants
            .NEGOTIATIONS_SALE_NEAR_EXPIRATION_DATE_TIME_COLUMN_NAME);
    negotiationsSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.NEGOTIATIONS_SALE_MEMO_COLUMN_NAME);
    negotiationsSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.NEGOTIATIONS_SALE_CANCEL_REASON_COLUMN_NAME);
    negotiationsSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants
            .NEGOTIATIONS_SALE_LAST_NEGOTIATION_UPDATE_DATE_COLUMN_NAME);
    /** Table Negotiations Sale addition. */
    DeveloperDatabaseTable negotiationsSaleTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            CustomerBrokerSaleNegotiationDatabaseConstants.NEGOTIATIONS_SALE_TABLE_NAME,
            negotiationsSaleColumns);
    tables.add(negotiationsSaleTable);

    /** Table Clauses Sale columns. */
    List<String> clausesSaleColumns = new ArrayList<String>();

    clausesSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.CLAUSES_SALE_CLAUSE_ID_COLUMN_NAME);
    clausesSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.CLAUSES_SALE_NEGOTIATION_ID_COLUMN_NAME);
    clausesSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.CLAUSES_SALE_TYPE_COLUMN_NAME);
    clausesSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.CLAUSES_SALE_VALUE_COLUMN_NAME);
    clausesSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.CLAUSES_SALE_STATUS_COLUMN_NAME);
    clausesSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.CLAUSES_SALE_PROPOSED_BY_COLUMN_NAME);
    clausesSaleColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.CLAUSES_SALE_INDEX_ORDER_COLUMN_NAME);
    /** Table Clauses Sale addition. */
    DeveloperDatabaseTable clausesSaleTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            CustomerBrokerSaleNegotiationDatabaseConstants.CLAUSES_SALE_TABLE_NAME,
            clausesSaleColumns);
    tables.add(clausesSaleTable);

    /** Table Locations Broker columns. */
    List<String> locationsBrokerColumns = new ArrayList<String>();

    locationsBrokerColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.LOCATIONS_BROKER_LOCATION_ID_COLUMN_NAME);
    locationsBrokerColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.LOCATIONS_BROKER_LOCATION_COLUMN_NAME);
    locationsBrokerColumns.add(
        CustomerBrokerSaleNegotiationDatabaseConstants.LOCATIONS_BROKER_URI_COLUMN_NAME);
    /** Table Locations Broker addition. */
    DeveloperDatabaseTable locationsBrokerTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            CustomerBrokerSaleNegotiationDatabaseConstants.LOCATIONS_BROKER_TABLE_NAME,
            locationsBrokerColumns);
    tables.add(locationsBrokerTable);

    return tables;
  }
 public List<DeveloperDatabase> getDatabaseList(DeveloperObjectFactory developerObjectFactory) {
   /** I only have one database on my plugin. I will return its name. */
   List<DeveloperDatabase> databases = new ArrayList<>();
   databases.add(developerObjectFactory.getNewDeveloperDatabase("Extra User", "ExtraUser"));
   return databases;
 }
  public static List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /** Table Digital Asset Transaction columns. */
    List<String> digitalAssetTransactionColumns = new ArrayList<String>();

    digitalAssetTransactionColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_DIGITAL_ASSET_PUBLIC_KEY_COLUMN_NAME);
    digitalAssetTransactionColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_DIGITAL_ASSET_LOCAL_STORAGE_PATH_COLUMN_NAME);
    digitalAssetTransactionColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_DIGITAL_ASSET_ASSETS_TO_GENERATE_COLUMN_NAME);
    digitalAssetTransactionColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_DIGITAL_ASSET_ASSETS_GENERATED_COLUMN_NAME);
    digitalAssetTransactionColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_DIGITAL_ASSET_BLOCKCHAIN_NETWORK_TYPE_COLUMN_NAME);
    digitalAssetTransactionColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_DIGITAL_ASSET_WALLET_PUBLIC_KEY_COLUMN_NAME);
    digitalAssetTransactionColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_DIGITAL_ASSET_ISSUING_STATUS_COLUMN_NAME);
    /** Table Digital Asset Transaction addition. */
    DeveloperDatabaseTable digitalAssetTransactionTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetIssuingTransactionDatabaseConstants.DIGITAL_ASSET_TRANSACTION_TABLE_NAME,
            digitalAssetTransactionColumns);
    tables.add(digitalAssetTransactionTable);

    /** Events Recorder table */
    List<String> eventsRecorderColumns = new ArrayList<String>();

    eventsRecorderColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_EVENTS_RECORDED_ID_COLUMN);
    eventsRecorderColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_EVENTS_RECORDED_EVENT_COLUMN);
    eventsRecorderColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_EVENTS_RECORDED_SOURCE_COLUMN);
    eventsRecorderColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_EVENTS_RECORDED_STATUS_COLUMN);
    eventsRecorderColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_EVENTS_RECORDED_TIMESTAMP_COLUMN);

    DeveloperDatabaseTable eventsRecorderTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetIssuingTransactionDatabaseConstants
                .DIGITAL_ASSET_TRANSACTION_EVENTS_RECORDED_TABLE_NAME,
            eventsRecorderColumns);
    tables.add(eventsRecorderTable);

    /** Asset Issuing table */
    List<String> assetIssuingColumns = new ArrayList<>();

    assetIssuingColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_TRANSACTION_ID_COLUMN_NAME);
    assetIssuingColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_GENESIS_TRANSACTION_COLUMN_NAME);
    assetIssuingColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_GENESIS_BLOCK_COLUMN_NAME);
    assetIssuingColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_GENESIS_ADDRESS_COLUMN_NAME);
    assetIssuingColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_TRANSACTION_STATE_COLUMN_NAME);
    assetIssuingColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_CRYPTO_STATUS_COLUMN_NAME);
    assetIssuingColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_PROTOCOL_STATUS_COLUMN_NAME);
    assetIssuingColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_DIGITAL_ASSET_HASH_COLUMN_NAME);
    assetIssuingColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_PUBLIC_KEY_COLUMN_NAME);
    assetIssuingColumns.add(
        AssetIssuingTransactionDatabaseConstants
            .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_OUTGOING_ID_COLUMN_NAME);

    DeveloperDatabaseTable assetIssuingTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetIssuingTransactionDatabaseConstants
                .DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_TABLE_NAME,
            assetIssuingColumns);
    tables.add(assetIssuingTable);

    return tables;
  }
  public static List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /** Table Asset Distribution columns. */
    List<String> assetDistributionColumns = new ArrayList<String>();

    assetDistributionColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_GENESIS_TRANSACTION_COLUMN_NAME);
    assetDistributionColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_DIGITAL_ASSET_HASH_COLUMN_NAME);
    assetDistributionColumns.add(
        AssetDistributionDatabaseConstants
            .ASSET_DISTRIBUTION_ACTOR_ASSET_USER_PUBLIC_KEY_COLUMN_NAME);
    assetDistributionColumns.add(
        AssetDistributionDatabaseConstants
            .ASSET_DISTRIBUTION_DIGITAL_ASSET_STORAGE_LOCAL_PATH_COLUMN_NAME);
    assetDistributionColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_DISTRIBUTION_STATUS_COLUMN_NAME);
    assetDistributionColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_CRYPTO_STATUS_COLUMN_NAME);
    assetDistributionColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_PROTOCOL_STATUS_COLUMN_NAME);
    assetDistributionColumns.add(
        AssetDistributionDatabaseConstants
            .ASSET_DISTRIBUTION_ACTOR_ASSET_USER_BITCOIN_ADDRESS_COLUMN_NAME);
    assetDistributionColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_DISTRIBUTION_ID_COLUMN_NAME);
    /** Table Asset Distribution addition. */
    DeveloperDatabaseTable assetDistributionTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_TABLE_NAME,
            assetDistributionColumns);
    tables.add(assetDistributionTable);

    /** Events Recorder table */
    List<String> eventsRecorderColumns = new ArrayList<String>();

    eventsRecorderColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_EVENTS_RECORDED_ID_COLUMN_NAME);
    eventsRecorderColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_EVENTS_RECORDED_EVENT_COLUMN_NAME);
    eventsRecorderColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_EVENTS_RECORDED_SOURCE_COLUMN_NAME);
    eventsRecorderColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_EVENTS_RECORDED_STATUS_COLUMN_NAME);
    eventsRecorderColumns.add(
        AssetDistributionDatabaseConstants
            .ASSET_DISTRIBUTION_EVENTS_RECORDED_TIMESTAMP_COLUMN_NAME);

    DeveloperDatabaseTable eventsRecorderTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_EVENTS_RECORDED_TABLE_NAME,
            eventsRecorderColumns);
    tables.add(eventsRecorderTable);

    /** Asset Distribution table */
    List<String> assetDeliveringColumns = new ArrayList<String>();

    assetDeliveringColumns.add(
        AssetDistributionDatabaseConstants
            .ASSET_DISTRIBUTION_DELIVERING_TRANSACTION_ID_COLUMN_NAME);
    assetDeliveringColumns.add(
        AssetDistributionDatabaseConstants
            .ASSET_DISTRIBUTION_DELIVERING_GENESIS_TRANSACTION_COLUMN_NAME);
    assetDeliveringColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_DELIVERING_NETWORK_TYPE_COLUMN_NAME);
    assetDeliveringColumns.add(
        AssetDistributionDatabaseConstants
            .ASSET_DISTRIBUTION_DELIVERING_ASSET_PUBLICKEY_COLUMN_NAME);
    assetDeliveringColumns.add(
        AssetDistributionDatabaseConstants
            .ASSET_DISTRIBUTION_DELIVERING_USER_PUBLICKEY_COLUMN_NAME);
    assetDeliveringColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_DELIVERING_START_TIME_COLUMN_NAME);
    assetDeliveringColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_DELIVERING_TIMEOUT_COLUMN_NAME);
    assetDeliveringColumns.add(
        AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_DELIVERING_STATE_COLUMN_NAME);
    assetDeliveringColumns.add(
        AssetDistributionDatabaseConstants
            .ASSET_DISTRIBUTION_DELIVERING_SENT_GENESISTX_COLUMN_NAME);
    assetDeliveringColumns.add(
        AssetDistributionDatabaseConstants
            .ASSET_DISTRIBUTION_DELIVERING_ATTEMPT_NUMBER_COLUMN_NAME);

    DeveloperDatabaseTable assetDeliveringTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetDistributionDatabaseConstants.ASSET_DISTRIBUTION_DELIVERING_TABLE_NAME,
            assetDeliveringColumns);
    tables.add(assetDeliveringTable);

    return tables;
  }
  public List<DeveloperDatabaseTable> getDatabaseTableList(
      final DeveloperObjectFactory developerObjectFactory,
      final DeveloperDatabase developerDatabase) {

    List<DeveloperDatabaseTable> tables = new ArrayList<>();

    switch (developerDatabase.getId()) {
      case FanActorNetworkServiceDatabaseConstants.FAN_ACTOR_NETWORK_SERVICE_DATABASE_NAME:

        /** Table Connection News columns. */
        List<String> connectionNewsColumns = new ArrayList<>();

        connectionNewsColumns.add(
            FanActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_REQUEST_ID_COLUMN_NAME);
        connectionNewsColumns.add(
            FanActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_SENDER_PUBLIC_KEY_COLUMN_NAME);
        connectionNewsColumns.add(
            FanActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_SENDER_ACTOR_TYPE_COLUMN_NAME);
        connectionNewsColumns.add(
            FanActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_SENDER_ALIAS_COLUMN_NAME);
        connectionNewsColumns.add(
            FanActorNetworkServiceDatabaseConstants
                .CONNECTION_NEWS_DESTINATION_PUBLIC_KEY_COLUMN_NAME);
        connectionNewsColumns.add(
            FanActorNetworkServiceDatabaseConstants
                .CONNECTION_NEWS_DESTINATION_ACTOR_TYPE_COLUMN_NAME);
        connectionNewsColumns.add(
            FanActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_REQUEST_TYPE_COLUMN_NAME);
        connectionNewsColumns.add(
            FanActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_REQUEST_STATE_COLUMN_NAME);
        connectionNewsColumns.add(
            FanActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_REQUEST_ACTION_COLUMN_NAME);
        connectionNewsColumns.add(
            FanActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_REQUEST_SENT_COUNT_COLUMN_NAME);
        connectionNewsColumns.add(
            FanActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_SENT_TIME_COLUMN_NAME);
        /** Table Connection News addition. */
        DeveloperDatabaseTable connectionNewsTable =
            developerObjectFactory.getNewDeveloperDatabaseTable(
                FanActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_TABLE_NAME,
                connectionNewsColumns);
        tables.add(connectionNewsTable);

        break;

      case CommunicationNetworkServiceDatabaseConstants.DATA_BASE_NAME:

        /** Table incoming messages columns. */
        List<String> incomingMessagesColumns = new ArrayList<>();

        incomingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_ID_COLUMN_NAME);
        incomingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_SENDER_ID_COLUMN_NAME);
        incomingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_RECEIVER_ID_COLUMN_NAME);
        incomingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_TYPE_COLUMN_NAME);
        incomingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants
                .INCOMING_MESSAGES_SHIPPING_TIMESTAMP_COLUMN_NAME);
        incomingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants
                .INCOMING_MESSAGES_DELIVERY_TIMESTAMP_COLUMN_NAME);
        incomingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_STATUS_COLUMN_NAME);
        incomingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants
                .INCOMING_MESSAGES_TEXT_CONTENT_COLUMN_NAME);
        /** Table incoming messages addition. */
        DeveloperDatabaseTable incomingMessagesTable =
            developerObjectFactory.getNewDeveloperDatabaseTable(
                CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_TABLE_NAME,
                incomingMessagesColumns);
        tables.add(incomingMessagesTable);

        /** Table outgoing messages columns. */
        List<String> outgoingMessagesColumns = new ArrayList<>();

        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_ID_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_SENDER_ID_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_SENDER_TYPE_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants
                .OUTGOING_MESSAGES_SENDER_NS_TYPE_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_RECEIVER_ID_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants
                .OUTGOING_MESSAGES_RECEIVER_TYPE_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants
                .OUTGOING_MESSAGES_RECEIVER_NS_TYPE_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_TYPE_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants
                .OUTGOING_MESSAGES_SHIPPING_TIMESTAMP_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants
                .OUTGOING_MESSAGES_DELIVERY_TIMESTAMP_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_FAIL_COUNT_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_STATUS_COLUMN_NAME);
        outgoingMessagesColumns.add(
            CommunicationNetworkServiceDatabaseConstants
                .OUTGOING_MESSAGES_TEXT_CONTENT_COLUMN_NAME);
        /** Table outgoing messages addition. */
        DeveloperDatabaseTable outgoingMessagesTable =
            developerObjectFactory.getNewDeveloperDatabaseTable(
                CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_TABLE_NAME,
                outgoingMessagesColumns);
        tables.add(outgoingMessagesTable);
        break;
    }

    return tables;
  }
  public List<DeveloperDatabaseTable> getDatabaseTableList(
      DeveloperObjectFactory developerObjectFactory) {
    List<DeveloperDatabaseTable> tables = new ArrayList<DeveloperDatabaseTable>();

    /** Table key_accounts columns. */
    List<String> key_accountsColumns = new ArrayList<String>();

    key_accountsColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_ID_COLUMN_NAME);
    key_accountsColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_DESCRIPTION_COLUMN_NAME);
    /** Table key_accounts addition. */
    DeveloperDatabaseTable key_accountsTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_TABLE_NAME,
            key_accountsColumns);
    tables.add(key_accountsTable);

    /** Table key_Maintenance columns. */
    List<String> key_MaintenanceColumns = new ArrayList<String>();

    key_MaintenanceColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_ACCOUNT_ID_COLUMN_NAME);
    key_MaintenanceColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_GENERATED_KEYS_COLUMN_NAME);
    key_MaintenanceColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_USED_KEYS_COLUMN_NAME);
    /** Table key_Maintenance addition. */
    DeveloperDatabaseTable key_MaintenanceTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_TABLE_NAME,
            key_MaintenanceColumns);
    tables.add(key_MaintenanceTable);

    /** Table key_Maintenance_detail columns. */
    List<String> key_Maintenance_DetailColumns = new ArrayList<String>();

    key_Maintenance_DetailColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_DETAIL_ACCOUNT_ID_COLUMN_NAME);
    key_Maintenance_DetailColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_DETAIL_KEY_DEPTH_COLUMN_NAME);
    key_Maintenance_DetailColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_DETAIL_PUBLIC_KEY_COLUMN_NAME);
    key_Maintenance_DetailColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_DETAIL_ADDRESS_COLUMN_NAME);

    /** Table key_Maintenance_Detail addition. */
    DeveloperDatabaseTable key_MaintenanceDetailTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_DETAIL_TABLE_NAME,
            key_Maintenance_DetailColumns);
    tables.add(key_MaintenanceDetailTable);

    /** Table key_Maintenance_Monitor columns. */
    List<String> key_Maintenance_MonitorColumns = new ArrayList<String>();

    key_Maintenance_MonitorColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_EXECUTION_NUMBER_COLUMN_NAME);
    key_Maintenance_MonitorColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_ACCOUNT_ID_COLUMN_NAME);
    key_Maintenance_MonitorColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_EXECUTION_DATE_COLUMN_NAME);
    key_Maintenance_MonitorColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_GENERATED_KEYS_COLUMN_NAME);
    key_Maintenance_MonitorColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_USED_KEYS_COLUMN_NAME);
    key_Maintenance_MonitorColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_THRESHOLD_COLUMN_NAME);
    /** Table key_Maintenance_Monitor addition. */
    DeveloperDatabaseTable key_Maintenance_MonitorTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_MONITOR_TABLE_NAME,
            key_Maintenance_MonitorColumns);
    tables.add(key_Maintenance_MonitorTable);

    /** Table active_Networks columns. */
    List<String> active_NetworksColumns = new ArrayList<String>();

    active_NetworksColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.ACTIVE_NETWORKS_NETWORKTYPE_COLUMN_NAME);
    active_NetworksColumns.add(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.ACTIVE_NETWORKS_ACTIVATION_DATE_COLUMN_NAME);
    /** Table active_Networks addition. */
    DeveloperDatabaseTable active_NetworksTable =
        developerObjectFactory.getNewDeveloperDatabaseTable(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.ACTIVE_NETWORKS_TABLE_NAME,
            active_NetworksColumns);
    tables.add(active_NetworksTable);

    return tables;
  }