Error Object 2 not found in author

Error Object 2 not found in author Olá, tudo bem? Estou iniciando minhas pesquisas no Adianti Framework a pouco tempo, estou estudando o módulo Biblioteca (library) disponibilizado pelo Pablo, estou mudando o seu template para o tema 3 e estou com o seguinte Error Object 2 not found in author. Se alguma alma caridosa puder ajudar, serei grato! Mais notei que as pessoas que participam do fórum são bastante colaborativas! ...

Jonathas Alves 31/05/2016 (há 9 anos)

Olá, tudo bem?

Estou iniciando minhas pesquisas no Adianti Framework a pouco tempo, estou estudando o módulo Biblioteca (library) disponibilizado pelo Pablo, estou mudando o seu template para o tema 3 e estou com o seguinte Error Object 2 not found in author.

Se alguma alma caridosa puder ajudar, serei grato! Mais notei que as pessoas que participam do fórum são bastante colaborativas!

Att,
Jonathas Alves

Curso Dominando o Adianti Framework

O material mais completo de treinamento do Framework.
Curso em vídeo aulas + Livro completo + Códigos fontes do projeto ERPHouse.
Conteúdo Atualizado!

Dominando o Adianti Framework Quero me inscrever agora!

Comentários (2)

Luis Alberto 06/06/2016 (há 9 anos)

ola Jonathas, resolveu?
posta como fez no BookList e no Model da tabela.

Jonathas Alves - AUTOR DO POST 06/06/2016 (há 9 anos)

Olá, Luis Alberto!

Tudo bem?
Ainda não consegui resolver

Control

 <?php
/**
 * BookList Listing
 *
 * @version    1.0
 * @package    samples
 * @subpackage library
 * @author     Pablo Dall'Oglio
 * @copyright  Copyright (c) 2006-2011 Adianti Solutions Ltd. (http://www.adianti.com.br)
 * @license    http://www.adianti.com.br/framework-license
 */
class BookList extends TPage
{
    private $form;     // registration form
    private $datagrid; // listing
    private $pageNavigation;
    private $loaded;
    
    /**
     * Class constructor
     * Creates the page, the form and the listing
     */
    public function __construct()
    {
        parent::__construct();
        // security check
        if (TSession::getValue('logged') !== TRUE)
        {
            throw new Exception(('Not logged'));
        }
        
        // creates the form
        $this->form = new TForm('form_search_Book');
        $this->form->class = 'tform';
        // creates a table
        $table = new TTable;
        $table->width = '100%';
        
        $table->addRowSet(new TLabel(('Books')), '')->class='tformtitle';
        
        // add the table inside the form
        $this->form->add($table);
        
        // create the form fields
        $title             = new TEntry('title');
        $author_id         = new TSeekButton('author_id');
        $author_name       = new TEntry('author_name');
        $collection_id     = new TDBCombo('collection_id', 'library', 'Collection', 'id', 'description');
        $classification_id = new TDBCombo('classification_id', 'library', 'Classification', 'id', 'description');
        
        $title->setValue(TSession::getValue('Book_title'));
        $author_id->setValue(TSession::getValue('Book_author_id'));
        $author_name->setValue(TSession::getValue('Book_author_name'));
        $collection_id->setValue(TSession::getValue('Book_collection_id'));
        $classification_id->setValue(TSession::getValue('Book_classification_id'));
        $author_name->setEditable(FALSE);
        
        $title->setSize(320);
        $author_id->setSize(100);
        $obj = new TStandardSeek;
        $action = new TAction(array($obj, 'onSetup'));
        $action->setParameter('database',      'library');
        $action->setParameter('parent',        'form_search_Book');
        $action->setParameter('model',         'Author');
        $action->setParameter('display_field', 'name');
        $action->setParameter('receive_key',   'author_id');
        $action->setParameter('receive_field', 'author_name');
        $author_id->setAction($action);
        
        // add a row for the title field
        $row=$table->addRow();
        $row->addCell(new TLabel(('Title') . ': '));
        $cell=$row->addCell($title);
        
        // add a row for the title field
        $row=$table->addRow();
        $row->addCell(new TLabel(('Author') . ': '));
        $row->addMultiCell($author_id, $author_name);
        
        // add a row for the title field
        $row=$table->addRow();
        $row->addCell(new TLabel(('Collection') . ': '));
        $cell=$row->addCell($collection_id);
        
        // add a row for the title field
        $row=$table->addRow();
        $row->addCell(new TLabel(('Classification') . ': '));
        $cell=$row->addCell($classification_id);
        
        // create two action buttons to the form
        $find_button = new TButton('find');
        $new_button  = new TButton('new');
        // define the button actions
        $find_button->setAction(new TAction(array($this, 'onSearch')), ('Find'));
        $find_button->setImage('fa:search');
        
        $new_button->setAction(new TAction(array('BookForm', 'onEdit')), ('New'));
        $new_button->setImage('fa:plus-square green');
        
        $table->addRowSet('', array($find_button, $new_button))->class='tformaction';
        
        // define wich are the form fields
        $this->form->setFields(array($title, $author_id, $author_name, $collection_id, $classification_id, $find_button, $new_button));
        
        // creates a DataGrid
        $this->datagrid = new TDataGrid;
        $this->datagrid->style = 'width: 100%';
        $this->datagrid->setHeight(280);
        
        // creates the datagrid columns
        $id                = new TDataGridColumn('id', ('Code'), 'right', 50);
        $title             = new TDataGridColumn('title', ('Title'), 'left', 200);
        $main_author       = new TDataGridColumn('author_name', ('Author'), 'left', 160);
        $edition           = new TDataGridColumn('edition', ('Edition'), 'left', 50);
        $call              = new TDataGridColumn('call_number', ('Call'), 'left', 80);
        // creates the datagrid actions
        $order1= new TAction(array($this, 'onReload'));
        $order2= new TAction(array($this, 'onReload'));
        // define the ordering parameters
        $order1->setParameter('order', 'id');
        $order2->setParameter('order', 'title');
        // assign the ordering actions
        $id->setAction($order1);
        $title->setAction($order2);
        
        // add the columns to the DataGrid
        $this->datagrid->addColumn($id);
        $this->datagrid->addColumn($title);
        $this->datagrid->addColumn($main_author);
        $this->datagrid->addColumn($edition);
        $this->datagrid->addColumn($call);
        
        // creates two datagrid actions
        $action1 = new TDataGridAction(array('BookForm', 'onEdit'));
        $action1->setLabel(('Edit'));
        $action1->setImage('fa:pencil-square-o blue fa-lg');
        $action1->setField('id');
        
        $action2 = new TDataGridAction(array($this, 'onDelete'));
        $action2->setLabel(('Delete'));
        $action2->setImage('fa:trash-o red fa-lg');
        $action2->setField('id');
        
        // add the actions to the datagrid
        $this->datagrid->addAction($action1);
        $this->datagrid->addAction($action2);
        
        // create the datagrid model
        $this->datagrid->createModel();
        
        // creates the page navigation
        $this->pageNavigation = new TPageNavigation;
        $this->pageNavigation->setAction(new TAction(array($this, 'onReload')));
        $this->pageNavigation->setWidth($this->datagrid->getWidth());
        
        // creates the page structure using a vbox
        $container = new TVBox;
        $container->style = 'width: 100%';
        $container->add($this->form);
        $container->add($this->datagrid);
        $container->add($this->pageNavigation);
        // add the vbox inside the page
        parent::add($container);
    }
    
    /**
     * method onSearch()
     * Register the filter in the session when the user performs a search
     */
    function onSearch()
    {
        // get the search form data
        $data = $this->form->getData();
        $filters = array();
        TSession::setValue('Book_title', '');
        TSession::setValue('Book_author_id', '');
        TSession::setValue('Book_author_name', '');
        TSession::setValue('Book_collection_id', '');
        TSession::setValue('Book_classification_id', '');
        TSession::setValue('Book_filters',   array());
        
        // check if the user has filled the form
        if ($data->title)
        {
            // creates a filter using what the user has typed
            $filter = new TFilter('title', 'like', "%{$data->title}%");
            
            // stores the filter in the session
            TSession::setValue('Book_title', $data->title);
            $filters[] = $filter;
        }
        
        if ($data->author_id)
        {
            // creates a filter using what the user has typed
            $filter = new TFilter('author_id', '=', "{$data->author_id}");
            
            // stores the filter in the session
            TSession::setValue('Book_author_id', $data->author_id);
            TSession::setValue('Book_author_name', $data->author_name);
            $filters[] = $filter;
        }
        
        if ($data->collection_id)
        {
            // creates a filter using what the user has typed
            $filter = new TFilter('collection_id', '=', "{$data->collection_id}");
            
            // stores the filter in the session
            TSession::setValue('Book_collection_id', $data->collection_id);
            $filters[] = $filter;
        }
        
        if ($data->classification_id)
        {
            // creates a filter using what the user has typed
            $filter = new TFilter('classification_id', '=', "{$data->classification_id}");
            
            // stores the filter in the session
            TSession::setValue('Book_classification_id', $data->classification_id);
            $filters[] = $filter;
        }
        
        if ($filters)
        {
            TSession::setValue('Book_filters',   $filters);
        }
        
        // fill the form with data again
        $this->form->setData($data);
        $param=array();
        $param['offset']    =0;
        $param['first_page']=1;
        $this->onReload($param);
    }
    
    /**
     * method onReload()
     * Load the datagrid with the database objects
     */
    function onReload($param = NULL)
    {
        try
        {
            // open a transaction with database 'library'
            TTransaction::open('library');
            
            // creates a repository for Book
            $repository = new TRepository('Book');
            $limit = 10;
            // creates a criteria
            $criteria = new TCriteria;
            $criteria->setProperties($param); // order, offset
            $criteria->setProperty('limit', $limit);
            
            if (TSession::getValue('Book_filters'))
            {
                foreach (TSession::getValue('Book_filters') as $filter)
                {
                    if ($filter instanceof TFilter)
                    {
                        // add the filter stored in the session to the criteria
                        $criteria->add($filter);
                    }
                }
            }
            
            // load the objects according to criteria
            $objects = $repository->load($criteria);
            
            $this->datagrid->clear();
            if ($objects)
            {
                // iterate the collection of active records
                foreach ($objects as $object)
                {
                    // add the object inside the datagrid
                    $this->datagrid->addItem($object);
                }
            }
            
            // reset the criteria for record count
            $criteria->resetProperties();
            $count= $repository->count($criteria);
            
            $this->pageNavigation->setCount($count); // count of records
            $this->pageNavigation->setProperties($param); // order, page
            $this->pageNavigation->setLimit($limit); // limit
            
            // close the transaction
            TTransaction::close();
            $this->loaded = true;
        }
        catch (Exception $e) // in case of exception
        {
            // shows the exception error message
            new TMessage('error', '<b>Error</b> ' . $e->getMessage());
            
            // undo all pending operations
            TTransaction::rollback();
        }
    }
    
    /**
     * method onDelete()
     * executed whenever the user clicks at the delete button
     * Ask if the user really wants to delete the record
     */
    function onDelete($param)
    {
        // get the parameter $key
        $key=$param['key'];
        
        // define two actions
        $action = new TAction(array($this, 'Delete'));
        
        // define the action parameters
        $action->setParameter('key', $key);
        
        // shows a dialog to the user
        new TQuestion(TAdiantiCoreTranslator::translate('Do you really want to delete ?'), $action);
    }
    
    /**
     * method Delete()
     * Delete a record
     */
    function Delete($param)
    {
        try
        {
            // get the parameter $key
            $key=$param['key'];
            // open a transaction with database 'library'
            TTransaction::open('library');
            
            // instantiates object Book
            $object = new Book($key);
            
            // deletes the object from the database
            $object->delete();
            
            // close the transaction
            TTransaction::close();
            
            // reload the listing
            $this->onReload();
            // shows the success message
            new TMessage('info', TAdiantiCoreTranslator::translate('Record deleted'));
        }
        catch (Exception $e) // in case of exception
        {
            // shows the exception error message
            new TMessage('error', '<b>Error</b> ' . $e->getMessage());
            
            // undo all pending operations
            TTransaction::rollback();
        }
    }
    
    /**
     * method show()
     * Shows the page
     */
    function show()
    {
        // check if the datagrid is already loaded
        if (!$this->loaded)
        {
            $this->onReload();
        }
        parent::show();
    }
}
?>

Model

 <?php
/**
 * Book Active Record
 *
 * @version    1.0
 * @package    samples
 * @subpackage library
 * @author     Pablo Dall'Oglio
 * @copyright  Copyright (c) 2006-2011 Adianti Solutions Ltd. (http://www.adianti.com.br)
 * @license    http://www.adianti.com.br/framework-license
 */
class Book extends TRecord
{
    const TABLENAME = 'book';
    const PRIMARYKEY= 'id';
    const IDPOLICY =  'max'; // {max, serial}
    use SystemChangeLogTrait; 
    
    private $authors;
    private $subjects;
    private $items;
    private $author;
    private $publisher;
    private $collection;
    
    /**
     * Returns the book author name
     */
    function get_author_name()
    {
        if (empty($this->author))
            $this->author = new Author($this->author_id);
        
        return $this->author->name;
    }
    
    /**
     * Returns the book collection description
     */
    function get_collection_description()
    {
        if (empty($this->collection))
            $this->collection = new Collection($this->collection_id);
        
        return $this->collection->description;
    }
    
    /**
     * Returns the book publisher name
     */
    function get_publisher_name()
    {
        if (empty($this->publisher))
            $this->publisher = new Publisher($this->publisher_id);
        
        return $this->publisher->name;
    }
    
    /**
     * Reset aggregates
     */
    public function clearParts()
    {
        $this->authors  = array();
        $this->subjects = array();
        $this->items    = array();
    }
    
    /**
     * Aggregation with Author
     */
    public function addAuthor(Author $author)
    {
        $this->authors[] = $author;
    }
    
    /**
     * Aggregation with Subject
     */
    public function addSubject(Subject $subject)
    {
        $this->subjects[] = $subject;
    }
    
    /**
     * Composition with Item
     */
    public function addItem(Item $item)
    {
        $this->items[] = $item;
    }
    
    /**
     * Return Author aggregates
     */
    public function getAuthors()
    {
        return $this->authors;
    }
    
    /**
     * Return Subject aggregates
     */
    public function getSubjects()
    {
        return $this->subjects;
    }
    
    /**
     * Return Items composition
     */
    public function getItems()
    {
        return $this->items;
    }
    
    /**
     * Load the object and the aggregates
     */
    public function load($id)
    {
        $book_author_rep  = new TRepository('BookAuthor');
        $book_subject_rep = new TRepository('BookSubject');
        $item_rep         = new TRepository('Item');
        
        $criteria = new TCriteria;
        $criteria->add(new TFilter('book_id', '=', $id));
        
        // load the Author aggregates
        $book_authors = $book_author_rep->load($criteria);
        if ($book_authors)
        {
            foreach ($book_authors as $book_author)
            {
                $author = new Author($book_author-> author_id);
                $this->addAuthor($author);
            }
        }
        
        // load the Subject aggregates
        $book_subjects = $book_subject_rep->load($criteria);
        if ($book_subjects)
        {
            foreach ($book_subjects as $book_subject)
            {
                $subject = new Subject($book_subject-> subject_id);
                $this->addSubject($subject);
            }
        }
        
        // load the Item composition
        $items = $item_rep->load($criteria);
        if ($items)
        {
            foreach ($items as $item)
            {
                $this->addItem($item);
            }
        }
        
        // load the object itself
        return parent::load($id);
    }
    
    /**
     * Stores the book and the aggregates (authors, subjects, items)
     */
    public function store()
    {
        // stores the Book
        parent::store();
        
        // delete the aggregates
        $criteria = new TCriteria;
        $criteria->add(new TFilter('book_id', '=', $this->id));
        
        $repository = new TRepository('BookAuthor');
        $repository->delete($criteria);
        $repository = new TRepository('BookSubject');
        $repository->delete($criteria);
        
        // collect persistent item ids
        if ($this->items)
        {
            foreach ($this->items as $item)
            {
                if ($item->id)
                {
                    $item_ids[] = $item->id;
                }
            }
        }
        
        
        // delete all items, except for those that persist
        $criteria->add(new TFilter('id', 'NOT IN', $item_ids));
        $repository = new TRepository('Item');
        $repository->delete($criteria);
        
        // store the authors
        if ($this->authors)
        {
            foreach ($this->authors as $author)
            {
                $book_author = new BookAuthor;
                $book_author-> book_id    = $this-> id;
                $book_author-> author_id  = $author-> id;
                $book_author->store();
            }
        }
        
        // store the subjects
        if ($this->subjects)
        {
            foreach ($this->subjects as $subject)
            {
                $book_subject = new BookSubject;
                $book_subject-> book_id     = $this-> id;
                $book_subject-> subject_id  = $subject-> id;
                $book_subject->store();
            }
        }
        
        // store the items
        if ($this->items)
        {
            foreach ($this->items as $item)
            {
                $item-> book_id = $this-> id;
                $item->store();
            }
        }
    }
    
    /**
     * Delete the book and its aggregates
     */
    public function delete($id = NULL)
    {
        $id = isset($id) ? $id : $this->{'id'};
        
        $criteria = new TCriteria;
        $criteria->add(new TFilter('book_id', '=', $id));
        
        $repository = new TRepository('BookAuthor');
        $repository->delete($criteria);
        $repository = new TRepository('BookSubject');
        $repository->delete($criteria);
        $repository = new TRepository('Item');
        $repository->delete($criteria);
        
        // delete the object itself
        parent::delete($id);
    }
}
?>

Novo Comentário