object_admin

Admin class for Plain Old Python Object

class camelot.admin.object_admin.FieldAttributesList(original_list)[source]

A list with field attributes that documents them for sphinx

class camelot.admin.object_admin.ObjectAdmin(app_admin, entity)[source]

The ObjectAdmin class describes the interface that will be used to interact with objects of a certain class. The behaviour of this class and the resulting interface can be tuned by specifying specific class attributes:

The name used in the GUI

The name used in the GUI for things like window titles and such can be specified using the verbose_name attribute.

verbose_name

A human-readable name for the object, singular

verbose_name = _('movie')

If this isn’t given, the class name will be used

verbose_name_plural

A human-readable name for the object, plural

verbose_name_plural = _('movies')

If this isn’t given, Camelot will use verbose_name + “s”

Fields displayed

list_display

a list with the fields that should be displayed in a table view

list_columns_frozen

the number of columns on the left of the tableview that should be frozen (don’t dissapear when the user uses the horizontal scroll bar), defaults to zero

lines_per_row

An integer number specifying the height of a row in the table view, expressed as the number of lines of text it should be able to display. Defaults to 1.

form_display

a list with the fields that should be displayed in a form view, defaults to the same fields as those specified in list_display

class Admin(EntityAdmin):
    form_display = ['title', 'rating', 'cover']

instead of telling which fields to display. It is also possible to define the form itself

from camelot.view.forms import Form, TabForm, WidgetOnlyForm, HBoxForm

class Admin(EntityAdmin):
    form_display = TabForm([
    ('Movie', Form([
      HBoxForm([['title', 'rating'], WidgetOnlyForm('cover')]),
      'short_description',
      'releasedate',
      'director',
      'script',
      'genre',
      'description', 'tags'], scrollbars=True)),
    ('Cast', WidgetOnlyForm('cast'))
  ])

Behaviour

save_mode

Specifies when the data should be send from the view to the model and flushed to the database. The default mode is ‘on_change’, meaning that every change in the view will be send immediately to the database. Other possibilities are :

  • ‘on_leave’ : the data will be send from the view to the model when the view

    is closed, eg. : the form is closed.

delete_mode

Indicates if the deletion of an object should be confirmed by the user, defaults to ‘on_request’, indicating object should be deleted when the user hits the trash button. Other possibilities are :

  • ‘on_confirm’ : the user will be asked for confirmation before the delete takes place.
form_size

a tuple indicating the size of a form view, defaults to (700,500)

form_actions

Actions to be accessible by pushbuttons on the side of a form, a list of tuples (button_label, action_function) where action_function takes as its single argument, a method that returns the the object that was displayed by the form when the button was pressed:

class Admin(EntityAdmin):
    form_actions = [('Foo', lamda o_getter:print 'foo')]

Field attributes

field_attributes

A dictionary specifying for each field of the model some additional attributes on how they should be displayed. All of these attributes are propagated to the constructor of the delegate of this field:

class Movie(Entity):
    title = Field(Unicode(50))

    class Admin(EntityAdmin):
        list_display = ['title']
        field_attributes = dict(title=dict(editable=False))

The Field Attributes documentation describes the various keys that can be used in the field attributes class attribute of an ObjectAdmin or EntityAdmin.

Window state

form_state

Set this attribute to ‘maximized’ or ‘minimized’ for respective behaviour. These are the only two defined at the moment. Please use the constants defined in camelot.core.constants (MINIMIZE and MAXIMIZE). Note that this attr needs to be set at the form, highest in the form hierarchy to work. Setting this on embedded forms will not influence the window state. Example:

class Movie(Entity):
    title = Field(Unicode(50))

    class Admin(EntityAdmin):
        from camelot.core import constants
        list_display = ['title']
        form_state = constants.MAXIMIZED
        field_attributes = dict(title=dict(editable=False))

Varia

model

The QAbstractItemModel class to be used to display collections of this object, defaults to a CollectionProxy

TableView

The QWidget class to be used when a table view is needed

class TableView(admin, search_text=None, parent=None)

A generic tableview widget that puts together some other widgets. The behaviour of this class and the resulting interface can be tuned by specifying specific class attributes which define the underlying widgets used

class MovieRentalTableView(TableView):
  title_format = 'Grand overview of recent movie rentals'

The attributes that can be specified are :

header_widget

The widget class to be used as a header in the table view:

header_widget = HeaderWidget
table_widget

The widget class used to display a table within the table view

table_widget = TableWidget

title_format

A string used to format the title of the view

title_format = ‘%(verbose_name_plural)s’

table_model

A class implementing QAbstractTableModel that will be used as a model for the table view

table_model = QueryTableProxy
  • emits the row_selected signal when a row has been selected
class AdminTableWidget(admin, parent=None)

A table widget that inspects the admin class and changes the behavior of the table as specified in the admin class

ObjectAdmin.TableView.cancelSearch()

resets search filtering to default

ObjectAdmin.TableView.closeEvent(event)

reimplements close event

ObjectAdmin.TableView.copy_selected_rows()

Copy the selected rows in this tableview

ObjectAdmin.TableView.create_table_model(admin)

Create a table model for the given admin interface

ObjectAdmin.TableView.deleteSelectedRows()

delete the selected rows in this tableview

ObjectAdmin.TableView.getColumns()

return the columns to be displayed in the table view

ObjectAdmin.TableView.getData()

generator for data queried by table model

ObjectAdmin.TableView.getTitle()

return the name of the entity managed by the admin attribute

ObjectAdmin.TableView.get_collection_getter(*args, **kwargs)
Returns:a list with all the objects corresponding to the rows in the table
ObjectAdmin.TableView.get_selection_getter(*args, **kwargs)
Returns:a function that when called return an iterable with all the

objects corresponding to the selected rows in the table.

ObjectAdmin.TableView.header_widget

alias of HeaderWidget

ObjectAdmin.TableView.importFromFile()

“import data : the data will be imported in the activeMdiChild

ObjectAdmin.TableView.newRow(*args, **kwargs)

Create a new row in the tableview

ObjectAdmin.TableView.rebuild_query()

resets the table model query

ObjectAdmin.TableView.refresh()

Refresh the whole view

ObjectAdmin.TableView.sectionClicked(section)

emits a row_selected signal

ObjectAdmin.TableView.selectTableRow(row)

selects the specified row

ObjectAdmin.TableView.selectedTableIndexes(*args, **kwargs)

returns a list of selected rows indexes

ObjectAdmin.TableView.set_admin(*args, **kwargs)

Switch to a different subclass, where admin is the admin object of the subclass

ObjectAdmin.TableView.set_filters_and_actions(*args, **kwargs)

sets filters for the tableview

ObjectAdmin.TableView.startSearch(text)

rebuilds query based on filtering text

ObjectAdmin.TableView.table_model

alias of QueryTableProxy

ObjectAdmin.TableView.to_html()

generates html of the table

ObjectAdmin.TableView.viewFirst()

selects first row

ObjectAdmin.TableView.viewLast()

selects last row

ObjectAdmin.TableView.viewNext()

selects next row

ObjectAdmin.TableView.viewPrevious()

selects previous row

ObjectAdmin.add(*args, **kwargs)[source]

Add an entity instance as a managed entity instance

ObjectAdmin.copy(*args, **kwargs)[source]

Duplicate this entity instance

ObjectAdmin.create_form_view(*args, **kwargs)[source]

Creates a Qt widget containing a form view, for a specific index in a model. Use this method to create a form view for a collection of objects, the user will be able to use PgUp/PgDown to move to the next object.

Parameters:
  • title – the title of the form view
  • model – the data model to be used to fill the form view
  • index – which row in the data model to display
  • parent – the parent widget for the form
ObjectAdmin.create_new_view(*args, **kwargs)[source]

Create a Qt widget containing a form to create a new instance of the entity related to this admin class

The returned class has an ‘entity_created_signal’ that will be fired when a valid new entity was created by the form

Parameters:collection_proxy – if specified, the object will be appended to

its underlying collection upon creation and removed from it upon discarding.

ObjectAdmin.create_object_form_view(*args, **kwargs)[source]

Create a form view for a single object, PgUp/PgDown will do nothing.

Parameters:
  • title – the title of the form view
  • object_getter – a function taking no arguments, and returning the object
  • parent – the parent widget for the form
ObjectAdmin.delete(*args, **kwargs)[source]

Delete an entity instance

ObjectAdmin.expunge(*args, **kwargs)[source]

Remove this object from the objects being managed

ObjectAdmin.flush(*args, **kwargs)[source]

Flush the pending changes of this entity instance to the backend

ObjectAdmin.get_all_fields_and_attributes(*args, **kwargs)[source]

A dictionary of (field_name:field_attributes) for all fields that can possibly appear in a list or a form or for which field attributes have been defined

ObjectAdmin.get_columns(*args, **kwargs)[source]

The columns to be displayed in the list view, returns a list of pairs of the name of the field and its attributes needed to display it properly

@return: [(field_name,
{‘widget’: widget_type,
‘editable’: True or False, ‘blank’: True or False, ‘validator_list’:[...], ‘name’:’Field name’}),

...]

ObjectAdmin.get_depending_objects(*args, **kwargs)[source]

Overwrite this function to generate a list of objects that depend on a given object. When obj is modified by the user, this function will be called to determine which other objects need their views updated.

Parameters:obj – an object of the type that is managed by this admin class
Returns:an iterator over objects that depend on obj
ObjectAdmin.get_dynamic_field_attributes(obj, field_names)[source]

Convenience function to get all the field attributes that are dynamic (depend on the object being visualized). This method is called once for each object/row in a table view and once for each object being visualized in a form view.

Parameters:
  • field_names – a list of field names
  • obj – the object at the row for which to get the values of the dynamic field attributes
Returns:

[{field_attribute_name:field_attribute_value, ...}, {}, ...]

The returned list has the same order than the requested field_names.

ObjectAdmin.get_field_attributes(field_name)[source]

Get the attributes needed to visualize the field field_name. This function is called by get_static_field_attributes and get_dynamic_field_attributes.

This function first tries to fill the dictionary with field attributes for a field with those gathered through introspection, and then updates them with those found in the field_attributes class attribute.

Parameters:field_name – the name of the field
Returns:a dictionary of attributes needed to visualize the field

The values of the returned dictionary either contain the value of the field attribute, or in the case of dynamic field attributes, a function that returns the value of the field attribute.

ObjectAdmin.get_form_actions(*args, **kwargs)[source]
Returns:a list of FormAction objects

Get an admin object for another object class. Taking into account preferences of this admin object or for those of admin object higher up the chain such as the application admin object.

Parameters:cls – the class for which an admin object is requested

deprecated : use get_related_admin

ObjectAdmin.get_static_field_attributes(field_names)[source]

Convenience function to get all the field attributes that are static (don’t depend on the object being visualized). This method is only called once for a table or form view, independent of the number of objects/records being visualized.

Parameters:field_names – a list of field names
Returns:[{field_attribute_name:field_attribute_value, ...}, {}, ...]

The returned list has the same order than the requested field_names.

ObjectAdmin.get_subclass_tree(*args, **kwargs)[source]

Get a tree of admin classes representing the subclasses of the class represented by this admin class

Returns:[(subclass_admin, [(subsubclass_admin, [...]),...]),...]
ObjectAdmin.get_verbose_identifier(*args, **kwargs)[source]

Create an identifier for an object that is interpretable for the user, eg : the primary key of an object. This verbose identifier can be used to generate a title for a form view of an object.

ObjectAdmin.is_deleted(*args, **kwargs)[source]
Returns:True if the object has been deleted from the persistent

state, False otherwise

ObjectAdmin.is_persistent(*args, **kwargs)[source]
Returns:True if the object has a persisted state, False otherwise
ObjectAdmin.model

alias of CollectionProxy

ObjectAdmin.refresh(*args, **kwargs)[source]

Undo the pending changes to the backend and restore the original state

ObjectAdmin.set_defaults(object_instance, include_nullable_fields=True)[source]

Set the defaults of an object :param include_nullable_fields: also set defaults for nullable fields, depending on the context, this should be set to False to allow the user to set the field to None

ObjectAdmin.validator

alias of ObjectValidator

Previous topic

not_editable_admin

Next topic

section

This Page


Comments
blog comments powered by Disqus