Managing campaigns

/**
 * Use case: Initialise and start campaign
 * The following class is an implementation on how to start a campaign
 * via Closed Loop Webservice.
 */
private class ImportRecipientsAndStartCampaign extends UseCase {
 
    @Override
    void runExceptional() throws Exception {
        // create a waveId, fix the template mailing
        _waveId = _closedLoopWebservice.prepareNewWave(
                    _session.getSessionId(), TEMPLATE_CAMPAIGN_ID);
        // The recipient field names can be different for every client
        // and are defined once during the configuration process in
        // optivo broadmail. Within the example code we used
        // recipientFieldNames are for demo purposes with most common
        // used fields.
        String[] recipientFieldNames =
            { "salutation"
            , "firstname"
            , "lastname"
            , "title"
            , "birthday"
            , "mobile"
            , "email"
            , "street"
            , "zipcode"
            , "city"
            , "state"
            , "country"
            , "extentityid"
            , "extcampaignid"};
        String[][] recipientFieldValues =
            {
              { "Mr."
              , "John"
              , "Doe"
              , "Phd"
              , "17.2.1956"
              , "0049307680780"
              , "[email protected]"
              , "Wallstrasse 16"
              , "10179"
              , "Berlin"
              , "Berlin"
              , "Germany"
              , "SAP-321XWZ654987"
              , "SAP-987ABG654223"
              }
            , { "Mrs."
              , "Jane"
              , "Doe"
              , "Phd"
              , "17.2.1952"
              , "0049307680780"
              , "004930768078199"
              , "[email protected]"
              , "Wallstrasse 16"
              , "10179"
              , "Berlin"
              , "Berlin"
              , "Germany"
              , "SAP-321XWZ654988"
              , "SAP-987ABG654223" } };
        _closedLoopWebservice.importRecipients(
            _session.getSessionId()
            , _waveId
            , recipientFieldNames
            , recipientFieldValues);
        // initialise the point in time the campaign will start to
        // generate response data
        _since = _closedLoopWebservice.getCurrentTime(
            _session.getSessionId());
        _closedLoopWebservice.importFinishedAndScheduleMailing(
            _session.getSessionId(), _waveId);
    }
}

/**
 * Use case: Receive campaign status.
 * Use this code to ask campaign status from optivo broadmail. This
 * makes sense after calling the use case "Initialise and start campaign"
 */
private class DetermineCampaignStatus extends UseCase {
 
    @Override
    void runExceptional() throws Exception {
        if (_waveId <= 0) {
            throw new IllegalStateException("waveId not positive.");
        }
 
        // Since the campaign is copied before it is started, we
        // have to translate the wave id to the campaign id that
        // was actually sent ...
        long campaignId;
        do {
            campaignId = _closedLoopWebservice.getMailingIdByWaveId(
                _session.getSessionId(), _waveId);
            if (campaignId <= 0) {
                sleepOneMinute();
            }
        } while (campaignId <= 0);
 
        // customise this to your needs. After a campaign switched to
        // status SENT, the status will be immutable
        while (true) {
            String campaignStatus = _mailingWebservice.getStatus(
                _session.getSessionId(), campaignId);
            if ("DONE".equals(campaignStatus)) {
                break;
            }
            if ("PAUSED".equals(campaignStatus) || "CANCELED".equals(
                campaignStatus))
            {
                throw new RuntimeException(
                    "Campaign is " + campaignStatus);
            }
 
            String campaignName = _mailingWebservice.getName(
                _session.getSessionId(), campaignId);
            // Log status for messages of campaign too.
            long[] messageIds = 
                _splitMailingWebservice.getSplitChildIds(
                    _session.getSessionId(), campaignId);
            for (long messageId : messageIds) {
                String messageStatus = _mailingWebservice.getStatus(
                    _session.getSessionId(), campaignId);
                String messageName = _mailingWebservice.getName(
                    _session.getSessionId(), messageId);
            }
            sleepOneMinute();
        }
    }
 
    private void sleepOneMinute() throws InterruptedException {
        Thread.sleep(TimeUnit.MINUTES.toMillis(1));
    }
}

/**
 * Use case: Read available campaigns for closed loop scenario
 * This is a usability method. You can show available Smart Campaigns
 * to your campaign manager. Scenario for smart campaigns only.
 */
private class GetCampaignData extends UseCase {
 
    @Override
    void runExceptional() throws Exception {
        String campaignType = "regular";
        String campaignStatus = "ACTIVATION_REQUIRED";
        long[] campaignIds = _mailingWebservice.getIdsInStatus(
            _session.getSessionId(), campaignType, campaignStatus);
        for (long campaignId : campaignIds) {
            String campaignName = _mailingWebservice.getName(
                _session.getSessionId(), campaignId);
            String description = _mailingWebservice.getDescription(
                _session.getSessionId(), campaignId);
            long[] messageIds =
                _splitMailingWebservice.getSplitChildIds(
                    _session.getSessionId(), campaignId);
            for (long messageId : messageIds) {
                String messageName = _mailingWebservice.getName(
                    _session.getSessionId(), messageId);
                String messageDescription =
                    _mailingWebservice.getDescription(
                        _session.getSessionId(), messageId);
            }
        }    
    }
}

/**
 * Use case: Get response data
 * This use case shows how to receive and process reponse data.
 * Response data are fetched within a certain interval, usually
 * 1-4 h, and processed according to your system needs.
*/
private class GetResponseData extends UseCase {
 
    @Override
    void runExceptional() throws Exception {
        long until = _closedLoopWebservice.getCurrentTime(
            _session.getSessionId());
        int numberOfRows = 1000;
        int startRow = 0;
 
        String[][] recipients;
        do {
            recipients = _closedLoopWebservice.getRecipients(
                _session.getSessionId(),
                _since, until, startRow, numberOfRows);
            processData(recipients);
            startRow += numberOfRows;
        } while (recipients.length >= numberOfRows);
 
        startRow = 0;
        String[][] clicks;
        do {
            clicks = _closedLoopWebservice.getClicks(
                _session.getSessionId(),
                _since, until, startRow, numberOfRows);
            processData(clicks);
            startRow += numberOfRows;
        } while (clicks.length >= numberOfRows);
 
        startRow = 0;
        String[][] opens;
        do {
            opens = _closedLoopWebservice.getOpens(
                _session.getSessionId(),
                _since, until, startRow, numberOfRows);
            processData(opens);
            startRow += numberOfRows;
        } while (opens.length >= numberOfRows);
 
        startRow = 0;
        String[][] links;
        do {
            links = _closedLoopWebservice.getLinks(
                _session.getSessionId(),
                _since, until, startRow, numberOfRows);
            processData(links);
            startRow += numberOfRows;
        } while (links.length >= numberOfRows);
 
        startRow = 0;
        String[][] responses;
        do {
            responses = _closedLoopWebservice.getResponses(
                _session.getSessionId(),
                _since, until, startRow, numberOfRows);
            processData(responses);
            startRow += numberOfRows;
        } while (responses.length >= numberOfRows);
 
        startRow = 0;
        String[][] unsubscribes;
        do {
            unsubscribes = _closedLoopWebservice.getUnsubscribes(
                _session.getSessionId(),
                _since, until, startRow, numberOfRows);
            processData(unsubscribes);
            startRow += numberOfRows;
        } while (unsubscribes.length >= numberOfRows);
 
        startRow = 0;
        String[][] mailingUnsubscribes;
        do {
            mailingUnsubscribes = 
                _closedLoopWebservice.getMailingUnsubscribes(
                    _session.getSessionId(),
                    _since, until, startRow, numberOfRows);
            processData(mailingUnsubscribes);
            startRow += numberOfRows;
        } while (mailingUnsubscribes.length >= numberOfRows);
 
        _since = until;
    }
 
    // customize this method according to your needs. This
    // includes creating campign reactions or upsert subscription-
    // or bounce status to your entities.
    private void processData(String[][] values) {
        if (values.length == 0) {
            // process no values here
        } else {
            for (String[] click : values) {
                // process your business logic/campaign reactions here
            }
        }
    }
}

/**
 * Use case: Reset bounce status
 * This is an example of how to reset the bounce status
 * of a recipient.
 */
private class ResetBounceStatus extends UseCase {
 
    @Override
    void runExceptional() throws Exception {
        resetBounceCounter(EMAIL_ADDRESS);
    }
 
    private void resetBounceCounter(String emailAdress)
        throws WebserviceException {
        _responseWebservice.resetBounceCounter(
            _session.getSessionId(), emailAdress);
    }
}