694 lines
34 KiB
Python
694 lines
34 KiB
Python
# ------------------------------------------------------------------------------
|
|
import re, time
|
|
from appy.shared.utils import Traceback
|
|
from appy.gen.utils import sequenceTypes, PageDescr
|
|
from appy.shared.data import countries
|
|
|
|
# Default Appy permissions -----------------------------------------------------
|
|
r, w, d = ('read', 'write', 'delete')
|
|
digit = re.compile('[0-9]')
|
|
alpha = re.compile('[a-zA-Z0-9]')
|
|
letter = re.compile('[a-zA-Z]')
|
|
|
|
# Descriptor classes used for refining descriptions of elements in types
|
|
# (pages, groups,...) ----------------------------------------------------------
|
|
class Page:
|
|
'''Used for describing a page, its related phase, show condition, etc.'''
|
|
def __init__(self, name, phase='main', show=True):
|
|
self.name = name
|
|
self.phase = phase
|
|
self.show = show
|
|
|
|
class Import:
|
|
'''Used for describing the place where to find the data to use for creating
|
|
an object.'''
|
|
def __init__(self, path, onElement=None, headers=(), sort=None):
|
|
self.id = 'import'
|
|
self.path = path
|
|
# p_onElement hereafter must be a function (or a static method) that
|
|
# will be called every time an element to import is found. It takes a
|
|
# single arg that is the absolute filen name of the file to import,
|
|
# within p_path. It must return a list of info about the element, or
|
|
# None if the element must be ignored. The list will be used to display
|
|
# information about the element in a tabular form.
|
|
self.onElement = onElement
|
|
# The following attribute must contain the names of the column headers
|
|
# of the table that will display elements to import (retrieved from
|
|
# calls to self.onElement). Every not-None element retrieved from
|
|
# self.onElement must have the same length as self.headers.
|
|
self.headers = headers
|
|
# The following attribute must store a function or static method that
|
|
# will be used to sort elements to import. It will be called with a
|
|
# single param containing the list of all not-None elements as retrieved
|
|
# by calls to self.onElement (but with one additional first element in
|
|
# every list, which is the absolute file name of the element to import)
|
|
# and must return a similar, sorted, list.
|
|
self.sort = sort
|
|
|
|
class Search:
|
|
'''Used for specifying a search for a given type.'''
|
|
def __init__(self, name, group=None, sortBy='', limit=None, **fields):
|
|
self.name = name
|
|
self.group = group # Searches may be visually grouped in the portlet
|
|
self.sortBy = sortBy
|
|
self.limit = limit
|
|
self.fields = fields # This is a dict whose keys are indexed field
|
|
# names and whose values are search values.
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class Type:
|
|
'''Basic abstract class for defining any appy type.'''
|
|
def __init__(self, validator, multiplicity, index, default, optional,
|
|
editDefault, show, page, group, move, indexed, searchable,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized):
|
|
# The validator restricts which values may be defined. It can be an
|
|
# interval (1,None), a list of string values ['choice1', 'choice2'],
|
|
# a regular expression, a custom function, a Selection instance, etc.
|
|
self.validator = validator
|
|
# Multiplicity is a tuple indicating the minimum and maximum
|
|
# occurrences of values.
|
|
self.multiplicity = multiplicity
|
|
# Type of the index on the values. If you want to represent a simple
|
|
# (ordered) list of values, specify None. If you want to
|
|
# index your values with unordered integers or with other types like
|
|
# strings (thus creating a dictionary of values instead of a list),
|
|
# specify a type specification for the index, like Integer() or
|
|
# String(). Note that this concept of "index" has nothing to do with
|
|
# the concept of "database index" (see fields "indexed" and
|
|
# "searchable" below). self.index is not yet used.
|
|
self.index = index
|
|
# Default value
|
|
self.default = default
|
|
# Is the field optional or not ?
|
|
self.optional = optional
|
|
# May the user configure a default value ?
|
|
self.editDefault = editDefault
|
|
# Must the field be visible or not?
|
|
self.show = show
|
|
# When displaying/editing the whole object, on what page and phase must
|
|
# this field value appear? Default is ('main', 'main'). pageShow
|
|
# indicates if the page must be shown or not.
|
|
self.page, self.phase, self.pageShow = PageDescr.getPageInfo(page, Page)
|
|
# Within self.page, in what group of fields must this field value
|
|
# appear?
|
|
self.group = group
|
|
# The following attribute allows to move a field back to a previous
|
|
# position (useful for content types that inherit from others).
|
|
self.move = move
|
|
# If indexed is True, a database index will be set on the field for
|
|
# fast access.
|
|
self.indexed = indexed
|
|
# If specified "searchable", the field will be added to some global
|
|
# index allowing to perform application-wide, keyword searches.
|
|
self.searchable = searchable
|
|
# Normally, permissions to read or write every attribute in a type are
|
|
# granted if the user has the global permission to read or
|
|
# create/edit instances of the whole type. If you want a given attribute
|
|
# to be protected by specific permissions, set one or the 2 next boolean
|
|
# values to "True".
|
|
self.specificReadPermission = specificReadPermission
|
|
self.specificWritePermission = specificWritePermission
|
|
# Widget width and height
|
|
self.width = width
|
|
self.height = height
|
|
# The behaviour of this field may depend on another, "master" field
|
|
self.master = master
|
|
if master:
|
|
self.master.slaves.append(self)
|
|
# When master has some value(s), there is impact on this field.
|
|
self.masterValue = masterValue
|
|
# If a field must retain attention in a particular way, set focus=True.
|
|
# It will be rendered in a special way.
|
|
self.focus = focus
|
|
# If we must keep track of changes performed on a field, "historized"
|
|
# must be set to True.
|
|
self.historized = historized
|
|
self.id = id(self)
|
|
self.type = self.__class__.__name__
|
|
self.pythonType = None # The True corresponding Python type
|
|
self.slaves = [] # The list of slaves of this field
|
|
self.selfClass = None # The Python class to which this Type definition
|
|
# is linked. This will be computed at runtime.
|
|
|
|
def isMultiValued(self):
|
|
'''Does this type definition allow to define multiple values?'''
|
|
res = False
|
|
maxOccurs = self.multiplicity[1]
|
|
if (maxOccurs == None) or (maxOccurs > 1):
|
|
res = True
|
|
return res
|
|
|
|
class Integer(Type):
|
|
def __init__(self, validator=None, multiplicity=(0,1), index=None,
|
|
default=None, optional=False, editDefault=False, show=True,
|
|
page='main', group=None, move=0, indexed=False,
|
|
searchable=False, specificReadPermission=False,
|
|
specificWritePermission=False, width=None, height=None,
|
|
master=None, masterValue=None, focus=False, historized=False):
|
|
Type.__init__(self, validator, multiplicity, index, default, optional,
|
|
editDefault, show, page, group, move, indexed, searchable,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized)
|
|
self.pythonType = long
|
|
|
|
class Float(Type):
|
|
def __init__(self, validator=None, multiplicity=(0,1), index=None,
|
|
default=None, optional=False, editDefault=False, show=True,
|
|
page='main', group=None, move=0, indexed=False,
|
|
searchable=False, specificReadPermission=False,
|
|
specificWritePermission=False, width=None, height=None,
|
|
master=None, masterValue=None, focus=False, historized=False,
|
|
precision=None):
|
|
Type.__init__(self, validator, multiplicity, index, default, optional,
|
|
editDefault, show, page, group, move, indexed, False,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized)
|
|
self.pythonType = float
|
|
# The precision is the number of decimal digits. This number is used
|
|
# for rendering the float, but the internal float representation is not
|
|
# rounded.
|
|
self.precision = precision
|
|
|
|
class String(Type):
|
|
# Some predefined regular expressions that may be used as validators
|
|
c = re.compile
|
|
EMAIL = c('[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.' \
|
|
'[a-zA-Z][a-zA-Z\.]*[a-zA-Z]')
|
|
ALPHANUMERIC = c('[\w-]+')
|
|
URL = c('(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*(\.[a-z]{2,5})?' \
|
|
'(([0-9]{1,5})?\/.*)?')
|
|
|
|
# Some predefined functions that may also be used as validators
|
|
@staticmethod
|
|
def _MODULO_97(obj, value, complement=False):
|
|
'''p_value must be a string representing a number, like a bank account.
|
|
this function checks that the 2 last digits are the result of
|
|
computing the modulo 97 of the previous digits. Any non-digit
|
|
character is ignored. If p_complement is True, it does compute the
|
|
complement of modulo 97 instead of modulo 97. p_obj is not used;
|
|
it will be given by the Appy validation machinery, so it must be
|
|
specified as parameter. The function returns True if the check is
|
|
successful.'''
|
|
if not value: return True # Plone calls me erroneously for
|
|
# non-mandatory fields.
|
|
# First, remove any non-digit char
|
|
v = ''
|
|
for c in value:
|
|
if digit.match(c): v += c
|
|
# There must be at least 3 digits for performing the check
|
|
if len(v) < 3: return False
|
|
# Separate the real number from the check digits
|
|
number = int(v[:-2])
|
|
checkNumber = int(v[-2:])
|
|
# Perform the check
|
|
if complement:
|
|
return (97 - (number % 97)) == checkNumber
|
|
else:
|
|
# The check number can't be 0. In this case, we force it to be 97.
|
|
# This is the way Belgian bank account numbers work. I hope this
|
|
# behaviour is general enough to be implemented here.
|
|
mod97 = (number % 97)
|
|
if mod97 == 0: return checkNumber == 97
|
|
else: return checkNumber == mod97
|
|
@staticmethod
|
|
def MODULO_97(obj, value): return String._MODULO_97(obj, value)
|
|
@staticmethod
|
|
def MODULO_97_COMPLEMENT(obj, value):
|
|
return String._MODULO_97(obj, value, True)
|
|
@staticmethod
|
|
def IBAN(obj, value):
|
|
'''Checks that p_value corresponds to a valid IBAN number. IBAN stands
|
|
for International Bank Account Number (ISO 13616). If the number is
|
|
valid, the method returns True.'''
|
|
if not value: return True # Plone calls me erroneously for
|
|
# non-mandatory fields.
|
|
# First, remove any non-digit or non-letter char
|
|
v = ''
|
|
for c in value:
|
|
if alpha.match(c): v += c
|
|
# Maximum size is 34 chars
|
|
if (len(v) < 8) or (len(v) > 34): return False
|
|
# 2 first chars must be a valid country code
|
|
if not countries.exists(v[:2].lower()): return False
|
|
# 2 next chars are a control code whose value must be between 0 and 96.
|
|
try:
|
|
code = int(v[2:4])
|
|
if (code < 0) or (code > 96): return False
|
|
except ValueError:
|
|
return False
|
|
# Perform the checksum
|
|
vv = v[4:] + v[:4] # Put the 4 first chars at the end.
|
|
nv = ''
|
|
for c in vv:
|
|
# Convert each letter into a number (A=10, B=11, etc)
|
|
# Ascii code for a is 65, so A=10 if we perform "minus 55"
|
|
if letter.match(c): nv += str(ord(c.upper()) - 55)
|
|
else: nv += c
|
|
return int(nv) % 97 == 1
|
|
@staticmethod
|
|
def BIC(obj, value):
|
|
'''Checks that p_value corresponds to a valid BIC number. BIC stands
|
|
for Bank Identifier Code (ISO 9362). If the number is valid, the
|
|
method returns True.'''
|
|
if not value: return True # Plone calls me erroneously for
|
|
# non-mandatory fields.
|
|
# BIC number must be 8 or 11 chars
|
|
if len(value) not in (8, 11): return False
|
|
# 4 first chars, representing bank name, must be letters
|
|
for c in value[:4]:
|
|
if not letter.match(c): return False
|
|
# 2 next chars must be a valid country code
|
|
if not countries.exists(value[4:6].lower()): return False
|
|
# Last chars represent some location within a country (a city, a
|
|
# province...). They can only be letters or figures.
|
|
for c in value[6:]:
|
|
if not alpha.match(c): return False
|
|
return True
|
|
|
|
# Possible values for "format"
|
|
LINE = 0
|
|
TEXT = 1
|
|
XHTML = 2
|
|
PASSWORD = 3
|
|
def __init__(self, validator=None, multiplicity=(0,1), index=None,
|
|
default=None, optional=False, editDefault=False, format=LINE,
|
|
show=True, page='main', group=None, move=0, indexed=False,
|
|
searchable=False, specificReadPermission=False,
|
|
specificWritePermission=False, width=None, height=None,
|
|
master=None, masterValue=None, focus=False, historized=False):
|
|
Type.__init__(self, validator, multiplicity, index, default, optional,
|
|
editDefault, show, page, group, move, indexed, searchable,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized)
|
|
self.format = format
|
|
self.isSelect = self.isSelection()
|
|
def isSelection(self):
|
|
'''Does the validator of this type definition define a list of values
|
|
into which the user must select one or more values?'''
|
|
res = True
|
|
if type(self.validator) in (list, tuple):
|
|
for elem in self.validator:
|
|
if not isinstance(elem, basestring):
|
|
res = False
|
|
break
|
|
else:
|
|
if not isinstance(self.validator, Selection):
|
|
res = False
|
|
return res
|
|
|
|
class Boolean(Type):
|
|
def __init__(self, validator=None, multiplicity=(0,1), index=None,
|
|
default=None, optional=False, editDefault=False, show=True,
|
|
page='main', group=None, move=0, indexed=False,
|
|
searchable=False, specificReadPermission=False,
|
|
specificWritePermission=False, width=None, height=None,
|
|
master=None, masterValue=None, focus=False, historized=False):
|
|
Type.__init__(self, validator, multiplicity, index, default, optional,
|
|
editDefault, show, page, group, move, indexed, searchable,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized)
|
|
self.pythonType = bool
|
|
|
|
class Date(Type):
|
|
# Possible values for "format"
|
|
WITH_HOUR = 0
|
|
WITHOUT_HOUR = 1
|
|
def __init__(self, validator=None, multiplicity=(0,1), index=None,
|
|
default=None, optional=False, editDefault=False,
|
|
format=WITH_HOUR, startYear=time.localtime()[0]-10,
|
|
endYear=time.localtime()[0]+10, show=True, page='main',
|
|
group=None, move=0, indexed=False, searchable=False,
|
|
specificReadPermission=False, specificWritePermission=False,
|
|
width=None, height=None, master=None, masterValue=None,
|
|
focus=False, historized=False):
|
|
Type.__init__(self, validator, multiplicity, index, default, optional,
|
|
editDefault, show, page, group, move, indexed, searchable,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized)
|
|
self.format = format
|
|
self.startYear = startYear
|
|
self.endYear = endYear
|
|
|
|
class File(Type):
|
|
def __init__(self, validator=None, multiplicity=(0,1), index=None,
|
|
default=None, optional=False, editDefault=False, show=True,
|
|
page='main', group=None, move=0, indexed=False,
|
|
searchable=False, specificReadPermission=False,
|
|
specificWritePermission=False, width=None, height=None,
|
|
master=None, masterValue=None, focus=False, historized=False,
|
|
isImage=False):
|
|
Type.__init__(self, validator, multiplicity, index, default, optional,
|
|
editDefault, show, page, group, move, indexed, False,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized)
|
|
self.isImage = isImage
|
|
|
|
class Ref(Type):
|
|
def __init__(self, klass=None, attribute=None, validator=None,
|
|
multiplicity=(0,1), index=None, default=None, optional=False,
|
|
editDefault=False, add=False, link=True, unlink=False,
|
|
back=None, isBack=False, show=True, page='main', group=None,
|
|
showHeaders=False, shownInfo=(), wide=False, select=None,
|
|
maxPerPage=30, move=0, indexed=False, searchable=False,
|
|
specificReadPermission=False, specificWritePermission=False,
|
|
width=None, height=None, master=None, masterValue=None,
|
|
focus=False, historized=False):
|
|
Type.__init__(self, validator, multiplicity, index, default, optional,
|
|
editDefault, show, page, group, move, indexed, False,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized)
|
|
self.klass = klass
|
|
self.attribute = attribute
|
|
self.add = add # May the user add new objects through this ref ?
|
|
self.link = link # May the user link existing objects through this ref?
|
|
self.unlink = unlink # May the user unlink existing objects?
|
|
self.back = back
|
|
self.isBack = isBack # Should always be False
|
|
self.showHeaders = showHeaders # When displaying a tabular list of
|
|
# referenced objects, must we show the table headers?
|
|
self.shownInfo = shownInfo # When displaying referenced object(s),
|
|
# we will display its title + all other fields whose names are listed
|
|
# in this attribute.
|
|
self.wide = wide # If True, the table of references will be as wide
|
|
# as possible
|
|
self.select = select # If a method is defined here, it will be used to
|
|
# filter the list of available tied objects.
|
|
self.maxPerPage = maxPerPage # Maximum number of referenced objects
|
|
# shown at once.
|
|
|
|
class Computed(Type):
|
|
def __init__(self, validator=None, multiplicity=(0,1), index=None,
|
|
default=None, optional=False, editDefault=False, show='view',
|
|
page='main', group=None, move=0, indexed=False,
|
|
searchable=False, specificReadPermission=False,
|
|
specificWritePermission=False, width=None, height=None,
|
|
method=None, plainText=True, master=None, masterValue=None,
|
|
focus=False, historized=False):
|
|
Type.__init__(self, None, multiplicity, index, default, optional,
|
|
False, show, page, group, move, indexed, False,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized)
|
|
self.method = method # The method used for computing the field value
|
|
self.plainText = plainText # Does field computation produce pain text
|
|
# or XHTML?
|
|
|
|
class Action(Type):
|
|
'''An action is a workflow-independent Python method that can be triggered
|
|
by the user on a given gen-class. For example, the custom installation
|
|
procedure of a gen-application is implemented by an action on the custom
|
|
tool class. An action is rendered as a button.'''
|
|
def __init__(self, validator=None, multiplicity=(1,1), index=None,
|
|
default=None, optional=False, editDefault=False, show=True,
|
|
page='main', group=None, move=0, indexed=False,
|
|
searchable=False, specificReadPermission=False,
|
|
specificWritePermission=False, width=None, height=None,
|
|
action=None, result='computation', confirm=False, master=None,
|
|
masterValue=None, focus=False, historized=False):
|
|
Type.__init__(self, None, (0,1), index, default, optional,
|
|
False, show, page, group, move, indexed, False,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized)
|
|
self.action = action # Can be a single method or a list/tuple of methods
|
|
self.result = result # 'computation' means that the action will simply
|
|
# compute things and redirect the user to the same page, with some
|
|
# status message about execution of the action. 'file' means that the
|
|
# result is the binary content of a file that the user will download.
|
|
self.confirm = confirm # If True, a popup will ask the user if she is
|
|
# really sure about triggering this action.
|
|
|
|
def __call__(self, obj):
|
|
'''Calls the action on p_obj.'''
|
|
try:
|
|
if type(self.action) in sequenceTypes:
|
|
# There are multiple Python methods
|
|
res = [True, '']
|
|
for act in self.action:
|
|
actRes = act(obj)
|
|
if type(actRes) in sequenceTypes:
|
|
res[0] = res[0] and actRes[0]
|
|
if self.result == 'file':
|
|
res[1] = res[1] + actRes[1]
|
|
else:
|
|
res[1] = res[1] + '\n' + actRes[1]
|
|
else:
|
|
res[0] = res[0] and actRes
|
|
else:
|
|
# There is only one Python method
|
|
actRes = self.action(obj)
|
|
if type(actRes) in sequenceTypes:
|
|
res = list(actRes)
|
|
else:
|
|
res = [actRes, '']
|
|
# If res is None (ie the user-defined action did not return
|
|
# anything), we consider the action as successfull.
|
|
if res[0] == None: res[0] = True
|
|
except Exception, e:
|
|
res = (False, 'An error occurred. %s' % str(e))
|
|
obj.log(Traceback.get(), type='error')
|
|
return res
|
|
|
|
class Info(Type):
|
|
'''An info is a field whose purpose is to present information
|
|
(text, html...) to the user.'''
|
|
def __init__(self, validator=None, multiplicity=(1,1), index=None,
|
|
default=None, optional=False, editDefault=False, show='view',
|
|
page='main', group=None, move=0, indexed=False,
|
|
searchable=False, specificReadPermission=False,
|
|
specificWritePermission=False, width=None, height=None,
|
|
master=None, masterValue=None, focus=False, historized=False):
|
|
Type.__init__(self, None, (0,1), index, default, optional,
|
|
False, show, page, group, move, indexed, False,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized)
|
|
|
|
class Pod(Type):
|
|
'''A pod is a field allowing to produce a (PDF, ODT, Word, RTF...) document
|
|
from data contained in Appy class and linked objects or anything you
|
|
want to put in it. It uses appy.pod.'''
|
|
def __init__(self, validator=None, index=None, default=None,
|
|
optional=False, editDefault=False, show='view',
|
|
page='main', group=None, move=0, indexed=False,
|
|
searchable=False, specificReadPermission=False,
|
|
specificWritePermission=False, width=None, height=None,
|
|
master=None, masterValue=None, focus=False, historized=False,
|
|
template=None, context=None, action=None, askAction=False):
|
|
Type.__init__(self, None, (0,1), index, default, optional,
|
|
False, show, page, group, move, indexed, searchable,
|
|
specificReadPermission, specificWritePermission, width,
|
|
height, master, masterValue, focus, historized)
|
|
self.template = template # The path to a POD template
|
|
self.context = context # A dict containing a specific pod context
|
|
self.action = action # A method that will be triggered after the
|
|
# document has been generated.
|
|
self.askAction = askAction # If True, the action will be triggered only
|
|
# if the user checks a checkbox, which, by default, will be unchecked.
|
|
|
|
# Workflow-specific types ------------------------------------------------------
|
|
class State:
|
|
def __init__(self, permissions, initial=False, phase='main', show=True):
|
|
self.permissions = permissions #~{s_permissionName:[s_roleName]}~ This
|
|
# dict gives, for every permission managed by a workflow, the list of
|
|
# roles for which the permission is granted in this state.
|
|
# Standard permissions are 'read', 'write' and 'delete'.
|
|
self.initial = initial
|
|
self.phase = phase
|
|
self.show = show
|
|
def getUsedRoles(self):
|
|
res = set()
|
|
for roleValue in self.permissions.itervalues():
|
|
if isinstance(roleValue, basestring):
|
|
res.add(roleValue)
|
|
elif roleValue:
|
|
for role in roleValue:
|
|
res.add(role)
|
|
return list(res)
|
|
def getTransitions(self, transitions, selfIsFromState=True):
|
|
'''Among p_transitions, returns those whose fromState is p_self (if
|
|
p_selfIsFromState is True) or those whose toState is p_self (if
|
|
p_selfIsFromState is False).'''
|
|
res = []
|
|
for t in transitions:
|
|
if self in t.getStates(selfIsFromState):
|
|
res.append(t)
|
|
return res
|
|
def getPermissions(self):
|
|
'''If you get the permissions mapping through self.permissions, dict
|
|
values may be of different types (a list of roles, a single role or
|
|
None). Iy you call this method, you will always get a list which
|
|
may be empty.'''
|
|
res = {}
|
|
for permission, roleValue in self.permissions.iteritems():
|
|
if roleValue == None:
|
|
res[permission] = []
|
|
elif isinstance(roleValue, basestring):
|
|
res[permission] = [roleValue]
|
|
else:
|
|
res[permission] = roleValue
|
|
return res
|
|
|
|
class Transition:
|
|
def __init__(self, states, condition=True, action=None, notify=None,
|
|
show=True):
|
|
self.states = states # In its simpler form, it is a tuple with 2
|
|
# states: (fromState, toState). But it can also be a tuple of several
|
|
# (fromState, toState) sub-tuples. This way, you may define only 1
|
|
# transition at several places in the state-transition diagram. It may
|
|
# be useful for "undo" transitions, for example.
|
|
self.condition = condition
|
|
self.action = action
|
|
self.notify = notify # If not None, it is a method telling who must be
|
|
# notified by email after the transition has been executed.
|
|
self.show = show # If False, the end user will not be able to trigger
|
|
# the transition. It will only be possible by code.
|
|
|
|
def getUsedRoles(self):
|
|
'''If self.condition is specifies a role.'''
|
|
res = []
|
|
if isinstance(self.condition, basestring):
|
|
res = [self.condition]
|
|
return res
|
|
|
|
def isSingle(self):
|
|
'''If this transitions is only define between 2 states, returns True.
|
|
Else, returns False.'''
|
|
return isinstance(self.states[0], State)
|
|
|
|
def getStates(self, fromStates=True):
|
|
'''Returns the fromState(s) if p_fromStates is True, the toState(s)
|
|
else. If you want to get the states grouped in tuples
|
|
(fromState, toState), simply use self.states.'''
|
|
res = []
|
|
stateIndex = 1
|
|
if fromStates:
|
|
stateIndex = 0
|
|
if self.isSingle():
|
|
res.append(self.states[stateIndex])
|
|
else:
|
|
for states in self.states:
|
|
theState = states[stateIndex]
|
|
if theState not in res:
|
|
res.append(theState)
|
|
return res
|
|
|
|
def hasState(self, state, isFrom):
|
|
'''If p_isFrom is True, this method returns True if p_state is a
|
|
starting state for p_self. If p_isFrom is False, this method returns
|
|
True if p_state is an ending state for p_self.'''
|
|
stateIndex = 1
|
|
if isFrom:
|
|
stateIndex = 0
|
|
if self.isSingle():
|
|
res = state == self.states[stateIndex]
|
|
else:
|
|
res = False
|
|
for states in self.states:
|
|
if states[stateIndex] == state:
|
|
res = True
|
|
break
|
|
return res
|
|
|
|
class Permission:
|
|
'''If you need to define a specific read or write permission of a given
|
|
attribute of an Appy type, you use the specific boolean parameters
|
|
"specificReadPermission" or "specificWritePermission" for this attribute.
|
|
When you want to refer to those specific read or write permissions when
|
|
defining a workflow, for example, you need to use instances of
|
|
"ReadPermission" and "WritePermission", the 2 children classes of this
|
|
class. For example, if you need to refer to write permission of
|
|
attribute "t1" of class A, write: "WritePermission("A.t1") or
|
|
WritePermission("x.y.A.t1") if class A is not in the same module as
|
|
where you instantiate the class.'''
|
|
def __init__(self, fieldDescriptor):
|
|
self.fieldDescriptor = fieldDescriptor
|
|
|
|
class ReadPermission(Permission): pass
|
|
class WritePermission(Permission): pass
|
|
|
|
class No:
|
|
'''When you write a workflow condition method and you want to return False
|
|
but you want to give to the user some explanations about why a transition
|
|
can't be triggered, do not return False, return an instance of No
|
|
instead. When creating such an instance, you can specify an error
|
|
message.'''
|
|
def __init__(self, msg):
|
|
self.msg = msg
|
|
def __nonzero__(self):
|
|
return False
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class Selection:
|
|
'''Instances of this class may be given as validator of a String, in order
|
|
to tell Appy that the validator is a selection that will be computed
|
|
dynamically.'''
|
|
def __init__(self, methodName):
|
|
# The p_methodName parameter must be the name of a method that will be
|
|
# called every time Appy will need to get the list of possible values
|
|
# for the related field. It must correspond to an instance method of
|
|
# the class defining the related field. This method accepts no argument
|
|
# and must return a list (or tuple) of pairs (lists or tuples):
|
|
# (id, text), where "id" is one of the possible values for the field,
|
|
# and "text" is the value as will be shown on the screen. You can use
|
|
# self.translate within this method to produce an internationalized
|
|
# "text" if needed.
|
|
self.methodName = methodName
|
|
|
|
def getText(self, obj, value):
|
|
'''Gets the text that corresponds to p_value.'''
|
|
vocab = obj._appy_getDynamicDisplayList(self.methodName)
|
|
if type(value) in sequenceTypes:
|
|
return [vocab.getValue(v) for v in value]
|
|
else:
|
|
return vocab.getValue(value)
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class Tool:
|
|
'''If you want so define a custom tool class, she must inherit from this
|
|
class.'''
|
|
class Flavour:
|
|
'''A flavour represents a given group of configuration options. If you want
|
|
to define a custom flavour class, she must inherit from this class.'''
|
|
def __init__(self, name): self.name = name
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class Config:
|
|
'''If you want to specify some configuration parameters for appy.gen and
|
|
your application, please create an instance of this class and modify its
|
|
attributes. You may put your instance anywhere in your application
|
|
(main package, sub-package, etc).'''
|
|
|
|
# The default Config instance, used if the application does not give one.
|
|
defaultConfig = None
|
|
def getDefault():
|
|
if not Config.defaultConfig:
|
|
Config.defaultConfig = Config()
|
|
return Config.defaultConfig
|
|
getDefault = staticmethod(getDefault)
|
|
|
|
def __init__(self):
|
|
# For every language code that you specify in this list, appy.gen will
|
|
# produce and maintain translation files.
|
|
self.languages = ['en']
|
|
# People having one of these roles will be able to create instances
|
|
# of classes defined in your application.
|
|
self.defaultCreators = ['Manager', 'Owner']
|
|
# If True, the following flag will produce a minimalist Plone, where
|
|
# some actions, portlets or other stuff less relevant for building
|
|
# web applications, are removed or hidden. Using this produces
|
|
# effects on your whole Plone site!
|
|
self.minimalistPlone = False
|
|
# If you want to replace the Plone front page with a page coming from
|
|
# your application, use the following parameter. Setting
|
|
# frontPage = True will replace the Plone front page with a page
|
|
# whose content will come fron i18n label "front_page_text".
|
|
self.frontPage = False
|
|
# If you don't need the portlet that appy.gen has generated for your
|
|
# application, set the following parameter to False.
|
|
self.showPortlet = True
|
|
# Default number of flavours. It will be used for generating i18n labels
|
|
# for classes in every flavour. Indeed, every flavour can name its
|
|
# concepts differently. For example, class Thing in flavour 2 may have
|
|
# i18n label "MyProject_Thing_2".
|
|
self.numberOfFlavours = 2
|
|
# ------------------------------------------------------------------------------
|