コード例 #1
0
  /**
   * Saves and outgoing transaction into the database
   *
   * @param hash
   * @param cryptoStatus
   * @param blockDepth
   * @param addressTo
   * @param addressFrom
   * @param value
   * @param op_Return
   * @param protocolStatus
   * @throws CantExecuteDatabaseOperationException
   */
  public void saveNewOutgoingTransaction(
      String hash,
      CryptoStatus cryptoStatus,
      int blockDepth,
      CryptoAddress addressTo,
      CryptoAddress addressFrom,
      long value,
      String op_Return,
      ProtocolStatus protocolStatus)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        database.getTable(BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_TABLE_NAME);
    DatabaseTableRecord record = databaseTable.getEmptyRecord();

    /** generates the trx_id */
    UUID trxId = UUID.randomUUID();

    record.setUUIDValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_TRX_ID_COLUMN_NAME, trxId);
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_HASH_COLUMN_NAME, hash);
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_CRYPTO_STATUS_COLUMN_NAME,
        cryptoStatus.getCode());
    record.setIntegerValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_BLOCK_DEPTH_COLUMN_NAME,
        blockDepth);
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_ADDRESS_TO_COLUMN_NAME,
        addressTo.getAddress());
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_ADDRESS_FROM_COLUMN_NAME,
        addressFrom.getAddress());
    record.setDoubleValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_VALUE_COLUMN_NAME, value);
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_OP_RETURN_COLUMN_NAME,
        op_Return);
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_PROTOCOL_STATUS_COLUMN_NAME,
        protocolStatus.getCode());
    record.setStringValue(
        BitcoinCryptoNetworkDatabaseConstants.INCOMING_TRANSACTIONS_LAST_UPDATE_COLUMN_NAME,
        getCurrentDateTime());
    try {
      databaseTable.insertRecord(record);
    } catch (CantInsertRecordException e) {
      StringBuilder outputMessage =
          new StringBuilder(
              "There was an error inserting a new transaction in the Outgoing Transactions Table. Transaction record is:");
      outputMessage.append(System.lineSeparator());
      outputMessage.append(XMLParser.parseObject(record));

      throw new CantExecuteDatabaseOperationException(
          CantExecuteDatabaseOperationException.DEFAULT_MESSAGE,
          e,
          outputMessage.toString(),
          "database issue.");
    }
  }
コード例 #2
0
  /**
   * Sets the new depth of the current Used keys value
   *
   * @param accountId
   * @param newValue
   * @throws CantExecuteDatabaseOperationException
   */
  public void setNewCurrentUsedKeyValue(int accountId, int newValue)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        getDatabaseTable(AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_TABLE_NAME);

    /** I will check to see if I already have a value for this account so i can updated it. */
    databaseTable.addStringFilter(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_ACCOUNT_ID_COLUMN_NAME,
        String.valueOf(accountId),
        DatabaseFilterType.EQUAL);
    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    DatabaseTableRecord record = null;
    try {
      if (databaseTable.getRecords().size() == 0) {
        // I will insert the new value
        record = databaseTable.getEmptyRecord();
        record.setIntegerValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_ACCOUNT_ID_COLUMN_NAME,
            accountId);
        record.setIntegerValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants
                .KEY_MAINTENANCE_GENERATED_KEYS_COLUMN_NAME,
            0);
        record.setIntegerValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_USED_KEYS_COLUMN_NAME,
            newValue);

        databaseTable.insertRecord(record);
      } else {
        // I will update the existing value
        record = databaseTable.getRecords().get(0);
        record.setIntegerValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_USED_KEYS_COLUMN_NAME,
            newValue);
        databaseTable.updateRecord(record);
      }
    } catch (CantInsertRecordException | CantUpdateRecordException e) {
      StringBuilder outputMessage =
          new StringBuilder(
              "There was an error inserting or updating the key depth value in the database.");
      outputMessage.append(System.lineSeparator());
      outputMessage.append("The record is:");
      outputMessage.append(System.lineSeparator());
      outputMessage.append(XMLParser.parseObject(record));

      throw new CantExecuteDatabaseOperationException(
          CantExecuteDatabaseOperationException.DEFAULT_MESSAGE,
          e,
          outputMessage.toString(),
          "database issue");
    }
  }
コード例 #3
0
  /**
   * Sets the active network type that the Bitcoin Network will need to listen too. Network types
   * are MainNet, TestNet and RegTest
   *
   * @param blockchainNetworkType
   * @throws CantExecuteDatabaseOperationException
   */
  public void setActiveNetworkType(BlockchainNetworkType blockchainNetworkType)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        getDatabaseTable(AssetsOverBitcoinCryptoVaultDatabaseConstants.ACTIVE_NETWORKS_TABLE_NAME);

    /** I will check to see if I already have a value for this account so i can updated it. */
    databaseTable.addStringFilter(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.ACTIVE_NETWORKS_NETWORKTYPE_COLUMN_NAME,
        blockchainNetworkType.getCode(),
        DatabaseFilterType.EQUAL);
    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }
    DatabaseTableRecord record = null;
    String date = new SimpleDateFormat("yyyyMMdd_HHmmss").format(Calendar.getInstance().getTime());
    try {
      if (databaseTable.getRecords().size() == 0) {
        // I will insert the new value
        record = databaseTable.getEmptyRecord();
        record.setStringValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.ACTIVE_NETWORKS_NETWORKTYPE_COLUMN_NAME,
            blockchainNetworkType.getCode());
        record.setStringValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants
                .ACTIVE_NETWORKS_ACTIVATION_DATE_COLUMN_NAME,
            date);
        databaseTable.insertRecord(record);
      } else {
        // I will update the existing value
        record = databaseTable.getRecords().get(0);
        record.setStringValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants
                .ACTIVE_NETWORKS_ACTIVATION_DATE_COLUMN_NAME,
            date);
        databaseTable.updateRecord(record);
      }
    } catch (CantInsertRecordException | CantUpdateRecordException e) {
      StringBuilder outputMessage =
          new StringBuilder(
              "There was an error inserting or updating the network type in the database.");
      outputMessage.append(System.lineSeparator());
      outputMessage.append("The record is:");
      outputMessage.append(System.lineSeparator());
      outputMessage.append(XMLParser.parseObject(record));

      throw new CantExecuteDatabaseOperationException(
          CantExecuteDatabaseOperationException.DEFAULT_MESSAGE,
          e,
          outputMessage.toString(),
          "database issue");
    }
  }
コード例 #4
0
  /**
   * Sets the new value of how many keys have been generated by the Key Maintainer
   *
   * @param accountId the account id
   * @param value the amount of keys generated. This value accumulates to the one that existed.
   * @throws CantExecuteDatabaseOperationException
   */
  public void setGeneratedKeysValue(int accountId, int value)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        getDatabaseTable(AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_TABLE_NAME);

    /**
     * first I see if we already have records for this account by setting a filter and getting the
     * values
     */
    databaseTable.addStringFilter(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_ACCOUNT_ID_COLUMN_NAME,
        String.valueOf(accountId),
        DatabaseFilterType.EQUAL);
    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    /** I will insert or update the record */
    DatabaseTableRecord record = null;
    try {
      if (databaseTable.getRecords().size() == 0) {
        // insert
        record = databaseTable.getEmptyRecord();
        record.setIntegerValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_ACCOUNT_ID_COLUMN_NAME,
            accountId);
        record.setIntegerValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants
                .KEY_MAINTENANCE_GENERATED_KEYS_COLUMN_NAME,
            value);
        record.setIntegerValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_USED_KEYS_COLUMN_NAME, 0);
        databaseTable.insertRecord(record);
      } else {
        // update
        record = databaseTable.getRecords().get(0);
        record.setIntegerValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants
                .KEY_MAINTENANCE_GENERATED_KEYS_COLUMN_NAME,
            value);
        databaseTable.updateRecord(record);
      }
    } catch (CantInsertRecordException | CantUpdateRecordException e) {
      StringBuilder outputMessage =
          new StringBuilder("There was an error inserting or updating the following table: ");
      outputMessage.append(databaseTable.getTableName());
      outputMessage.append(System.lineSeparator());
      outputMessage.append("The record is:");
      outputMessage.append(System.lineSeparator());
      outputMessage.append(XMLParser.parseObject(record));
    }
  }
コード例 #5
0
  /**
   * Inserts into the database new statistics from the key maintainer
   *
   * @param hierarchyAccountId
   * @param date
   * @param currentGeneratedKeys
   * @param currentUsedKeys
   * @param currentThreshold
   * @throws CantExecuteDatabaseOperationException
   */
  private void insertNewMaintainerStatistics(
      int hierarchyAccountId,
      String date,
      int currentGeneratedKeys,
      int currentUsedKeys,
      int currentThreshold)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        getDatabaseTable(
            AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_MONITOR_TABLE_NAME);

    DatabaseTableRecord databaseTableRecord = databaseTable.getEmptyRecord();
    databaseTableRecord.setIntegerValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_EXECUTION_NUMBER_COLUMN_NAME,
        1);
    databaseTableRecord.setIntegerValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_ACCOUNT_ID_COLUMN_NAME,
        hierarchyAccountId);
    databaseTableRecord.setStringValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_EXECUTION_DATE_COLUMN_NAME,
        date);
    databaseTableRecord.setIntegerValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_GENERATED_KEYS_COLUMN_NAME,
        currentGeneratedKeys);
    databaseTableRecord.setIntegerValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_MONITOR_USED_KEYS_COLUMN_NAME,
        currentUsedKeys);
    databaseTableRecord.setIntegerValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_MONITOR_THRESHOLD_COLUMN_NAME,
        currentThreshold);

    try {
      databaseTable.insertRecord(databaseTableRecord);
    } catch (CantInsertRecordException e) {
      /** I will create the output meessage */
      StringBuilder outputMessage =
          new StringBuilder("there was an error inserting a new record into ");
      outputMessage.append(
          AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_MONITOR_TABLE_NAME);
      outputMessage.append(System.lineSeparator());
      outputMessage.append("The record to insert is: ");
      outputMessage.append(XMLParser.parseObject(databaseTableRecord));

      throw new CantExecuteDatabaseOperationException(
          CantExecuteDatabaseOperationException.DEFAULT_MESSAGE,
          e,
          outputMessage.toString(),
          "Database issue");
    }
  }
コード例 #6
0
  /**
   * Updates existing key maintainer statistics.
   *
   * @param date
   * @param currentGeneratedKeys
   * @param currentUsedKeys
   * @param currentThreshold
   * @throws CantExecuteDatabaseOperationException
   */
  private void updateExistingMaintainerStatistics(
      DatabaseTableRecord recordToUpdate,
      String date,
      int currentGeneratedKeys,
      int currentUsedKeys,
      int currentThreshold)
      throws CantExecuteDatabaseOperationException {
    int previousExecNumber =
        recordToUpdate.getIntegerValue(
            AssetsOverBitcoinCryptoVaultDatabaseConstants
                .KEY_MAINTENANCE_MONITOR_EXECUTION_NUMBER_COLUMN_NAME);
    recordToUpdate.setIntegerValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_EXECUTION_NUMBER_COLUMN_NAME,
        previousExecNumber + 1);
    recordToUpdate.setStringValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_EXECUTION_DATE_COLUMN_NAME,
        date);
    recordToUpdate.setIntegerValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants
            .KEY_MAINTENANCE_MONITOR_GENERATED_KEYS_COLUMN_NAME,
        currentGeneratedKeys);
    recordToUpdate.setIntegerValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_MONITOR_USED_KEYS_COLUMN_NAME,
        currentUsedKeys);
    recordToUpdate.setIntegerValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_MONITOR_THRESHOLD_COLUMN_NAME,
        currentThreshold);

    try {
      getDatabaseTable(
              AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_MONITOR_TABLE_NAME)
          .updateRecord(recordToUpdate);
    } catch (CantUpdateRecordException e) {
      /** I will create the output meessage */
      StringBuilder outputMessage =
          new StringBuilder("there was an error updating an existing record from ");
      outputMessage.append(
          AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_MAINTENANCE_MONITOR_TABLE_NAME);
      outputMessage.append(System.lineSeparator());
      outputMessage.append("The record to insert is: ");
      outputMessage.append(XMLParser.parseObject(recordToUpdate));

      throw new CantExecuteDatabaseOperationException(
          CantExecuteDatabaseOperationException.DEFAULT_MESSAGE,
          e,
          outputMessage.toString(),
          "Database issue");
    }
  }
 @Override
 public Language getLanguageFromXmlString(String languageStructure)
     throws CantGetLanguageException {
   try {
     Language language = new Language();
     language = (Language) XMLParser.parseXML(languageStructure, language);
     return language;
   } catch (Exception e) {
     errorManager.reportUnexpectedPluginException(
         Plugins.BITDUBAI_WALLET_LANGUAGE_MIDDLEWARE,
         UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
         e);
     throw new CantGetLanguageException(
         CantGetLanguageException.DEFAULT_MESSAGE, e, "Cant get language", "");
   }
 }
 @Override
 public String getLanguageXmlFromClassStructure(Language language)
     throws CantGetLanguageException {
   try {
     String xml = null;
     if (language != null) {
       xml = XMLParser.parseObject(language);
     }
     return xml;
   } catch (Exception e) {
     errorManager.reportUnexpectedPluginException(
         Plugins.BITDUBAI_WALLET_LANGUAGE_MIDDLEWARE,
         UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
         e);
     throw new CantGetLanguageException(
         CantGetLanguageException.DEFAULT_MESSAGE, e, "Cant get language", "");
   }
 }
コード例 #9
0
  /**
   * Marks to RECEPTION_NOTIFIED the protocol status of this Outgoing transaction if found.
   *
   * @param transactionID
   */
  private void confirmOutgoingTransactionReception(UUID transactionID)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        database.getTable(BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_TABLE_NAME);
    databaseTable.setStringFilter(
        BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_TRX_ID_COLUMN_NAME,
        transactionID.toString(),
        DatabaseFilterType.EQUAL);

    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    /** set the value to RECEPTION_NOTIFIED and the Last_update_time to now */
    if (databaseTable.getRecords().size() > 0) {
      DatabaseTableRecord record = databaseTable.getRecords().get(0);
      record.setStringValue(
          BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_PROTOCOL_STATUS_COLUMN_NAME,
          ProtocolStatus.RECEPTION_NOTIFIED.getCode());
      record.setStringValue(
          BitcoinCryptoNetworkDatabaseConstants.OUTGOING_TRANSACTIONS_LAST_UPDATE_COLUMN_NAME,
          getCurrentDateTime());

      try {
        databaseTable.updateRecord(record);
      } catch (CantUpdateRecordException e) {
        StringBuilder errorOutput =
            new StringBuilder(
                "There was a problem setting to RECEPTION_NOTIFIED the following transaction:");
        errorOutput.append(System.lineSeparator());
        errorOutput.append(XMLParser.parseObject(record));
        throw new CantExecuteDatabaseOperationException(
            CantExecuteDatabaseOperationException.DEFAULT_MESSAGE,
            e,
            errorOutput.toString(),
            "database issue");
      }
    }
  }
 /**
  * i get the path and name of the file and i load it
  *
  * @param walletLanguage of the language you're trying to get
  * @return language class structure
  * @throws CantGetLanguageException
  * @throws LanguageNotFoundException
  */
 @Override
 public Language getLanguage(WalletLanguage walletLanguage)
     throws CantGetLanguageException, LanguageNotFoundException {
   if (walletLanguage != null) {
     try {
       String languageFileName = getLanguageFileName(walletLanguage);
       PluginTextFile pluginTextFile =
           pluginFileSystem.getTextFile(
               pluginId,
               WALLET_LANGUAGES_PATH,
               languageFileName,
               FilePrivacy.PRIVATE,
               FileLifeSpan.PERMANENT);
       pluginTextFile.loadFromMedia();
       String xml = pluginTextFile.getContent();
       Language language = new Language();
       language = (Language) XMLParser.parseXML(xml, language);
       return language;
     } catch (CantCreateFileException | CantLoadFileException e) {
       errorManager.reportUnexpectedPluginException(
           Plugins.BITDUBAI_WALLET_LANGUAGE_MIDDLEWARE,
           UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
           e);
       throw new CantGetLanguageException(
           CantGetLanguageException.DEFAULT_MESSAGE, e, "Cant get language", "");
     } catch (FileNotFoundException e) {
       errorManager.reportUnexpectedPluginException(
           Plugins.BITDUBAI_WALLET_LANGUAGE_MIDDLEWARE,
           UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
           e);
       throw new LanguageNotFoundException(
           LanguageNotFoundException.DEFAULT_MESSAGE, e, "Language not found.", "");
     }
   } else {
     throw new CantGetLanguageException(
         CantGetLanguageException.DEFAULT_MESSAGE, null, "Wallet Language is null.", "");
   }
 }
コード例 #11
0
  /**
   * Inserts a new HierarchyAccount into the database
   *
   * @param hierarchyAccount
   * @throws CantExecuteDatabaseOperationException
   * @throws CantInsertRecordException
   */
  public void addNewHierarchyAccount(HierarchyAccount hierarchyAccount)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        getDatabaseTable(AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_TABLE_NAME);
    DatabaseTableRecord record = databaseTable.getEmptyRecord();

    record.setIntegerValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_ID_COLUMN_NAME,
        hierarchyAccount.getId());
    record.setStringValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_DESCRIPTION_COLUMN_NAME,
        hierarchyAccount.getDescription());
    record.setStringValue(
        AssetsOverBitcoinCryptoVaultDatabaseConstants.KEY_ACCOUNTS_TYPE_COLUMN_NAME,
        hierarchyAccount.getHierarchyAccountType().getCode());

    try {
      databaseTable.insertRecord(record);
    } catch (CantInsertRecordException e) {
      /**
       * if there was an error inserting the object, I will prepare the error message and throw it.
       */
      StringBuilder outputMessage =
          new StringBuilder("There was an error inserting a new HierarchyAccount value.");
      outputMessage.append(System.lineSeparator());
      outputMessage.append("HierarchyAccount value:");
      outputMessage.append(System.lineSeparator());
      outputMessage.append(XMLParser.parseObject(hierarchyAccount));

      throw new CantExecuteDatabaseOperationException(
          CantExecuteDatabaseOperationException.DEFAULT_MESSAGE,
          e,
          outputMessage.toString(),
          "A database error.");
    }
  }
コード例 #12
0
    private void doTheMainTask() throws CannotSendContractHashException, CantUpdateRecordException {

      try {
        openContractBusinessTransactionDao =
            new OpenContractBusinessTransactionDao(pluginDatabaseSystem, pluginId, database);
        /** Check if exist in database new contracts to send */
        List<String> contractPendingToSubmitList =
            openContractBusinessTransactionDao.getPendingToSubmitContractHash();
        String contractXML;
        ContractPurchaseRecord purchaseContract = new ContractPurchaseRecord();
        ContractSaleRecord saleContract = new ContractSaleRecord();
        ContractType contractType;
        UUID transactionId;
        if (!contractPendingToSubmitList.isEmpty()) {
          for (String hashToSubmit : contractPendingToSubmitList) {
            System.out.println("OPEN CONTRACT - Hash to submit:\n" + hashToSubmit);
            contractXML = openContractBusinessTransactionDao.getContractXML(hashToSubmit);
            contractType = openContractBusinessTransactionDao.getContractType(hashToSubmit);
            transactionId = openContractBusinessTransactionDao.getTransactionId(hashToSubmit);
            switch (contractType) {
              case PURCHASE:
                purchaseContract =
                    (ContractPurchaseRecord) XMLParser.parseXML(contractXML, purchaseContract);
                transactionTransmissionManager.sendContractHashToCryptoBroker(
                    transactionId,
                    purchaseContract.getPublicKeyCustomer(),
                    purchaseContract.getPublicKeyBroker(),
                    hashToSubmit,
                    purchaseContract.getNegotiationId());
                break;
              case SALE:
                saleContract = (ContractSaleRecord) XMLParser.parseXML(contractXML, saleContract);
                transactionTransmissionManager.sendContractHashToCryptoCustomer(
                    transactionId,
                    saleContract.getPublicKeyBroker(),
                    saleContract.getPublicKeyCustomer(),
                    hashToSubmit,
                    saleContract.getNegotiationId());
                break;
            }
            // Update the ContractTransactionStatus
            openContractBusinessTransactionDao.updateContractTransactionStatus(
                hashToSubmit, ContractTransactionStatus.CHECKING_HASH);
          }
        }

        /** Check if pending contract to confirm */
        List<String> contractPendingToConfirmList =
            openContractBusinessTransactionDao.getPendingToConfirmContractHash();
        if (!contractPendingToConfirmList.isEmpty()) {
          for (String hashToSubmit : contractPendingToSubmitList) {
            System.out.println("OPEN CONTRACT - Hash to confirm:\n" + hashToSubmit);
            contractXML = openContractBusinessTransactionDao.getContractXML(hashToSubmit);
            contractType = openContractBusinessTransactionDao.getContractType(hashToSubmit);
            switch (contractType) {
              case PURCHASE:
                purchaseContract =
                    (ContractPurchaseRecord) XMLParser.parseXML(contractXML, purchaseContract);
                transactionTransmissionManager.sendTransactionNewStatusNotification(
                    purchaseContract.getPublicKeyCustomer(),
                    purchaseContract.getPublicKeyBroker(),
                    hashToSubmit,
                    ContractTransactionStatus.CONTRACT_CONFIRMED);
                break;
              case SALE:
                saleContract = (ContractSaleRecord) XMLParser.parseXML(contractXML, saleContract);
                transactionTransmissionManager.sendTransactionNewStatusNotification(
                    purchaseContract.getPublicKeyBroker(),
                    purchaseContract.getPublicKeyCustomer(),
                    hashToSubmit,
                    ContractTransactionStatus.CONTRACT_CONFIRMED);
                break;
            }
            // Update the ContractTransactionStatus
            openContractBusinessTransactionDao.updateContractTransactionStatus(
                hashToSubmit, ContractTransactionStatus.CONTRACT_CONFIRMED);
          }
        }

        /** Check if pending events */
        List<String> pendingEventsIdList = openContractBusinessTransactionDao.getPendingEvents();
        for (String eventId : pendingEventsIdList) {
          checkPendingEvent(eventId);
        }

      } catch (CantGetContractListException e) {
        throw new CannotSendContractHashException(
            e, "Sending contract hash", "Cannot get the contract list from database");
      } catch (UnexpectedResultReturnedFromDatabaseException e) {
        throw new CannotSendContractHashException(
            e, "Sending contract hash", "Unexpected result in database");
      } catch (CantSendBusinessTransactionHashException e) {
        throw new CannotSendContractHashException(
            e, "Sending contract hash", "Error in Transaction Transmission Network Service");
      }
    }
コード例 #13
0
  /**
   * Update the crypto vault statistics when called to start monitoring the network.
   *
   * @param cryptoVault
   * @param monitoredPublicKeys
   * @throws CantExecuteDatabaseOperationException
   */
  public void updateCryptoVaultsStatistics(CryptoVaults cryptoVault, int monitoredPublicKeys)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        database.getTable(BitcoinCryptoNetworkDatabaseConstants.CRYPTOVAULTS_STATS_TABLE_NAME);
    databaseTable.setStringFilter(
        BitcoinCryptoNetworkDatabaseConstants.CRYPTOVAULTS_STATS_CRYPTO_VAULT_COLUMN_NAME,
        cryptoVault.getCode(),
        DatabaseFilterType.EQUAL);
    /** I will check if I have the record to update it */
    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    DatabaseTableRecord record = null;
    try {
      if (databaseTable.getRecords().size() == 0) {
        /** I will insert a new record */
        record = databaseTable.getEmptyRecord();
        record.setStringValue(
            BitcoinCryptoNetworkDatabaseConstants.CRYPTOVAULTS_STATS_CRYPTO_VAULT_COLUMN_NAME,
            cryptoVault.getCode());
        record.setStringValue(
            BitcoinCryptoNetworkDatabaseConstants
                .CRYPTOVAULTS_STATS_LAST_CONNECTION_REQUEST_COLUMN_NAME,
            getCurrentDateTime());
        record.setIntegerValue(
            BitcoinCryptoNetworkDatabaseConstants
                .CRYPTOVAULTS_STATS_MONITORED_PUBLICKEYS_COLUMN_NAME,
            monitoredPublicKeys);

        databaseTable.insertRecord(record);
      } else {
        /** I will update an existing record. */
        record = databaseTable.getRecords().get(0);
        record.setStringValue(
            BitcoinCryptoNetworkDatabaseConstants
                .CRYPTOVAULTS_STATS_LAST_CONNECTION_REQUEST_COLUMN_NAME,
            getCurrentDateTime());
        record.setIntegerValue(
            BitcoinCryptoNetworkDatabaseConstants
                .CRYPTOVAULTS_STATS_MONITORED_PUBLICKEYS_COLUMN_NAME,
            monitoredPublicKeys);

        databaseTable.updateRecord(record);
      }
    } catch (CantInsertRecordException | CantUpdateRecordException e) {
      StringBuilder outputMessage =
          new StringBuilder("There was an error inserting or updating a record in table ");
      outputMessage.append(databaseTable.getTableName());
      outputMessage.append("Record is:");
      outputMessage.append(System.lineSeparator());
      outputMessage.append(XMLParser.parseObject(record));

      throw new CantExecuteDatabaseOperationException(
          CantExecuteDatabaseOperationException.DEFAULT_MESSAGE,
          e,
          outputMessage.toString(),
          "database issue.");
    }
  }
  /**
   * (non-javadoc)
   *
   * @see FermatMessageProcessor#processingMessage(FermatMessage, JsonObject)
   */
  @Override
  public void processingMessage(FermatMessage fermatMessage, JsonObject jsonMsjContent) {

    try {

      /*
       * Get the XML representation of the Digital Asset Metadata
       */
      String digitalAssetMetadataXml =
          jsonMsjContent.get(AssetTransmissionJsonAttNames.DIGITAL_ASSET_METADATA).getAsString();
      PlatformComponentType senderType =
          gson.fromJson(
              jsonMsjContent.get(AssetTransmissionJsonAttNames.SENDER_TYPE).getAsString(),
              PlatformComponentType.class);
      PlatformComponentType receiverType =
          gson.fromJson(
              jsonMsjContent.get(AssetTransmissionJsonAttNames.RECEIVER_TYPE).getAsString(),
              PlatformComponentType.class);

      /*
       * Convert the xml to object
       */
      DigitalAssetMetadata digitalAssetMetadata =
          (DigitalAssetMetadata)
              XMLParser.parseXML(digitalAssetMetadataXml, new DigitalAssetMetadata());

      /*
       * Construct a new digitalAssetMetadataTransaction
       */
      DigitalAssetMetadataTransactionImpl digitalAssetMetadataTransaction =
          new DigitalAssetMetadataTransactionImpl();
      digitalAssetMetadataTransaction.setGenesisTransaction(
          digitalAssetMetadata.getGenesisTransaction());
      digitalAssetMetadataTransaction.setSenderId(fermatMessage.getSender());
      digitalAssetMetadataTransaction.setSenderType(senderType);
      digitalAssetMetadataTransaction.setReceiverId(fermatMessage.getReceiver());
      digitalAssetMetadataTransaction.setReceiverType(receiverType);
      digitalAssetMetadataTransaction.setDigitalAssetMetadata(digitalAssetMetadata);
      digitalAssetMetadataTransaction.setDistributionStatus(DistributionStatus.ASSET_DISTRIBUTED);
      digitalAssetMetadataTransaction.setType(
          DigitalAssetMetadataTransactionType.META_DATA_TRANSMIT);
      digitalAssetMetadataTransaction.setProcessed(
          DigitalAssetMetadataTransactionImpl.NO_PROCESSED);

      /*
       * Save into data base for audit control
       */
      getAssetTransmissionNetworkServicePluginRoot()
          .getDigitalAssetMetaDataTransactionDao()
          .create(digitalAssetMetadataTransaction);

      /*
       * Mark the message as read
       */
      ((FermatMessageCommunication) fermatMessage)
          .setFermatMessagesStatus(FermatMessagesStatus.READ);
      ((CommunicationNetworkServiceConnectionManager)
              getAssetTransmissionNetworkServicePluginRoot().getNetworkServiceConnectionManager())
          .getIncomingMessageDao()
          .update(fermatMessage);

      /*
       * Notify to the interested
       */
      FermatEvent event =
          getAssetTransmissionNetworkServicePluginRoot()
              .getEventManager()
              .getNewEvent(EventType.RECEIVED_NEW_DIGITAL_ASSET_METADATA_NOTIFICATION);
      event.setSource(AssetTransmissionNetworkServicePluginRoot.EVENT_SOURCE);
      getAssetTransmissionNetworkServicePluginRoot().getEventManager().raiseEvent(event);

    } catch (Exception e) {
      getAssetTransmissionNetworkServicePluginRoot()
          .getErrorManager()
          .reportUnexpectedPluginException(
              Plugins.BITDUBAI_DAP_ASSET_TRANSMISSION_NETWORK_SERVICE,
              UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
              e);
    }
  }
  // CREATE SEND NEW NEGOTIATION TRANSACTION
  public void createCustomerBrokerCloseNegotiationTransaction(
      UUID transactionId,
      Negotiation negotiation,
      NegotiationType negotiationType,
      NegotiationTransactionStatus statusTransaction)
      throws CantRegisterCustomerBrokerCloseNegotiationTransactionException {

    Date time = new Date();
    long timestamp = time.getTime();
    String negotiationXML = XMLParser.parseObject(negotiation);

    try {

      DatabaseTable table =
          this.database.getTable(
              CustomerBrokerCloseNegotiationTransactionDatabaseConstants
                  .CUSTOMER_BROKER_CLOSE_TABLE_NAME);
      DatabaseTableRecord record = table.getEmptyRecord();

      record.setUUIDValue(
          CustomerBrokerCloseNegotiationTransactionDatabaseConstants
              .CUSTOMER_BROKER_CLOSE_TRANSACTION_ID_COLUMN_NAME,
          transactionId);
      record.setUUIDValue(
          CustomerBrokerCloseNegotiationTransactionDatabaseConstants
              .CUSTOMER_BROKER_CLOSE_NEGOTIATION_ID_COLUMN_NAME,
          negotiation.getNegotiationId());
      record.setStringValue(
          CustomerBrokerCloseNegotiationTransactionDatabaseConstants
              .CUSTOMER_BROKER_CLOSE_PUBLIC_KEY_BROKER_COLUMN_NAME,
          negotiation.getBrokerPublicKey());
      record.setStringValue(
          CustomerBrokerCloseNegotiationTransactionDatabaseConstants
              .CUSTOMER_BROKER_CLOSE_PUBLIC_KEY_CUSTOMER_COLUMN_NAME,
          negotiation.getCustomerPublicKey());
      record.setStringValue(
          CustomerBrokerCloseNegotiationTransactionDatabaseConstants
              .CUSTOMER_BROKER_CLOSE_STATUS_COLUMN_NAME,
          statusTransaction.getCode());
      record.setStringValue(
          CustomerBrokerCloseNegotiationTransactionDatabaseConstants
              .CUSTOMER_BROKER_CLOSE_NEGOTIATION_TYPE_COLUMN_NAME,
          negotiationType.getCode());
      record.setStringValue(
          CustomerBrokerCloseNegotiationTransactionDatabaseConstants
              .CUSTOMER_BROKER_CLOSE_NEGOTIATION_XML_COLUMN_NAME,
          negotiationXML);
      record.setLongValue(
          CustomerBrokerCloseNegotiationTransactionDatabaseConstants
              .CUSTOMER_BROKER_CLOSE_TIMESTAMP_COLUMN_NAME,
          timestamp);

      table.insertRecord(record);

      if (statusTransaction.getCode()
          == NegotiationTransactionStatus.PENDING_SUBMIT_CONFIRM.getCode()) {
        System.out.print(
            "\n\n**** 22) MOCK NEGOTIATION TRANSACTION - CUSTOMER BROKER CLOSE - DAO. CONFIRM negotiationType: "
                + negotiationType.getCode()
                + " transactionId: "
                + transactionId
                + " ****\n");
      } else {
        System.out.print(
            "\n\n**** 4) MOCK NEGOTIATION TRANSACTION - CUSTOMER BROKER CLOSE - DAO. NEGOTIATION negotiationType: "
                + negotiationType.getCode()
                + "transactionId: "
                + transactionId
                + " ****\n");
      }

    } catch (CantInsertRecordException e) {
      throw new CantRegisterCustomerBrokerCloseNegotiationTransactionException(
          e.getMessage(),
          e,
          "customer broker close Negotiation Transaction",
          "Cant create new customer broker close Negotiation Transaction, insert database problems.");
    } catch (Exception e) {
      throw new CantRegisterCustomerBrokerCloseNegotiationTransactionException(
          e.getMessage(),
          FermatException.wrapException(e),
          "customer broker close Negotiation Transaction",
          "Cant create new customer broker close Negotiation Transaction, unknown failure.");
    }
  }
コード例 #16
0
ファイル: MessageImpl.java プロジェクト: yeniree/fermat
 /**
  * This method returns a String in XML format containing all this object information
  *
  * @return
  */
 public String toString() {
   return XMLParser.parseObject(this);
 }
コード例 #17
0
  /**
   * Updates the execution statistics of the event Agent it will insert a new record if we have
   * pending transactions, and update the existing value if we have zero transactions.
   *
   * @param pendingIncoming
   * @param pendingOutgoing
   */
  public void updateEventAgentStats(int pendingIncoming, int pendingOutgoing)
      throws CantExecuteDatabaseOperationException {
    DatabaseTable databaseTable =
        database.getTable(BitcoinCryptoNetworkDatabaseConstants.EVENTAGENT_STATS_TABLE_NAME);

    /** I will get the current execution number */
    int currentExecutionNumber;
    databaseTable.setFilterOrder(
        BitcoinCryptoNetworkDatabaseConstants.EVENTAGENT_STATS_EXECUTION_NUMBER_COLUMN_NAME,
        DatabaseFilterOrder.DESCENDING);
    try {
      databaseTable.loadToMemory();
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    }

    if (databaseTable.getRecords().size() != 0)
      currentExecutionNumber =
          databaseTable
              .getRecords()
              .get(0)
              .getIntegerValue(
                  BitcoinCryptoNetworkDatabaseConstants
                      .EVENTAGENT_STATS_EXECUTION_NUMBER_COLUMN_NAME);
    else currentExecutionNumber = 0;

    /**
     * if I have pending transactions, I will insert a new record, also if this is the first time
     * I'm executing.
     */
    DatabaseTableRecord record = null;
    try {
      if (pendingIncoming != 0 || pendingOutgoing != 0 || currentExecutionNumber == 0) {
        record = databaseTable.getEmptyRecord();
        record.setIntegerValue(
            BitcoinCryptoNetworkDatabaseConstants.EVENTAGENT_STATS_EXECUTION_NUMBER_COLUMN_NAME,
            currentExecutionNumber + 1);
        record.setStringValue(
            BitcoinCryptoNetworkDatabaseConstants.EVENTAGENT_STATS_LAST_EXECUTION_DATE_COLUMN_NAME,
            getCurrentDateTime());
        record.setIntegerValue(
            BitcoinCryptoNetworkDatabaseConstants
                .EVENTAGENT_STATS_PENDING_INCOMING_TRANSACTIONS_COLUMN_NAME,
            pendingIncoming);
        record.setIntegerValue(
            BitcoinCryptoNetworkDatabaseConstants
                .EVENTAGENT_STATS_PENDING_OUTGOING_TRANSACTIONS_COLUMN_NAME,
            pendingOutgoing);

        databaseTable.insertRecord(record);

      } else {
        /** I will update existing value with zero pending transactions */
        DatabaseTableFilter filterIncoming = databaseTable.getEmptyTableFilter();
        filterIncoming.setColumn(
            BitcoinCryptoNetworkDatabaseConstants
                .EVENTAGENT_STATS_PENDING_INCOMING_TRANSACTIONS_COLUMN_NAME);
        filterIncoming.setValue("0");
        filterIncoming.setType(DatabaseFilterType.EQUAL);

        DatabaseTableFilter filterOutgoing = databaseTable.getEmptyTableFilter();
        filterOutgoing.setColumn(
            BitcoinCryptoNetworkDatabaseConstants
                .EVENTAGENT_STATS_PENDING_OUTGOING_TRANSACTIONS_COLUMN_NAME);
        filterOutgoing.setValue("0");
        filterOutgoing.setType(DatabaseFilterType.EQUAL);

        /** I create the two filters and add them to form a filter group. */
        List<DatabaseTableFilter> filters = new ArrayList<>();
        filters.add(filterIncoming);
        filters.add(filterOutgoing);

        List<DatabaseTableFilterGroup> filterGroups = new ArrayList<>();
        databaseTable.setFilterGroup(
            databaseTable.getNewFilterGroup(filters, filterGroups, DatabaseFilterOperator.AND));
        databaseTable.loadToMemory();

        record = databaseTable.getRecords().get(0);
        record.setIntegerValue(
            BitcoinCryptoNetworkDatabaseConstants.EVENTAGENT_STATS_EXECUTION_NUMBER_COLUMN_NAME,
            currentExecutionNumber + 1);
        record.setStringValue(
            BitcoinCryptoNetworkDatabaseConstants.EVENTAGENT_STATS_LAST_EXECUTION_DATE_COLUMN_NAME,
            getCurrentDateTime());

        databaseTable.updateRecord(record);
      }
    } catch (CantLoadTableToMemoryException e) {
      throwLoadToMemoryException(e, databaseTable.getTableName());
    } catch (CantInsertRecordException | CantUpdateRecordException e) {
      StringBuilder outputMessage =
          new StringBuilder("There was an error inserting or modifying a record. The record is:");
      outputMessage.append(System.lineSeparator());
      outputMessage.append(XMLParser.parseObject(record));

      throw new CantExecuteDatabaseOperationException(
          CantExecuteDatabaseOperationException.DEFAULT_MESSAGE,
          e,
          outputMessage.toString(),
          "database issue");
    }
  }