Peace/lib/Peace/Model/Application.pm

package Peace::Model::Application;
use v5.30.0;

use strict;
use warnings;

use Data::Dumper;

use Params::ValidationCompiler qw/validation_for/;
use Types::Standard qw/Str InstanceOf Bool Num HasMethods/;

use DateTime;

{
    my $validator = validation_for(
        params => {
            uuid          => { type => Str,                     optional => 1 },
            date_creation => { type => InstanceOf ['DateTime'], optional => 1 },
            name          => { type => Str },
            description   => { type => Str },
            url           => { type => Str },
            developer     =>
              { type => InstanceOf ['Peace::Model::Developer'], optional => 1 },
            developer_uuid => { type => Str, optional => 1 },
            dbh => { type => HasMethods ['selectrow_hashref'], optional => 1 },
            price                => { type => Num },
            git_repo             => { type => Str },
            flatpak_builder_file => { type => Str },
            verified             => { type => Bool },
        }
    );

    sub new {
        my $class  = shift;
        my %params = $validator->(@_);
        die 'developer or developer_uuid should be passed on construct'
          unless exists $params{developer}
          || ( exists $params{developer_uuid} && exists $params{dbh} );
        my $self = bless {%params}, $class;
        return $self;
    }
}

{
    my $validator =
      validation_for( params => [ { type => Str, optional => 1 } ] );

    sub uuid {
        my $self = shift;
        if (@_) {
            my ($new_uuid) = $validator->(@_);
            $self->{uuid} = $new_uuid;
        }
        return $self->{uuid};
    }
}

{
    my $validator =
      validation_for(
        params => [ { type => InstanceOf ['DateTime'], optional => 1 } ] );

    sub date_creation {
        my $self = shift;
        if (@_) {
            my ($new_date_creation) = $validator->(@_);
            $self->{date_creation} = $new_date_creation;
        }
        return $self->{date_creation};
    }
}

{
    my $validator =
      validation_for( params => [ { type => Str, optional => 1 } ] );

    sub name {
        my $self = shift;
        if (@_) {
            my ($new_name) = $validator->(@_);
            $self->{name} = $new_name;
        }
        return $self->{name};
    }
}

{
    my $validator =
      validation_for( params => [ { type => Str, optional => 1 } ] );

    sub description {
        my $self = shift;
        if (@_) {
            my ($new_description) = $validator->(@_);
            $self->{description} = $new_description;
        }
        return $self->{description};
    }
}

{
    my $validator =
      validation_for( params => [ { type => Str, optional => 1 } ] );

    sub url {
        my $self = shift;
        if (@_) {
            my ($new_url) = $validator->(@_);
            $self->{url} = $new_url;
        }
        return $self->{url};
    }
}

{
    my $validator =
      validation_for( params =>
          [ { type => InstanceOf ['Peace::Model::Developer'], optional => 1 } ]
      );

    sub developer {
        my $self = shift;
        if (@_) {
            my ($new_developer) = $validator->(@_);
            $self->{developer} = $new_developer;
        }
        unless ( exists $self->{developer} ) {
            my $developer_uuid = $self->{developer_uuid};
            my $developer_dao =
              Peace::DAO::Developer->new( dbh => $self->_dbh );
            $self->{developer} =
              $developer_dao->recover_by_uuid( uuid => $developer_uuid );
        }
        return $self->{developer};
    }
}

{
    my $validator =
      validation_for( params => [ { type => Num, optional => 1 } ] );

    sub price {
        my $self = shift;
        if (@_) {
            my ($new_price) = $validator->(@_);
            $self->{price} = $new_price;
        }
        return $self->{price};
    }
}

{
    my $validator =
      validation_for( params => [ { type => Str, optional => 1 } ] );

    sub flatpak_builder_file {
        my $self = shift;
        if (@_) {
            my ($new_flatpak_builder_file) = $validator->(@_);
            $self->{flatpak_builder_file} = $new_flatpak_builder_file;
        }
        return $self->{flatpak_builder_file};
    }
}

{
    my $validator =
      validation_for( params => [ { type => Bool, optional => 1 } ] );

    sub verified {
        my $self = shift;
        if (@_) {
            my ($new_verified) = $validator->(@_);
            $self->{verified} = $new_verified;
        }
        return $self->{verified};
    }
}

{
    my $validator = 
        validation_for( params => [ { type => Str, optional => 1 } ] );

    sub git_repo {
        my $self = shift;
        if (@_) {
            my ($new_git_repo) = $validator->(@_);
            $self->{git_repo} = $new_git_repo;
        }
        return $self->{git_repo};
    }
}

sub _dbh {
    my $self = shift;
    return $self->{dbh};
}
1;