view release on metacpan or  search on metacpan

lib/App/SD/Replica/gcode/PullEncoder.pm  view on Meta::CPAN

    my $ticket_data = {
        $self->sync_source->uuid . '-id' => $ticket->id,
        owner                            => $ticket->owner,
        created     => $ticket->reported->ymd . ' ' . $ticket->reported->hms,
        reporter    => $ticket->reporter,
        status      => $self->translate_prop_status( $ticket->status ),
        summary     => $ticket->summary,
        description => $ticket->description,
        tags        => (join ', ', @tags),
        cc          => $ticket->cc,
    };

    for my $p ( keys %prop ) {
        $ticket_data->{$p} = $prop{$p};
    }

    # delete undefined and empty fields
    delete $ticket_data->{$_}
      for grep { !defined $ticket_data->{$_} || $ticket_data->{$_} eq '' || $ticket_data->{$_} eq '----' }
      keys %$ticket_data;

    return $ticket_data;
}

=head2 find_matching_tickets QUERY

Returns a array of all tickets found matching your QUERY hash.

=cut

sub find_matching_tickets {
    my $self                   = shift;
    my %args  = (@_);
    my $query = $args{query};
    my %query;
    if ($query) {
        if ( $query =~ /=/ ) {
            %query = map { /(.+)=(.*)/; $1 => $2 }
              split /&/, $query;
        }
        else {
            $query{q} = $query;
        }
    }

    my $last_changeset_seen_dt = $self->_only_pull_tickets_modified_after()
      || DateTime->from_epoch( epoch => 0 );
    $self->sync_source->log("Searching for tickets. This can take a very long time on initial sync or if you haven't synced in a long time.");
    require Net::Google::Code;

    if ( $Net::Google::Code::VERSION lt '0.15' ) {
        die
"query support is only for Net::Google::Code version not less than 0.15"
          if $args{query};
        require Net::Google::Code::Issue::Search;
        my $search =
          Net::Google::Code::Issue::Search->new(
            project => $self->sync_source->project, );

        if ( $search->updated_after($last_changeset_seen_dt) ) {
            return $search->results;
        }
        else {
            return [];
        }
    }
    else {
        my $issue = Net::Google::Code::Issue->new(
            map { $_ => $self->sync_source->gcode->$_ }
              grep { $self->sync_source->gcode->$_ }
              qw/project email password/ );

        if ( keys %query == 0 ) {

            # we can use old updated_after method here if no query strings
            # loading issue by checking feeds update is more effective, if
            # possible
            local $Net::Google::Code::Issue::USE_HYBRID = 0;
            require Net::Google::Code::Issue::Search;
            my $search =
              Net::Google::Code::Issue::Search->new(
                project => $self->sync_source->project, );

            # 0 here is to not fallback to ->search method
            if ( $search->updated_after( $last_changeset_seen_dt, 0 ) ) {
                return $search->results;
            }
        }

        $query{can} ||= 'all';
        $query{max_results} ||= 1_000_000_000;
        delete $query{q} unless defined $query{q};
        my $results = $issue->list( %query,
            updated_min => $query{updated_min}
              && $query{updated_min} gt "$last_changeset_seen_dt"
            ? $query{updated_min}
            : "$last_changeset_seen_dt" );

        $_->load for @$results;
        return $results;
    }
}

sub _only_pull_tickets_modified_after {
    my $self = shift;

    my $last_pull = $self->sync_source->upstream_last_modified_date();
    return unless $last_pull;
    my $before = App::SD::Util::string_to_datetime($last_pull);
    $self->log_debug( "Failed to parse '" . $self->sync_source->upstream_last_modified_date() . "' as a timestamp. That means we have to sync ALL history") unless ($before);
    return $before;
}

sub translate_ticket_state {
    my $self         = shift;
    my $ticket       = shift;
    my $transactions = shift;

    my $final_state   = $self->_translate_final_ticket_state($ticket);
    my %earlier_state = %{$final_state};

    my $pre_txn;
    for my $txn ( sort { $b->{'serial'} <=> $a->{'serial'} } @$transactions ) {
        $txn->{post_state} = {%earlier_state};

        if ( $txn->{serial} == 0 ) {
            $txn->{pre_state} = {};
            last;
        }

        my $updates = $txn->{object}->updates;

        for my $prop (qw(owner status summary)) {
            next unless exists $updates->{$prop};
            my $value = delete $updates->{$prop};
            $value = '' if ($value eq '----');
            if ( my $sub = $self->can( 'translate_prop_' . $prop ) ) {
                $value = $sub->( $self, $value );
            }

            $earlier_state{ $PROP_MAP{$prop} } =
              $self->warp_list_to_old_value( $earlier_state{ $PROP_MAP{$prop} },
                $value, undef );
            $txn->{post_state}{ $PROP_MAP{$prop} } = $value;
        }

        if ( $updates->{cc} ) {
            my $value = delete $updates->{cc};
            my $is_delete;
            my @cc = split /\s+/, $value;
            for my $value (@cc) {
                if ( $value =~ /^-(.*)$/ ) {
                    $is_delete = 1;
                    $value     = $1;
                }