public void testUpdate() throws Exception {

    String summary = "A Ticket at " + new Date();

    Ticket ticket = new Ticket();
    ticket.setState(Ticket.State.OPEN);
    ticket.setSummary(summary);
    ticket.setDetails("Ticket details for ticket: " + new Date());

    m_ticketer.saveOrUpdate(ticket);

    assertNotNull(ticket.getId());

    Ticket newTicket = m_ticketer.get(ticket.getId());

    assertNotNull(newTicket);
    assertTicketEquals(ticket, newTicket);

    newTicket.setState(Ticket.State.CLOSED);
    newTicket.setDetails("These details have changed");

    System.err.println("TicketId = " + newTicket.getId());

    m_ticketer.saveOrUpdate(newTicket);

    Thread.sleep(500);

    Ticket newerTicket = m_ticketer.get(newTicket.getId());

    assertTicketEquals(newTicket, newerTicket);
  }
  private void update(Ticket ticketToUpdate) throws PluginException {
    Ticket currentTicket = get(ticketToUpdate.getId());
    LOG.debug("updating existing ticket : {}", currentTicket.getId());

    if (currentTicket.getState() != ticketToUpdate.getState()) {

      OTRSTicketUpdateTicket ticketUpdate = new OTRSTicketUpdateTicket();

      ticketUpdate.setStateID(openNMSToOTRSState(ticketToUpdate.getState()));

      OTRSArticle articleUpdate = new OTRSArticle();

      // TODO Figure out why we can't set ArticleFrom without an error from OTRS
      // otrsArticle.setFrom(m_configDao.getArticleFrom());

      articleUpdate.setSubject(m_configDao.getArticleUpdateSubject());

      // All OTRS article fields from defaults

      articleUpdate.setArticleType(m_configDao.getArticleType());
      articleUpdate.setSenderType(m_configDao.getArticleSenderType());
      articleUpdate.setContentType(m_configDao.getArticleContentType());
      articleUpdate.setHistoryType(m_configDao.getArticleHistoryType());
      articleUpdate.setHistoryComment(m_configDao.getArticleHistoryComment());

      switch (ticketToUpdate.getState()) {
        case OPEN:
          // ticket is new
          articleUpdate.setBody(m_configDao.getTicketOpenedMessage());
          break;
        case CANCELLED:
          // not sure how often we see this
          articleUpdate.setBody(m_configDao.getTicketCancelledMessage());
          break;
        case CLOSED:
          // closed successful
          articleUpdate.setBody(m_configDao.getTicketClosedMessage());
          break;
        default:
          LOG.debug("No valid OpenNMS state on ticket");
          articleUpdate.setBody(m_configDao.getTicketUpdatedMessage());
      }

      TicketUpdate update = new TicketUpdate();
      update.setUserLogin(m_configDao.getUserName());
      update.setPassword(m_configDao.getPassword());
      update.setTicketID(new BigInteger(currentTicket.getId()));
      update.setTicket(ticketUpdate);
      update.setArticle(articleUpdate);

      m_ticketConnector.ticketUpdate(update);

    } else {

      // There is no else at the moment
      // Tickets are _only_ updated with new state

    }
  }
  private void assertTicketEquals(Ticket ticket, Ticket newTicket) {
    assertEquals(ticket.getId(), newTicket.getId());
    assertEquals(ticket.getState(), newTicket.getState());
    assertEquals(ticket.getSummary(), newTicket.getSummary());

    // TODO: Implement this later when we need 2 way retrieval of comments/details
    // assertEquals(ticket.getDetails(), newTicket.getDetails());
  }
  public void testGet() {

    // This may need to be changed ;-)
    String ticketId = "TST-12206";
    Ticket newTicket = m_ticketer.get(ticketId);

    assertNotNull(newTicket);
    assertEquals(ticketId, newTicket.getId());
    System.out.println(newTicket.getId() + ":" + newTicket.getSummary());
    assertTrue(newTicket.getSummary().startsWith("This is the summary"));

    // TODO: Implement this later when we need 2 way retrieval of comments/details
    // assertEquals("These are the details", newTicket.getDetails());

  }
  public void testSave() {

    Ticket ticket = new Ticket();
    ticket.setState(Ticket.State.OPEN);
    ticket.setSummary("This is the summary");
    ticket.setDetails("These are the details");

    m_ticketer.saveOrUpdate(ticket);

    assertNotNull(ticket.getId());

    Ticket newTicket = m_ticketer.get(ticket.getId());

    assertNotNull(newTicket);
    assertTicketEquals(ticket, newTicket);
  }
  /*
   * (non-Javadoc)
   * @see
   * org.opennms.api.integration.ticketing.Plugin#saveOrUpdate(org.opennms
   * .api.integration.ticketing.Ticket)
   */
  @Override
  public void saveOrUpdate(Ticket ticketToUpdateOrCreate) throws PluginException {
    Objects.requireNonNull(ticketToUpdateOrCreate, "The provided ticket must not be null");

    if (ticketToUpdateOrCreate.getId() == null) {
      create(ticketToUpdateOrCreate);
    } else {
      update(ticketToUpdateOrCreate);
    }
  }
Example #7
0
  /*
   * (non-Javadoc)
   * @see org.opennms.api.integration.ticketing.Plugin#saveOrUpdate(org.opennms.api.integration.ticketing.Ticket)
   */
  @Override
  public void saveOrUpdate(Ticket ticket) throws PluginException {

    JiraRestClient jira = getConnection();

    if (ticket.getId() == null || ticket.getId().equals("")) {
      // If we can't find a ticket with the specified ID then create one.
      IssueInputBuilder builder =
          new IssueInputBuilder(
              getProperties().getProperty("jira.project"),
              Long.valueOf(getProperties().getProperty("jira.type").trim()));
      builder.setReporterName(getProperties().getProperty("jira.username"));
      builder.setSummary(ticket.getSummary());
      builder.setDescription(ticket.getDetails());
      builder.setDueDate(new DateTime(Calendar.getInstance()));

      BasicIssue createdIssue;
      try {
        createdIssue = jira.getIssueClient().createIssue(builder.build()).get();
      } catch (InterruptedException | ExecutionException e) {
        throw new PluginException("Failed to create issue.", e);
      }
      LOG.info("created ticket " + createdIssue);

      ticket.setId(createdIssue.getKey());

    } else {
      // Otherwise update the existing ticket
      LOG.info("Received ticket: {}", ticket.getId());

      Issue issue;
      try {
        issue = jira.getIssueClient().getIssue(ticket.getId()).get();
      } catch (InterruptedException | ExecutionException e) {
        throw new PluginException("Failed to get issue with id:" + ticket.getId(), e);
      }

      Iterable<Transition> transitions;
      try {
        transitions = jira.getIssueClient().getTransitions(issue).get();
      } catch (InterruptedException | ExecutionException e) {
        throw new PluginException(
            "Failed to get transitions for issue with id:" + issue.getId(), e);
      }

      if (Ticket.State.CLOSED.equals(ticket.getState())) {
        Comment comment = Comment.valueOf("Issue resolved by OpenNMS.");
        for (Transition transition : transitions) {
          if (getProperties().getProperty("jira.resolve").equals(transition.getName())) {
            LOG.info("Resolving ticket {}", ticket.getId());
            // Resolve the issue
            try {
              jira.getIssueClient()
                  .transition(issue, new TransitionInput(transition.getId(), comment))
                  .get();
            } catch (InterruptedException | ExecutionException e) {
              throw new PluginException("Failed to get resolve issue with id:" + issue.getId(), e);
            }
            return;
          }
        }
        LOG.warn(
            "Could not resolve ticket {}, no '{}' operation available.",
            ticket.getId(),
            getProperties().getProperty("jira.resolve"));
      } else if (Ticket.State.OPEN.equals(ticket.getState())) {
        Comment comment = Comment.valueOf("Issue reopened by OpenNMS.");
        for (Transition transition : transitions) {
          if (getProperties().getProperty("jira.reopen").equals(transition.getName())) {
            LOG.info("Reopening ticket {}", ticket.getId());
            // Resolve the issue
            try {
              jira.getIssueClient()
                  .transition(issue, new TransitionInput(transition.getId(), comment))
                  .get();
            } catch (InterruptedException | ExecutionException e) {
              throw new PluginException("Failed to reopen issue with id:" + issue.getId(), e);
            }
            return;
          }
        }
        LOG.warn(
            "Could not reopen ticket {}, no '{}' operation available.",
            ticket.getId(),
            getProperties().getProperty("jira.reopen"));
      }
    }
  }