model Package — Camelot documentation

### Navigation

- index
- modules |
- Camelot documentation »

# model Package

## `model` Package

## `authentication` Module

class `camelot.model.authentication.` `Address`(**kwargs)

  Bases: `elixir.entity.Entity`

  The Address to be given to a Party (a Person or an Organization)

  Fields :

  > - city : refers to City
  > - street1 : VARCHAR(128), required
  > - street2 : VARCHAR(128), not required

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'street1': {'minimal_column_width': 30}}
    `form_actions` = [('Show on map', <function <lambda> at 0xb116bc4>)]
    `form_size` = (700, 150)
    `list_display` = ['street1', 'street2', 'city']
    `verbose_name` = _('Address')
    `verbose_name_plural` = _('Addresses')
  `Address.` `city` = Property(city, <class 'camelot.model.authentication.Address'>)
  classmethod `Address.` `getOrCreate`(street1, street2, city)
  `Address.` `mapper` = None
  `Address.` `name` = Property(name, <class 'camelot.model.authentication.Address'>)
  `Address.` `showMap`()
  `Address.` `street1` = Property(street1, <class 'camelot.model.authentication.Address'>)
  `Address.` `street2` = Property(street2, <class 'camelot.model.authentication.Address'>)
  `Address.` `table` = None

class `camelot.model.authentication.` `AddressAdmin`(app_admin, entity)

  Bases: `camelot.admin.entity_admin.EntityAdmin`

  Admin with only the Address information and not the Party information

  `field_attributes` = {'address_street1': {'editable': True, 'name': _('Street'), 'nullable': False}, 'address_city': {'delegate': <class 'camelot.view.controls.delegates.many2onedelegate.Many2OneDelegate'>, 'editable': True, 'target': <class 'camelot.model.authentication.City'>, 'name': _('City'), 'nullable': False}, 'address_street2': {'editable': True, 'name': _('Street Extra')}}
  `flush`(party_address)
  `form_display` = ['address_street1', 'address_street2', 'address_city', 'comment', 'from_date', 'thru_date']
  `list_display` = ['address_street1', 'address_city', 'comment']
  `refresh`(party_address)
  `verbose_name` = _('Address')

class `camelot.model.authentication.` `AuthenticationMechanism`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `list_display` = ['last_login', 'is_active']
    `verbose_name` = _('Authentication mechanism')
  `AuthenticationMechanism.` `is_active` = Property(is_active, <class 'camelot.model.authentication.AuthenticationMechanism'>)
  `AuthenticationMechanism.` `last_login` = Property(last_login, <class 'camelot.model.authentication.AuthenticationMechanism'>)
  `AuthenticationMechanism.` `mapper` = None
  `AuthenticationMechanism.` `table` = None

class `camelot.model.authentication.` `City`(**kwargs)

  Bases: `camelot.model.authentication.GeographicBoundary`

  A subclass of GeographicBoundary used to store the name, the postal code
    and the Country of a city

  Fields :

  > - country : refers to Country

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `form_size` = (700, 150)
    `list_display` = ['code', 'name', 'country']
    `verbose_name` = _('City')
    `verbose_name_plural` = _('Cities')
  `City.` `country` = Property(country, <class 'camelot.model.authentication.City'>)
  classmethod `City.` `getOrCreate`(country, code, name)
  `City.` `mapper` = None
  `City.` `table` = None

class `camelot.model.authentication.` `ContactMechanism`(**kwargs)

  Bases: `elixir.entity.Entity`

  Fields :

  > - party_contact_mechanisms : refers to PartyContactMechanism
  > - mechanism : VARCHAR(256), required
  > - party_address : refers to PartyAddress

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'mechanism': {'minimal_column_width': 25}}
    `form_display` = ['mechanism', 'party_address']
    `form_size` = (700, 150)
    `get_depending_objects`(contact_mechanism)
    `list_display` = ['mechanism']
    `verbose_name` = _('Contact mechanism')
  `ContactMechanism.` `mapper` = None
  `ContactMechanism.` `mechanism` = Property(mechanism, <class 'camelot.model.authentication.ContactMechanism'>)
  `ContactMechanism.` `party_address` = Property(party_address, <class 'camelot.model.authentication.ContactMechanism'>)
  `ContactMechanism.` `party_contact_mechanisms` = Property(party_contact_mechanisms, <class 'camelot.model.authentication.ContactMechanism'>)
  `ContactMechanism.` `table` = None

class `camelot.model.authentication.` `Country`(**kwargs)

  Bases: `camelot.model.authentication.GeographicBoundary`

  A subclass of GeographicBoundary used to store the name and the
    ISO code of a country

  Fields :

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `form_size` = (700, 150)
    `list_display` = ['name', 'code']
    `verbose_name` = _('Country')
    `verbose_name_plural` = _('Countries')
  classmethod `Country.` `getOrCreate`(code, name)
  `Country.` `mapper` = None
  `Country.` `table` = None

class `camelot.model.authentication.` `DirectedDirector`(**kwargs)

  Bases: `camelot.model.authentication.PartyRelationship`

  Relation from a directed organization to a director

  class `Admin`(app_admin, entity)

    Bases: `camelot.model.authentication.Admin`

    `field_attributes` = {'established_to': {'name': _('Director')}, 'established_from': {'name': _('Organization')}}
    `list_display` = ['established_from', 'established_to', 'title', 'represented_by']
    `list_search` = ['established_from.full_name', 'established_to.full_name']
    `verbose_name` = _('Direction structure')
    `verbose_name_plural` = _('Direction structures')
  class `DirectedDirector.` `DirectedAdmin`(app_admin, entity)

    Bases: `camelot.model.authentication.Admin`

    `form_display` = ['established_from', 'title', 'from_date', 'thru_date', 'represented_by', 'comment']
    `list_display` = ['established_from', 'title', 'from_date', 'thru_date']
    `verbose_name` = _('Directed organization')
  class `DirectedDirector.` `DirectorAdmin`(app_admin, entity)

    Bases: `camelot.model.authentication.Admin`

    `form_display` = ['established_to', 'title', 'from_date', 'thru_date', 'represented_by', 'comment']
    `list_display` = ['established_to', 'title', 'from_date', 'thru_date']
    `verbose_name` = _('Director')
  `DirectedDirector.` `established_from` = Property(established_from, <class 'camelot.model.authentication.DirectedDirector'>)
  `DirectedDirector.` `established_to` = Property(established_to, <class 'camelot.model.authentication.DirectedDirector'>)
  `DirectedDirector.` `mapper` = None
  `DirectedDirector.` `represented_by` = Property(represented_by, <class 'camelot.model.authentication.DirectedDirector'>)
  `DirectedDirector.` `table` = None
  `DirectedDirector.` `title` = Property(title, <class 'camelot.model.authentication.DirectedDirector'>)

class `camelot.model.authentication.` `EmployerEmployee`(**kwargs)

  Bases: `camelot.model.authentication.PartyRelationship`

  Relation from employer to employee

  class `Admin`(app_admin, entity)

    Bases: `camelot.model.authentication.Admin`

    `list_filter` = ['established_from.name']
    `list_search` = ['established_from.name', 'established_to.first_name', 'established_to.last_name']
    `verbose_name` = _('Employment relation')
    `verbose_name_plural` = _('Employment relations')
  class `EmployerEmployee.` `EmployeeAdmin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'established_to': {'name': _('Name')}}
    `form_display` = ['established_to', 'comment', 'from_date', 'thru_date']
    `list_display` = ['established_to', 'from_date', 'thru_date']
    `verbose_name` = _('Employee')
  class `EmployerEmployee.` `EmployerAdmin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'established_from': {'name': _('Name')}}
    `form_display` = ['established_from', 'comment', 'from_date', 'thru_date']
    `list_display` = ['established_from', 'from_date', 'thru_date']
    `verbose_name` = _('Employer')
  `EmployerEmployee.` `established_from` = Property(established_from, <class 'camelot.model.authentication.EmployerEmployee'>)
  `EmployerEmployee.` `established_to` = Property(established_to, <class 'camelot.model.authentication.EmployerEmployee'>)
  `EmployerEmployee.` `first_name` = Property(first_name, <class 'camelot.model.authentication.EmployerEmployee'>)
  `EmployerEmployee.` `last_name` = Property(last_name, <class 'camelot.model.authentication.EmployerEmployee'>)
  `EmployerEmployee.` `mapper` = None
  `EmployerEmployee.` `social_security_number` = Property(social_security_number, <class 'camelot.model.authentication.EmployerEmployee'>)
  `EmployerEmployee.` `table` = None

class `camelot.model.authentication.` `GeographicBoundary`(**kwargs)

  Bases: `elixir.entity.Entity`

  The base class for Country and City

  `code` = Property(code, <class 'camelot.model.authentication.GeographicBoundary'>)
  `full_name` = Property(full_name, <class 'camelot.model.authentication.GeographicBoundary'>)
  `mapper` = None
  `name` = Property(name, <class 'camelot.model.authentication.GeographicBoundary'>)
  `table` = None

class `camelot.model.authentication.` `Organization`(**kwargs)

  Bases: `camelot.model.authentication.Party`

  An organization represents any internal or external organization. Organizations can include
    businesses and groups of individuals

  Fields :

  > - name : VARCHAR(50), required
  > - employees : refers to EmployerEmployee
  > - shareholders : refers to SharedShareholder
  > - directors : refers to DirectedDirector
  > - customers : refers to SupplierCustomer
  > - tax_id : VARCHAR(20), not required
  > - logo : VARCHAR(100), not required
  > - suppliers : refers to SupplierCustomer

  class `Admin`(app_admin, entity)

    Bases: `camelot.model.authentication.Admin`

    `form_display` = ['name', 'tax_id', 'addresses', 'contact_mechanisms', 'employees', 'customers', 'suppliers', 'directors', 'shareholders', 'shares', 'logo', 'categories', 'status']
    `list_display` = ['name', 'tax_id', 'contact_mechanisms_email', 'contact_mechanisms_phone']
    `verbose_name` = _('Organization')
    `verbose_name_plural` = _('Organizations')
  `Organization.` `customers` = Property(customers, <class 'camelot.model.authentication.Organization'>)
  `Organization.` `directors` = Property(directors, <class 'camelot.model.authentication.Organization'>)
  `Organization.` `employees` = Property(employees, <class 'camelot.model.authentication.Organization'>)
  `Organization.` `logo` = Property(logo, <class 'camelot.model.authentication.Organization'>)
  `Organization.` `mapper` = None
  `Organization.` `name` = Property(name, <class 'camelot.model.authentication.Organization'>)
  `Organization.` `number_of_shares_issued`
  `Organization.` `shareholders` = Property(shareholders, <class 'camelot.model.authentication.Organization'>)
  `Organization.` `suppliers` = Property(suppliers, <class 'camelot.model.authentication.Organization'>)
  `Organization.` `table` = None
  `Organization.` `tax_id` = Property(tax_id, <class 'camelot.model.authentication.Organization'>)

class `camelot.model.authentication.` `Party`(**kwargs)

  Bases: `elixir.entity.Entity`

  Base class for persons and organizations. Use this base class to refer to either persons or organisations in building authentication systems, contact management or CRM

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'customers': {'admin': <class 'camelot.model.authentication.CustomerAdmin'>}, 'addresses': {'admin': <class 'camelot.model.authentication.AddressAdmin'>}, 'contact_mechanisms_fax': {'from_string': <function <lambda> at 0xb1168b4>, 'minimal_column_width': 20, 'name': _('Fax'), 'address_type': 'fax', 'editable': True, 'delegate': <class 'camelot.view.controls.delegates.virtualaddressdelegate.VirtualAddressDelegate'>}, 'sex': {'choices': [(u'M', _('male')), (u'F', _('female'))]}, 'phone': {'minimal_column_width': 20, 'editable': False}, 'contact_mechanisms': {'admin': <class 'camelot.model.authentication.PartyPartyContactMechanismAdmin'>}, 'employers': {'admin': <class 'camelot.model.authentication.EmployerAdmin'>}, 'contact_mechanisms_email': {'from_string': <function <lambda> at 0xb116844>, 'minimal_column_width': 20, 'name': _('Email'), 'address_type': 'email', 'editable': True, 'delegate': <class 'camelot.view.controls.delegates.virtualaddressdelegate.VirtualAddressDelegate'>}, 'shareholders': {'admin': <class 'camelot.model.authentication.ShareholderAdmin'>}, 'name': {'minimal_column_width': 50}, 'contact_mechanisms_phone': {'from_string': <function <lambda> at 0xb11687c>, 'minimal_column_width': 20, 'name': _('Phone'), 'address_type': 'phone', 'editable': True, 'delegate': <class 'camelot.view.controls.delegates.virtualaddressdelegate.VirtualAddressDelegate'>}, 'employees': {'admin': <class 'camelot.model.authentication.EmployeeAdmin'>}, 'shares': {'admin': <class 'camelot.model.authentication.SharedAdmin'>}, 'email': {'minimal_column_width': 20, 'editable': False}, 'directors': {'admin': <class 'camelot.model.authentication.DirectorAdmin'>}, 'suppliers': {'admin': <class 'camelot.model.authentication.SupplierAdmin'>}, 'directed_organizations': {'admin': <class 'camelot.model.authentication.DirectedAdmin'>}}
    `flush`(party)
    `form_display` = ['addresses', 'contact_mechanisms', 'shares', 'directed_organizations']
    `list_display` = ['name', 'contact_mechanisms_email', 'contact_mechanisms_phone']
    `list_filter` = ['categories.name']
    `list_search` = ['full_name']
    `verbose_name` = _('Party')
    `verbose_name_plural` = _('Parties')
  `Party.` `addresses` = Property(addresses, <class 'camelot.model.authentication.Party'>)
  `Party.` `categories` = Property(categories, <class 'camelot.model.authentication.Party'>)
  `Party.` `contact_mechanisms` = Property(contact_mechanisms, <class 'camelot.model.authentication.Party'>)
  `Party.` `contact_mechanisms_email`
  `Party.` `contact_mechanisms_fax`
  `Party.` `contact_mechanisms_phone`
  `Party.` `directed_organizations` = Property(directed_organizations, <class 'camelot.model.authentication.Party'>)
  `Party.` `email` = Property(email, <class 'camelot.model.authentication.Party'>)
  `Party.` `fax` = Property(fax, <class 'camelot.model.authentication.Party'>)
  `Party.` `full_name` = Property(full_name, <class 'camelot.model.authentication.Party'>)
  `Party.` `mapper` = None
  `Party.` `name`
  `Party.` `phone` = Property(phone, <class 'camelot.model.authentication.Party'>)
  `Party.` `shares` = Property(shares, <class 'camelot.model.authentication.Party'>)
  `Party.` `status` = Property(status, <class 'camelot.model.authentication.Party'>)
  `Party.` `table` = None

class `camelot.model.authentication.` `PartyAddress`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'party_name': {'minimal_column_width': 30, 'editable': False, 'name': 'Party'}, 'address_name': {'minimal_column_width': 30, 'editable': False, 'name': 'Address'}, 'address': {'embedded': True}}
    `form_actions` = [('Show on map', <function <lambda> at 0xb116d84>)]
    `form_display` = ['party', 'address', 'comment', 'from_date', 'thru_date']
    `form_size` = (700, 200)
    `list_display` = ['party_name', 'address_name', 'comment']
    `list_search` = ['party_name', 'address_name']
    `verbose_name` = _('Address')
    `verbose_name_plural` = _('Addresses')
  `PartyAddress.` `address` = Property(address, <class 'camelot.model.authentication.PartyAddress'>)
  `PartyAddress.` `address_name` = Property(address_name, <class 'camelot.model.authentication.PartyAddress'>)
  `PartyAddress.` `comment` = Property(comment, <class 'camelot.model.authentication.PartyAddress'>)
  `PartyAddress.` `from_date` = Property(from_date, <class 'camelot.model.authentication.PartyAddress'>)
  `PartyAddress.` `mapper` = None
  `PartyAddress.` `party` = Property(party, <class 'camelot.model.authentication.PartyAddress'>)
  `PartyAddress.` `party_name` = Property(party_name, <class 'camelot.model.authentication.PartyAddress'>)
  `PartyAddress.` `showMap`()
  `PartyAddress.` `table` = None
  `PartyAddress.` `thru_date` = Property(thru_date, <class 'camelot.model.authentication.PartyAddress'>)

class `camelot.model.authentication.` `PartyAddressRoleType`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `list_display` = ['code', 'description']
    `verbose_name` = _('Address role type')
  `PartyAddressRoleType.` `code` = Property(code, <class 'camelot.model.authentication.PartyAddressRoleType'>)
  `PartyAddressRoleType.` `description` = Property(description, <class 'camelot.model.authentication.PartyAddressRoleType'>)
  `PartyAddressRoleType.` `mapper` = None
  `PartyAddressRoleType.` `table` = None

class `camelot.model.authentication.` `PartyAuthentication`(**kwargs)

  Bases: `elixir.entity.Entity`

  `address` = Property(address, <class 'camelot.model.authentication.PartyAuthentication'>)
  `comment` = Property(comment, <class 'camelot.model.authentication.PartyAuthentication'>)
  `from_date` = Property(from_date, <class 'camelot.model.authentication.PartyAuthentication'>)
  `mapper` = None
  `table` = None
  `thru_date` = Property(thru_date, <class 'camelot.model.authentication.PartyAuthentication'>)

class `camelot.model.authentication.` `PartyCategory`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `list_display` = ['name', 'color']
    `verbose_name` = _('Category')
    `verbose_name_plural` = _('Categories')
  `PartyCategory.` `color` = Property(color, <class 'camelot.model.authentication.PartyCategory'>)
  `PartyCategory.` `get_contact_mechanisms`(virtual_address_type)

    Function to be used to do messaging

    Parameters: | virtual_address_type – a virtual address type, such as ‘phone’ or ‘email’
    Returns: | a generator that yields strings of contact mechanisms, egg 'info@example.com‘

  `PartyCategory.` `mapper` = None
  `PartyCategory.` `name` = Property(name, <class 'camelot.model.authentication.PartyCategory'>)
  `PartyCategory.` `parent` = Property(parent, <class 'camelot.model.authentication.PartyCategory'>)
  `PartyCategory.` `parties` = Property(parties, <class 'camelot.model.authentication.PartyCategory'>)
  `PartyCategory.` `table` = None

class `camelot.model.authentication.` `PartyContactMechanism`(**kwargs)

  Bases: `elixir.entity.Entity`

  `Admin`

    alias of `PartyContactMechanismAdmin`

  `comment` = Property(comment, <class 'camelot.model.authentication.PartyContactMechanism'>)
  `contact_mechanism` = Property(contact_mechanism, <class 'camelot.model.authentication.PartyContactMechanism'>)
  `contact_mechanism_mechanism`
  `from_date` = Property(from_date, <class 'camelot.model.authentication.PartyContactMechanism'>)
  `mapper` = None
  `mechanism` = Property(mechanism, <class 'camelot.model.authentication.PartyContactMechanism'>)
  `party` = Property(party, <class 'camelot.model.authentication.PartyContactMechanism'>)
  `party_name` = Property(party_name, <class 'camelot.model.authentication.PartyContactMechanism'>)
  `table` = None
  `thru_date` = Property(thru_date, <class 'camelot.model.authentication.PartyContactMechanism'>)

class `camelot.model.authentication.` `PartyContactMechanismAdmin`(app_admin, entity)

  Bases: `camelot.admin.entity_admin.EntityAdmin`

  `field_attributes` = {'contact_mechanism_mechanism': {'delegate': <class 'camelot.view.controls.delegates.virtualaddressdelegate.VirtualAddressDelegate'>, 'minimal_column_width': 25, 'editable': True, 'name': _('Mechanism'), 'nullable': False}, 'party_name': {'minimal_column_width': 25, 'editable': False}, 'mechanism': {'minimal_column_width': 25, 'editable': False}}
  `flush`(party_contact_mechanism)
  `form_display` = ['contact_mechanism_mechanism', 'comment', 'from_date', 'thru_date']
  `form_size` = (700, 200)
  `get_depending_objects`(contact_mechanism)
  `list_display` = ['party_name', 'contact_mechanism_mechanism', 'comment', 'from_date']
  `list_search` = ['party_name', 'mechanism']
  `refresh`(party_contact_mechanism)
  `verbose_name` = _('Contact mechanism')
  `verbose_name_plural` = _('Contact mechanisms')

class `camelot.model.authentication.` `PartyPartyContactMechanismAdmin`(app_admin, entity)

  Bases: `camelot.model.authentication.PartyContactMechanismAdmin`

  `list_display` = ['contact_mechanism_mechanism', 'comment', 'from_date']
  `list_search` = ['party_name', 'mechanism']

class `camelot.model.authentication.` `PartyRelationship`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `list_display` = ['established_from', 'established_to', 'from_date', 'thru_date']
    `verbose_name` = _('Relationship')
    `verbose_name_plural` = _('Relationships')
  `PartyRelationship.` `comment` = Property(comment, <class 'camelot.model.authentication.PartyRelationship'>)
  `PartyRelationship.` `from_date` = Property(from_date, <class 'camelot.model.authentication.PartyRelationship'>)
  `PartyRelationship.` `mapper` = None
  `PartyRelationship.` `table` = None
  `PartyRelationship.` `thru_date` = Property(thru_date, <class 'camelot.model.authentication.PartyRelationship'>)

class `camelot.model.authentication.` `Person`(**kwargs)

  Bases: `camelot.model.authentication.Party`

  Person represents natural persons

  Fields :

  > - comment : TEXT, not required
  > - picture : VARCHAR(100), not required
  > - last_name : VARCHAR(40), required
  > - suffix : VARCHAR(3), not required
  > - first_name : VARCHAR(40), required
  > - sex : VARCHAR(1), not required
  > - is_staff : <class ‘sqlalchemy.types.Boolean’>, not required
  > - social_security_number : VARCHAR(12), not required
  > - employers : refers to EmployerEmployee
  > - middle_name : VARCHAR(40), not required
  > - passport_number : VARCHAR(20), not required
  > - birthdate : DATE, not required
  > - is_superuser : <class ‘sqlalchemy.types.Boolean’>, not required
  > - passport_expiry_date : DATE, not required
  > - personal_title : VARCHAR(10), not required
  > - martial_status : VARCHAR(1), not required

  class `Admin`(app_admin, entity)

    Bases: `camelot.model.authentication.Admin`

    `field_attributes` = {'customers': {'admin': <class 'camelot.model.authentication.CustomerAdmin'>}, 'addresses': {'admin': <class 'camelot.model.authentication.AddressAdmin'>}, 'contact_mechanisms_fax': {'from_string': <function <lambda> at 0xb1168b4>, 'minimal_column_width': 20, 'name': _('Fax'), 'address_type': 'fax', 'editable': True, 'delegate': <class 'camelot.view.controls.delegates.virtualaddressdelegate.VirtualAddressDelegate'>}, 'sex': {'choices': [(u'M', _('male')), (u'F', _('female'))]}, 'phone': {'minimal_column_width': 20, 'editable': False}, 'contact_mechanisms': {'admin': <class 'camelot.model.authentication.PartyPartyContactMechanismAdmin'>}, 'employers': {'admin': <class 'camelot.model.authentication.EmployerAdmin'>}, 'contact_mechanisms_email': {'from_string': <function <lambda> at 0xb116844>, 'minimal_column_width': 20, 'name': _('Email'), 'address_type': 'email', 'editable': True, 'delegate': <class 'camelot.view.controls.delegates.virtualaddressdelegate.VirtualAddressDelegate'>}, 'shareholders': {'admin': <class 'camelot.model.authentication.ShareholderAdmin'>}, 'name': {'minimal_column_width': 50}, 'contact_mechanisms_phone': {'from_string': <function <lambda> at 0xb11687c>, 'minimal_column_width': 20, 'name': _('Phone'), 'address_type': 'phone', 'editable': True, 'delegate': <class 'camelot.view.controls.delegates.virtualaddressdelegate.VirtualAddressDelegate'>}, 'employees': {'admin': <class 'camelot.model.authentication.EmployeeAdmin'>}, 'shares': {'admin': <class 'camelot.model.authentication.SharedAdmin'>}, 'note': {'delegate': <class 'camelot.view.controls.delegates.notedelegate.NoteDelegate'>}, 'directors': {'admin': <class 'camelot.model.authentication.DirectorAdmin'>}, 'suppliers': {'admin': <class 'camelot.model.authentication.SupplierAdmin'>}, 'email': {'minimal_column_width': 20, 'editable': False}, 'directed_organizations': {'admin': <class 'camelot.model.authentication.DirectedAdmin'>}}
    `form_display` = ['note', 'first_name', 'last_name', 'sex', 'contact_mechanisms_email', 'contact_mechanisms_phone', 'contact_mechanisms_fax', 'picture', 'comment', 'birthdate', 'social_security_number', 'passport_number', 'passport_expiry_date', 'addresses', 'contact_mechanisms', 'employers', 'directed_organizations', 'shares', 'categories']
    `list_display` = ['first_name', 'last_name', 'contact_mechanisms_email', 'contact_mechanisms_phone']
    `verbose_name` = _('Person')
    `verbose_name_plural` = _('Persons')
  `Person.` `birthdate` = Property(birthdate, <class 'camelot.model.authentication.Person'>)
  `Person.` `comment` = Property(comment, <class 'camelot.model.authentication.Person'>)
  `Person.` `employers` = Property(employers, <class 'camelot.model.authentication.Person'>)
  `Person.` `first_name` = Property(first_name, <class 'camelot.model.authentication.Person'>)
  `Person.` `is_staff` = Property(is_staff, <class 'camelot.model.authentication.Person'>)
  `Person.` `is_superuser` = Property(is_superuser, <class 'camelot.model.authentication.Person'>)
  `Person.` `last_name` = Property(last_name, <class 'camelot.model.authentication.Person'>)
  `Person.` `mapper` = None
  `Person.` `martial_status` = Property(martial_status, <class 'camelot.model.authentication.Person'>)
  `Person.` `middle_name` = Property(middle_name, <class 'camelot.model.authentication.Person'>)
  `Person.` `name`
  `Person.` `note`
  `Person.` `passport_expiry_date` = Property(passport_expiry_date, <class 'camelot.model.authentication.Person'>)
  `Person.` `passport_number` = Property(passport_number, <class 'camelot.model.authentication.Person'>)
  `Person.` `personal_title` = Property(personal_title, <class 'camelot.model.authentication.Person'>)
  `Person.` `picture` = Property(picture, <class 'camelot.model.authentication.Person'>)
  `Person.` `sex` = Property(sex, <class 'camelot.model.authentication.Person'>)
  `Person.` `social_security_number` = Property(social_security_number, <class 'camelot.model.authentication.Person'>)
  `Person.` `suffix` = Property(suffix, <class 'camelot.model.authentication.Person'>)
  `Person.` `table` = None

class `camelot.model.authentication.` `RepresentedRepresentor`(**kwargs)

  Bases: `elixir.entity.Entity`

  Relation from a representing party to the person representing the party

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'established_from': {'name': _('Name')}}
    `form_display` = ['established_from', 'from_date', 'thru_date', 'comment']
    `list_display` = ['established_from', 'from_date', 'thru_date']
    `verbose_name` = _('Represented by')
  `RepresentedRepresentor.` `comment` = Property(comment, <class 'camelot.model.authentication.RepresentedRepresentor'>)
  `RepresentedRepresentor.` `established_from` = Property(established_from, <class 'camelot.model.authentication.RepresentedRepresentor'>)
  `RepresentedRepresentor.` `established_to` = Property(established_to, <class 'camelot.model.authentication.RepresentedRepresentor'>)
  `RepresentedRepresentor.` `from_date` = Property(from_date, <class 'camelot.model.authentication.RepresentedRepresentor'>)
  `RepresentedRepresentor.` `mapper` = None
  `RepresentedRepresentor.` `table` = None
  `RepresentedRepresentor.` `thru_date` = Property(thru_date, <class 'camelot.model.authentication.RepresentedRepresentor'>)

class `camelot.model.authentication.` `SharedShareholder`(**kwargs)

  Bases: `camelot.model.authentication.PartyRelationship`

  Relation from a shared organization to a shareholder

  class `Admin`(app_admin, entity)

    Bases: `camelot.model.authentication.Admin`

    `field_attributes` = {'established_to': {'name': _('Shareholder')}, 'established_from': {'name': _('Organization')}}
    `list_display` = ['established_from', 'established_to', 'shares']
    `list_search` = ['established_from.full_name', 'established_to.full_name']
    `verbose_name` = _('Shareholder structure')
    `verbose_name_plural` = _('Shareholder structures')
  class `SharedShareholder.` `SharedAdmin`(app_admin, entity)

    Bases: `camelot.model.authentication.Admin`

    `form_display` = ['established_from', 'shares', 'from_date', 'thru_date', 'comment']
    `form_size` = (500, 300)
    `list_display` = ['established_from', 'shares', 'from_date', 'thru_date']
    `verbose_name` = _('Shares')
    `verbose_name_plural` = _('Shares')
  class `SharedShareholder.` `ShareholderAdmin`(app_admin, entity)

    Bases: `camelot.model.authentication.Admin`

    `form_display` = ['established_to', 'shares', 'from_date', 'thru_date', 'comment']
    `form_size` = (500, 300)
    `list_display` = ['established_to', 'shares', 'from_date', 'thru_date']
    `verbose_name` = _('Shareholder')
  `SharedShareholder.` `established_from` = Property(established_from, <class 'camelot.model.authentication.SharedShareholder'>)
  `SharedShareholder.` `established_to` = Property(established_to, <class 'camelot.model.authentication.SharedShareholder'>)
  `SharedShareholder.` `mapper` = None
  `SharedShareholder.` `shares` = Property(shares, <class 'camelot.model.authentication.SharedShareholder'>)
  `SharedShareholder.` `table` = None

class `camelot.model.authentication.` `SupplierCustomer`(**kwargs)

  Bases: `camelot.model.authentication.PartyRelationship`

  Relation from supplier to customer

  class `Admin`(app_admin, entity)

    Bases: `camelot.model.authentication.Admin`

    `list_display` = ['established_from', 'established_to', 'from_date', 'thru_date']
    `verbose_name` = _('Supplier - Customer')
  class `SupplierCustomer.` `CustomerAdmin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'established_to': {'name': _('Name')}}
    `form_display` = ['established_to', 'comment', 'from_date', 'thru_date']
    `list_display` = ['established_to']
    `verbose_name` = _('Customer')
  class `SupplierCustomer.` `SupplierAdmin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'established_from': {'name': _('Name')}}
    `form_display` = ['established_from', 'comment', 'from_date', 'thru_date']
    `list_display` = ['established_from']
    `verbose_name` = _('Supplier')
  `SupplierCustomer.` `established_from` = Property(established_from, <class 'camelot.model.authentication.SupplierCustomer'>)
  `SupplierCustomer.` `established_to` = Property(established_to, <class 'camelot.model.authentication.SupplierCustomer'>)
  `SupplierCustomer.` `mapper` = None
  `SupplierCustomer.` `table` = None

class `camelot.model.authentication.` `UsernameAuthenticationMechanism`(**kwargs)

  Bases: `camelot.model.authentication.AuthenticationMechanism`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `list_display` = ['username', 'last_login', 'is_active']
    `verbose_name` = _('Authentication mechanism')
  classmethod `UsernameAuthenticationMechanism.` `getOrCreateAuthentication`(username)
  `UsernameAuthenticationMechanism.` `mapper` = None
  `UsernameAuthenticationMechanism.` `password` = Property(password, <class 'camelot.model.authentication.UsernameAuthenticationMechanism'>)
  `UsernameAuthenticationMechanism.` `table` = None
  `UsernameAuthenticationMechanism.` `username` = Property(username, <class 'camelot.model.authentication.UsernameAuthenticationMechanism'>)

`camelot.model.authentication.` `clear_current_authentication`()

`camelot.model.authentication.` `end_of_times`()

`camelot.model.authentication.` `getCurrentAuthentication`(_obj=None)

  Get the currently logged in person

`camelot.model.authentication.` `updateLastLogin`()

  Update the last login of the current person to now

## `batch_job` Module

Most applications need to perform some scheduled jobs to process information. Users need to be able to monitor the functioning of those scheduled jobs.

These classes provide the means to store the result of batch jobs to enable the user to review or plan them.

class `camelot.model.batch_job.` `BatchJob`(**kwargs)

  Bases: `elixir.entity.Entity`

  Information the batch job that is planned, running or has run

  Fields :

  > - status : INTEGER, required
  > - host : VARCHAR(256), required
  > - date : <class ‘sqlalchemy.types.DateTime’>, required
  > - message : TEXT, not required
  > - type : refers to BatchJobType

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `form_actions` = [<camelot.model.batch_job.CancelBatchJob object at 0xb18390c>]
    `form_display` = ['date', 'host', 'type', 'status', 'message']
    `list_display` = ['date', 'host', 'type', 'status']
    `list_filter` = ['status', <camelot.view.filters.ComboBoxFilter object at 0xb18388c>]
    `verbose_name` = _('Batch job')
  `BatchJob.` `add_exception_to_message`(exception)

    If an exception occurs in a batch job, this method can be used to add the stack trace of the exception to the message

  `BatchJob.` `add_strings_to_message`(strings)

    Parameters: | strings – a list or generator of strings

  `BatchJob.` `date` = Property(date, <class 'camelot.model.batch_job.BatchJob'>)
  `BatchJob.` `host` = Property(host, <class 'camelot.model.batch_job.BatchJob'>)
  `BatchJob.` `is_canceled`()

    Verifies if this Batch Job is canceled. Returns `True` if it is. This verification is done without using the ORM, so the verification has no impact on the current session or the objects itself. This method is thus suited to call inside a running batch job to verifiy if another user has canceled the running job.

    Returns: | `True` or `False`

  `BatchJob.` `mapper` = None
  `BatchJob.` `message` = Property(message, <class 'camelot.model.batch_job.BatchJob'>)
  `BatchJob.` `status` = Property(status, <class 'camelot.model.batch_job.BatchJob'>)
  `BatchJob.` `table` = None
  `BatchJob.` `type` = Property(type, <class 'camelot.model.batch_job.BatchJob'>)

class `camelot.model.batch_job.` `BatchJobType`(**kwargs)

  Bases: `elixir.entity.Entity`

  The type of batch job, the user will be able to filter his
    jobs based on their type. A type might be ‘Create management reports’

  Fields :

  > - name : VARCHAR(256), required
  > - parent : refers to BatchJobType

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `list_display` = ['name', 'parent']
    `verbose_name` = _('Batch job type')
  classmethod `BatchJobType.` `get_or_create`(name)
  `BatchJobType.` `mapper` = None
  `BatchJobType.` `name` = Property(name, <class 'camelot.model.batch_job.BatchJobType'>)
  `BatchJobType.` `parent` = Property(parent, <class 'camelot.model.batch_job.BatchJobType'>)
  `BatchJobType.` `table` = None

class `camelot.model.batch_job.` `CancelBatchJob`

  Bases: `camelot.admin.action.base.Action`

  `model_run`(model_context)

`camelot.model.batch_job.` `hostname`()

## `fixture` Module

class `camelot.model.fixture.` `Fixture`(**kwargs)

  Bases: `elixir.entity.Entity`

  Keep track of static data loaded into the database

  classmethod `findFixture`(entity, fixture_key, fixture_class=None)

    Find a registered fixture, return None if no fixture is found

  classmethod `findFixtureKey`(entity, primary_key)

    Find the fixture key for an object of type entity with primary key :return: fixture_key

  classmethod `findFixtureKeyAndClass`(obj)

    Find the fixture key and class of an object @param obj: the object we are looking for @return: (fixture_key, fixture_class) if the object is a registered fixture, (None, None) otherwise

  classmethod `findFixtureKeysAndClasses`(entity)

    Load all fixture keys of a certain entity in batch :param entity: the model class for which the fixtures should be found :return: a dictionary mapping the primary key of a on object of type entity to its (fixture key, fixture class)

  classmethod `findFixtureReference`(entity, fixture_key, fixture_class=None)
  `fixture_class` = Property(fixture_class, <class 'camelot.model.fixture.Fixture'>)
  `fixture_key` = Property(fixture_key, <class 'camelot.model.fixture.Fixture'>)
  classmethod `insertOrUpdateFixture`(entity, fixture_key, values, fixture_class=None)
  `mapper` = None
  `model` = Property(model, <class 'camelot.model.fixture.Fixture'>)
  `primary_key` = Property(primary_key, <class 'camelot.model.fixture.Fixture'>)
  classmethod `removeAllFixtures`(entity)
  classmethod `removeFixture`(entity, fixture_key, fixture_class)

    Remove a fixture from the database

  `table` = None

class `camelot.model.fixture.` `FixtureVersion`(**kwargs)

  Bases: `elixir.entity.Entity`

  Keep track of the version the fixtures have in the current database, the subversion revision number is a good candidate to be used as a fixture version.

  Returns: | an integer representing the current version, 0 if no version found

  `fixture_class` = Property(fixture_class, <class 'camelot.model.fixture.FixtureVersion'>)
  `fixture_version` = Property(fixture_version, <class 'camelot.model.fixture.FixtureVersion'>)
  classmethod `get_current_version`(fixture_class=None)

    Get the current version of the fixtures in the database for a certain fixture class.

    Parameters: | fixture_class – the fixture class for which to get the version

  `mapper` = None
  classmethod `set_current_version`(fixture_class=None, fixture_version=0)

    Set the current version of the fixtures in the database for a certain fixture class.

    Parameters: | fixture_class – the fixture class for which to get the version fixture_version – the version number to which to set the fixture version

  `table` = None

## `i18n` Module

class `camelot.model.i18n.` `ExportAsPO`

  Bases: `camelot.admin.action.base.Action`

  `icon` = Icon('tango/16x16/actions/document-save.png')
  `model_run`(model_context)
  `verbose_name` = _('PO Export')

class `camelot.model.i18n.` `Translation`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'language': {'default': <function default_language at 0xaff3614>}}
    `form_size` = (700, 150)
    `list_actions` = [<camelot.model.i18n.ExportAsPO object at 0xb17784c>]
    `list_display` = ['source', 'language', 'value', 'uid']
    `list_filter` = ['language']
    `section` = 'configuration'
    `verbose_name_plural` = _('Translations')
  `Translation.` `cid` = Property(cid, <class 'camelot.model.i18n.Translation'>)
  `Translation.` `language` = Property(language, <class 'camelot.model.i18n.Translation'>)
  `Translation.` `mapper` = None
  `Translation.` `source` = Property(source, <class 'camelot.model.i18n.Translation'>)
  `Translation.` `table` = None
  classmethod `Translation.` `translate`(source, language)

    Translate source to language, return None if no translation is found

  classmethod `Translation.` `translate_or_register`(source, language)

    Translate source to language, if no translation is found, register the source as to be translated and return the source

  `Translation.` `uid` = Property(uid, <class 'camelot.model.i18n.Translation'>)
  `Translation.` `value` = Property(value, <class 'camelot.model.i18n.Translation'>)

`camelot.model.i18n.` `tr`(source)

## `memento` Module

class `camelot.model.memento.` `BeforeDelete`(**kwargs)

  Bases: `camelot.model.memento.Memento`

  The state of the object before it is deleted

  class `Admin`(app_admin, entity)

    Bases: `camelot.model.memento.Admin`

    `verbose_name` = _('Delete')
    `verbose_name_plural` = _('Deletes')
  `BeforeDelete.` `description`
  `BeforeDelete.` `mapper` = None
  `BeforeDelete.` `previous_attributes` = Property(previous_attributes, <class 'camelot.model.memento.BeforeDelete'>)
  `BeforeDelete.` `table` = None

class `camelot.model.memento.` `BeforeUpdate`(**kwargs)

  Bases: `camelot.model.memento.Memento`

  The state of the object before an update took place

  class `Admin`(app_admin, entity)

    Bases: `camelot.model.memento.Admin`

    `verbose_name` = _('Update')
    `verbose_name_plural` = _('Updates')
  `BeforeUpdate.` `description`
  `BeforeUpdate.` `mapper` = None
  `BeforeUpdate.` `previous_attributes` = Property(previous_attributes, <class 'camelot.model.memento.BeforeUpdate'>)
  `BeforeUpdate.` `table` = None

class `camelot.model.memento.` `Create`(**kwargs)

  Bases: `camelot.model.memento.Memento`

  Marks the creation of an object

  class `Admin`(app_admin, entity)

    Bases: `camelot.model.memento.Admin`

    `verbose_name` = _('Create')
    `verbose_name_plural` = _('Creates')
  `Create.` `description`
  `Create.` `mapper` = None
  `Create.` `table` = None

class `camelot.model.memento.` `Memento`(**kwargs)

  Bases: `elixir.entity.Entity`

  Keeps information on the previous state of objects, to keep track of changes and enable restore to that previous state

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `list_display` = ['creation_date', 'authentication', 'model', 'primary_key', 'description']
    `list_filter` = [<camelot.view.filters.ComboBoxFilter object at 0xb17b74c>]
    `verbose_name` = _('History')
    `verbose_name_plural` = _('History')
  `Memento.` `authentication` = Property(authentication, <class 'camelot.model.memento.Memento'>)
  `Memento.` `creation_date` = Property(creation_date, <class 'camelot.model.memento.Memento'>)
  `Memento.` `description`
  `Memento.` `mapper` = None
  `Memento.` `model` = Property(model, <class 'camelot.model.memento.Memento'>)
  `Memento.` `primary_key` = Property(primary_key, <class 'camelot.model.memento.Memento'>)
  `Memento.` `table` = None

## `synchronization` Module

class `camelot.model.synchronization.` `Synchronized`(**kwargs)

  Bases: `elixir.entity.Entity`

  `database` = Property(database, <class 'camelot.model.synchronization.Synchronized'>)
  `last_update` = Property(last_update, <class 'camelot.model.synchronization.Synchronized'>)
  `mapper` = None
  `primary_key` = Property(primary_key, <class 'camelot.model.synchronization.Synchronized'>)
  `table` = None
  `tablename` = Property(tablename, <class 'camelot.model.synchronization.Synchronized'>)

## `task` Module

Most users have the need to do some basic task tracking across various parts of the data model.

These classes provide basic task tracking with configurable statuses, categories and roles. They are presented to the user as “Todo’s”

class `camelot.model.task.` `Task`(**kwargs)

  Bases: `elixir.entity.Entity`, `camelot.model.type_and_status.Type3StatusMixin`

  Fields :

  > - status : refers to Task_status
  > - due_date : <class ‘sqlalchemy.types.Date’>, not required
  > - description : VARCHAR(255), required
  > - described_by : refers to TaskType
  > - creation_date : <class ‘sqlalchemy.types.Date’>, required
  > - categories : refers to PartyCategory
  > - documents : refers to TaskDocument
  > - roles : refers to TaskRole
  > - notes : refers to TaskNote

  `Admin`

    alias of `TaskAdmin`

  `categories` = Property(categories, <class 'camelot.model.task.Task'>)
  `creation_date` = Property(creation_date, <class 'camelot.model.task.Task'>)
  `current_status_sql` = Property(current_status_sql, <class 'camelot.model.task.Task'>)
  `described_by` = Property(described_by, <class 'camelot.model.task.Task'>)
  `description` = Property(description, <class 'camelot.model.task.Task'>)
  `documents` = Property(documents, <class 'camelot.model.task.Task'>)
  `documents_icon`
  `due_date` = Property(due_date, <class 'camelot.model.task.Task'>)
  `hidden` = Property(hidden, <class 'camelot.model.task.Task'>)
  `mapper` = None
  `note`
  `notes` = Property(notes, <class 'camelot.model.task.Task'>)
  `number_of_documents` = Property(number_of_documents, <class 'camelot.model.task.Task'>)
  `role_1` = Property(role_1, <class 'camelot.model.task.Task'>)
  `role_2` = Property(role_2, <class 'camelot.model.task.Task'>)
  classmethod `role_query`(columns, role_type_rank)
  `roles` = Property(roles, <class 'camelot.model.task.Task'>)
  `status` = Property(status, <class 'camelot.model.task.Task'>)
  `table` = None

class `camelot.model.task.` `TaskAdmin`(app_admin, entity)

  Bases: `camelot.admin.entity_admin.EntityAdmin`

  `field_attributes` = {'description': {'minimal_column_width': 50}, 'described_by': {'delegate': <class 'camelot.view.controls.delegates.manytoonechoicesdelegate.ManyToOneChoicesDelegate'>, 'name': _('Type')}, 'current_status_sql': {'editable': False, 'name': 'Current status'}, 'note': {'editable': <function <lambda> at 0xb18f41c>, 'delegate': <class 'camelot.view.controls.delegates.richtextdelegate.RichTextDelegate'>}, 'role_2': {'editable': False}, 'role_1': {'editable': False}}
  `flush`(obj)

    Set the status of the agreement to draft if it has no status yet

  `form_display` = ['description', 'described_by', 'current_status', 'creation_date', 'due_date', 'note', 'categories', 'roles', 'documents', 'status']
  `form_state` = 'maximized'
  `get_field_attributes`(field_name)
  `list_display` = ['creation_date', 'due_date', 'description', 'described_by', 'current_status_sql', 'role_1', 'role_2', 'documents_icon']
  `list_filter` = [<camelot.view.filters.ComboBoxFilter object at 0xb1918ac>, <camelot.view.filters.ComboBoxFilter object at 0xb183bcc>, <camelot.view.filters.ComboBoxFilter object at 0xb183b6c>, 'hidden']
  `verbose_name` = _('Task')
  `verbose_name_plural` = _('Tasks')

class `camelot.model.task.` `TaskDocument`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'type': {'delegate': <class 'camelot.view.controls.delegates.manytoonechoicesdelegate.ManyToOneChoicesDelegate'>}, 'created_by': {'default': <function getCurrentAuthentication at 0xb111df4>}}
    `form_display` = ['document', 'description', 'type', 'created_at', 'created_by', 'summary']
    `list_display` = ['document', 'description', 'type']
    `verbose_name` = _('Document')
  `TaskDocument.` `created_at` = Property(created_at, <class 'camelot.model.task.TaskDocument'>)
  `TaskDocument.` `created_by` = Property(created_by, <class 'camelot.model.task.TaskDocument'>)
  `TaskDocument.` `description` = Property(description, <class 'camelot.model.task.TaskDocument'>)
  `TaskDocument.` `document` = Property(document, <class 'camelot.model.task.TaskDocument'>)
  `TaskDocument.` `mapper` = None
  `TaskDocument.` `of` = Property(of, <class 'camelot.model.task.TaskDocument'>)
  `TaskDocument.` `summary` = Property(summary, <class 'camelot.model.task.TaskDocument'>)
  `TaskDocument.` `table` = None
  `TaskDocument.` `type` = Property(type, <class 'camelot.model.task.TaskDocument'>)

class `camelot.model.task.` `TaskDocumentType`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `list_display` = ['description', 'rank']
    `verbose_name` = _('Document Type')
  `TaskDocumentType.` `description` = Property(description, <class 'camelot.model.task.TaskDocumentType'>)
  `TaskDocumentType.` `mapper` = None
  `TaskDocumentType.` `rank` = Property(rank, <class 'camelot.model.task.TaskDocumentType'>)
  `TaskDocumentType.` `table` = None

class `camelot.model.task.` `TaskNote`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `form_display` = ['created_at', 'created_by', 'note']
    `list_display` = ['created_at', 'created_by']
    `verbose_name` = _('Note')
  `TaskNote.` `created_at` = Property(created_at, <class 'camelot.model.task.TaskNote'>)
  `TaskNote.` `created_by` = Property(created_by, <class 'camelot.model.task.TaskNote'>)
  `TaskNote.` `mapper` = None
  `TaskNote.` `note` = Property(note, <class 'camelot.model.task.TaskNote'>)
  `TaskNote.` `of` = Property(of, <class 'camelot.model.task.TaskNote'>)
  `TaskNote.` `table` = None

class `camelot.model.task.` `TaskRole`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'described_by': {'name': _('Type'), 'delegate': <class 'camelot.view.controls.delegates.manytoonechoicesdelegate.ManyToOneChoicesDelegate'>}, 'rank': {'choices': [(1, '1'), (2, '2'), (3, '3'), (4, '4')]}}
    `i` = 4
    `list_display` = ['party', 'described_by', 'comment', 'rank']
    `verbose_name` = _('Role within task')
  `TaskRole.` `comment` = Property(comment, <class 'camelot.model.task.TaskRole'>)
  `TaskRole.` `described_by` = Property(described_by, <class 'camelot.model.task.TaskRole'>)
  `TaskRole.` `mapper` = None
  `TaskRole.` `party` = Property(party, <class 'camelot.model.task.TaskRole'>)
  `TaskRole.` `rank` = Property(rank, <class 'camelot.model.task.TaskRole'>)
  `TaskRole.` `table` = None
  `TaskRole.` `task` = Property(task, <class 'camelot.model.task.TaskRole'>)

class `camelot.model.task.` `TaskRoleType`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `list_display` = ['description', 'rank']
    `verbose_name` = _('Task Role Type')
  `TaskRoleType.` `description` = Property(description, <class 'camelot.model.task.TaskRoleType'>)
  `TaskRoleType.` `mapper` = None
  `TaskRoleType.` `rank` = Property(rank, <class 'camelot.model.task.TaskRoleType'>)
  `TaskRoleType.` `table` = None

class `camelot.model.task.` `TaskStatusTypeAdmin`(app_admin, entity)

  Bases: `camelot.model.type_and_status.Admin`

  `delete_mode` = 'on_confirm'
  `get_delete_message`(obj)

class `camelot.model.task.` `TaskStatusTypeFeature`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `field_attributes` = {'described_by': {'name': _('Feature'), 'tooltip': <function <lambda> at 0xb18f4fc>}, 'value': {'choices': <function <lambda> at 0xb18f534>}}
    `form_display` = ['described_by', 'comment', 'value', 'comment']
    `list_display` = ['described_by', 'comment', 'value']
    `verbose_name` = _('TaskStatusTypeFeature')
  `TaskStatusTypeFeature.` `comment` = Property(comment, <class 'camelot.model.task.TaskStatusTypeFeature'>)
  `TaskStatusTypeFeature.` `described_by` = Property(described_by, <class 'camelot.model.task.TaskStatusTypeFeature'>)
  `TaskStatusTypeFeature.` `mapper` = None
  `TaskStatusTypeFeature.` `table` = None
  `TaskStatusTypeFeature.` `task_status_type_id` = Property(task_status_type_id, <class 'camelot.model.task.TaskStatusTypeFeature'>)
  `TaskStatusTypeFeature.` `value` = Property(value, <class 'camelot.model.task.TaskStatusTypeFeature'>)

class `camelot.model.task.` `TaskType`(**kwargs)

  Bases: `elixir.entity.Entity`

  class `Admin`(app_admin, entity)

    Bases: `camelot.admin.entity_admin.EntityAdmin`

    `list_display` = ['description', 'rank']
    `verbose_name` = _('Task Type')
  `TaskType.` `description` = Property(description, <class 'camelot.model.task.TaskType'>)
  `TaskType.` `mapper` = None
  `TaskType.` `rank` = Property(rank, <class 'camelot.model.task.TaskType'>)
  `TaskType.` `table` = None

`camelot.model.task.` `task_has_id`(task)

## `type_and_status` Module

Created on Sep 25, 2009

@author: Erik De Rijcke

`camelot.model.type_and_status.` `create_type_3_status_mixin`(status_attribute)

  Create a class that can be subclassed to provide a class that has a type 3 status with methods to manipulate and review its status :param status_attribute: the name of the type 3 status attribute

`camelot.model.type_and_status.` `entity_type`(typable_entity, metadata, collection, verbose_entity_name=None)

  Creates a new type related to the given entity. .. typeable_entity:: A string referring to an entity.

`camelot.model.type_and_status.` `get_status_class`(cls_name)

  Parameters: | cls_name – an Entity class name
  Returns: | the status class used for this entity

`camelot.model.type_and_status.` `get_status_type_class`(cls_name)

  Parameters: | cls_name – an Entity class name
  Returns: | the status type class used for this entity

`camelot.model.type_and_status.` `type_3_status`(statusable_entity, metadata, collection, verbose_entity_name=None, enumeration=None)

  Creates a new type 3 status related to the given entity :statusable_entity: A string referring to an entity. :enumeration: if this parameter is used, no status type Entity is created, but the status type is described by the enumeration.

### Navigation

- index
- modules |
- Camelot documentation »

Comments
blog comments powered by Disqus