def get_value(self, name, language=None):
field = self.get_field(name)
if field is None:
msg = 'field {name} is not defined on {class_id}'
log_warning(msg.format(name=name, class_id=self.class_id))
return None
# Check context
self.check_if_context_exists()
# Check if field is obsolete
if field.obsolete:
msg = 'field {name} is obsolete on {class_id}'
log_warning(msg.format(name=name, class_id=self.class_id))
# TODO: Use decorator for cache
# TODO: Reactivate when ready
#cache_key = (name, language)
#if self._values.has_key(cache_key):
# return self._values[cache_key]
if self._brain and field.stored and not is_prototype(
field.datatype, Decimal):
try:
value = self.get_value_from_brain(name, language)
except Exception:
# FIXME Sometimes we cannot get value from brain
# We're tying to debug this problem
msg = 'Warning: cannot get value from brain {0} {1}'
msg = msg.format(self.abspath, name)
print(msg)
value = field.get_value(self, name, language)
else:
value = field.get_value(self, name, language)
#self._values[cache_key] = value
return value
def get_value(self, name, language=None):
field = self.get_field(name)
if field is None:
msg = 'field {name} is not defined on {class_id}'
log_warning(msg.format(name=name, class_id=self.class_id))
return None
# Check context
self.check_if_context_exists()
# Check if field is obsolete
if field.obsolete:
msg = 'field {name} is obsolete on {class_id}'
log_warning(msg.format(name=name, class_id=self.class_id))
# TODO: Use decorator for cache
# TODO: Reactivate when ready
#cache_key = (name, language)
#if self._values.has_key(cache_key):
# return self._values[cache_key]
if self._brain and field.stored and not is_prototype(field.datatype, Decimal):
try:
value = self.get_value_from_brain(name, language)
except Exception:
# FIXME Sometimes we cannot get value from brain
# We're tying to debug this problem
msg = 'Warning: cannot get value from brain {0} {1}'
msg = msg.format(self.abspath, name)
print(msg)
value = field.get_value(self, name, language)
else:
value = field.get_value(self, name, language)
#self._values[cache_key] = value
return value
def search_widgets(self):
widgets = []
for name, field in self._search_fields:
if is_prototype(field, Select_Field):
widget = field.widget
widgets.append(
widget(name, has_empty_option=True, title=field.title))
return widgets
def make_element(tagname, attributes={}, content=u""):
if is_prototype(content, MSG):
content = content.gettext()
element = [u"<", tagname]
for key, value in attributes.iteritems():
if value is None:
continue
if type(value) is list:
value = u" ".join(value)
elif is_prototype(value, MSG):
value = value.gettext()
element.extend((u" ", key, u'="', value, u'"'))
if tagname in ('input', 'img'):
element.extend((u"/>", content))
else:
element.extend((u">", content, u"</", tagname, u">"))
return u"".join(element)
def search_widgets(self):
widgets = []
for name, field in self._search_fields:
if is_prototype(field, Select_Field):
widget = field.widget
widgets.append(
widget(name, has_empty_option=True, title=field.title))
return widgets
def get_field_and_datatype(elt):
""" Now schema can be Datatype or Field.
To be compatible:
- we return datatype if a field is given
- we build a field if a datatype is given
"""
if is_prototype(elt, Field):
return elt, elt.get_datatype()
return Field(datatype=elt), elt
def get_message(self):
# Custom message
value = self.msg
if value is not None:
if is_prototype(value, MSG):
return value
return ERROR(value)
# Default message
msg = u'There are errors... XXX'
return ERROR(msg)
def get_message(self):
# Custom message
value = self.msg
if value is not None:
if is_prototype(value, MSG):
return value
return ERROR(value)
# Default message
msg = u"There are errors... XXX"
return ERROR(msg)
def repl(match):
expression = match.group(1)
value = evaluate(expression, stack, repeat_stack)
# Remove if None
if value is None:
return ''
# Send the string
if is_prototype(value, MSG):
return value.gettext().encode(encoding)
elif type(value) is unicode:
return value.encode(encoding)
return str(value)
def repl(match):
expression = match.group(1)
value = evaluate(expression, stack, repeat_stack)
# Remove if None
if value is None:
return ''
# Send the string
if is_prototype(value, MSG):
return value.gettext().encode(encoding)
elif type(value) is unicode:
return value.encode(encoding)
return str(value)
def get_fields(self):
cls = self._resource_class
for name in self.fields:
field = self.get_field(name)
if not is_prototype(field, Field):
field = cls.get_field(name)
if not field:
continue
# Access control
if field.access('write', cls):
yield name
def get_fields(self):
cls = self._resource_class
for name in self.fields:
field = self.get_field(name)
if not is_prototype(field, Field):
field = cls.get_field(name)
if not field:
continue
# Access control
if field.access('write', cls):
yield name
def get_value(self, key, args, kw):
if type(key) is int:
return args[key]
msg, kw = kw
if key in kw:
value = kw[key]
else:
value = getattr(msg, key)
if is_prototype(value, MSG):
return value.gettext()
return value
def get_value(self, key, args, kw):
if type(key) is int:
return args[key]
msg, kw = kw
if key in kw:
value = kw[key]
else:
value = getattr(msg, key)
if is_prototype(value, MSG):
return value.gettext()
return value
def default(self, o):
if isinstance(o, Decimal):
return str(o)
elif isinstance(o, datetime):
return o.isoformat()
elif isinstance(o, date):
return o.isoformat()
elif isinstance(o, time):
return o.isoformat()
elif is_prototype(o, MSG):
return o.gettext()
elif isinstance(o, XMLParser):
return stream_to_str_as_html(o)
return JSONEncoder.default(self, o)
def action_export(self, resource, context, form, writer_cls=ODSWriter):
name = MSG(u"{title} Users").gettext(title=resource.get_title())
writer = writer_cls(name)
header = [title.gettext() for column, title in self.table_columns]
writer.add_row(header, is_header=True)
results = self.get_items(resource, context)
context.query['batch_size'] = 0
for item in self.sort_and_batch(resource, context, results):
row = []
for column, title in self.table_columns:
if column == 'state':
item_brain, item_resource = item
user = context.root.get_user(item_brain.name)
if (user is not None
and user.get_value('password') is None):
state = NOT_REGISTERED
else:
state = item_brain.form_state
value = WorkflowState.get_value(state)
else:
value = self.get_item_value(resource, context, item,
column)
if type(value) is tuple:
value = value[0]
if type(value) is unicode:
pass
elif is_prototype(value, MSG):
value = value.gettext()
elif type(value) is str:
value = unicode(value)
elif type(value) is datetime:
return context.format_datetime(value)
elif value is None:
value = ''
else:
raise NotImplementedError, str(type(value))
row.append(value)
writer.add_row(row)
body = writer.to_str()
context.set_content_type(writer_cls.mimetype)
context.set_content_disposition('attachment',
filename="{0}-users.{1}".format(
resource.name,
writer_cls.extension))
return body
def get_fields(self):
context = self.context
resource = self.resource
for name in self.fields:
field = self.get_field(resource, name)
if not is_prototype(field, Field):
field = resource.get_field(name)
if not field:
continue
# Access control
if field.access("write", resource):
yield name
def get_view(self, name, query=None):
# To define a default view, override this
if name is None:
name = self.get_default_view_name()
if name is None:
return None
# Explicit view, defined by name
view = getattr(self, name, None)
if is_prototype(view, BaseView):
context = get_context()
view = view(resource=self, context=context) # bind
return view
return None
def get_fields(self):
context = self.context
resource = self.resource
for name in self.fields:
field = self.get_field(resource, name)
if not is_prototype(field, Field):
field = resource.get_field(name)
if not field:
continue
# Access control
if field.access('write', resource):
yield name
def get_view(self, name, query=None):
# To define a default view, override this
if name is None:
name = self.get_default_view_name()
if name is None:
return None
# Explicit view, defined by name
view = getattr(self, name, None)
if is_prototype(view, BaseView):
context = get_context()
view = view(resource=self, context=context) # bind
return view
return None
def come_back(self, message, goto=None, keep=freeze([]), **kw):
"""This is a handy method that builds a resource URI from some
parameters. It exists to make short some common patterns.
"""
# By default we come back to the referrer
if goto is None:
goto = self.get_referrer()
# Replace goto if no referrer
if goto is None:
goto = str(self.uri)
if '/;' in goto:
goto = goto.split('/;')[0]
if type(goto) is str:
goto = get_reference(goto)
# Preserve some form values
form = {}
for key, value in self.get_form().items():
# Be robust
if not key:
continue
# Omit methods
if key[0] == ';':
continue
# Omit files
if isinstance(value, tuple) and len(value) == 3:
continue
# Keep form field
if (keep is True) or (key in keep):
form[key] = value
if form:
goto = goto.replace(**form)
# Translate the source message
if message:
text = message.gettext(**kw)
if is_prototype(message, ERROR):
goto = goto.replace(error=text)
else:
goto = goto.replace(info=text)
# Keep fancybox
if 'fancybox' in self.uri.query:
goto.query['fancybox'] = '1'
# Ok
return goto
def come_back(self, message, goto=None, keep=freeze([]), **kw):
"""This is a handy method that builds a resource URI from some
parameters. It exists to make short some common patterns.
"""
# By default we come back to the referrer
if goto is None:
goto = self.get_referrer()
# Replace goto if no referrer
if goto is None:
goto = str(self.uri)
if '/;' in goto:
goto = goto.split('/;')[0]
if type(goto) is str:
goto = get_reference(goto)
# Preserve some form values
form = {}
for key, value in self.get_form().items():
# Be robust
if not key:
continue
# Omit methods
if key[0] == ';':
continue
# Omit files
if isinstance(value, tuple) and len(value) == 3:
continue
# Keep form field
if (keep is True) or (key in keep):
form[key] = value
if form:
goto = goto.replace(**form)
# Translate the source message
if message:
text = message.gettext(**kw)
if is_prototype(message, ERROR):
goto = goto.replace(error=text)
else:
goto = goto.replace(info=text)
# Keep fancybox
if 'fancybox' in self.uri.query:
goto.query['fancybox'] = '1'
# Ok
return goto
def get_fields_handlers(self):
handlers = []
root = self.get_root()
langs = root.get_value('website_languages')
# Fields
for name, field in self.get_fields():
if is_prototype(field, File_Field):
if field.multilingual:
for language in langs:
value = field.get_value(self, name, language)
if value is not None:
handlers.append(value)
else:
value = field.get_value(self, name)
if value is not None:
handlers.append(value)
# Ok
return handlers
def get_fields_handlers(self):
handlers = []
root = self.get_root()
langs = root.get_value('website_languages')
# Fields
for name, field in self.get_fields():
if is_prototype(field, File_Field):
if field.multilingual:
for language in langs:
value = field.get_value(self, name, language)
if value is not None:
handlers.append(value)
else:
value = field.get_value(self, name)
if value is not None:
handlers.append(value)
# Ok
return handlers
def get_html_field_body_stream(self, name, language=None):
"""Utility method, returns the stream for the given html field.
"""
# 1. Check it is an html-file field
field = self.get_field(name)
if not is_prototype(field, HTMLFile_Field):
raise ValueError, 'expected html-file field'
# 2. Get the handler
handler = field.get_value(self, name, language)
if not handler:
handler = field.class_handler()
# 3. Get the body
body = handler.get_body()
if not body:
raise ValueError, 'html file does not have a body'
return body.get_content_elements()
def get_html_field_body_stream(self, name, language=None):
"""Utility method, returns the stream for the given html field.
"""
# 1. Check it is an html-file field
field = self.get_field(name)
if not is_prototype(field, HTMLFile_Field):
raise ValueError, 'expected html-file field'
# 2. Get the handler
handler = field.get_value(self, name, language)
if not handler:
handler = field.class_handler()
# 3. Get the body
body = handler.get_body()
if not body:
raise ValueError, 'html file does not have a body'
return body.get_content_elements()
def __new__(mcs, name, bases, dict):
cls = type.__new__(mcs, name, bases, dict)
if 'class_id' in dict:
RODatabase.register_resource_class(cls)
# Lookup fields
cls.fields = [
x for x in dir(cls) if is_prototype(getattr(cls, x), Field)
]
# Register new fields in the catalog
for name in cls.fields:
if name in dict:
field = dict[name]
field.name = name
if field.indexed or field.stored:
datatype = field.get_datatype()
register_field(name, datatype)
# Ok
return cls
def __new__(mcs, name, bases, dict):
cls = type.__new__(mcs, name, bases, dict)
if 'class_id' in dict:
RODatabase.register_resource_class(cls)
# Lookup fields
if 'fields' not in dict:
cls.fields = [ x for x in dir(cls)
if is_prototype(getattr(cls, x), Field) ]
# Register new fields in the catalog
for name in cls.fields:
if name in dict:
field = dict[name]
if field.indexed or field.stored:
datatype = field.get_datatype()
register_field(name, datatype)
# Ok
return cls
def substitute(data, stack, repeat_stack, encoding='utf-8'):
"""Interprets the given data as a substitution string with the "${expr}"
format, where the expression within the brackets is an STL expression.
Returns a tuple with the interpreted string and the number of
substitutions done.
"""
if type(data) is not str:
raise ValueError, 'byte string expected, not %s' % type(data)
segments = subs_expr.split(data)
for i, segment in enumerate(segments):
if i % 2:
# Evaluate expression
value = evaluate(segment, stack, repeat_stack)
# An STL template (duck typing)
render = getattr(value, 'render', None)
if render:
value = render()
# Ignore if None
if value is None:
continue
# Case MSG: it returns <unicode> or <XMLParser>
if is_prototype(value, MSG):
value = value.gettext()
# Yield
if type(value) is unicode:
yield TEXT, value.encode(encoding), 0
elif is_xml_stream(value):
for x in value:
if type(x) is not tuple:
raise STLError, ERR_EXPR_XML % (type(x), segment)
yield x
else:
yield TEXT, str(value), 0
elif segment:
yield TEXT, segment, 0
def get_view(self, name, query=None):
# Add resource form
if name == 'new_resource' and query:
class_id = query.get('type')
if class_id:
cls = self.database.get_resource_class(class_id)
view = cls.new_instance
if is_prototype(view, BaseView):
context = get_context()
view = view(resource=self, context=context) # bind
# XXX Should we really check access here?
# Should raise forbidden, but callers are not ready.
root = context.root
user = context.user
if not root.has_permission(user, 'add', self, class_id):
return None
if not context.is_access_allowed(self, view):
return None
return view
# Default
return super(Folder, self).get_view(name, query)
def get_view(self, name, query=None):
# Add resource form
if name == 'new_resource' and query:
class_id = query.get('type')
if class_id:
cls = self.database.get_resource_class(class_id)
view = cls.new_instance
if is_prototype(view, BaseView):
context = get_context()
view = view(resource=self, context=context) # bind
# XXX Should we really check access here?
# Should raise forbidden, but callers are not ready.
root = context.root
user = context.user
if not root.has_permission(user, 'add', self, class_id):
return None
if not context.is_access_allowed(self, view):
return None
return view
# Default
return super(Folder, self).get_view(name, query)
def substitute(data, stack, repeat_stack, encoding='utf-8'):
"""Interprets the given data as a substitution string with the "${expr}"
format, where the expression within the brackets is an STL expression.
Returns a tuple with the interpreted string and the number of
substitutions done.
"""
if type(data) is not str:
raise ValueError, 'byte string expected, not %s' % type(data)
segments = subs_expr.split(data)
for i, segment in enumerate(segments):
if i % 2:
# Evaluate expression
value = evaluate(segment, stack, repeat_stack)
# An STL template (duck typing)
render = getattr(value, 'render', None)
if render:
value = render()
# Ignore if None
if value is None:
continue
# Case MSG: it returns <unicode> or <XMLParser>
if is_prototype(value, MSG):
value = value.gettext()
# Yield
if type(value) is unicode:
yield TEXT, value.encode(encoding), 0
elif is_xml_stream(value):
for x in value:
if type(x) is not tuple:
raise STLError, ERR_EXPR_XML % (type(x), segment)
yield x
else:
yield TEXT, str(value), 0
elif segment:
yield TEXT, segment, 0
def substitute_attribute(data, stack, repeat_stack, encoding='utf-8'):
"""Interprets the given data as a substitution string with the "${expr}"
format, where the expression within the brackets is an STL expression.
Returns a tuple with the interpreted string and the number of
substitutions done.
"""
if type(data) is not str:
raise ValueError, 'byte string expected, not %s' % type(data)
# Solo, preserve the value None
match = subs_expr_solo.match(data)
if match is not None:
expression = match.group(1)
value = evaluate(expression, stack, repeat_stack)
# Preserve the value None
if value is None:
return None, 1
# Send the string
if is_prototype(value, MSG):
return value.gettext().encode(encoding), 1
elif type(value) is unicode:
return value.encode(encoding), 1
return str(value), 1
# A little more complex
def repl(match):
expression = match.group(1)
value = evaluate(expression, stack, repeat_stack)
# Remove if None
if value is None:
return ''
# Send the string
if is_prototype(value, MSG):
return value.gettext().encode(encoding)
elif type(value) is unicode:
return value.encode(encoding)
return str(value)
return subs_expr.subn(repl, data)
def rename_handlers(self, new_name):
"""Consider we want to rename this resource to the given 'new_name',
return the old a new names for all the attached handlers (except the
metadata).
This method is required by the "move_resource" method.
"""
langs = self.get_resource('/').get_value('website_languages')
aux = []
for field_name in self.fields:
field = self.get_field(field_name)
if field and is_prototype(field, File_Field):
old = '%s.%s' % (self.name, field_name)
new = '%s.%s' % (new_name, field_name)
if field.multilingual:
for language in langs:
aux.append(('%s.%s' % (old, language),
'%s.%s' % (new, language)))
else:
aux.append((old, new))
return aux
def rename_handlers(self, new_name):
"""Consider we want to rename this resource to the given 'new_name',
return the old a new names for all the attached handlers (except the
metadata).
This method is required by the "move_resource" method.
"""
langs = self.get_resource('/').get_value('website_languages')
aux = []
for field_name in self.fields:
field = self.get_field(field_name)
if field and is_prototype(field, File_Field):
old = '%s.%s' % (self.name, field_name)
new = '%s.%s' % (new_name, field_name)
if field.multilingual:
for language in langs:
aux.append(('%s.%s' % (old, language),
'%s.%s' % (new, language)))
else:
aux.append((old, new))
return aux
def substitute_attribute(data, stack, repeat_stack, encoding='utf-8'):
"""Interprets the given data as a substitution string with the "${expr}"
format, where the expression within the brackets is an STL expression.
Returns a tuple with the interpreted string and the number of
substitutions done.
"""
if type(data) is not str:
raise ValueError, 'byte string expected, not %s' % type(data)
# Solo, preserve the value None
match = subs_expr_solo.match(data)
if match is not None:
expression = match.group(1)
value = evaluate(expression, stack, repeat_stack)
# Preserve the value None
if value is None:
return None, 1
# Send the string
if is_prototype(value, MSG):
return value.gettext().encode(encoding), 1
elif type(value) is unicode:
return value.encode(encoding), 1
return str(value), 1
# A little more complex
def repl(match):
expression = match.group(1)
value = evaluate(expression, stack, repeat_stack)
# Remove if None
if value is None:
return ''
# Send the string
if is_prototype(value, MSG):
return value.gettext().encode(encoding)
elif type(value) is unicode:
return value.encode(encoding)
return str(value)
return subs_expr.subn(repl, data)
def get_field(self, name):
cls = self._resource_class
field = getattr(self, name, None)
if field is None or not is_prototype(field, Field):
field = cls.get_field(name)
return field
def search_schema(self):
schema = {}
for name, field in self._search_fields:
if is_prototype(field, Select_Field):
schema[name] = field.datatype(default=None)
return schema
def send_email(self, to_addr, subject, reply_to=None, text=None,
html=None, encoding='utf-8', subject_with_host=True,
return_receipt=False, attachment=None):
# 1. Check input data
if type(subject) is unicode:
subject = subject.encode(encoding)
elif is_prototype(subject, MSG):
subject = subject.gettext()
else:
raise TypeError, 'unexpected subject of type %s' % type(subject)
if len(subject.splitlines()) > 1:
raise ValueError, 'the subject cannot have more than one line'
if text and not isinstance(text, unicode):
raise TypeError, 'the text must be a Unicode string'
if html and not isinstance(html, unicode):
raise TypeError, 'the html must be a Unicode string'
# 2. Local variables
context = get_context()
server = context.server
mail = self.get_resource('/config/mail')
# 3. Start the message
message = MIMEMultipart('related')
message['Date'] = formatdate(localtime=True)
# 4. From
from_addr = mail.get_value('emails_from_addr').strip()
if from_addr:
# FIXME Parse the address and use Header
message['From'] = from_addr.encode(encoding)
else:
message['From'] = server.smtp_from
# 5. To
if isinstance(to_addr, tuple):
real_name, address = to_addr
to_addr = '%s <%s>' % (Header(real_name, encoding), address)
message['To'] = to_addr
# 6. Subject
if subject_with_host is True:
subject = '[%s] %s' % (context.uri.authority, subject)
message['Subject'] = Header(subject, encoding)
# 7. Reply-To
if reply_to:
message['Reply-To'] = reply_to
elif mail.get_value('emails_reply_to'):
user = context.user
if user:
user_title = Header(user.get_title(), encoding)
user_email = user.get_value('email')
message['Reply-To'] = '%s <%s>' % (user_title, user_email)
# Return Receipt
if return_receipt and reply_to:
message['Disposition-Notification-To'] = reply_to # Standard
message['Return-Receipt-To'] = reply_to # Outlook 2000
# 8. Body
signature = mail.get_value('emails_signature')
if signature:
signature = signature.strip()
if not signature.startswith('--'):
signature = '-- \n%s' % signature
text += '\n\n%s' % signature
# Create MIMEText
if html:
html = html.encode(encoding)
message_html = MIMEText(html, 'html', _charset=encoding)
if text:
text = text.encode(encoding)
message_text = MIMEText(text, _charset=encoding)
# Attach MIMETEXT to message
if text and html:
message_alternative = MIMEMultipart('alternative')
message.attach(message_alternative)
message_alternative.attach(message_text)
message_alternative.attach(message_html)
elif html:
message.attach(message_html)
elif text:
message.attach(message_text)
# Attach attachment
if attachment:
subtype = attachment.get_mimetype()
data = attachment.to_str()
if subtype[:6] == 'image/':
subtype = subtype[6:]
mime_cls = MIMEImage
else:
mime_cls = MIMEApplication
message_attachment = mime_cls(data, subtype)
message_attachment.add_header('Content-Disposition', 'attachment',
filename=attachment.name)
message.attach(message_attachment)
# 6. Send email
server.send_email(message)
def get_field(self, resource, name):
field = getattr(self, name, None)
if field is not None and is_prototype(field, Field):
return field
return resource.get_field(name)
def get_namespace(self, resource, context):
namespace = super(AutoForm, self).get_namespace(resource, context)
# Local Variables
template = context.get_template(self.template_field)
fields = self.get_schema(resource, context)
languages = resource.get_edit_languages(context)
# Build widgets namespace
fields_list = []
fields_dict = {}
first_widget = None
onsubmit = None
for widget in self.get_widgets(resource, context):
widget_name = widget.name
datatype = fields.get(widget.name, None)
field_ns = namespace.get(widget.name, {"name": widget.name, "value": None, "error": None})
field_ns["title"] = getattr(widget, "title", None)
field_ns["id"] = widget.id
field_ns["mandatory"] = getattr(datatype, "mandatory", False)
field_ns["tip"] = widget.tip
field_ns["endline"] = getattr(widget, "endline", False)
# onsubmit
widget_onsubmit = getattr(widget, "onsubmit", None)
if widget_onsubmit is not None and onsubmit is not None:
raise ValueError, "2 widgets want to change onsubmit"
onsubmit = widget_onsubmit
# Get value
if self.method == "get":
value = context.get_query_value(widget.name, datatype)
if issubclass(datatype, Enumerate):
value = datatype.get_namespace(value)
else:
value = field_ns["value"]
if is_prototype(datatype, DateTime) and len(value) <= 10:
value_time = namespace.get("%s_time" % widget.name, {"value": None})
value_time = value_time["value"]
if value_time:
value += "T%s" % value_time
# multilingual or monolingual
field_ns["widgets"] = widgets_html = []
if getattr(datatype, "multilingual", False):
for language in languages:
language_title = get_language_msg(language)
widget = widget(
name="%s:%s" % (widget_name, language),
datatype=datatype,
value=value[language],
language=language_title,
)
widgets_html.append(widget)
if first_widget is None and widget.focus:
first_widget = widget.id
# fix label
if widgets_html:
field_ns["name"] = widgets_html[0].name
else:
widget = widget(datatype=datatype, value=value)
widgets_html.append(widget)
if first_widget is None and widget.focus:
first_widget = widget.id
# Ok
stream = stl(template, field_ns)
fields_list.append(stream)
fields_dict[widget_name] = stream
# Enctype
enctype = "multipart/form-data" if self.method == "post" else None
# Get the actions
actions = self._get_action_namespace(resource, context)
# Before and after
before = self.get_before_namespace(resource, context)
after = self.get_after_namespace(resource, context)
# Build namespace
return {
"form_id": self.form_id,
"before": before,
"actions": actions,
"method": self.method,
"enctype": enctype,
"onsubmit": onsubmit,
"title": self.get_title(context),
"description": self.description,
"first_widget": first_widget,
"fields_list": fields_list,
"fields": fields_dict,
"after": after,
}
def key(item, cache={}):
title = Groups_Datatype.get_value(item.group)
if is_prototype(title, MSG):
title = title.gettext()
return title.lower()
def __init__(self, message, *args, **kw):
if is_prototype(message, MSG):
message = message.gettext()
return super(FormatError, self).__init__(message, *args, **kw)
def get_namespace(self, resource, context):
namespace = super(AutoForm, self).get_namespace(resource, context)
# Local Variables
template = context.get_template(self.template_field)
fields = self.get_schema(resource, context)
languages = resource.get_edit_languages(context)
# Build widgets namespace
fields_list = []
fields_dict = {}
first_widget = None
onsubmit = None
for widget in self.get_widgets(resource, context):
widget_name = widget.name
datatype = fields.get(widget.name, None)
field_ns = namespace.get(widget.name, {
'name': widget.name,
'value': None,
'error': None
})
field_ns['title'] = getattr(widget, 'title', None)
field_ns['id'] = widget.id
field_ns['mandatory'] = getattr(datatype, 'mandatory', False)
field_ns['tip'] = widget.tip
field_ns['endline'] = getattr(widget, 'endline', False)
# onsubmit
widget_onsubmit = getattr(widget, 'onsubmit', None)
if widget_onsubmit is not None and onsubmit is not None:
raise ValueError, "2 widgets want to change onsubmit"
onsubmit = widget_onsubmit
# Get value
if self.method == 'get':
value = context.get_query_value(widget.name, datatype)
if issubclass(datatype, Enumerate):
value = datatype.get_namespace(value)
else:
value = field_ns['value']
if is_prototype(datatype, DateTime) and len(value) <= 10:
value_time = namespace.get('%s_time' % widget.name,
{'value': None})
value_time = value_time['value']
if value_time:
value += 'T%s' % value_time
# multilingual or monolingual
field_ns['widgets'] = widgets_html = []
if getattr(datatype, 'multilingual', False):
for language in languages:
language_title = get_language_msg(language)
lwidget = widget(name='%s:%s' % (widget_name, language),
field_name=widget_name,
datatype=datatype,
value=value[language],
language_name=language,
language=language_title)
widgets_html.append(lwidget)
if first_widget is None and lwidget.focus:
first_widget = lwidget.id
# fix label
if widgets_html:
field_ns['name'] = widgets_html[0].name
else:
widget = widget(field_name=widget_name,
datatype=datatype,
value=value)
widgets_html.append(widget)
if first_widget is None and widget.focus:
first_widget = widget.id
# Ok
stream = stl(template, field_ns)
fields_list.append(stream)
fields_dict[widget_name] = stream
# Enctype
enctype = 'multipart/form-data' if self.method == 'post' else None
# Get the actions
actions = self._get_action_namespace(resource, context)
# Before and after
before = self.get_before_namespace(resource, context)
after = self.get_after_namespace(resource, context)
# Build namespace
return {
'form_id': self.form_id,
'form_css': self.form_css,
'before': before,
'actions': actions,
'method': self.method,
'enctype': enctype,
'onsubmit': onsubmit,
'title': self.get_title(context),
'description': self.description,
'first_widget': first_widget,
'fields_list': fields_list,
'fields': fields_dict,
'after': after
}
def get_field(self, name):
cls = self._resource_class
field = getattr(self, name, None)
if field is None or not is_prototype(field, Field):
field = cls.get_field(name)
return field
def get_field(self, name):
field = getattr(self, name, None)
if is_prototype(field, Field):
return field
return None
def _choice_widget(context, form, datatype, name, value, schema, fields,
readonly, container, container_attributes, choice,
choice_attributes, choice_checked, multiline, tabindex):
html = []
# True -> '1' ; False -> '2'
data = datatype.encode(value)
if readonly:
for option in datatype.get_namespace(data):
attributes = merge_dicts(choice_attributes,
value=option['name'],
disabled=u"disabled")
attributes.setdefault(u"class", []).append(u"disabled")
if option['selected']:
attributes[choice_checked] = choice_checked
value = option['value']
if is_prototype(value, MSG):
value = value.gettext()
content = XMLContent.encode(value)
input = make_element(choice, attributes, content)
if multiline is True:
# Une option par ligne
html.append(make_element(u"div", content=input))
else:
html.append(input)
else:
if type(data) == type("") or type(data) == type(u""):
try:
data_tmp = data.decode("utf-8").split('|')
except:
data_tmp = data
else:
data_tmp = data
for option in datatype.get_namespace(data_tmp):
js = []
opt_name = option['name']
attributes = merge_dicts(choice_attributes, value=opt_name)
if option['selected'] or data == option['name'].strip().encode(
'utf-8'):
attributes[choice_checked] = choice_checked
if form.is_disabled_by_dependency(name, schema, fields):
attributes[u"disabled"] = u"disabled"
attributes.setdefault(u"class", []).append(u"disabled")
# 0005970: Le Javascript pour (dés)activer les autres champs
dep_names = form.get_dep_names(name, schema)
for dep_name in dep_names:
dependency = schema[dep_name].dependency
if not dependency:
continue
# Add js action on simple boolean expressions. ie: "C11"
if not Expression.is_simple(dependency):
# Authorized operators are "==", "=" and "in"
# ie:"C11=='others'", "C11='others'", "'others' in C11"
if 'in' in dependency:
dep_value = dependency.split('in', 1)[0].strip()
elif '==' in dependency:
exclusive, dep_value = dependency.rsplit('==', 1)
elif '!=' in dependency:
exclusive, dep_value = dependency.rsplit('!=', 1)
else:
msg = 'K col operator unknown in "%s"' % dependency
log_warning(msg)
continue
if dep_value[:1] in ("u'", 'u"'):
dep_value = dep_value[:2]
dep_value = (dep_value.replace("'", '').replace('"', ''))
#dep_value = checkid(dep_value)
else:
dep_value = 'false'
js_code = (
'$("input[name=\\"%s\\"][value=\\"%s\\"]")'
'.change(function(){switch_input($(this),"%s","%s");});' %
(name, opt_name, dep_name, dep_value))
js.append(js_code)
# 0005970 fin
value = option['value']
if is_prototype(value, MSG):
value = value.gettext()
content = XMLContent.encode(value)
input = make_element(choice, attributes, content)
if multiline is True:
# Une option par ligne
html.append(make_element(u"div", content=input))
else:
html.append(input)
# Append JS code
content = XMLContent.encode(u'\n'.join(js))
attributes = {u'type': "text/javascript"}
html.append(make_element(u'script', attributes, content))
attributes = merge_dicts(container_attributes,
id=u"field_{name}".format(name=name))
check_errors(context,
form,
datatype,
name,
data,
schema,
fields,
readonly,
attributes,
tabindex=None)
return make_element(container, attributes, u"".join(html))
def get_namespace(self, resource, context):
namespace = super(AutoForm, self).get_namespace(resource, context)
# Local Variables
template = context.get_template(self.template_field)
fields = self.get_schema(resource, context)
languages = resource.get_edit_languages(context)
# Build widgets namespace
fields_list = []
fields_dict = {}
first_widget = None
onsubmit = None
for widget in self.get_widgets(resource, context):
widget_name = widget.name
datatype = fields.get(widget.name, None)
field_ns = namespace.get(widget.name,
{'name': widget.name, 'value': None,
'error': None})
field_ns['title'] = getattr(widget, 'title', None)
field_ns['id'] = widget.id
field_ns['mandatory'] = getattr(datatype, 'mandatory', False)
field_ns['tip'] = widget.tip
field_ns['endline'] = getattr(widget, 'endline', False)
# onsubmit
widget_onsubmit = getattr(widget, 'onsubmit', None)
if widget_onsubmit is not None and onsubmit is not None:
raise ValueError, "2 widgets want to change onsubmit"
onsubmit = widget_onsubmit
# Get value
if self.method == 'get':
value = context.get_query_value(widget.name, datatype)
if issubclass(datatype, Enumerate):
value = datatype.get_namespace(value)
else:
value = field_ns['value']
if is_prototype(datatype, DateTime) and len(value) <= 10:
value_time = namespace.get('%s_time' % widget.name,
{'value': None})
value_time = value_time['value']
if value_time:
value += 'T%s' % value_time
# multilingual or monolingual
field_ns['widgets'] = widgets_html = []
if getattr(datatype, 'multilingual', False):
for language in languages:
language_title = get_language_msg(language)
lwidget = widget(name='%s:%s' % (widget_name, language),
datatype=datatype,
value=value[language],
language=language_title)
widgets_html.append(lwidget)
if first_widget is None and lwidget.focus:
first_widget = lwidget.id
# fix label
if widgets_html:
field_ns['name'] = widgets_html[0].name
else:
widget = widget(datatype=datatype, value=value)
widgets_html.append(widget)
if first_widget is None and widget.focus:
first_widget = widget.id
# Ok
stream = stl(template, field_ns)
fields_list.append(stream)
fields_dict[widget_name] = stream
# Enctype
enctype = 'multipart/form-data' if self.method == 'post' else None
# Get the actions
actions = self._get_action_namespace(resource, context)
# Before and after
before = self.get_before_namespace(resource, context)
after = self.get_after_namespace(resource, context)
# Build namespace
return {
'form_id': self.form_id,
'before': before,
'actions': actions,
'method': self.method,
'enctype': enctype,
'onsubmit': onsubmit,
'title': self.get_title(context),
'description': self.description,
'first_widget': first_widget,
'fields_list': fields_list,
'fields': fields_dict,
'after': after}
def search_schema(self):
schema = {}
for name, field in self._search_fields:
if is_prototype(field, Select_Field):
schema[name] = field.datatype(default=None)
return schema
def key(item, cache={}):
title = Groups_Datatype.get_value(item.group)
if is_prototype(title, MSG):
title = title.gettext()
return title.lower()
def get_field(self, resource, name):
field = getattr(self, name, None)
if field is not None and is_prototype(field, Field):
return field
return resource.get_field(name)
def get_csv_table_name(self, resource, context):
table_name = self.csv_table_name
if is_prototype(table_name, MSG):
table_name = table_name.gettext()
return table_name
