gistfile1.txt

use strict;
use warnings;

package TFX::Flight::Conex;

use Moose;
use MooseX::HasDefaults::RO;

use List::Util qw( min reduce );

extends 'TFX::Flight';

has [qw( itinerary half_return )] => ( isa => 'HashRef', required => 1 );

has [qw(
    operator flight_type flight_sequence min_advance_days flight_tariff flight_kind seat_count special_code
    price_two_way direction rate1_type rate1_min_age   rate1_max_age   rate1_price   rate2_type   rate2_min_age
    rate2_max_age   rate2_price rate3_type   rate3_min_age   rate3_max_age   rate3_price
)] => ( isa => 'Any' );

sub _build_table_name { "OWF" }
sub _build_data_type { "F" }
sub _build_version { "3.0" }

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

    my ( undef, @additional_legs ) = @{$self->legs};
    return if !@additional_legs;

    my @via_codes = map { $_->{departure}{code} } @additional_legs;
    return join ',', @via_codes;
}

sub leg {
    my ( $self, $leg_id ) = @_;
    $leg_id ||= 0;
    return $self->legs->[$leg_id] || {};
}

sub legs { $_[0]->itinerary->{segmentList} }

sub _build_flight_carrier { $_[0]->leg_flight_carrier }
sub _build_leg1_flight_carrier { $_[0]->leg_flight_carrier(0) }
sub _build_leg2_flight_carrier { $_[0]->leg_flight_carrier(1) }
sub _build_leg3_flight_carrier { $_[0]->leg_flight_carrier(2) }
sub leg_flight_carrier { $_[0]->leg( $_[1] )->{operatingAirline}{code} }

sub _build_flight_number { $_[0]->leg_flight_number }
sub _build_leg1_flight_number { $_[0]->leg_flight_number(0) }
sub _build_leg2_flight_number { $_[0]->leg_flight_number(1) }
sub _build_leg3_flight_number { $_[0]->leg_flight_number(2) }
sub leg_flight_number { $_[0]->leg( $_[1] )->{flightNumber} }

sub _build_depart_code { $_[0]->leg_depart_code }
sub _build_leg1_depart_code { $_[0]->leg_depart_code(0) }
sub _build_leg2_depart_code { $_[0]->leg_depart_code(1) }
sub _build_leg3_depart_code { $_[0]->leg_depart_code(2) }
sub leg_depart_code { $_[0]->leg( $_[1] )->{departure}{code} }

sub _build_arrive_code { $_[0]->leg_arrive_code(-1) }
sub _build_leg1_arrive_code { $_[0]->leg_arrive_code(0) }
sub _build_leg2_arrive_code { $_[0]->leg_arrive_code(1) }
sub _build_leg3_arrive_code { $_[0]->leg_arrive_code(2) }
sub leg_arrive_code { $_[0]->leg( $_[1] )->{destination}{code} }

sub _build_depart_date { $_[0]->leg_depart_date }
sub _build_leg1_depart_date { $_[0]->leg_depart_date(0) }
sub _build_leg2_depart_date { $_[0]->leg_depart_date(1) }
sub _build_leg3_depart_date { $_[0]->leg_depart_date(2) }
sub leg_depart_date { $_[0]->regex_filter_leg( $_[1], 'departureDate' ) }

sub _build_depart_time { $_[0]->leg_depart_time }
sub _build_leg1_depart_time { $_[0]->leg_depart_time(0) }
sub _build_leg2_depart_time { $_[0]->leg_depart_time(1) }
sub _build_leg3_depart_time { $_[0]->leg_depart_time(2) }
sub leg_depart_time { $_[0]->regex_filter_leg( $_[1], 'departureTimestamp' ) }

sub _build_arrive_time { $_[0]->leg_arrive_time(-1) }
sub _build_leg1_arrive_time { $_[0]->leg_arrive_time(0) }
sub _build_leg2_arrive_time { $_[0]->leg_arrive_time(1) }
sub _build_leg3_arrive_time { $_[0]->leg_arrive_time(2) }
sub leg_arrive_time { $_[0]->regex_filter_leg( $_[1], 'arrivalTimestamp' ) }

sub regex_filter_leg {
    my ( $self, $leg_id, $key ) = @_;

    my $value = $self->leg( $leg_id )->{$key};
    return if !$value;

    $value =~ s/^.*T(\d+):(\d+):.*$/$1$2/ if grep { $_ eq $key } qw( departureTimestamp arrivalTimestamp );
    $value =~ s:(\d+)-(\d+)-(\d+):$3.$2.$1: if grep { $_ eq $key } qw( departureDate );

    return $value;
}

sub _build_currency { $_[0]->price->{currencyIsoCode} }
sub _build_price_one_way { $_[0]->price->{value} }
sub _build_combination_id { $_[0]->air_rule_set->{openJawCombinationGroup}{name} }

sub price { $_[0]->half_return->{farePassengerTypePriceList}[0]{purchasePrice} }

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

    my $tax_list = $self->half_return->{taxQuoteList}[0]{taxList};
    my @taxes = values %{$tax_list};

    no warnings 'once';
    return reduce { $a + $b->{price}{value} } 0, @taxes;
}

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

    my @rules = map $self->convert_duration( $_ ), qw( minimumStay maximumStay );

    my $sunday_rule = $self->air_rule_set->{minimumStay}{sundayRule};
    push @rules, 'SUN' if $sunday_rule and $sunday_rule eq 'true';

    return join ',', @rules;
}

sub convert_duration {
    my ( $self, $type ) = @_;

    my $duration = $self->air_rule_set->{$type};
    die "duration type missing: '$type'" if !$duration;

    my $prefix = $self->get_duration_rule_prefix( $type );
    $duration->{value} = min( $duration->{value}, 99 );

    return $prefix . "99" if $duration->{value} > 3  and $duration->{unit}{id} eq 'STU_MONTHS';
    return $prefix . "99" if $duration->{value} >= 1 and $duration->{unit}{id} eq 'STU_YEARS';

    return sprintf( "%s%02d", $prefix, $duration->{value} )      if $duration->{unit}{id} eq 'STU_DAYS';
    return sprintf( "%s%02d", $prefix, $duration->{value} * 30 ) if $duration->{unit}{id} eq 'STU_MONTHS';

    die "unknown duration unit id '$duration->{unit}{id}' with value '$duration->{value}'";
}

sub get_duration_rule_prefix {
    my ( $self, $type ) = @_;
    return 'A' if $type eq 'minimumStay';
    return 'B' if $type eq 'maximumStay';
    die "unknown duration type";
}

sub air_rule_set { $_[0]->half_return->{airRuleSet} }

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

    my $class_id = $self->air_rule_set->{cabinClass}{id};

    my %classes = (
        CAB_ECONOMY  => 'Y',
        CAB_BUSINESS => 'C',
    );

    return $classes{$class_id} || die "Unknown class id: $class_id";
}

1;