POE::Component::Client::opentick::OTClient - An opentick.com otFeed-compatible interface for the POE opentick client.

 #!/usr/bin/perl

 package OTTest;

 use strict;
 use POE qw( Component::Client::opentick::OTClient );
 use base qw( POE::Component::Client::opentick::OTClient );

 sub onLogin {
    my( $self, @args ) = @_;
    print "Logged in.\n";
    $self->requestEquityInit( 'Q' => 'MSFT' );
 }

 sub onEquityInit
 {
    my( $self, $req_id, $cmd_id, $record ) = @_;
    print "Data: ", join( ', ', $record->get_data() ), "\n";
    print "Logging out.\n";
    $self->logout();
 }

 sub onError {
    my( $self, $req_id, $cmd_id, $error ) = @_;
    print "ERROR: $error\n";
 }

 sub startup {
    my( $self ) = @_;
    print "Connecting to opentick server...\n";
    $self->login();
 }

 package main;

 use strict;
 use POE qw( Component::Client::opentick::OTClient );

 my $user = 'CHANGEME';
 my $pass = 'CHANGEMETOO';

 my $opentick = OTTest->new( $user, $pass );

 $poe_kernel->run();
 exit(0);

    use POE::Component::Client::opentick::Constant;

    OTConstant('OT_FLAG_HIGH')

    my $opentick = OTClient->new( undef, undef, AutoLogin => 1, ... );

    my $obj = new( $username, $password, \%args );

    $object->initialize( %args );

    $object->addHost( $hostname, $port );

    $object->clearHosts();

    $object->getStatus();

    $object->isLoggedIn();

    $object->setPlatformId( $id );

    $object->login();

    $object->logout();

    my( $exchange, $symbol ) = $otclient->getEntityById( $request_id );

    my $req_id = $object->requestTickStream( $exchange, $symbol [, $flags ] );

    my $req_id = $object->requestBookStream( $exchange, $symbol, [, $flags ] );

    my $req_id = requestMarketDepth( $exchange, $symbol );

    my $req_id = $object->requestOptionChain( $exchange, $symbol, $expMonth, $expYear, $mask );

    my $req_id = $object->requestEquityInit( $exchange, $symbol );

    my $req_id = $object->requestHistData( $exchange, $symbol, $startDate, $endDate, $dt, $interval );

    my $req_id = requestHistTicks( $exchange, $symbol, $startDate, $endDate, $mask );

    my $req_id = $object->requestTodaysOHL( $exchange, $symbol );

    my $req_id = $object->requestListExchanges();

    my $req_id = $object->requestListSymbols( $exchange );

    my $req_id = $object->requestHistBooks( $exchange, $symbol, $startDate, $endDate, $mask );

    my $req_id = $object->requestOptionInit( $exchange, $symbol, $expMonth, $expYear, $minStrike, $maxStrike, $paramsType );

    my $req_id = $object->requestSplits( $exchange, $symbol, $startDate, $endDate );

    my $req_id = $object->requestDividends( $exchange, $symbol, $startDate, $endDate );

    my $req_id = requestTickSnapshot( $exchange, $symbol, $mask );

    my $req_id = $object->requestOptionChainSnapshot( $exchange, $symbol, $expMonth, $expYear, $mask, $minStrike, $maxStrike, $paramsType );

    my $cancel_id = $object->cancelTickStream( $req_id );

    my $cancel_id = $object->cancelBookStream( $req_id );

    my $cancel_id = $object->cancelMarketDepth( $req_id );

    my $cancel_id = $object->cancelOptionChain( $req_id );

    my $cancel_id = $object->cancelHistData( $req_id );

package POE::Component::Client::opentick::OTClient;
#
#   opentick.com POE client, otFeed Standard API facade class.
#
#   infi/2008
#
#   $Id: OTClient.pm 56 2009-01-08 16:51:14Z infidel $
#
#   Full POD documentation after __END__
#

use strict;
use warnings;
use Socket;
use Carp qw( croak );
use Data::Dumper;
use Time::HiRes qw( time );
use POE;

# Ours.
use POE::Component::Client::opentick::Constants;
use POE::Component::Client::opentick;

###
### Variables
###

use vars qw( $VERSION $TRUE $FALSE $poe_kernel );

($VERSION) = q$Revision: 56 $ =~ /(\d+)/;
*TRUE      = \1;
*FALSE     = \0;

my $dispatch_cmd = {
    OTConstant( 'OT_REQUEST_LIST_EXCHANGES' )   => 'onListExchanges',
    OTConstant( 'OT_REQUEST_LIST_SYMBOLS' )     => 'onListSymbols',
    OTConstant( 'OT_REQUEST_LIST_SYMBOLS_EX' )  => 'onListSymbols',
    OTConstant( 'OT_REQUEST_SPLITS' )           => 'onSplit',
    OTConstant( 'OT_REQUEST_DIVIDENDS' )        => 'onDividend',
    OTConstant( 'OT_REQUEST_OPTION_INIT' )      => 'onOptionInit',
    OTConstant( 'OT_REQUEST_EQUITY_INIT' )      => 'onEquityInit',
    OTConstant( 'OT_REQUEST_TICK_STREAM' )      => 'onRealtime',
    OTConstant( 'OT_REQUEST_TICK_STREAM_EX' )   => 'onRealtime',
    OTConstant( 'OT_REQUEST_TICK_SNAPSHOT' )    => 'onRealtime',
    OTConstant( 'OT_REQUEST_HIST_DATA' )        => 'onHist',
    OTConstant( 'OT_REQUEST_HIST_TICKS' )       => 'onHist',
    OTConstant( 'OT_REQUEST_OPTION_CHAIN' )     => 'onRealtime',
    OTConstant( 'OT_REQUEST_OPTION_CHAIN_EX' )  => 'onRealtime',
    OTConstant( 'OT_REQUEST_BOOK_STREAM' )      => 'onBook',
    OTConstant( 'OT_REQUEST_BOOK_STREAM_EX' )   => 'onBook',
    OTConstant( 'OT_REQUEST_HIST_BOOKS' )       => 'onHistBook',
    OTConstant( 'OT_REQUEST_OPTION_CHAIN' )     => 'onRealtime',
    OTConstant( 'OT_REQUEST_OPTION_CHAIN_EX' )  => 'onRealtime',
    OTConstant( 'OT_REQUEST_OPTION_CHAIN_U' )   => 'onRealtime',
    OTConstant( 'OT_REQUEST_OPTION_CHAIN_SNAPSHOT' ) => 'onRealtime',
};

my $dispatch_dt = {
    OTConstant( 'OT_DATATYPE_QUOTE' )           => 'Quote',
    OTConstant( 'OT_DATATYPE_MMQUOTE' )         => 'MMQuote',
    OTConstant( 'OT_DATATYPE_TRADE' )           => 'Trade',
    OTConstant( 'OT_DATATYPE_BBO' )             => 'BBO',
    OTConstant( 'OT_DATATYPE_OHLC' )            => 'OHLC',
    OTConstant( 'OT_DATATYPE_CANCEL' )          => 'Cancel',
    OTConstant( 'OT_DATATYPE_CHANGE' )          => 'Change',
    OTConstant( 'OT_DATATYPE_DELETE' )          => 'Delete',
    OTConstant( 'OT_DATATYPE_EXECUTE' )         => 'Execute',
    OTConstant( 'OT_DATATYPE_ORDER' )           => 'Order',
    OTConstant( 'OT_DATATYPE_PRICELEVEL' )      => 'PriceLevel',
    OTConstant( 'OT_DATATYPE_PURGE' )           => 'Purge',
    OTConstant( 'OT_DATATYPE_REPLACE' )         => 'Replace',
    OTConstant( 'OT_DATATYPE_OHL_TODAY' )       => 'onTodaysOHL',
};

########################################################################
###   Public methods                                                 ###
########################################################################

# Create the object
sub new
{
    my( $class, $username, $password, @args ) = @_;
    croak( "$class requires an even number of parameters" ) if( @args & 1 );

    # Set our default variables
    my $self = {
        alias       => 'otFeed-' . time,    # our alias
        opentick    => undef,               # opentick object
        session_id  => undef,               # POE session pointer
        requests    => {},                  # outstanding requests
        hosts       => [],                  # host list
    };

    bless( $self, $class );

    $self->initialize( $username, $password, @args );

    return( $self );
}

# Initialize this object instance
sub initialize
{
    my( $self, $username, $password, %args ) = @_;

    $args{username} = $username or $ENV{OPENTICK_USER} or
        croak( "OTClient requires a \$username argument" );
    $args{password} = $password or $ENV{OPENTICK_PASS} or
        croak( "OTClient requires a \$password argument" );

    $self->{hosts} = $args{Hosts} if( $args{Hosts} );
    $self->{hosts} = $args{hosts} if( $args{hosts} );

    # Create our own POE session here
    $self->{session_id} = POE::Session->create(
        object_states   => [
            $self => {
                _start                  => '_poe_started',
                ot_on_login             => '_ot_on_login',
                ot_status_changed       => '_ot_status_changed',
                ot_on_data              => '_ot_on_data',
                ot_on_error             => '_ot_on_error',
                ot_request_complete     => '_ot_request_complete',
                ot_request_cancelled    => '_ot_request_cancelled',
# Not needed for this interface.
#                ot_connect_failed       => '_ot_connect_failed',
#                ot_on_logout            => '_ot_on_logout',
            },
        ],
        heap    => $self,
    )->ID();

    # Create main object POE session here, passing args along
    $self->{opentick} = POE::Component::Client::opentick->spawn(
            Notifyee        => $self->{alias},  # our alias
            Events          => [ 'all' ],       # events to catch
            ReconnRetries   => 0,               # unlimited
#            Debug           => 1,               # TALK LOTS
            Quiet           => 1,               # Hush.
            AutoLogin       => 0,               # manual login.
            %args,
    );

    $self->startup();

    return;
}

#######################################################################
###   otFeed Standard API methods                                   ###
#######################################################################

sub requestTickStream
{
    my( $self, @args ) = @_;

    return( $self->_issue_request( 'requestTickStreamEx', @args ) );
}

sub requestBookStream
{
    my( $self, $exch, $sym, $mask ) = @_;

    my $req_id = $mask
         ? $self->_issue_request( 'requestBookStreamEx', $exch, $sym, $mask )
         : $self->_issue_request( 'requestBookStream', $exch, $sym );

    return( $req_id );
}

# Duplicates functionality from API interface
sub requestMarketDepth
{
    my( $self, $exch, $sym ) = @_;

    my $book_exchanges = { ar => 1, at => 1, br => 1, bt => 1,
                           is => 1, no => 1, cm => 1, em => 1,
                           ct => 1, ec => 1 };

    if( exists( $book_exchanges->{$exch} ) )
    {
        return( $self->_issue_request( 'requestBookStream', $exch, $sym ) );
    }
    else
    {
        return( $self->_issue_request( 'requestTickStreamEx', $exch, $sym,
                                       OTConstant( 'OT_TICK_TYPE_LEVEL2' ) ) );
    }
}

sub requestOptionChain
{
    my( $self, @args ) = @_;

    return( $self->_issue_request( 'requestOptionChainEx', @args ) );
}

sub requestEquityInit
{
    my( $self, @args ) = @_;

    return( $self->_issue_request( 'requestEqInit', @args ) );
}

sub requestHistData
{
    my( $self, @args ) = @_;

    return( $self->_issue_request( 'requestHistData', @args ) );
}

sub requestHistTicks
{
    my( $self, @args ) = @_;

    return( $self->_issue_request( 'requestHistTicks', @args ) );
}

sub requestTodaysOHL
{
    my( $self, $exchange, $symbol ) = @_;

    return( $self->_issue_request( 'requestHistData',
                                   $exchange,
                                   $symbol,
                                   0,
                                   0,
                                   OTConstant( 'OT_HIST_OHL_TODAY' ),
                                   0,
    ) );

    return;
}

# Don't store a request id
sub requestListExchanges
{
    my( $self, @args ) = @_;

    $self->{opentick}->yield( 'requestListExchanges', @args );

    return;
}

# Don't store a request id
sub requestListSymbols
{
    my( $self, @args ) = @_;

    $self->{opentick}->yield( 'requestListSymbolsEx', @args );

    return;
}

sub requestHistBooks
{
    my( $self, @args ) = @_;

    return( $self->_issue_request( 'requestHistBooks', @args ) );
}

sub requestOptionInit
{
    my( $self, @args ) = @_;

    return( $self->_issue_request( 'requestOptionInit', @args ) );
}

sub requestSplits
{
    my( $self, @args ) = @_;

    return( $self->_issue_request( 'requestSplits', @args ) );
}

sub requestDividends
{
    my( $self, @args ) = @_;

    return( $self->_issue_request( 'requestDividends', @args ) );
}

sub requestTickSnapshot
{
    my( $self, $exch, $sym, $mask ) = @_;

    $mask ||= OTConstant( 'OT_MASK_TYPE_QUOTE' ) |
              OTConstant( 'OT_MASK_TYPE_MMQUOTE' ) |
              OTConstant( 'OT_MASK_TYPE_TRADE' ) |
              OTConstant( 'OT_MASK_TYPE_BBO' );

    return( $self->_issue_request( 'requestTickSnapshot', $exch, $sym, $mask ));
}

sub requestOptionChainSnapshot
{
    my( $self, @args ) = @_;

    return( $self->_issue_request( 'requestOptionChainSnapshot', @args ) );
}

# Cancellation
sub cancelTickStream
{
    my( $self, $req_id ) = @_;

    return( $self->_cancel_request( 'cancelTickStream', $req_id ) );
}

sub cancelOptionChain
{
    my( $self, $req_id ) = @_;

    return( $self->_cancel_request( 'cancelOptionChain', $req_id ) );
}

sub cancelBookStream
{
    my( $self, $req_id ) = @_;

    return( $self->_cancel_request( 'cancelBookStream', $req_id ) );
}

sub cancelMarketDepth
{
    my( $self, $req_id ) = @_;

    # leave command undef, and let _cancel_request resolve it.
    return( $self->_cancel_request( undef, $req_id ) );
}

sub cancelHistData
{
    my( $self, $req_id ) = @_;

    return( $self->_cancel_request( 'cancelHistData', $req_id ) );
}

########################################################################
###   otFeed Standard API Auxiliary Functions                        ###
########################################################################

# Halfassed workaround.
sub addHost
{
    my( $self, $host, $port ) = @_;

    push( @{ $self->{hosts} }, $host );
    $self->{opentick}->set_hosts( $self->{hosts} );
    $self->{opentick}->set_port( $port ) if( $port );

    return;
}

# Halfassed workaround.
sub clearHosts
{
    my( $self ) = @_;

    $self->{hosts} = [];
    $self->{opentick}->set_hosts( $self->{hosts} );

    return;
}

sub login
{
    my( $self ) = @_;

    $self->{opentick}->call( 'connect' );

    return;
}

sub logout
{
    my( $self ) = @_;

    $self->{opentick}->call( 'disconnect' );

    return;
}

sub isLoggedIn
{
    my( $self ) = @_;

    return( $self->{opentick}->ready() );
}

sub getStatus
{
    my( $self ) = @_;

    return( $self->{opentick}->get_status() );
}

sub setPlatformId
{
    my( $self, $id, $pass ) = @_;

    $self->{opentick}->set_platform_id( $id, $pass );

    return;
}

sub getEntityById
{
    my( $self, $req_id ) = @_;

    my $req      = $self->{requests}->{$req_id};
    my $exchange = $req->{exchange};
    my $symbol   = $req->{symbol};

    return( $exchange, $symbol );
}

########################################################################
###   Event Handlers                                                 ###
########################################################################

### NOTE: These do nothing by default.  You are to subclass this module
#         and override these methods to do something useful in your
#         application.

# Local extension
sub startup {}

# From API
sub onLogin {}
sub onRestoreConnection {}
sub onStatusChanged {}
sub onError {}
sub onMessage {}
sub onListExchanges {}
sub onListSymbols {}
sub onRealtimeTrade {}
sub onRealtimeQuote {}
sub onRealtimeBBO {}
sub onRealtimeMMQuote {}
sub onTodaysOHL {}
sub onEquityInit {}
sub onBookCancel {}
sub onBookChange {}
sub onBookDelete {}
sub onBookExecute {}
sub onBookOrder {}
sub onBookPriceLevel {}
sub onBookPurge {}
sub onBookReplace {}
sub onHistQuote {}
sub onHistMMQuote {}
sub onHistTrade {}
sub onHistBBO {}
sub onHistOHLC {}
sub onHistBookCancel {}
sub onHistBookChange {}
sub onHistBookDelete {}
sub onHistBookExecute {}
sub onHistBookOrder {}
sub onHistBookPriceLevel {}
sub onHistBookPurge {}
sub onHistBookReplace {}
sub onSplit {}
sub onDividend {}
sub onOptionInit {}

########################################################################
###   Private methods                                                ###
########################################################################

sub _issue_request
{
    my( $self, $command, @args ) = @_;

    # Call opentick to issue the request and get a ReqID
    my $req_id = $self->{opentick}->call( $command, @args );

    # Stash the ReqID and issue time
    $self->{requests}->{$req_id} = {
            cmd_id      => OTAPItoCommand( $command ),
            stamp       => time,
            # FIXME: These won't always be valid; will fix later.
            exchange    => $args[0],
            symbol      => $args[1],
    };

    return( $req_id );
}

sub _cancel_request
{
    my( $self, $command, $req_id ) = @_;

    # Resolve command for requestMarketDepth
    $command =
        OTCommandtoAPI( OTCanceller( $self->{requests}->{$req_id}->{cmd_id} ) )
            unless( $command );

    # Just return boolean; handle req deletion in _ot_on_data
    return( $self->{opentick}->call( $command, $req_id ) ? $TRUE : $FALSE );
}

sub _delete_request
{
    my( $self, $req_id ) = @_;

    return( delete( $self->{requests}->{$req_id} ) );
}

########################################################################
###   POE event handlers                                             ###
########################################################################

# Happens very early, so we'll call started() from initialize() instead.
sub _poe_started
{
    my( $self ) = @_;

    $poe_kernel->alias_set( $self->{alias} );

    return;
}

sub _ot_on_login
{
    my( $self ) = @_;

    my( $wasloggedin ) = $self->{wasloggedin};
    $self->{wasloggedin} = $TRUE;

    # Why do there need to be two of these?  The semantics are confused.
    $wasloggedin && $self->onRestoreConnection() || $self->onLogin();

    return;
}

sub _ot_status_changed
{
    my( $self, $state ) = @_[OBJECT,ARG0];

    $self->onStatusChanged( $state );

    return;
}

# Dispatch to the appropriate request handler.
sub _ot_on_data
{
    my( $self, $req_id, $cmd_id, $object ) = @_[OBJECT,ARG0..ARG2];

    return unless( ref( $object ) );
    my $datatype = $object->get_datatype();

    # Ugly as sin.  Works like a charm.
    my $method;
    if( ( $datatype >= OTConstant('OT_DATATYPE_QUOTE') &&
          $datatype <= OTConstant('OT_DATATYPE_REPLACE') ) ||
          $datatype == OTConstant('OT_DATATYPE_OHLC') )
    {
        $method = $dispatch_cmd->{ $cmd_id } . $dispatch_dt->{ $datatype };
    }
    elsif( $datatype == OTConstant( 'OT_DATATYPE_OHL_TODAY' ) )
    {
        $method = $dispatch_dt->{ $datatype };
    }
    else
    {
        $method = $dispatch_cmd->{ $cmd_id };
    }

    $self->$method( $req_id, $cmd_id, $object );

    return;
}

sub _ot_on_error
{
    my( $self, @args ) = @_[OBJECT,ARG0..$#_];

    $self->onError( @args );

    return;
}

sub _ot_request_complete
{
    my( $self, $req_id, $cmd_id, $obj ) = @_[OBJECT,ARG0..$#_];

    $self->_delete_request( $req_id ) if( $req_id );

    $self->onMessage( $req_id,
                      $cmd_id,
                      OTConstant( 'OT_MSG_END_OF_DATA' ),
                      "Request $req_id completed." );

    return;
}

sub _ot_request_cancelled
{
    my( $self, $req_id, $cmd_id, $obj ) = @_[OBJECT,ARG0..$#_];

    $self->_delete_request( $req_id ) if( $req_id );

    $self->onMessage( $req_id,
                      $cmd_id,
                      OTConstant( 'OT_MSG_END_OF_REQUEST' ),
                      "Request $req_id cancelled." );

    return;
}

1;

__END__