public final void handleNewMessages(final FermatMessage fermatMessage) {

    try {

      final Gson gson = new Gson();

      final String jsonMessage = fermatMessage.getContent();

      final NetworkServiceMessage networkServiceMessage =
          gson.fromJson(jsonMessage, NetworkServiceMessage.class);

      switch (networkServiceMessage.getMessageType()) {
        case INFORMATION:
          // update the request to processing receive state with the given action.
          final InformationMessage informationMessage =
              gson.fromJson(jsonMessage, InformationMessage.class);
          receiveInformationMessage(informationMessage);
          System.out.println(
              " CPR NS - Information Message Received: " + informationMessage.toString());
          break;
        case REQUEST:
          // create the request in processing receive state.
          final RequestMessage requestMessage = gson.fromJson(jsonMessage, RequestMessage.class);
          receiveCryptoPaymentRequest(requestMessage);
          System.out.println(" CPR NS - Request Message Received: " + requestMessage.toString());
          break;
      }

    } catch (Exception e) {
      reportUnexpectedException(e);
    }
  }
  /**
   * Construct a DatabaseTableRecord whit the values of the a FermatMessage pass by parameter
   *
   * @param incomingTemplateNetworkServiceMessage the contains the values
   * @return DatabaseTableRecord whit the values
   */
  private DatabaseTableRecord constructFrom(FermatMessage incomingTemplateNetworkServiceMessage) {

    /*
     * Create the record to the entity
     */
    DatabaseTableRecord entityRecord = getDatabaseTable().getEmptyRecord();

    /*
     * Set the entity values
     */
    entityRecord.setStringValue(
        CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_ID_COLUMN_NAME,
        incomingTemplateNetworkServiceMessage.getId().toString());
    entityRecord.setStringValue(
        CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_SENDER_ID_COLUMN_NAME,
        incomingTemplateNetworkServiceMessage.getSender().toString());
    entityRecord.setStringValue(
        CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_RECEIVER_ID_COLUMN_NAME,
        incomingTemplateNetworkServiceMessage.getReceiver().toString());
    entityRecord.setStringValue(
        CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_TEXT_CONTENT_COLUMN_NAME,
        incomingTemplateNetworkServiceMessage.getContent());
    entityRecord.setStringValue(
        CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_TYPE_COLUMN_NAME,
        incomingTemplateNetworkServiceMessage.getFermatMessageContentType().getCode());

    if (incomingTemplateNetworkServiceMessage.getShippingTimestamp() != null) {
      entityRecord.setLongValue(
          CommunicationNetworkServiceDatabaseConstants
              .OUTGOING_MESSAGES_SHIPPING_TIMESTAMP_COLUMN_NAME,
          incomingTemplateNetworkServiceMessage.getShippingTimestamp().getTime());
    } else {
      entityRecord.setLongValue(
          CommunicationNetworkServiceDatabaseConstants
              .OUTGOING_MESSAGES_SHIPPING_TIMESTAMP_COLUMN_NAME,
          new Long(0));
    }

    if (incomingTemplateNetworkServiceMessage.getDeliveryTimestamp() != null) {
      entityRecord.setLongValue(
          CommunicationNetworkServiceDatabaseConstants
              .INCOMING_MESSAGES_SHIPPING_TIMESTAMP_COLUMN_NAME,
          incomingTemplateNetworkServiceMessage.getDeliveryTimestamp().getTime());
    } else {
      entityRecord.setLongValue(
          CommunicationNetworkServiceDatabaseConstants
              .INCOMING_MESSAGES_DELIVERY_TIMESTAMP_COLUMN_NAME,
          new Long(0));
    }

    entityRecord.setStringValue(
        CommunicationNetworkServiceDatabaseConstants.INCOMING_MESSAGES_STATUS_COLUMN_NAME,
        incomingTemplateNetworkServiceMessage.getFermatMessagesStatus().getCode());

    /*
     * return the new table record
     */
    return entityRecord;
  }
  /**
   * (non-Javadoc)
   *
   * @see FermatEventHandler#handleEvent(FermatEvent)
   * @param platformEvent
   * @throws Exception
   */
  @Override
  public void handleEvent(FermatEvent platformEvent) throws FermatException {

    if (platformEvent.getSource() == NetworkServiceChatNetworkServicePluginRoot.EVENT_SOURCE) {

      // System.out.println("CompleteComponentConnectionRequestNotificationEventHandler -
      // handleEvent platformEvent =" + platformEvent.toString());
      //  System.out.println("NetworkServiceChatNetworkServicePluginRoot  - NOTIFICACION EVENTO
      // MENSAJE RECIBIDO!!!!");

      /*
       * Get the message receive
       */
      NewNetworkServiceMessageReceivedNotificationEvent
          newNetworkServiceMessageReceivedNotificationEvent =
              (NewNetworkServiceMessageReceivedNotificationEvent) platformEvent;
      FermatMessage fermatMessageReceive =
          (FermatMessage) newNetworkServiceMessageReceivedNotificationEvent.getData();

      /*
       * Get the content of the message like a JsonObject
       */
      JsonObject jsonMsjContent = parser.parse(fermatMessageReceive.getContent()).getAsJsonObject();

      /*
       * Extract the type of content of the message
       */
      ChatMessageTransactionType chatMessageTransactionType =
          gson.fromJson(
              jsonMsjContent.get(ChatTransmissionJsonAttNames.MSJ_CONTENT_TYPE),
              ChatMessageTransactionType.class);

      /*
       * Process the messages for his type
       */
      if (messagesProcessorsRegistered.containsKey(chatMessageTransactionType)) {
        messagesProcessorsRegistered
            .get(chatMessageTransactionType)
            .processingMessage(fermatMessageReceive, jsonMsjContent);
      } else {
        System.out.println(
            "NetworkServiceChatNetworkServicePluginRoot - CompleteComponentConnectionRequestNotificationEventHandler - message type no supported = "
                + chatMessageTransactionType);
      }
    }
  }
  /**
   * Notify the client when a incoming message is receive by the
   * incomingTemplateNetworkServiceMessage ant fire a new event
   *
   * @param incomingMessage received
   */
  private void onMessageReceived(FermatMessage incomingMessage) {

    System.out.println("CommunicationNetworkServiceLocal - onMessageReceived ");
    System.out.println(incomingMessage.getContent());

    /*
     * set the last message received
     */
    this.lastMessageReceived = incomingMessage;

    /** Put the message on a event and fire new event */
    FermatEvent fermatEvent =
        eventManager.getNewEvent(P2pEventType.NEW_NETWORK_SERVICE_MESSAGE_RECEIVE_NOTIFICATION);
    fermatEvent.setSource(AssetTransmissionNetworkServicePluginRoot.EVENT_SOURCE);
    ((NewNetworkServiceMessageReceivedNotificationEvent) fermatEvent).setData(incomingMessage);
    ((NewNetworkServiceMessageReceivedNotificationEvent) fermatEvent)
        .setNetworkServiceTypeApplicant(networkServiceTypePluginRoot);
    eventManager.raiseEvent(fermatEvent);
  }
  /**
   * This method read for new messages pending to send on the data base in the table <code>
   * outbox_messages</code> and encrypt the message content, sing the message and send it
   */
  public void processMessageToSend() {

    try {

      try {

        Map<String, Object> filters = new HashMap<>();
        filters.put(
            CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_STATUS_COLUMN_NAME,
            MessagesStatus.PENDING_TO_SEND.getCode());
        filters.put(
            CommunicationNetworkServiceDatabaseConstants.OUTGOING_MESSAGES_RECEIVER_ID_COLUMN_NAME,
            communicationsVPNConnection.getRemoteParticipant().getIdentityPublicKey());

        /*
         * Read all pending message from database
         */
        List<FermatMessage> messages = outgoingMessageDao.findAll(filters);
        /*
         * For each message
         */
        for (FermatMessage message : messages) {

          if (communicationsVPNConnection.isActive()
              && (message.getFermatMessagesStatus() != FermatMessagesStatus.SENT)) {

            /*
             * Encrypt the content of the message whit the remote network service public key
             */
            ((FermatMessageCommunication) message)
                .setContent(
                    AsymmetricCryptography.encryptMessagePublicKey(
                        message.getContent(),
                        communicationsVPNConnection
                            .getRemoteParticipantNetworkService()
                            .getIdentityPublicKey()));

            /*
             * Sing the message
             */
            String signature =
                AsymmetricCryptography.createMessageSignature(
                    message.getContent(), eccKeyPair.getPrivateKey());
            ((FermatMessageCommunication) message).setSignature(signature);

            /*
             * Send the message
             */
            communicationsVPNConnection.sendMessage(message);

            /*
             * Change the message and update in the data base
             */

            ((FermatMessageCommunication) message)
                .setFermatMessagesStatus(FermatMessagesStatus.SENT);
            outgoingMessageDao.update(message);

            /*
             * Put the message on a event and fire new event
             */
            FermatEvent fermatEvent =
                eventManager.getNewEvent(
                    P2pEventType.NEW_NETWORK_SERVICE_MESSAGE_SENT_NOTIFICATION);
            fermatEvent.setSource(AssetIssuerActorNetworkServicePluginRoot.EVENT_SOURCE);
            ((NewNetworkServiceMessageSentNotificationEvent) fermatEvent).setData(message);
            eventManager.raiseEvent(fermatEvent);
          }
        }

      } catch (CantUpdateRecordDataBaseException e) {
        errorManager.reportUnexpectedPluginException(
            Plugins.BITDUBAI_DAP_ASSET_ISSUER_ACTOR_NETWORK_SERVICE,
            UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
            new Exception("Can not process messages to send. Error reason: " + e.getMessage()));
      } catch (CantReadRecordDataBaseException e) {
        errorManager.reportUnexpectedPluginException(
            Plugins.BITDUBAI_DAP_ASSET_ISSUER_ACTOR_NETWORK_SERVICE,
            UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
            new Exception("Can not process messages to send. Error reason: " + e.getMessage()));
      }

      // Sleep for a time
      toSend.sleep(CommunicationNetworkServiceRemoteAgent.SLEEP_TIME);

    } catch (InterruptedException e) {
      errorManager.reportUnexpectedPluginException(
          Plugins.BITDUBAI_DAP_ASSET_ISSUER_ACTOR_NETWORK_SERVICE,
          UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
          new Exception("Can not sleep"));
    }
  }
  /**
   * This method process the message received and save on the data base in the table <code>
   * incoming_messages</code> and notify all observers to the new messages received
   */
  private void processMessageReceived() {

    try {

      // System.out.println("CommunicationNetworkServiceRemoteAgent -
      // communicationsVPNConnection.isActive() = "+communicationsVPNConnection.isActive());

      /** Verified the status of the connection */
      if (communicationsVPNConnection.isActive()) {

        // System.out.println("CommunicationNetworkServiceRemoteAgent -
        // communicationsVPNConnection.getUnreadMessagesCount() =
        // "+communicationsVPNConnection.getUnreadMessagesCount());

        /** process all pending messages */
        for (int i = 0; i < communicationsVPNConnection.getUnreadMessagesCount(); i++) {

          /*
           * Read the next message in the queue
           */
          FermatMessage message = communicationsVPNConnection.readNextMessage();

          /*
           * Validate the message signature
           */
          AsymmetricCryptography.verifyMessageSignature(
              message.getSignature(),
              message.getContent(),
              communicationsVPNConnection
                  .getRemoteParticipantNetworkService()
                  .getIdentityPublicKey());

          /*
           * Decrypt the message content
           */
          ((FermatMessageCommunication) message)
              .setContent(
                  AsymmetricCryptography.decryptMessagePrivateKey(
                      message.getContent(), eccKeyPair.getPrivateKey()));

          /*
           * Change to the new status
           */
          ((FermatMessageCommunication) message)
              .setFermatMessagesStatus(FermatMessagesStatus.NEW_RECEIVED);

          /*
           * Save to the data base table
           */
          incomingMessageDao.create(message);

          /*
           * Remove the message from the queue
           */
          communicationsVPNConnection.removeMessageRead(message);

          /*
           * Notify all observer of this agent that Received a new message
           */
          setChanged();
          notifyObservers(message);
        }
      }

      // Sleep for a time
      toReceive.sleep(CommunicationNetworkServiceRemoteAgent.SLEEP_TIME);

    } catch (InterruptedException e) {
      errorManager.reportUnexpectedPluginException(
          Plugins.BITDUBAI_DAP_ASSET_ISSUER_ACTOR_NETWORK_SERVICE,
          UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
          new Exception("Can not sleep"));
    } catch (CantInsertRecordDataBaseException e) {
      errorManager.reportUnexpectedPluginException(
          Plugins.BITDUBAI_DAP_ASSET_ISSUER_ACTOR_NETWORK_SERVICE,
          UnexpectedPluginExceptionSeverity.DISABLES_SOME_FUNCTIONALITY_WITHIN_THIS_PLUGIN,
          new Exception("Can not process message received. Error reason: " + e.getMessage()));
    }
  }
Beispiel #7
0
 /**
  * Decode a FermatMessage
  *
  * @param fermatMessage
  * @return
  */
 public static JsonObject decodeMsjContent(FermatMessage fermatMessage) {
   return parser.parse(fermatMessage.getContent()).getAsJsonObject();
 }
 @Override
 protected final void handleNewMessages(FermatMessage message) throws FermatException {
   System.out.println(
       "******************* Crypto Payment Request messages arrived: " + message.getContent());
   ((CryptoPaymentRequestNetworkServicePluginRoot) networkService).handleNewMessages(message);
 }