view release on metacpan or  search on metacpan

lib/ExtJS/Generator/DBIC/Model.pm  view on Meta::CPAN

        my $our_col = $relinfo->{cond}->{$rel_col};
        $rel_col =~ s/^foreign\.//;
        $our_col =~ s/^self\.//;
        my $column_info = $columns_info->{$our_col};

        my $remote_rsrc = $schema->source($relinfo->{source});
        my $remote_relname;
        foreach my $relname ( $remote_rsrc->relationships ) {
            my $remote_relinfo = $remote_rsrc->relationship_info($relname);

            # FIXME: handle complex relationship conditions, skip for now
            if ( ! (ref $remote_relinfo->{cond} eq 'HASH') ) {
                warn "$extjsname:\t$relname: complex relationship condition, skipping";
                next;
            }
            my ($remote_rel_col) = keys %{ $remote_relinfo->{cond} };
            my $remote_our_col = $remote_relinfo->{cond}->{$remote_rel_col};
            $remote_rel_col =~ s/^foreign\.//;
            $remote_our_col =~ s/^self\.//;
            if ( $remote_relinfo->{source} eq $rsrc->result_class
                && $rel_col eq $remote_our_col
                && $our_col eq $remote_rel_col ) {
                $remote_relname = $relname;
                last;
            }
        }
        warn "$extjsname:\t$relname: can't find reverse relationship name\n"
            if not defined $remote_relname;

        my $attrs = $relinfo->{attrs};

        #my $extjs_rel = {
        #    name           => $relname,
        #    associationKey => $relname,
        #
        #    # class instead of source?
        #    model      => $self->extjs_model_name( $relinfo->{source} ),
        #    primaryKey => $rel_col,
        #    foreignKey => $our_col,
        #};

        # belongs_to
        #{
        #    attrs => {
        #        accessor                  => "filter",
        #        is_depends_on             => 1,
        #        is_foreign_key_constraint => 1,
        #        undef_on_null_fk          => 1
        #    },
        #    class => "My::Schema::Result::Another",
        #    cond  => {
        #        "foreign.id" => "self.another_id"
        #    },
        #    source => "My::Schema::Result::Another"
        #}

        # has_one
        #{
        #    attrs => {
        #        accessor       => "single",
        #        cascade_delete => 0,
        #        cascade_update => 1,
        #        is_depends_on  => 0,
        #        proxy          => [ "radusername_realm" ]
        #    },
        #    class => "NAC::Model::DBIC::Table::View_Raduser",
        #    cond  => {
        #        "foreign.id_raduser" => "self.id_raduser"
        #    },
        #    source => "NAC::Model::DBIC::Table::View_Raduser"
        #}
        if (
            $attrs->{is_foreign_key_constraint}
            && (   $attrs->{accessor} eq 'single'
                || $attrs->{accessor} eq 'filter' )
            ) {
            if ( exists $field_by_colname{$our_col}->{reference}) {
                warn "$extjsname:\t$relname: relationship for column '$our_col' would overwrite '"
                    . $field_by_colname{$our_col}->{reference}->{role}
                    . "', skipping\n";
                next;
            }
            # add reference to field definition
            $field_by_colname{$our_col}->{reference} = {
                type => $self->extjs_model_entityname(
                    $self->extjs_model_name( $relinfo->{source} ) ),
                role => $relname,
                (defined $remote_relname
                    ? (inverse => $remote_relname)
                    : ()
                ),
            };

            $field_by_colname{$our_col}->{allowBlank} = false()
                if exists $column_info->{is_nullable} 
                    and !$column_info->{is_nullable};

            $field_by_colname{$our_col}->{unique} = true()
                if $attrs->{accessor} eq 'single'
                && $attrs->{is_depends_on} == 0;

            #$extjs_rel->{type} = 'belongsTo';
        }

        #{
        #    attrs => {
        #        accessor       => "multi",
        #        cascade_copy   => 1,
        #        cascade_delete => 1,
        #        is_depends_on  => 0,
        #        join_type      => "LEFT"
        #    },
        #    class => "My::Schema::Result::Basic",
        #    cond  => {
        #        "foreign.another_id" => "self.id"
        #    },
        #    source => "My::Schema::Result::Basic"
        #}
        #elsif ( $attrs->{accessor} eq 'multi' ) {
        #    $extjs_rel->{type} = 'hasMany';
        #}
        #push @assocs, $extjs_rel;
    }
    my $model = {

        extend => $self->model_baseclass,
        alias => $self->extjs_model_alias($extjsname),
        requires => [ sort keys %requires ],
    };
    my @pk = $rsrc->primary_columns;
    if ( @pk == 1 ) {
        $model->{idProperty} = $pk[0];
    }
    else {
        warn
            "$extjsname:\tnot setting idProperty because number of primary key columns isn't one\n";
    }
    my @fields;

    # always keep the primary column as the first entry
    push @fields, delete $field_by_colname{ $model->{idProperty} }
        if exists $model->{idProperty};
    push @fields, map { $field_by_colname{$_} } sort keys %field_by_colname;
    $model->{fields} = \@fields;

    #$model->{associations} = \@assocs
    #    if @assocs;

    # override any generated config properties
    if ( $self->model_args ) {
        my %foo = ( %$model, %{ $self->model_args } );
        $model = \%foo;
    }

    return [ $extjsname, $model ];
}


sub extjs_models {
    my $self = shift;

    my $schema = $self->schema;

    my %output;
    foreach my $rsrcname ( $schema->sources ) {
        my $extjs_model = $self->extjs_model($rsrcname);

        $output{ $extjs_model->[0] } = $extjs_model;
    }