public Database createDatabase(UUID ownerId, UUID walletId) throws CantCreateDatabaseException {
Database database = null;
try {
database = this.pluginDatabaseSystem.createDatabase(ownerId, walletId.toString());
createLossProtetedWalletTable(ownerId, database.getDatabaseFactory());
createLossProtectedWalletBalancesTable(ownerId, database.getDatabaseFactory());
createLossProtectedWalletSpentTableFactory(ownerId, database.getDatabaseFactory());
insertInitialBalancesRecord(database);
database.closeDatabase();
return database;
} catch (CantCreateTableException | CantInsertRecordException exception) {
if (database != null) database.closeDatabase();
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE, exception, null, "Check the cause");
} catch (CantCreateDatabaseException exception) {
throw exception;
} catch (Exception exception) {
if (database != null) database.closeDatabase();
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
FermatException.wrapException(exception),
null,
null);
}
}
private void setUpMockitoRules() throws Exception {
when(mockDatabase.getDatabaseFactory()).thenReturn(mockDatabaseFactory);
when(mockDatabaseTable.getEmptyRecord()).thenReturn(mockDatabaseTableRecord);
when(mockDatabase.getTable(AssetIssuingDatabaseConstants.ASSET_ISSUING_TABLE_NAME))
.thenReturn(mockDatabaseTable);
when(pluginDatabaseSystem.openDatabase(
pluginId, AssetIssuingDatabaseConstants.ASSET_ISSUING_DATABASE))
.thenReturn(mockDatabase);
// when(mockExtraUserActorDatabaseFactory.createDatabase(pluginId,
// pluginId.toString())).thenReturn(mockDatabase);
when(deviceUser.getPublicKey()).thenReturn("myPublicKey");
when(deviceUserManager.getLoggedInDeviceUser()).thenReturn(deviceUser);
when(eventManager.getNewListener(
EventType.INCOMING_ASSET_ON_CRYPTO_NETWORK_WAITING_TRANSFERENCE_ASSET_ISSUER))
.thenReturn(fermatEventListener1);
when(eventManager.getNewListener(
EventType.INCOMING_ASSET_ON_BLOCKCHAIN_WAITING_TRANSFERENCE_ASSET_ISSUER))
.thenReturn(fermatEventListener2);
when(eventManager.getNewListener(
EventType.INCOMING_ASSET_REVERSED_ON_BLOCKCHAIN_WAITING_TRANSFERENCE_ASSET_ISSUER))
.thenReturn(fermatEventListener3);
when(eventManager.getNewListener(
EventType.INCOMING_ASSET_REVERSED_ON_CRYPTO_NETWORK_WAITING_TRANSFERENCE_ASSET_ISSUER))
.thenReturn(fermatEventListener4);
when(eventManager.getNewListener(EventType.RECEIVED_NEW_DIGITAL_ASSET_METADATA_NOTIFICATION))
.thenReturn(fermatEventListener5);
when(actorAssetIssuerManager.getActorAssetIssuer()).thenReturn(actorAssetIssuer);
}
private void setUpMockitoGeneralRules() throws Exception {
when(mockPluginDatabaseSystem.createDatabase(
pluginId, IntraWalletUserActorDatabaseConstants.INTRA_WALLET_USER_DATABASE_NAME))
.thenReturn(mockDatabase);
when(mockDatabase.getDatabaseFactory()).thenReturn(mockDatabaseFactory);
when(mockDatabaseFactory.newTableFactory(
pluginId, IntraWalletUserActorDatabaseConstants.INTRA_WALLET_USER_TABLE_NAME))
.thenReturn(mockIntraUserTableFactory);
when(mockDatabase.getTable(IntraWalletUserActorDatabaseConstants.INTRA_WALLET_USER_TABLE_NAME))
.thenReturn(mockTable);
when(mockTable.getEmptyRecord()).thenReturn(mockTableRecord);
}
public void setUpMockitoRules() throws Exception {
when(mockDatabase.getDatabaseFactory()).thenReturn(mockDatabaseFactory);
when(mockDatabaseTable.getEmptyRecord()).thenReturn(mockDatabaseTableRecord);
when(mockDatabase.getTable(CryptoIndexDatabaseConstants.CRYPTO_INDEX_TABLE_NAME))
.thenReturn(mockDatabaseTable);
when(mockPluginDatabaseSystem.openDatabase(
pluginId, CryptoIndexDatabaseConstants.CRYPTO_INDEX_DATABASE_NAME))
.thenReturn(mockDatabase);
when(mockCryptoIndexDatabaseFactory.createDatabase(
pluginId, CryptoIndexDatabaseConstants.CRYPTO_INDEX_DATABASE_NAME))
.thenReturn(mockDatabase);
cryptoIndexDao = new CryptoIndexDao(mockPluginDatabaseSystem, pluginId);
}
private void setUpMockitoRules() throws Exception {
when(mockDatabase.getDatabaseFactory()).thenReturn(mockDatabaseFactory);
when(mockDatabaseTable.getEmptyRecord()).thenReturn(mockDatabaseTableRecord);
when(mockDatabase.getTable(
AssetIssuingTransactionDatabaseConstants.DIGITAL_ASSET_TRANSACTION_TABLE_NAME))
.thenReturn(mockDatabaseTable);
when(mockDatabase.getTable(
AssetIssuingTransactionDatabaseConstants
.DIGITAL_ASSET_TRANSACTION_ASSET_ISSUING_TABLE_NAME))
.thenReturn(mockDatabaseTable2);
when(mockDatabaseTable2.getEmptyRecord()).thenReturn(mockDatabaseTableRecord);
when(mockDatabaseTable2.getRecords()).thenReturn(records);
when(pluginDatabaseSystem.openDatabase(
pluginId, AssetIssuingTransactionDatabaseConstants.DIGITAL_ASSET_TRANSACTION_DATABASE))
.thenReturn(mockDatabase);
when(deviceUser.getPublicKey()).thenReturn("myPublicKey");
when(deviceUserManager.getLoggedInDeviceUser()).thenReturn(deviceUser);
when(actorAssetIssuerManager.getActorAssetIssuer()).thenReturn(actorAssetIssuer);
when(eventManager.getNewListener(
EventType.INCOMING_ASSET_ON_CRYPTO_NETWORK_WAITING_TRANSFERENCE_ASSET_ISSUER))
.thenReturn(fermatEventListener1);
when(eventManager.getNewListener(
EventType.INCOMING_ASSET_ON_BLOCKCHAIN_WAITING_TRANSFERENCE_ASSET_ISSUER))
.thenReturn(fermatEventListener2);
when(eventManager.getNewListener(
EventType.INCOMING_ASSET_REVERSED_ON_BLOCKCHAIN_WAITING_TRANSFERENCE_ASSET_ISSUER))
.thenReturn(fermatEventListener3);
when(eventManager.getNewListener(
EventType.INCOMING_ASSET_REVERSED_ON_CRYPTO_NETWORK_WAITING_TRANSFERENCE_ASSET_ISSUER))
.thenReturn(fermatEventListener4);
when(pluginFileSystem.createTextFile(
this.pluginId,
"digital-asset-issuing/publicKey",
"name.xml",
FilePrivacy.PUBLIC,
FileLifeSpan.PERMANENT))
.thenReturn(pluginTextFile);
when(bitcoinWalletManager.loadWallet(this.walletPublicKey)).thenReturn(bitcoinWalletWallet);
when(bitcoinWalletWallet.getBalance(BalanceType.AVAILABLE)).thenReturn(bitcoinWalletBalance);
when(bitcoinWalletBalance.getBalance()).thenReturn(bitcoinWalletAvailableBalance);
when(assetVaultManager.getNewAssetVaultCryptoAddress(this.blockchainNetworkType))
.thenReturn(cryptoAddress);
// doNothing().when(assetIssuingPluginRoot).issueAssets(digitalAsset, 1, walletPublicKey,
// blockchainNetworkType);
}
@Test
public void Initialize_DatabaseNotFound_MethodSuccesfullyInvoked() throws Exception {
when(mockPluginDatabaseSystem.openDatabase(
testId, IncomingExtraUserDataBaseConstants.INCOMING_EXTRA_USER_DATABASE))
.thenThrow(
new DatabaseNotFoundException(
DatabaseNotFoundException.DEFAULT_MESSAGE, null, null, null));
when(mockPluginDatabaseSystem.createDatabase(
testId, IncomingExtraUserDataBaseConstants.INCOMING_EXTRA_USER_DATABASE))
.thenReturn(mockDatabase);
when(mockDatabase.getDatabaseFactory()).thenReturn(mockDatabaseFactory);
when(mockDatabaseFactory.newTableFactory(any(UUID.class), anyString()))
.thenReturn(mockTableFactory);
testRegistry = new IncomingExtraUserRegistry();
testRegistry.setErrorManager(mockErrorManager);
testRegistry.setPluginDatabaseSystem(mockPluginDatabaseSystem);
catchException(testRegistry).initialize(testId);
assertThat(caughtException()).isNull();
}
/**
* Create the database
*
* @param ownerId the owner id
* @param databaseName the database name
* @return Database
* @throws CantCreateDatabaseException
*/
protected Database createDatabase(UUID ownerId, String databaseName)
throws CantCreateDatabaseException {
Database database;
/** I will create the database where I am going to store the information of this wallet. */
try {
database = this.pluginDatabaseSystem.createDatabase(ownerId, databaseName);
} catch (CantCreateDatabaseException cantCreateDatabaseException) {
/** I can not handle this situation. */
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateDatabaseException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the database.");
}
/** Next, I will add the needed tables. */
try {
DatabaseTableFactory table;
DatabaseFactory databaseFactory = database.getDatabaseFactory();
/** Create Wallet Identity table. */
table =
databaseFactory.newTableFactory(
ownerId, CustomersMiddlewareDatabaseConstants.CUSTOMERS_TABLE_NAME);
table.addColumn(
CustomersMiddlewareDatabaseConstants.CUSTOMERS_RELATIONSHIP_ID_COLUMN_NAME,
DatabaseDataType.STRING,
36,
Boolean.TRUE);
table.addColumn(
CustomersMiddlewareDatabaseConstants.CUSTOMERS_CRYPTO_BROKER_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CustomersMiddlewareDatabaseConstants.CUSTOMERS_CRYPTO_CUSTOMER_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CustomersMiddlewareDatabaseConstants.CUSTOMERS_CUSTOMER_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
20,
Boolean.FALSE);
table.addIndex(CustomersMiddlewareDatabaseConstants.CUSTOMERS_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
} catch (InvalidOwnerIdException invalidOwnerId) {
/**
* This shouldn't happen here because I was the one who gave the owner id to the database file
* system, but anyway, if this happens, I can not continue.
*/
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
invalidOwnerId,
"",
"There is a problem with the ownerId of the database.");
}
return database;
}
/**
* Create the database
*
* @param ownerId the owner id
* @param databaseName the database name
* @return Database
* @throws CantCreateDatabaseException
*/
protected Database createDatabase(UUID ownerId, String databaseName)
throws CantCreateDatabaseException {
Database database;
/** I will create the database where I am going to store the information of this wallet. */
try {
database = this.pluginDatabaseSystem.createDatabase(ownerId, databaseName);
} catch (CantCreateDatabaseException cantCreateDatabaseException) {
/** I can not handle this situation. */
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateDatabaseException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the database.");
}
/** Next, I will add the needed tables. */
try {
DatabaseTableFactory table;
DatabaseFactory databaseFactory = database.getDatabaseFactory();
/** Create Wallets table. */
table =
databaseFactory.newTableFactory(
ownerId, MatchingEngineMiddlewareDatabaseConstants.WALLETS_TABLE_NAME);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.WALLETS_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.TEXT,
100,
Boolean.TRUE);
table.addIndex(MatchingEngineMiddlewareDatabaseConstants.WALLETS_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create Earning Pair table. */
table =
databaseFactory.newTableFactory(
ownerId, MatchingEngineMiddlewareDatabaseConstants.EARNING_PAIR_TABLE_NAME);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_PAIR_ID_COLUMN_NAME,
DatabaseDataType.TEXT,
100,
Boolean.TRUE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_PAIR_EARNING_CURRENCY_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_PAIR_EARNING_CURRENCY_TYPE_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_PAIR_LINKED_CURRENCY_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_PAIR_LINKED_CURRENCY_TYPE_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants
.EARNING_PAIR_EARNINGS_WALLET_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.TEXT,
100,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_PAIR_WALLET_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.TEXT,
100,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_PAIR_STATE_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addIndex(MatchingEngineMiddlewareDatabaseConstants.EARNING_PAIR_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create Earning Transaction table. */
table =
databaseFactory.newTableFactory(
ownerId, MatchingEngineMiddlewareDatabaseConstants.EARNING_TRANSACTION_TABLE_NAME);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_TRANSACTION_ID_COLUMN_NAME,
DatabaseDataType.TEXT,
100,
Boolean.TRUE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants
.EARNING_TRANSACTION_EARNING_CURRENCY_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants
.EARNING_TRANSACTION_EARNING_CURRENCY_TYPE_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_TRANSACTION_AMOUNT_COLUMN_NAME,
DatabaseDataType.MONEY,
0,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_TRANSACTION_STATE_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_TRANSACTION_TIME_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
0,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.EARNING_TRANSACTION_EARNING_PAIR_ID_COLUMN_NAME,
DatabaseDataType.TEXT,
100,
Boolean.FALSE);
table.addIndex(
MatchingEngineMiddlewareDatabaseConstants.EARNING_TRANSACTION_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create Input Transaction table. */
table =
databaseFactory.newTableFactory(
ownerId, MatchingEngineMiddlewareDatabaseConstants.INPUT_TRANSACTION_TABLE_NAME);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.INPUT_TRANSACTION_ID_COLUMN_NAME,
DatabaseDataType.TEXT,
100,
Boolean.TRUE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants
.INPUT_TRANSACTION_ORIGIN_TRANSACTION_ID_COLUMN_NAME,
DatabaseDataType.TEXT,
100,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.INPUT_TRANSACTION_CURRENCY_GIVING_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants
.INPUT_TRANSACTION_CURRENCY_GIVING_TYPE_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.INPUT_TRANSACTION_AMOUNT_GIVING_COLUMN_NAME,
DatabaseDataType.MONEY,
0,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants
.INPUT_TRANSACTION_CURRENCY_RECEIVING_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants
.INPUT_TRANSACTION_CURRENCY_RECEIVING_TYPE_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.INPUT_TRANSACTION_AMOUNT_RECEIVING_COLUMN_NAME,
DatabaseDataType.MONEY,
0,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.INPUT_TRANSACTION_TYPE_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.INPUT_TRANSACTION_STATE_COLUMN_NAME,
DatabaseDataType.TEXT,
10,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants
.INPUT_TRANSACTION_EARNING_TRANSACTION_ID_COLUMN_NAME,
DatabaseDataType.TEXT,
100,
Boolean.FALSE);
table.addColumn(
MatchingEngineMiddlewareDatabaseConstants.INPUT_TRANSACTION_EARNING_PAIR_ID_COLUMN_NAME,
DatabaseDataType.TEXT,
100,
Boolean.FALSE);
table.addIndex(MatchingEngineMiddlewareDatabaseConstants.INPUT_TRANSACTION_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
} catch (InvalidOwnerIdException invalidOwnerId) {
/**
* This shouldn't happen here because I was the one who gave the owner id to the database file
* system, but anyway, if this happens, I can not continue.
*/
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
invalidOwnerId,
"",
"There is a problem with the ownerId of the database.");
}
return database;
}
/**
* Create the database
*
* @param ownerId the owner id
* @param databaseName the database name
* @return Database
* @throws CantCreateDatabaseException
*/
protected Database createDatabase(UUID ownerId, String databaseName)
throws CantCreateDatabaseException {
Database database;
/** I will create the database where I am going to store the information of this wallet. */
try {
database = this.pluginDatabaseSystem.createDatabase(ownerId, databaseName);
} catch (CantCreateDatabaseException cantCreateDatabaseException) {
/** I can not handle this situation. */
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateDatabaseException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the database.");
}
/** Next, I will add the needed tables. */
try {
DatabaseTableFactory table;
DatabaseFactory databaseFactory = database.getDatabaseFactory();
/** Create Fiat Index table. */
table =
databaseFactory.newTableFactory(
ownerId, FiatIndexWorldDatabaseConstants.FIAT_INDEX_TABLE_NAME);
table.addColumn(
FiatIndexWorldDatabaseConstants.FIAT_INDEX_ID_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.TRUE);
table.addColumn(
FiatIndexWorldDatabaseConstants.FIAT_INDEX_CURRENCY_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
FiatIndexWorldDatabaseConstants.FIAT_INDEX_SALE_PRICE_COLUMN_NAME,
DatabaseDataType.REAL,
100,
Boolean.FALSE);
table.addColumn(
FiatIndexWorldDatabaseConstants.FIAT_INDEX_PURCHASE_PRICE_COLUMN_NAME,
DatabaseDataType.REAL,
100,
Boolean.FALSE);
table.addColumn(
FiatIndexWorldDatabaseConstants.FIAT_INDEX_PROVIDER_DESCRIPTION_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
FiatIndexWorldDatabaseConstants.FIAT_INDEX_TIMESTAMP_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
100,
Boolean.FALSE);
table.addIndex(FiatIndexWorldDatabaseConstants.FIAT_INDEX_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
} catch (InvalidOwnerIdException invalidOwnerId) {
/**
* This shouldn't happen here because I was the one who gave the owner id to the database file
* system, but anyway, if this happens, I can not continue.
*/
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
invalidOwnerId,
"",
"There is a problem with the ownerId of the database.");
}
return database;
}
/**
* Create the database
*
* @param ownerId the owner id
* @param databaseName the database name
* @return Database
* @throws CantCreateDatabaseException
*/
protected Database createDatabase(final UUID ownerId, final String databaseName)
throws CantCreateDatabaseException {
Database database;
/** I will create the database where I am going to store the information of this wallet. */
try {
database = this.pluginDatabaseSystem.createDatabase(ownerId, databaseName);
} catch (final CantCreateDatabaseException e) {
/** I can not handle this situation. */
throw new CantCreateDatabaseException(
e,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the database.");
}
/** Next, I will add the needed tables. */
try {
DatabaseTableFactory table;
com.bitdubai.fermat_api.layer.osa_android.database_system.DatabaseFactory databaseFactory =
database.getDatabaseFactory();
/** Create Connection News table. */
table =
databaseFactory.newTableFactory(
ownerId, ChatActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_TABLE_NAME);
table.addColumn(
ChatActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_REQUEST_ID_COLUMN_NAME,
DatabaseDataType.STRING,
36,
Boolean.TRUE);
table.addColumn(
ChatActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_SENDER_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
130,
Boolean.FALSE);
table.addColumn(
ChatActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_SENDER_ACTOR_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
ChatActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_SENDER_ALIAS_COLUMN_NAME,
DatabaseDataType.STRING,
130,
Boolean.FALSE);
table.addColumn(
ChatActorNetworkServiceDatabaseConstants
.CONNECTION_NEWS_DESTINATION_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
130,
Boolean.FALSE);
table.addColumn(
ChatActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_REQUEST_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
ChatActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_REQUEST_STATE_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
ChatActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_REQUEST_ACTION_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
ChatActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_SENT_TIME_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
0,
Boolean.FALSE);
table.addIndex(ChatActorNetworkServiceDatabaseConstants.CONNECTION_NEWS_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
return database;
} catch (InvalidOwnerIdException invalidOwnerId) {
/**
* This shouldn't happen here because I was the one who gave the owner id to the database file
* system, but anyway, if this happens, I can not continue.
*/
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
invalidOwnerId,
"",
"There is a problem with the ownerId of the database.");
}
}
public Database createDatabase(UUID ownerId, String databaseName)
throws CantCreateDatabaseException {
try {
Database database = this.pluginDatabaseSystem.createDatabase(ownerId, databaseName);
DatabaseFactory databaseFactory = database.getDatabaseFactory();
DatabaseTableFactory outgoinExtraUserTable =
databaseFactory.newTableFactory(
ownerId, OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_NAME);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_TRANSACTION_ID_COLUMN_NAME,
DatabaseDataType.STRING,
36,
true);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants
.OUTGOING_EXTRA_USER_TABLE_WALLET_ID_TO_DEBIT_COLUMN_NAME,
DatabaseDataType.STRING,
130,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_TRANSACTION_HASH_COLUMN_NAME,
DatabaseDataType.STRING,
64,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_ADDRESS_FROM_COLUMN_NAME,
DatabaseDataType.STRING,
34,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_ADDRESS_TO_COLUMN_NAME,
DatabaseDataType.STRING,
34,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_CRYPTO_CURRENY_COLUMN_NAME,
DatabaseDataType.STRING,
3,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_CRYPTO_AMOUNT_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
0,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants
.OUTGOING_EXTRA_USER_TABLE_TRANSACTION_STATUS_COLUMN_NAME,
DatabaseDataType.STRING,
10,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_DESCRIPTION_COLUMN_NAME,
DatabaseDataType.STRING,
100,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_TIMESTAMP_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
0,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_CRYPTO_STATUS_COLUMN_NAME,
DatabaseDataType.STRING,
10,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_ACTOR_FROM_ID_COLUMN_NAME,
DatabaseDataType.STRING,
36,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_ACTOR_FROM_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
10,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_ACTOR_TO_ID_COLUMN_NAME,
DatabaseDataType.STRING,
36,
false);
outgoinExtraUserTable.addColumn(
OutgoingExtraUserDatabaseConstants.OUTGOING_EXTRA_USER_TABLE_ACTOR_TO_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
10,
false);
databaseFactory.createTable(ownerId, outgoinExtraUserTable);
return database;
} catch (CantCreateDatabaseException cantCreateDatabaseException) {
throw cantCreateDatabaseException;
} catch (InvalidOwnerIdException invalidOwnerId) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE, invalidOwnerId);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE, cantCreateTableException);
} catch (Exception exception) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
FermatException.wrapException(exception),
null,
null);
}
}
protected Database createDatabase(UUID ownerId, String databaseName)
throws CantCreateDatabaseException {
try {
Database database = this.pluginDatabaseSystem.createDatabase(ownerId, databaseName);
DatabaseTableFactory table;
DatabaseFactory databaseFactory = database.getDatabaseFactory();
/** Create Crypto Address Request table. */
table =
databaseFactory.newTableFactory(
ownerId,
CryptoAddressesNetworkServiceDatabaseConstants.CRYPTO_ADDRESS_REQUEST_TABLE_NAME);
table.addColumn(
CryptoAddressesNetworkServiceDatabaseConstants
.CRYPTO_ADDRESS_REQUEST_REQUEST_ID_COLUMN_NAME,
DatabaseDataType.STRING,
40,
Boolean.TRUE);
table.addColumn(
CryptoAddressesNetworkServiceDatabaseConstants
.CRYPTO_ADDRESS_REQUEST_WALLET_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
130,
Boolean.FALSE);
table.addColumn(
CryptoAddressesNetworkServiceDatabaseConstants
.CRYPTO_ADDRESS_REQUEST_IDENTITY_TYPE_REQUESTING_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
CryptoAddressesNetworkServiceDatabaseConstants
.CRYPTO_ADDRESS_REQUEST_IDENTITY_TYPE_ACCEPTING_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
CryptoAddressesNetworkServiceDatabaseConstants
.CRYPTO_ADDRESS_REQUEST_IDENTITY_PUBLIC_KEY_REQUESTING_COLUMN_NAME,
DatabaseDataType.STRING,
130,
Boolean.FALSE);
table.addColumn(
CryptoAddressesNetworkServiceDatabaseConstants
.CRYPTO_ADDRESS_REQUEST_IDENTITY_PUBLIC_KEY_ACCEPTING_COLUMN_NAME,
DatabaseDataType.STRING,
130,
Boolean.FALSE);
table.addColumn(
CryptoAddressesNetworkServiceDatabaseConstants
.CRYPTO_ADDRESS_REQUEST_CRYPTO_ADDRESS_FROM_REQUEST_COLUMN_NAME,
DatabaseDataType.STRING,
130,
Boolean.FALSE);
table.addColumn(
CryptoAddressesNetworkServiceDatabaseConstants
.CRYPTO_ADDRESS_REQUEST_CRYPTO_ADDRESS_FROM_RESPONSE_COLUMN_NAME,
DatabaseDataType.STRING,
130,
Boolean.FALSE);
table.addColumn(
CryptoAddressesNetworkServiceDatabaseConstants
.CRYPTO_ADDRESS_REQUEST_CRYPTO_CURRENCY_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
CryptoAddressesNetworkServiceDatabaseConstants
.CRYPTO_ADDRESS_REQUEST_BLOCKCHAIN_NETWORK_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
CryptoAddressesNetworkServiceDatabaseConstants.CRYPTO_ADDRESS_REQUEST_STATE_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addIndex(
CryptoAddressesNetworkServiceDatabaseConstants.CRYPTO_ADDRESS_REQUEST_FIRST_KEY_COLUMN);
try {
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
return database;
} catch (CantCreateDatabaseException cantCreateDatabaseException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateDatabaseException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the database.");
} catch (InvalidOwnerIdException invalidOwnerId) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
invalidOwnerId,
"",
"There is a problem with the ownerId of the database.");
}
}
/**
* Method that create a new database and her tables.
*
* @return Object database.
* @throws CantCreateDatabaseException
*/
public Database createDatabase(UUID pluginId) throws CantCreateDatabaseException {
Database database;
/** I will create the database where I am going to store the information of this User. */
try {
database =
this.pluginDatabaseSystem.createDatabase(
pluginId, RedeemPointIdentityDatabaseConstants.REDEEM_POINT_IDENTITY_DB_NAME);
/** Next, I will add the needed tables. */
DatabaseTableFactory table;
/** Asset Issuer Identity table. */
DatabaseFactory databaseFactory = database.getDatabaseFactory();
table =
databaseFactory.newTableFactory(
RedeemPointIdentityDatabaseConstants.REDEEM_POINT_IDENTITY_TABLE_NAME);
table.addColumn(
RedeemPointIdentityDatabaseConstants.REDEEM_POINT_IDENTITY_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
130,
true);
table.addColumn(
RedeemPointIdentityDatabaseConstants.REDEEM_POINT_IDENTITY_PRIVATE_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
130,
false);
table.addColumn(
RedeemPointIdentityDatabaseConstants.REDEEM_POINT_IDENTITY_ALIAS_COLUMN_NAME,
DatabaseDataType.STRING,
36,
false);
table.addColumn(
RedeemPointIdentityDatabaseConstants.REDEEM_POINT_IDENTITY_STATUS_COLUMN_NAME,
DatabaseDataType.STRING,
130,
false);
table.addColumn(
RedeemPointIdentityDatabaseConstants
.REDEEM_POINT_IDENTITY_DEVICE_USER_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
130,
false);
table.addIndex(RedeemPointIdentityDatabaseConstants.REDEEM_POINT_IDENTITY_FIRST_KEY_COLUMN);
databaseFactory.createTable(table);
} catch (CantCreateDatabaseException cantCreateDatabaseException) {
/** I can not handle this situation. */
String message = CantCreateDatabaseException.DEFAULT_MESSAGE;
FermatException cause = cantCreateDatabaseException.getCause();
String context =
"Asset Issuer Identity DataBase_Factory: " + cantCreateDatabaseException.getContext();
String possibleReason =
"The exception is thrown the Create Database Asset Issuer Identity 'this.platformDatabaseSystem.createDatabase(\"AssetIssuerIdentity\")'"
+ cantCreateDatabaseException.getPossibleReason();
throw new CantCreateDatabaseException(message, cause, context, possibleReason);
} catch (CantCreateTableException cantCreateTableException) {
String message = CantCreateTableException.DEFAULT_MESSAGE;
FermatException cause = cantCreateTableException.getCause();
String context = "Create Table Asset Issuer Identity" + cantCreateTableException.getContext();
String possibleReason =
"The exception is generated when creating the table Asset Issuer Identity - DatabaseFactory.createTable(table) "
+ cantCreateTableException.getPossibleReason();
throw new CantCreateDatabaseException(message, cause, context, possibleReason);
} catch (Exception exception) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
FermatException.wrapException(exception),
null,
null);
}
return database;
}
/**
* Create the database
*
* @param ownerId the owner id
* @param databaseName the database name
* @return Database
* @throws CantCreateDatabaseException
*/
public Database createDatabase(UUID ownerId, String databaseName)
throws CantCreateDatabaseException {
Database database;
/** I will create the database where I am going to store the information of this wallet. */
try {
database = this.pluginDatabaseSystem.createDatabase(ownerId, databaseName);
} catch (CantCreateDatabaseException cantCreateDatabaseException) {
/** I can not handle this situation. */
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateDatabaseException,
"Chat Identity",
"Exception not handled by the plugin, There is a problem and i cannot create the database.");
}
/** Next, I will add the needed tables. */
try {
DatabaseTableFactory table;
DatabaseFactory databaseFactory = database.getDatabaseFactory();
/** Create Chat Identity */
table =
databaseFactory.newTableFactory(ownerId, ChatIdentityDatabaseConstants.CHAT_TABLE_NAME);
table.addColumn(
ChatIdentityDatabaseConstants.CHAT_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
255,
Boolean.TRUE);
table.addColumn(
ChatIdentityDatabaseConstants.CHAT_ALIAS_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
ChatIdentityDatabaseConstants.CHAT_DEVICE_USER_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
255,
Boolean.FALSE);
table.addColumn(
ChatIdentityDatabaseConstants.CHAT_EXPOSURE_LEVEL_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addIndex(ChatIdentityDatabaseConstants.CHAT_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"Chat Identity",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
} catch (InvalidOwnerIdException invalidOwnerId) {
/**
* This shouldn't happen here because I was the one who gave the owner id to the database file
* system, but anyway, if this happens, I can not continue.
*/
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
invalidOwnerId,
"Chat Identity",
"There is a problem with the ownerId of the database.");
}
return database;
}
/**
* Create the database
*
* @param ownerId the owner id
* @param databaseName the database name
* @return Database
* @throws CantCreateDatabaseException
*/
protected Database createDatabase(UUID ownerId, String databaseName)
throws CantCreateDatabaseException {
Database database;
/** I will create the database where I am going to store the information of this wallet. */
try {
database = this.pluginDatabaseSystem.createDatabase(ownerId, databaseName);
} catch (CantCreateDatabaseException cantCreateDatabaseException) {
/** I can not handle this situation. */
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateDatabaseException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the database.");
}
/** Next, I will add the needed tables. */
try {
DatabaseTableFactory table;
DatabaseFactory databaseFactory = database.getDatabaseFactory();
/** Create Incoming_Transactions table. */
table =
databaseFactory.newTableFactory(
ownerId, BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_TABLE_NAME);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_TRX_ID_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_HASH_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_BLOCK_HASH_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_BLOCKCHAIN_NETWORK_TYPE,
DatabaseDataType.STRING,
20,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_CRYPTO_STATUS_COLUMN_NAME,
DatabaseDataType.STRING,
30,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_BLOCK_DEPTH_COLUMN_NAME,
DatabaseDataType.INTEGER,
10,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_ADDRESS_TO_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_ADDRESS_FROM_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_BTC_AMOUNT_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
10,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_FEE_AMOUNT_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
10,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_CRYPTO_AMOUNT_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
10,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_OP_RETURN_COLUMN_NAME,
DatabaseDataType.STRING,
150,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_PROTOCOL_STATUS_COLUMN_NAME,
DatabaseDataType.STRING,
30,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_LAST_UPDATE_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
0,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
5,
Boolean.FALSE);
table.addIndex(BitcoinCryptoNetworkDatabaseConstants.TRANSACTIONS_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create CryptoVaults_Stats table. */
table =
databaseFactory.newTableFactory(
ownerId, BitcoinCryptoNetworkDatabaseConstants.CRYPTOVAULTS_STATS_TABLE_NAME);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.CRYPTOVAULTS_STATS_CRYPTO_VAULT_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants
.CRYPTOVAULTS_STATS_LAST_CONNECTION_REQUEST_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.CRYPTOVAULTS_STATS_MONITORED_PUBLICKEYS_COLUMN_NAME,
DatabaseDataType.INTEGER,
10,
Boolean.FALSE);
table.addIndex(BitcoinCryptoNetworkDatabaseConstants.CRYPTOVAULTS_STATS_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create CryptoVaults_detailed_Stats table. */
table =
databaseFactory.newTableFactory(
ownerId,
BitcoinCryptoNetworkDatabaseConstants.CRYPTOVAULTS_DETAILED_STATS_TABLE_NAME);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants
.CRYPTOVAULTS_DETAILED_STATS_CRYPTO_VAULT_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.CRYPTOVAULTS_DETAILED_STATS_NETWORK_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.CRYPTOVAULTS_DETAILED_STATS_ORDER_COLUMN_NAME,
DatabaseDataType.INTEGER,
0,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants
.CRYPTOVAULTS_DETAILED_STATS_MONITORED_PUBLICKEYS_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants
.CRYPTOVAULTS_DETAILED_STATS_MONITORED_ADDRESSES_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addIndex(
BitcoinCryptoNetworkDatabaseConstants.CRYPTOVAULTS_DETAILED_STATS_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create EventAgent_Stats table. */
table =
databaseFactory.newTableFactory(
ownerId, BitcoinCryptoNetworkDatabaseConstants.EVENTAGENT_STATS_TABLE_NAME);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.EVENTAGENT_STATS_EXECUTION_NUMBER_COLUMN_NAME,
DatabaseDataType.INTEGER,
10,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.EVENTAGENT_STATS_LAST_EXECUTION_DATE_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants
.EVENTAGENT_STATS_PENDING_INCOMING_TRANSACTIONS_COLUMN_NAME,
DatabaseDataType.INTEGER,
10,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants
.EVENTAGENT_STATS_PENDING_OUTGOING_TRANSACTIONS_COLUMN_NAME,
DatabaseDataType.INTEGER,
10,
Boolean.FALSE);
table.addIndex(BitcoinCryptoNetworkDatabaseConstants.EVENTAGENT_STATS_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create Broadcast table. */
table =
databaseFactory.newTableFactory(
ownerId, BitcoinCryptoNetworkDatabaseConstants.BROADCAST_TABLE_NAME);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.BROADCAST_EXECUTION_NUMBER_COLUMN_NAME,
DatabaseDataType.INTEGER,
10,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.BROADCAST_NETWORK,
DatabaseDataType.STRING,
20,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.BROADCAST_TRANSACTION_ID,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.BROADCAST_TX_HASH,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.BROADCAST_PEER_COUNT,
DatabaseDataType.INTEGER,
10,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.BROADCAST_PEER_BROADCAST_IP,
DatabaseDataType.STRING,
50,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.BROADCAST_RETRIES_COUNT,
DatabaseDataType.INTEGER,
5,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.BROADCAST_STATUS,
DatabaseDataType.STRING,
5,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.BROADCAST_EXCEPTION,
DatabaseDataType.STRING,
300,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.BROADCAST_LAST_EXECUTION_DATE_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
10,
Boolean.FALSE);
table.addIndex(BitcoinCryptoNetworkDatabaseConstants.BRTOADCAST_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create ACTIVENETWORKS table. */
table =
databaseFactory.newTableFactory(
ownerId, BitcoinCryptoNetworkDatabaseConstants.ACTIVENETWORKS_TABLE_NAME);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.ACTIVENETWORKS_NETWORKTYPE,
DatabaseDataType.STRING,
20,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.ACTIVENETWORKS_KEYS,
DatabaseDataType.INTEGER,
0,
Boolean.FALSE);
table.addColumn(
BitcoinCryptoNetworkDatabaseConstants.ACTIVENETWORKS_LAST_UPDATE,
DatabaseDataType.LONG_INTEGER,
0,
Boolean.FALSE);
table.addIndex(BitcoinCryptoNetworkDatabaseConstants.ACTIVENETWORKS_NETWORKTYPE);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
} catch (InvalidOwnerIdException invalidOwnerId) {
/**
* This shouldn't happen here because I was the one who gave the owner id to the database file
* system, but anyway, if this happens, I can not continue.
*/
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
invalidOwnerId,
"",
"There is a problem with the ownerId of the database.");
}
return database;
}
/**
* Create the database
*
* @param ownerId the owner id
* @param databaseName the database name
* @return Database
* @throws CantCreateDatabaseException
*/
public Database createDatabase(UUID ownerId, String databaseName)
throws CantCreateDatabaseException {
Database database;
/** I will create the database where I am going to store the information of this wallet. */
try {
database = this.pluginDatabaseSystem.createDatabase(ownerId, databaseName);
} catch (CantCreateDatabaseException cantCreateDatabaseException) {
/** I can not handle this situation. */
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateDatabaseException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the database.");
}
/** Next, I will add the needed tables. */
try {
DatabaseTableFactory table;
DatabaseFactory databaseFactory = database.getDatabaseFactory();
/** Create incoming messages table. */
table =
databaseFactory.newTableFactory(
ownerId, CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_TABLE_NAME);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_ID_COLUMN_NAME,
DatabaseDataType.STRING,
36,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_SENDER_ID_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_RECEIVER_ID_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_TEXT_CONTENT_COLUMN_NAME,
DatabaseDataType.STRING,
255,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.INCOMING_MESSAGES_SHIPPING_TIMESTAMP_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.INCOMING_MESSAGES_DELIVERY_TIMESTAMP_COLUMN_NAME,
DatabaseDataType.STRING,
255,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_STATUS_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addIndex(
CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create outgoing messages table. */
table =
databaseFactory.newTableFactory(
ownerId, CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_TABLE_NAME);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_ID_COLUMN_NAME,
DatabaseDataType.STRING,
36,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_SENDER_ID_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_RECEIVER_ID_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_TEXT_CONTENT_COLUMN_NAME,
DatabaseDataType.STRING,
255,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.OUTGOING_MESSAGES_SHIPPING_TIMESTAMP_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.OUTGOING_MESSAGES_DELIVERY_TIMESTAMP_COLUMN_NAME,
DatabaseDataType.STRING,
255,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_STATUS_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addIndex(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/*
* Create outgoing notification table.
*/
table =
databaseFactory.newTableFactory(
ownerId,
CommunicationNetworkServiceDatabaseConstants.OUTGOING_NOTIFICATION_TABLE_NAME);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_NOTIFICATION_ID_COLUMN_NAME,
DatabaseDataType.STRING,
36,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.OUTGOING_NOTIFICATION_SENDER_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
50,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.OUTGOING_NOTIFICATION_RECEIVER_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
50,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.OUTGOING_NOTIFICATION_SENDER_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
25,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.OUTGOING_NOTIFICATION_RECEIVER_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
25,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_NOTIFICATION_TIMESTAMP_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
59,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.OUTGOING_NOTIFICATION_SENDER_ALIAS_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.OUTGOING_NOTIFICATION_SENDER_IMAGE_COLUMN_NAME,
DatabaseDataType.STRING,
255,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_NOTIFICATION_DESCRIPTOR_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.OUTGOING_NOTIFICATION_PROTOCOL_STATE_COLUMN_NAME,
DatabaseDataType.STRING,
30,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_NOTIFICATION_READ_MARK_COLUMN_NAME,
DatabaseDataType.STRING,
6,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_NOTIFICATION_SENT_COUNT_COLUMN_NAME,
DatabaseDataType.INTEGER,
6,
Boolean.FALSE);
table.addIndex(
CommunicationNetworkServiceDatabaseConstants.OUTGOING_NOTIFICATION_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/*
* Create incoming messages table.
*/
table =
databaseFactory.newTableFactory(
ownerId,
CommunicationNetworkServiceDatabaseConstants.INCOMING_NOTIFICATION_TABLE_NAME);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.INCOMING_NOTIFICATION_ID_COLUMN_NAME,
DatabaseDataType.STRING,
36,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.INCOMING_NOTIFICATION_SENDER_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
50,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.INCOMING_NOTIFICATION_RECEIVER_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
50,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.INCOMING_NOTIFICATION_SENDER_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
25,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.INCOMING_NOTIFICATION_RECEIVER_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
25,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.INCOMING_NOTIFICATION_TIMESTAMP_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
50,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.INCOMING_NOTIFICATION_SENDER_ALIAS_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.INCOMING_NOTIFICATION_SENDER_IMAGE_COLUMN_NAME,
DatabaseDataType.STRING,
255,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.INCOMING_NOTIFICATION_DESCRIPTOR_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants
.INCOMING_NOTIFICATION_PROTOCOL_STATE_COLUMN_NAME,
DatabaseDataType.STRING,
6,
Boolean.FALSE);
table.addColumn(
CommunicationNetworkServiceDatabaseConstants.INCOMING_NOTIFICATION_READ_MARK_COLUMN_NAME,
DatabaseDataType.STRING,
6,
Boolean.FALSE);
table.addIndex(
CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
} catch (InvalidOwnerIdException invalidOwnerId) {
/**
* This shouldn't happen here because I was the one who gave the owner id to the database file
* system, but anyway, if this happens, I can not continue.
*/
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
invalidOwnerId,
"",
"There is a problem with the ownerId of the database.");
}
return database;
}
public Database createDatabase(UUID ownerId, String databaseName)
throws CantCreateDatabaseException {
Database database;
/** I will create the database where I am going to store the information of this wallet. */
try {
database = this.pluginDatabaseSystem.createDatabase(ownerId, databaseName);
} catch (CantCreateDatabaseException exception) {
/** I can not handle this situation. */
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
exception,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the database.");
}
/** Next, I will add the needed tables. */
try {
DatabaseTableFactory table;
DatabaseFactory databaseFactory = database.getDatabaseFactory();
/** Create Asset Issuer database table. */
table =
databaseFactory.newTableFactory(
ownerId, RedeemPointActorDatabaseConstants.REDEEM_POINT_TABLE_NAME);
// PUBLIC KEYS
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.TRUE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_LINKED_IDENTITY_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_CONNECTION_STATE_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTRATION_DATE_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
0,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_MODIFIED_DATE_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
0,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_CONTACT_INFORMATION_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_HOURS_OF_OPERATION_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
// COLUMNAS DE ADDRESS
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_ADDRESS_COUNTRY_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_ADDRESS_POSTAL_CODE_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_ADDRESS_PROVINCE_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_ADDRESS_CITY_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_ADDRESS_STREET_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_ADDRESS_HOUSE_NUMBER_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
// COLUMAS DE CRYPTOADDRESS
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_CRYPTO_ADDRESS_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_CRYPTO_CURRENCY_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
// COLUMNAS DE LOCATION
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_LOCATION_LATITUDE_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_LOCATION_LONGITUDE_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addIndex(RedeemPointActorDatabaseConstants.REDEEM_POINT_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
// CREATE THE REGISTERED TABLE.
table =
databaseFactory.newTableFactory(
ownerId, RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_TABLE_NAME);
// PUBLIC KEYS
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.TRUE);
table.addColumn(
RedeemPointActorDatabaseConstants
.REDEEM_POINT_REGISTERED_LINKED_IDENTITY_PUBLIC_KEY_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_CONNECTION_STATE_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_REGISTRATION_DATE_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
0,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_MODIFIED_DATE_COLUMN_NAME,
DatabaseDataType.LONG_INTEGER,
0,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_CONTACT_INFORMATION_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_HOURS_OF_OPERATION_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
// COLUMNAS DE ADDRESS
table.addColumn(
RedeemPointActorDatabaseConstants
.REDEEM_POINT_REGISTERED_ADDRESS_COUNTRY_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_ADDRESS_POSTAL_CODE_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants
.REDEEM_POINT_REGISTERED_ADDRESS_PROVINCE_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_ADDRESS_CITY_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_ADDRESS_STREET_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants
.REDEEM_POINT_REGISTERED_ADDRESS_HOUSE_NUMBER_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
// COLUMAS DE CRYPTOADDRESS
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_CRYPTO_ADDRESS_COLUMN_NAME,
DatabaseDataType.STRING,
256,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_CRYPTO_CURRENCY_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
// COLUMNAS DE LOCATION
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_LOCATION_LATITUDE_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_LOCATION_LONGITUDE_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addIndex(RedeemPointActorDatabaseConstants.REDEEM_POINT_REGISTERED_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create Asset Issuer relation Redeem Point Associate table. */
// table = databaseFactory.newTableFactory(ownerId,
// RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_TABLE_NAME);
//
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_PUBLIC_KEY_COLUMN_NAME, DatabaseDataType.STRING, 256, Boolean.TRUE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_REDEEM_POINT_PUBLIC_KEY_COLUMN_NAME, DatabaseDataType.LONG_INTEGER, 0, Boolean.TRUE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_NAME_COLUMN_NAME, DatabaseDataType.STRING, 100, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_STATUS_COLUMN_NAME, DatabaseDataType.STRING, 10, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_ASSETS_COUNT_COLUMN_NAME, DatabaseDataType.STRING, 10, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_REGISTRATION_DATE_COLUMN_NAME, DatabaseDataType.LONG_INTEGER, 10, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_REDEEM_POINT_NAME_COLUMN_NAME, DatabaseDataType.LONG_INTEGER, 0, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_REDEEM_POINT_STATUS_COLUMN_NAME, DatabaseDataType.STRING, 10, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_REDEEM_POINT_REGISTRATION_DATE_COLUMN_NAME, DatabaseDataType.LONG_INTEGER, 0, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_REDEEM_POINT_MODIFIED_DATE_COLUMN_NAME, DatabaseDataType.LONG_INTEGER, 0, Boolean.FALSE);
//
//
// table.addIndex(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ISSUER_ASSET_FIRST_KEY_COLUMN);
//
// try {
// //Create the table
// databaseFactory.createTable(ownerId, table);
// } catch (CantCreateTableException cantCreateTableException) {
// throw new
// CantCreateDatabaseException(CantCreateDatabaseException.DEFAULT_MESSAGE,
// cantCreateTableException, "", "Exception not handled by the plugin, There is a problem and
// i cannot create the table.");
// }
/** Create Asset Issuer relation Asset User table. */
// table = databaseFactory.newTableFactory(ownerId,
// RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_TABLE_NAME);
//
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_USER_PUBLIC_KEY_COLUMN_NAME, DatabaseDataType.STRING, 256, Boolean.TRUE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_RELATION_ISSUER_NAME_COLUMN_NAME, DatabaseDataType.STRING, 100, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_ISSUER_IDENTITY_COLUMN_NAME, DatabaseDataType.STRING, 100, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_USER_NAME_COLUMN_NAME, DatabaseDataType.STRING, 100, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_USER_SEX_COLUMN_NAME, DatabaseDataType.STRING, 100, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_USER_UBICACION_COLUMN_NAME, DatabaseDataType.STRING, 100, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_USER_AGE_COLUMN_NAME, DatabaseDataType.STRING, 10, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_ASSET_DESCRIPTION_COLUMN_NAME, DatabaseDataType.STRING, 200, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_ASSET_NAME_COLUMN_NAME, DatabaseDataType.STRING, 100, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_ASSET_ID_COLUMN_NAME, DatabaseDataType.STRING, 100, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_ASSET_HASH_COLUMN_NAME, DatabaseDataType.STRING, 100, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_ASSET_STATUS_COLUMN_NAME, DatabaseDataType.STRING, 10, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_ASSET_RESOURCES_COLUMN_NAME, DatabaseDataType.LONG_INTEGER, 0, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_ASSET_AMOUNT_COLUMN_NAME, DatabaseDataType.LONG_INTEGER, 0, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_ASSET_CURRENCY_COLUMN_NAME, DatabaseDataType.STRING, 10, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_ASSET_EXPIRATION_DATE_COLUMN_NAME, DatabaseDataType.LONG_INTEGER, 0, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_REDEEMPTION_TIMESTAMP_COLUMN_NAME, DatabaseDataType.LONG_INTEGER, 0, Boolean.FALSE);
//
// table.addColumn(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_REDEEMPTION_DATE_COLUMN_NAME, DatabaseDataType.LONG_INTEGER, 0, Boolean.FALSE);
//
//
// table.addIndex(RedeemPointActorDatabaseConstants.REDEEM_POINT_RELATION_ASSET_USER_FIRST_KEY_COLUMN);
//
// try {
// //Create the table
// databaseFactory.createTable(ownerId, table);
// } catch (CantCreateTableException cantCreateTableException) {
// throw new
// CantCreateDatabaseException(CantCreateDatabaseException.DEFAULT_MESSAGE,
// cantCreateTableException, "", "Exception not handled by the plugin, There is a problem and
// i cannot create the table.");
// }
} catch (InvalidOwnerIdException exception) {
/**
* This shouldn't happen here because I was the one who gave the owner id to the database file
* system, but anyway, if this happens, I can not continue.
*/
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
exception,
"",
"There is a problem with the ownerId of the database.");
}
return database;
}
/**
* Create the database
*
* @param ownerId the owner id
* @param databaseName the database name
* @return Database
* @throws CantCreateDatabaseException
*/
public Database createDatabase(UUID ownerId, String databaseName)
throws CantCreateDatabaseException {
Database database;
/** I will create the database where I am going to store the information of this wallet. */
try {
database = this.pluginDatabaseSystem.createDatabase(ownerId, databaseName);
} catch (CantCreateDatabaseException cantCreateDatabaseException) {
/** I can not handle this situation. */
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateDatabaseException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the database.");
}
/** Next, I will add the needed tables. */
try {
DatabaseTableFactory table;
DatabaseFactory databaseFactory = database.getDatabaseFactory();
/** Create System Data table. */
table =
databaseFactory.newTableFactory(
ownerId, SystemMonitorNetworkServiceDatabaseConstants.SYSTEM_DATA_TABLE_NAME);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.SYSTEM_DATA_SYSTEM_ID_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.TRUE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.SYSTEM_DATA_NODE_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
10,
Boolean.FALSE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.SYSTEM_DATA_HARDWARE_COLUMN_NAME,
DatabaseDataType.STRING,
15,
Boolean.FALSE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.SYSTEM_DATA_OS_COLUMN_NAME,
DatabaseDataType.STRING,
50,
Boolean.FALSE);
table.addIndex(SystemMonitorNetworkServiceDatabaseConstants.SYSTEM_DATA_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create Connections table. */
table =
databaseFactory.newTableFactory(
ownerId, SystemMonitorNetworkServiceDatabaseConstants.CONNECTIONS_TABLE_NAME);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.CONNECTIONS_CONNID_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.TRUE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.CONNECTIONS_PEERID_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.CONNECTIONS_PEER_IPV4_COLUMN_NAME,
DatabaseDataType.STRING,
15,
Boolean.FALSE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.CONNECTIONS_PEER_IPV6_COLUMN_NAME,
DatabaseDataType.STRING,
50,
Boolean.FALSE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.CONNECTIONS_NETWORK_SERVICE_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
50,
Boolean.FALSE);
table.addIndex(SystemMonitorNetworkServiceDatabaseConstants.CONNECTIONS_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
/** Create Services table. */
table =
databaseFactory.newTableFactory(
ownerId, SystemMonitorNetworkServiceDatabaseConstants.SERVICES_TABLE_NAME);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.SERVICES_ID_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.TRUE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.SERVICES_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
100,
Boolean.FALSE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.SERVICES_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
15,
Boolean.FALSE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.SERVICES_SUBTYPE_COLUMN_NAME,
DatabaseDataType.STRING,
15,
Boolean.FALSE);
table.addIndex(SystemMonitorNetworkServiceDatabaseConstants.SERVICES_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
table =
databaseFactory.newTableFactory(
ownerId, SystemMonitorNetworkServiceDatabaseConstants.PLATFORM_COMPONENTS_TABLE_NAME);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.COMPONENT_ID_COLUMN_NAME,
DatabaseDataType.STRING,
50,
Boolean.TRUE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.COMPONENT_NAME_COLUMN_NAME,
DatabaseDataType.STRING,
40,
Boolean.FALSE);
table.addColumn(
SystemMonitorNetworkServiceDatabaseConstants.COMPONENT_TYPE_COLUMN_NAME,
DatabaseDataType.STRING,
15,
Boolean.FALSE);
table.addIndex(SystemMonitorNetworkServiceDatabaseConstants.COMPONENT_FIRST_KEY_COLUMN);
try {
// Create the table
databaseFactory.createTable(ownerId, table);
} catch (CantCreateTableException cantCreateTableException) {
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
cantCreateTableException,
"",
"Exception not handled by the plugin, There is a problem and i cannot create the table.");
}
} catch (InvalidOwnerIdException invalidOwnerId) {
/**
* This shouldn't happen here because I was the one who gave the owner id to the database file
* system, but anyway, if this happens, I can not continue.
*/
throw new CantCreateDatabaseException(
CantCreateDatabaseException.DEFAULT_MESSAGE,
invalidOwnerId,
"",
"There is a problem with the ownerId of the database.");
}
return database;
}