def create_top (self, cmd, ** kw) :
RST = GTW.RST
TOP = RST.TOP
result = TOP.Root \
( language = "de"
, ** kw
)
result.add_entries \
( TOP.MOM.Admin.Site
( name = "Admin"
, short_title = "Admin"
, pid = "Admin"
, title = u"Verwaltung der Homepage"
, head_line = u"Administration der Homepage"
, auth_required = True
, entries = self._nav_admin_groups ()
)
, TOP.Auth
( name = _ ("Auth")
, pid = "Auth"
, short_title = _ ("Authorization and Account handling")
, hidden = True
)
, TOP.L10N
( name = _ ("L10N")
, short_title =
_ ("Choice of language used for localization")
, country_map = dict (de = "AT")
)
)
return result
class A_Date(_A_Date_):
"""Date value."""
example = "2010-10-10"
completer = MOM.Attr.Completer_Spec(4)
typ = _("Date")
P_Type = datetime.date
Q_Ckd_Type = MOM.Attr.Querier.Date
Q_Name = "DATE"
syntax = _("yyyy-mm-dd")
ui_length = 12
input_formats = \
( "%Y-%m-%d", "%Y/%m/%d", "%Y%m%d", "%Y %m %d"
, "%d/%m/%Y", "%d.%m.%Y", "%d-%m-%Y"
)
_tuple_len = 3
class _Doc_Map_(_A_Date_._Doc_Map_):
input_formats = """
The possible strftime-formats used to convert raw values to cooked
values.
"""
# end class _Doc_Map_
def as_rest_cargo_ckd(self, obj, *args, **kw):
value = self.kind.get_value(obj)
if value is not None:
return pyk.text_type(value.strftime("%Y-%m-%d"))
# end def as_rest_cargo_ckd
@TFL.Meta.Class_and_Instance_Method
def cooked(soc, value):
if isinstance(value, datetime.datetime):
value = value.date()
elif isinstance(value, pyk.string_types):
try:
value = soc._from_string(value)
except ValueError:
msg = "Date expected, got %r" % (value, )
raise MOM.Error.Attribute_Syntax(None, soc, value, msg)
elif not isinstance(value, datetime.date):
raise TypeError("Date expected, got %r" % (value, ))
return value
# end def cooked
@classmethod
def now(cls):
return datetime.datetime.now().date()
# end def now
@TFL.Meta.Class_and_Instance_Method
def value_range_delta(self, obj):
from _CAL.Delta import Date_Delta
return Date_Delta(1)
class desc(A_String):
"""Short description of the %(ui_name.lower ())s"""
kind = Attr.Optional
example = _("Office")
max_length = 20
ui_name = _("Description")
completer = Attr.Completer_Spec(1)
class A_Sex(_A_Named_Object_):
"""Sex of a person."""
example = "F"
typ = "Sex"
P_Type = pyk.text_type
Table = \
{ "F" : _("Female")
, "M" : _("Male")
}
def recover (cls, request, value, ttl_s = None) :
"""Recover a signed token from `value`"""
root = request.root
result = cls.__new__ (cls)
result.request = request
result.x_value = value
parts = value.split (cls.val_sep, 2)
if len (parts) != 3 :
if value :
fmt = _ ("Malformed %s value '%s'")
else :
fmt = _ ("Missing %s%s")
result._invalid = _T (fmt) % (cls.__name__, value)
return result
(result.cargo, result.timestamp, result.x_signature) = parts
enc = result.encoding
try:
result.data = data = base64.b64decode (result.cargo).decode (enc)
except Exception as exc :
result._invalid = str (exc)
return result
if not root.HTTP.safe_str_cmp (result.x_signature, result.signature) :
result._invalid = msg = \
_T ("Invalid %s signature for '%s'") % (cls.__name__, data)
logging.warning (msg)
try :
timestamp = base64.b64decode (result.timestamp).decode (enc)
except Exception as exc :
result._invalid = repr (exc)
else :
try :
then = result.time = int (timestamp)
except Exception as exc :
result._invalid = repr (exc)
if result :
now = request.current_time
ttl = ttl_s if ttl_s is not None else request.resource.session_ttl_s
if then < (now - ttl) :
result._invalid = msg = \
( _T ("Expired %s '%s' older then %s seconds")
% (cls.__name__, data, ttl)
)
logging.warning (msg)
elif then > now + 180 :
### don't accept tokens with a timestamp more than 2 minutes in
### the future
result._invalid = msg = \
( _T ("Time-travelling %s '%s' [%s seconds ahead]")
% (cls.__name__, data, then - now)
)
logging.warning (msg)
return result
def recover(cls, request, value, ttl_s=None):
"""Recover a signed token from `value`"""
root = request.root
result = cls.__new__(cls)
result.request = request
result.x_value = value
parts = value.split(cls.val_sep, 2)
if len(parts) != 3:
if value:
fmt = _("Malformed %s value '%s'")
else:
fmt = _("Missing %s%s")
result._invalid = _T(fmt) % (cls.__name__, value)
return result
(result.cargo, result.timestamp, result.x_signature) = parts
enc = result.encoding
try:
result.data = data = base64.b64decode(result.cargo).decode(enc)
except Exception as exc:
result._invalid = str(exc)
return result
if not root.HTTP.safe_str_cmp(result.x_signature, result.signature):
result._invalid = msg = \
_T ("Invalid %s signature for '%s'") % (cls.__name__, data)
logging.warning(msg)
try:
timestamp = base64.b64decode(result.timestamp).decode(enc)
except Exception as exc:
result._invalid = repr(exc)
else:
try:
then = result.time = int(timestamp)
except Exception as exc:
result._invalid = repr(exc)
if result:
now = request.current_time
ttl = ttl_s if ttl_s is not None else request.resource.session_ttl_s
if then < (now - ttl):
result._invalid = msg = \
( _T ("Expired %s '%s' older then %s seconds")
% (cls.__name__, data, ttl)
)
logging.warning(msg)
elif then > now + 180:
### don't accept tokens with a timestamp more than 2 minutes in
### the future
result._invalid = msg = \
( _T ("Time-travelling %s '%s' [%s seconds ahead]")
% (cls.__name__, data, then - now)
)
logging.warning(msg)
return result
class title (A_String) :
"""Academic title"""
kind = Attr.Primary_Optional
ignore_case = True
example = "Dr."
max_length = 20
rank = 2
ui_name = _("Academic title")
ui_name_short = _("Title")
completer = Attr.Completer_Spec (0)
polisher = \
Attr.Polisher.capitalize_if_lower_case_compress_spaces
class A_Int_Range (_A_Range_) :
"""Integer range."""
C_Type = A_Int
P_Type = TFL.Int_Range
example = "[1, 5]"
typ = _ ("Int_Range")
class _Attributes (_A_Range_._Attributes) :
_Ancestor = _A_Range_._Attributes
class btype (_Ancestor.btype) :
default = "[]"
# end class btype
class lower (_Ancestor.lower, A_Int) :
pass
# end class lower
class upper (_Ancestor.upper, A_Int) :
pass
def _test(self):
"""This is a method doc string"""
print(_T(ckw.title or "Baz"))
print(_T("Foo"))
foo = _("Markup %d")
print(_T(foo) % 42)
print(_Tn("Singular", "Plural", 4))
class A_Date_Range(_A_Range_):
"""Date range."""
C_Type = A_Date
P_Type = CAL.Date_Range
example = "[2016-07-05, 2016-07-20]"
typ = _("Date_Range")
class _Attributes(_A_Range_._Attributes):
_Ancestor = _A_Range_._Attributes
class btype(_Ancestor.btype):
default = "[]"
# end class btype
class lower(_Ancestor.lower, A_Date):
ui_name = _("start")
# end class lower
class upper(_Ancestor.upper, A_Date):
ui_name = _("finish")
class A_TX_Power(_A_Unit_, _A_Float_):
"""Transmit Power specified in multiples of W or dBW, dBm,
converted to dBm.
"""
typ = _("TX Power")
needs_raw_value = True
_default_unit = "dBm"
_unit_dict = dict \
( mW = 1
, W = 1.E3
, kW = 1.E6
, MW = 1.E9
, dBm = 1
, dBmW = 1 # alias for dBm, see http://en.wikipedia.org/wiki/DBm
, dBW = 1
)
def _from_string(self, s, obj, glob, locl):
v = self.__super._from_string(s, obj, glob, locl)
pat = self._unit_pattern
unit = ""
if pat.search(s):
unit = pat.unit
if unit.startswith('dB'):
if unit == 'dBW':
v += 30
else:
v = log(v) / log(10) * 10.
return v
class standard(A_Id_Entity):
"""Wireless standard used by the wireless interface."""
kind = Attr.Necessary
P_Type = CNDB.OMP.Wireless_Standard
ui_allow_new = False
ui_name = _("Wi-Fi Standard")
def _test (self) :
"""This is a method doc string"""
print (_T (ckw.title or "Baz"))
print (_T ("Foo"))
foo = _("Markup %d")
print (_T(foo) % 42)
print (_Tn ("Singular", "Plural", 4))
class A_Time_Range(_A_Range_):
"""Time range."""
C_Type = A_Time_X
P_Type = CAL.Time_Range
example = "[08:30, 10:00)"
typ = _("Time_Range")
class _Attributes(_A_Range_._Attributes):
_Ancestor = _A_Range_._Attributes
class btype(_Ancestor.btype):
default = "[)"
# end class btype
class lower(_Ancestor.lower, A_Time_X):
ui_name = _("start")
# end class lower
class upper(_Ancestor.upper, A_Time_X):
ui_name = _("finish")
class Range_Contains(_Range_):
"""Range-Attribute query filter for contains."""
desc = _ \
("Select entities where the attribute contains the specified value")
op_fct = _("CONTAINS")
op_nam = "contains"
class Delete(_Action_):
action = "remove"
css_class = ""
description = _("Delete %(tn)s %(obj)s")
href = None
icon = "trash-o"
class Range_Overlaps(_Range_):
"""Range-Attribute query filter for overlaps."""
desc = _ \
("Select entities where the attribute overlaps the specified range ")
op_fct = _("OVERLAPS")
op_nam = "overlaps"
class left(_Ancestor.left):
"""The wireless standard for this channel"""
role_name = 'standard'
role_type = CNDB.OMP.Wireless_Standard
ui_allow_new = False
ui_name = _("Wi-Fi Standard")
class Change(_Action_):
action = "change"
css_class = ""
description = _("Change %(tn)s %(obj)s")
href = None
icon = "pencil"
class A_IM_Protocol(A_Enum):
"""Instant messaging protocol"""
example = "XMPP"
typ = "im_protocol"
C_Type = A_String
max_length = 16
Table = dict \
( ICQ = _("First internet-wide instant messaging service")
, IRC = _("Internet relay chat")
, XMPP = _
( "Extensible messaging and presence protocol; used by Jabber "
"and Google Talk"
)
)
class Starts_With(_String_):
"""Attribute query for starts-with."""
desc = _ \
( "Select entities where the attribute value starts "
"with the specified value"
)
op_fct = _("STARTSWITH")
class Ends_With(_String_):
"""Attribute query for ends-with."""
desc = _ \
( "Select entities where the attribute value ends "
"with the specified value"
)
op_fct = _("ENDSWITH")
class role(A_String):
"""Role of crew member."""
kind = Attr.Optional
example = _("trimmer")
max_length = 32
completer = Attr.Completer_Spec(1)
class desc(A_String):
"""Description of %(ui_name.lower ())s."""
kind = Attr.Optional
max_length = 160
ui_name = _("Description")
completer = Attr.Completer_Spec(1)
def _auto_doc(cls, attrs, kw):
"""Auto-compute docstring for predicate over `attrs`."""
return \
( _ ("The attribute values for %s must be %s for each object")
% ( portable_repr (attrs) if len (attrs) > 1
else portable_repr (attrs [0])
, cls.Kind_Cls.typ
)
)
def _auto_doc (cls, attrs, kw) :
"""Auto-compute docstring for predicate over `attrs`."""
return \
( _ ("The attribute values for %s must be %s for each object")
% ( portable_repr (attrs) if len (attrs) > 1
else portable_repr (attrs [0])
, cls.Kind_Cls.typ
)
)
class Create(_Action_):
description = _("Create a new %(tn)s")
icon = "plus-circle"
template_macro = "action_button_create"
@Once_Property
@getattr_safe
def href(self):
return self.resource.href_create()
class desc(A_String):
"""Short description of the link"""
kind = Attr.Optional
Kind_Mixins = (Attr.Computed_Set_Mixin, )
max_length = 20
ui_name = _("Description")
completer = Attr.Completer_Spec(1)
def computed(self, obj):
return getattr(obj.right, self.name, "")
def _checkers(self, e_type, kind):
for c in self.__super._checkers(e_type, kind):
yield c
if self.not_in_future:
name = self.name
p_name = "%s__not_in_future" % name
check = MOM.Pred.Condition.__class__ \
( p_name, (MOM.Pred.Condition, )
, dict
( assertion = "%s <= now" % (name, )
, attributes = (name, )
, bindings = dict
( now = "Q.%s.NOW" % (self.Q_Name, )
)
, kind = MOM.Pred.Object
, name = p_name
, __doc__ = _ ("Value must not be in the future")
)
)
yield check
if self.not_in_past:
name = self.name
p_name = "%s__not_in_past" % name
check = MOM.Pred.Condition.__class__ \
( p_name, (MOM.Pred.Condition, )
, dict
( assertion = "%s >= now" % (name, )
, attributes = (name, )
, bindings = dict
( now = "Q.%s.NOW" % (self.Q_Name, )
)
, guard = "not playback_p"
, guard_attr = ("playback_p", )
, kind = MOM.Pred.Object_Init
, name = p_name
, __doc__ =
_ ("Value must be in the future, not the past")
)
)
yield check
def _checkers (self, e_type, kind) :
for c in self.__super._checkers (e_type, kind) :
yield c
if self.not_in_future :
name = self.name
p_name = "%s__not_in_future" % name
check = MOM.Pred.Condition.__class__ \
( p_name, (MOM.Pred.Condition, )
, dict
( assertion = "%s <= now" % (name, )
, attributes = (name, )
, bindings = dict
( now = "Q.%s.NOW" % (self.Q_Name, )
)
, kind = MOM.Pred.Object
, name = p_name
, __doc__ = _ ("Value must not be in the future")
)
)
yield check
if self.not_in_past :
name = self.name
p_name = "%s__not_in_past" % name
check = MOM.Pred.Condition.__class__ \
( p_name, (MOM.Pred.Condition, )
, dict
( assertion = "%s >= now" % (name, )
, attributes = (name, )
, bindings = dict
( now = "Q.%s.NOW" % (self.Q_Name, )
)
, guard = "not playback_p"
, guard_attr = ("playback_p", )
, kind = MOM.Pred.Object_Init
, name = p_name
, __doc__ =
_ ("Value must be in the future, not the past")
)
)
yield check
def __init__ \
(self, e_type, needed, missing, epk, kw, kind = _("required")) :
kw = dict (kw)
raw = kw.pop ("raw", False)
self.__super.__init__ (e_type, raw)
self.attributes = missing
self.epk = epk
self.e_type = e_type
self.kind = kind
self.kw = kw
self.missing = missing
self.needed = needed
self.val_disp = kw
self.args = (self.head, self.description)
def __init__ \
(self, e_type, needed, missing, epk, kw, kind = _("required")) :
kw = dict (kw)
raw = kw.pop ("raw", False)
self.__super.__init__ (e_type, raw)
self.attributes = missing
self.epk = epk
self.e_type = e_type
self.kind = kind
self.kw = kw
self.missing = missing
self.needed = needed
self.val_disp = kw
self.args = (self.head, self.description)
class sn(A_Numeric_String):
"""Subscriber number (without country code, network destination code, extension)"""
kind = Attr.Primary_Optional
max_length = 14
min_length = 3
check = ("value != '0'", )
example = "234567"
rank = 3
ui_name = _("Subscriber number")
ui_rank = -3
completer = Attr.Completer_Spec(1, Attr.Selector.primary)
polisher = PAP.E164.Polisher.SN()
class A_DNS_Time(_A_Unit_, _A_Int_):
""" Allow specification of DNS times in other units than seconds """
typ = _("DNS Time")
needs_raw_value = True
min_value = 0
max_value = 2147483647
_unit_dict = dict \
( seconds = 1
, minutes = 60
, hours = 60 * 60
, days = 60 * 60 * 24
, weeks = 60 * 60 * 24 * 7
)
class A_Time_Delta(A_Attr_Type):
"""Time delta value."""
example = "1 h"
completer = MOM.Attr.Completer_Spec(0)
typ = _("Time-Delta")
P_Type = datetime.timedelta
Pickler = Pickler_As_String
syntax = _ \
( "hh:mm:ss, the seconds `ss` are optional\n"
"One can also use values like::\n"
" 30m"
" 20 minutes"
" 1.5h10.25m7.125s"
" 1.5 hours 10.25 minutes 7.125 seconds"
" 1.5 hours, 10.25 minutes, 7.125 seconds"
)
@TFL.Meta.Class_and_Instance_Method
def cooked(soc, value):
if value is not None:
msg = "%s expected, got %r" % (soc.typ, value)
if isinstance(value, pyk.string_types):
try:
value = CAL.Time_Delta.from_string(value)._body
except ValueError:
raise MOM.Error.Attribute_Syntax(None, soc, value, msg)
elif not isinstance(value, (datetime.timedelta)):
raise TypeError(msg)
return value
# end def cooked
@TFL.Meta.Class_and_Instance_Method
def as_string(soc, value):
result = ""
if value is not None:
result = str(value)
if result.endswith(":00"):
result = result[:-3]
return result
# end def as_string
@TFL.Meta.Class_and_Instance_Method
def _from_string(soc, s, obj=None):
s = s.strip()
if s:
return soc.cooked(s)
def _description (self) :
return _ ("Number of %s belonging to %s")
def iso_7064_mod11_10 (cls, vin) :
result = 0
for i in vin :
result = (((result or 10) * 2) % 11 + int (i)) % 10
return result == 1
# end def iso_7064_mod11_10
@classmethod
def mod11 (cls, vin) :
return not (vin % 11)
# end def mod11
# end class _Country_Rule_
### EU
_Country_Rule_ ( "AT", _ ("Austria"), r"U\d{8}")
_Country_Rule_ ( "BE", _ ("Belgium"), r"[01]\d{9}")
_Country_Rule_ ( "BG", _ ("Bulgaria"), r"\d{9,10}")
_Country_Rule_ ( "CZ", _ ("Czech Republic "), r"\d{8,10}")
_Country_Rule_ ( "DE", _ ("Germany"), r"\d{9}")
_Country_Rule_ ( "DK", _ ("Denmark"), r"\d{8}")
_Country_Rule_ ( "EE", _ ("Estland"), r"\d{9}")
_Country_Rule_ ( "EL", _ ("Greece"), r"\d{9}")
_Country_Rule_ ( "ES", _ ("Spain"), r"[A-Z0-9]\d{7}[A-Z0-9]")
_Country_Rule_ ( "FI", _ ("Finland"), r"\d{8}")
_Country_Rule_ ( "FR", _ ("France"), r"\d{2}\d{9}"
, checker = _Country_Rule_.fr_checker
)
_Country_Rule_ ( "GB", _ ("United Kingdom"), r"\d{9}(?:\d{3})?")
_Country_Rule_ ( "HR", _ ("Croatia"), r"\d{11}"
, checker = _Country_Rule_.iso_7064_mod11_10
# Test file which will be parsed.
#
# Revision Dates
# 15-Apr-2010 (MG) Creation
# 10-Oct-2016 (CT) Make Python-3 compatible
# ««revision-date»»···
# --
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from _TFL.I18N import _, _T, _Tn, Translations, Config
import os
_("Just markup")
print(_T("Markup and translation"))
print(_Tn("Singular", "Plural", 2))
path = os.path.join(os.path.dirname(__file__), "-I18N", "de.mo")
Config.current = Translations(open(path), "messages")
print("_T tests")
print(_T("Just markup"))
print(_T("Markup and translation"))
print(_T("Singular"))
print(_T("Plural"))
print("_Tn tests")
print(_Tn("Singular", "Plural", 0))
print(_Tn("Singular", "Plural", 1))
print(_Tn("Singular", "Plural", 2))
return [node], []
# end def _added_role
register_local_role ("added", _added_role)
def _deleted_role (role, rawtext, text, lineno, inliner, options={}, content=[]) :
cssc = "deleted" if len (rawtext) > 60 else "deleted-inline"
node = nodes.inline (rawtext, text, classes = [cssc], ** options)
return [node], []
# end def _deleted_role
register_local_role ("deleted", _deleted_role)
### http://de.wikipedia.org/wiki/Anf%C3%BChrungszeichen#Kodierung
_quot_map = dict \
( qd = (_("\u201C"), _("\u201D")) # ("“", "”")
, qf = (_("\u2039"), _("\u203A")) # ("‹", "›")
, qg = (_("«"), _("»")) # ("«", "»")
, qs = (_("\u2018"), _("\u2019")) # ("‘", "’")
)
def _quoted_role \
(role, rawtext, text, lineno, inliner, options={}, content=[]) :
ql, qr = _quot_map.get (role) or _quot_map ["qd"]
text = "%s%s%s" % (_T (ql), text, _T (qr))
node = nodes.inline (rawtext, text, ** options)
return [node], []
# end def _quoted_role
register_local_role ("q", _quoted_role)
register_local_role ("qd", _quoted_role)
def create_top (self, cmd, ** kw) :
import _GTW._RST._TOP.import_TOP
import rst_top
RST = GTW.RST
TOP = RST.TOP
auth_r \
= TOP.MOM.Admin.E_Type._auth_required \
= TOP.MOM.Admin.Group._auth_required \
= cmd.auth_required
result = rst_top.create (cmd, ** kw)
result.add_entries \
( RST_addons.Dashboard
( auth_required = auth_r
, pid = "DB"
)
, TOP.Page_ReST
( name = "about"
, short_title = "Über Funkfeuer"
, title = "Über Funkfeuer"
, page_template_name = "html/dashboard/about.jnj"
)
, TOP.Dir
( name = "My-Funkfeuer"
, short_title = "My Funkfeuer"
, auth_required = auth_r
, permission = RST_addons.Login_has_Person
, entries =
[ RST_addons.User_Node
( name = "node"
)
, RST_addons.User_Net_Device
( name = "device"
, short_title = _T ("Device")
)
, RST_addons.User_Net_Interface
( name = "interface"
, short_title = _T ("Interface")
)
, RST_addons.User_Net_Interface_in_IP_Network
( name = "interface_in_ip_network"
, short_title = _T ("Interface in Network")
, hidden = True
)
, RST_addons.User_Wired_Interface
( name = "wired-interface"
, short_title = _T ("Wired_Interface")
)
, RST_addons.User_Wireless_Interface
( name = "wireless-interface"
, short_title = _T ("Wireless_Interface")
)
, RST_addons.User_Antenna
( name = "antenna"
, short_title = _T ("Antenna")
)
, RST_addons.User_Person
( name = "person"
, hidden = True
)
, RST_addons.User_Person_has_Address
( name = "has_address"
, hidden = True
)
, RST_addons.User_Person_has_Account
( name = "has_account"
, hidden = True
)
, RST_addons.User_Person_has_Email
( name = "has_email"
, hidden = True
)
, RST_addons.User_Person_has_IM_Handle
( name = "has_im_handle"
, hidden = True
)
, RST_addons.User_Person_has_Phone
( name = "has_phone"
, hidden = True
)
]
)
, TOP.MOM.Doc.App_Type
( name = "Doc"
, short_title = _ ("Model doc")
, title = _ ("Documentation for FFG object model")
)
, TOP.Alias \
( name = "/Doc/FFG"
, target = "/Doc/CNDB"
, hidden = True
)
, TOP.MOM.Admin.Site
( name = "Admin"
, short_title = "Admin"
, pid = "Admin"
, title = _ ("Administration of FFG node database")
, head_line = _ ("Administration of FFG node database")
, auth_required = auth_r
, entries =
[ self.nav_admin_group
( "FFG"
, _ ("Administration of node database")
, "CNDB"
, permission = RST.In_Group ("FFG-admin")
if auth_r else None
)
, self.nav_admin_group
( "PAP"
, _ ("Administration of persons/addresses...")
, "GTW.OMP.PAP"
, permission = RST.In_Group ("FFG-admin")
if auth_r else None
)
, self.nav_admin_group
( _ ("Users")
, _ ("Administration of user accounts and groups")
, "GTW.OMP.Auth"
, permission = RST.Is_Superuser ()
)
]
)
, GTW.RST.MOM.Scope
( name = "api"
, auth_required = auth_r
, exclude_robots = True
, json_indent = 2
, pid = "RESTful"
)
, TOP.Page_ReST
( name = "impressum"
, short_title = "Impressum"
, title = "Impressum"
, page_template_name = "html/dashboard/static.jnj"
, src_contents = impressum_contents
)
, GTW.RST.MOM.Doc.App_Type
( name = "api-doc"
, hidden = True
)
, TOP.Auth
( name = _ ("Auth")
, pid = "Auth"
, short_title = _ (u"Authorization and Account handling")
, hidden = True
)
, TOP.L10N
( name = _ ("L10N")
, short_title =
_ (u"Choice of language used for localization")
, country_map = dict (de = "AT")
)
, TOP.Robot_Excluder ()
)
if cmd.debug :
result.add_entries \
( TOP.Console
( name = "Console"
, short_title = _ ("Console")
, title = _ ("Interactive Python interpreter")
, permission = RST.Is_Superuser ()
)
, RST.Raiser
( name = "RAISE"
, hidden = True
)
)
if result.DEBUG :
scope = result.__dict__.get ("scope", "*not yet created*")
print ("RST.TOP root created,", scope)
return result
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from _CAL import CAL
from _TFL import TFL
from _TFL.I18N import _
import _TFL.G8R
Month_Abbrs = TFL.G8R \
( [ _("Jan"), _("Feb"), _("Mar"), _("Apr"), _("May"), _("Jun")
, _("Jul"), _("Aug"), _("Sep"), _("Oct"), _("Nov"), _("Dec")
]
)
Month_Names = TFL.G8R \
( [ _("January"), _("February"), _("March")
, _("April"), _("May"), _("June")
, _("July"), _("August"), _("September")
, _("October"), _("November"), _("December")
]
)
Months = TFL.G8R (Month_Abbrs.words, Month_Names.words)
Recurrence_Units = TFL.G8R \
def __repr__ (self) :
return pyk.reprify (_ ("Infinity"))
def create_top (self, cmd, ** kw) :
import _GTW._RST._TOP.import_TOP
import rst_top
RST = GTW.RST
TOP = RST.TOP
auth_r \
= TOP.MOM.Admin.E_Type._auth_required \
= TOP.MOM.Admin.Group._auth_required \
= cmd.auth_required
result = rst_top.create (cmd, ** kw)
result.add_entries \
( TOP.Dir
( name = "My-Funkfeuer"
, short_title = "My Funkfeuer"
, auth_required = auth_r
, permission = RST_addons.Login_has_Person
, entries =
[ RST_addons.User_Node
( name = "node"
)
, RST_addons.User_Net_Device
( name = "device"
, short_title = _T ("Device")
)
, RST_addons.User_Wired_Interface
( name = "wired-interface"
, short_title = _T ("Wired IF")
)
, RST_addons.User_Wireless_Interface
( name = "wireless-interface"
, short_title = _T ("Wireless IF")
)
]
)
, TOP.Page_ReST
( name = "Funkfeuer"
, short_title = "Funkfeuer?"
, title = "Was ist Funkfeuer?"
, src_contents = landing_page
)
, TOP.MOM.Doc.App_Type
( name = "Doc"
, short_title = _ ("Model doc")
, title = _ ("Documentation for FFM object model")
)
, TOP.MOM.Admin.Site
( name = "Admin"
, short_title = "Admin"
, pid = "Admin"
, title = _ ("Administration of FFM node database")
, head_line = _ ("Administration of FFM node database")
, auth_required = auth_r
, entries =
[ self.nav_admin_group
( "FFM"
, _ ("Administration of node database")
, "FFM"
, permission = RST.In_Group ("FFM-admin")
if auth_r else None
)
, self.nav_admin_group
( "PAP"
, _ ("Administration of persons/addresses...")
, "GTW.OMP.PAP"
, permission = RST.In_Group ("FFM-admin")
if auth_r else None
)
, self.nav_admin_group
( _ ("Users")
, _ ("Administration of user accounts and groups")
, "GTW.OMP.Auth"
, permission = RST.Is_Superuser ()
)
]
)
, GTW.RST.MOM.Scope
( name = "api"
, auth_required = auth_r
, exclude_robots = True
, json_indent = 2
)
, TOP.Auth
( name = _ ("Auth")
, pid = "Auth"
, short_title = _ (u"Authorization and Account handling")
, hidden = True
)
, TOP.L10N
( name = _ ("L10N")
, short_title =
_ (u"Choice of language used for localization")
, country_map = dict (de = "AT")
)
, TOP.Robot_Excluder ()
)
if cmd.debug :
result.add_entries \
( TOP.Console
( name = "Console"
, short_title = _ ("Console")
, title = _ ("Interactive Python interpreter")
, permission = RST.Is_Superuser ()
)
, RST.Raiser
( name = "RAISE"
, hidden = True
)
)
if result.DEBUG :
scope = result.__dict__.get ("scope", "*not yet created*")
print ("RST.TOP root created, Scope", scope)
return result
from _TFL.pyk import pyk
from _TFL.Regexp import *
from _TFL._Meta.Once_Property import Once_Property
import _TFL._Meta.Object
import _TFL.Caller
from random import randrange
_obfuscator_format = """\
<a class="nospam" title="%(need)s">%(text)s</a>\
<b class="nospam" title="%(js_args)s"></b>\
"""
scheme_map = dict \
( mailto = _("email address")
, tel = _("phone number")
)
def obfuscated (text) :
"""Return `text` as (slightly) obfuscated Javascript array."""
result = ",".join \
( "%s%+d" % (s, c - s)
for (c, s) in ((ord (c), randrange (1, 256)) for c in text)
)
return result
# end def obfuscated
def _obfuscator (scheme = "mailto") :
def _rep (match) :
return _obfuscator_format % dict \
