class MyRoot(RootController):
"""A small root controller for our exception handling tests"""
[expose()]
def no_error(self, name):
"""Test controller"""
Person(name=name)
raise redirect("/confirm")
def e_handler(self, tg_exceptions=None):
"""Test error handler"""
cherrypy.response.code = 501
return "An exception occurred: %r (%s)" % ((tg_exceptions, ) * 2)
[expose()]
def create_person(self, id, docom=0, doerr=0, doflush=0):
"""Test controller"""
Person(id=id)
if int(docom):
cherrypy.request.sa_transaction.commit()
if int(doerr) == 1:
raise Exception('User generated exception')
if int(doerr) == 2:
raise turbogears.redirect('/')
if int(doflush):
try:
session.flush()
except Exception:
if int(doflush) == 1:
raise
return "No exceptions occurred"
create_person = errorhandling.exception_handler(e_handler)(create_person)
class MyRoot(turbogears.controllers.RootController):
def test(self):
return dict(form=form)
test = turbogears.expose(template=".form")(test)
def test_value(self):
value = dict(repeat=[{
'name': 'foo',
'comment': 'hello'
}, None, None, {
'name': 'bar',
'comment': 'byebye'
}])
return dict(form=form, value=value)
test_value = turbogears.expose(template=".form")(test_value)
def test_validation(self):
return dict(form=form)
test_validation = turbogears.expose(template=".form")(test_validation)
test_validation = turbogears.validate(form=form)(test_validation)
test_validation = turbogears.error_handler(test_validation)(
test_validation)
class MyRoot(controllers.RootController):
def set_name(self, name):
cookies = cherrypy.response.simple_cookie
cookies['name'] = name
return "Hello " + name
set_name = expose()(set_name)
def get_name(self):
cookies = cherrypy.request.simple_cookie
if 'name' in cookies:
return cookies['name'].value
else:
return "cookie not found"
get_name = expose()(get_name)
def get_unicode_name(self):
"""Return a nonsense string of non-ascii characters"""
cherrypy.response.headers[
'Content-Type'] = 'text/plain; encoding=utf-8'
return u'\u1234\u9876\u3456'.encode('utf-8')
get_unicode_name = expose()(get_unicode_name)
def redirect(self):
raise redirect("foo")
redirect = expose()(redirect)
class MyRoot(controllers.RootController):
[expose()]
def fields(self):
return tf.render(format='xhtml')
[expose()]
def override(self):
return tf2.render(format='xhtml')
class ExposeRoot(controllers.RootController):
[expose("turbogears.tests.simple")]
[expose("json")]
def with_json(self):
return dict(title="Foobar", mybool=False, someval="foo")
[expose("turbogears.tests.simple")]
[expose("json", accept_format = "application/json", as_format="json")]
[expose('cheetah:turbogears.tests.textfmt', accept_format="text/plain")]
def with_json_via_accept(self):
return dict(title="Foobar", mybool=False, someval="foo")
class NestedController(controllers.Controller):
[expose()]
[validate(form=nestedform)]
def checkform(self, foo):
self.foo = foo
class RemoteFormDesc(CoreWD):
name = "AJAX Form"
class TestFormFields(WidgetsList):
name = TextField()
age = TextField()
check = CheckBox()
radio = RadioButtonList(options=list(enumerate(
"Python Java Pascal Ruby".split())), default=3)
template = """
<div>
${for_widget.display()}
<div id="post_data"> </div>
</div>
"""
full_class_name = "turbogears.widgets.RemoteForm"
def __init__(self, *args, **kw):
super(RemoteFormDesc, self).__init__(*args, **kw)
self.for_widget = RemoteForm(
fields = self.TestFormFields(),
name="remote_form",
update = "post_data",
action = "%s/post_data_rf" % self.full_class_name,
before = "alert('pre-hook')",
confirm = "Confirm?",
)
[expose()]
def post_data_rf(self, **kw):
return """Received data:<br/>%r""" % kw
def import_service(self, base, servicedir):
service = DataObject()
sys.path.insert(0, base)
module = __import__(servicedir)
sys.path.remove(base)
service_data = module.init()
service.ServiceClass = service_data['service_class']
service.name = service_data.get('name', servicedir)
service.title = service_data.get('title')
service.version = service_data.get('version')
service.model = service_data.get('model')
service.obj = service.ServiceClass()
service.status = 'Running'
service.started = datetime.now()
service.methods = []
for m in dir(service.obj):
member = getattr(service.obj, m)
if 'webmethodtype' in dir(member):
t = member.__dict__['webmethodtype']
service.methods.append(m)
member = expose(member)
return service
class AutoCompleteTextFieldDesc(CoreWD):
name = "AutoCompleteTextField"
states = AutoCompleteFieldDesc.states
state_code = AutoCompleteFieldDesc.state_code
template = """
<table xmlns:py="http://purl.org/kid/ns#">
<tr><th>State</th><td py:content="for_widget.display()"/></tr>
</table>
"""
full_class_name = "turbogears.widgets.AutoCompleteTextField"
def __init__(self, *args, **kw):
super(AutoCompleteTextFieldDesc, self).__init__(*args, **kw)
self.for_widget = AutoCompleteTextField(name="state_only",
search_controller="%s/search" % self.full_class_name,
search_param="state", result_name="states")
[expose(format="json")]
def search(self, state):
states = []
code = state.upper()
if code in self.state_code:
states.append(self.state_code[code])
else:
states.extend([s for s in self.states
if s.lower().startswith(state.lower())])
return dict(states=states)
class Controller(controllers.RootController):
[expose()]
[validate(validators=AddingNestedSchema(), state_factory=State)]
def validation(self, a, b, c):
return 'counter: %d' % cherrypy.request.validation_state.counter
def expose(*args, **kw):
"""BusyBe's version of Turbogear's version of Cherrypy's expose.
This is for the authentication of the user.
"""
decorator = turbogears.expose(*args, **kw)
return decorator
class VisitRoot(controllers.RootController):
[expose()]
def index(self):
cur_visit = visit.current()
return cur_visit.key
class AjaxGridDesc(CoreWD):
name = "AJAX Grid"
def facgen(n):
total = 1
yield 0, 1
for x in xrange(1, n+1):
total *= x
yield x, total
facgen = staticmethod(facgen)
full_class_name = "turbogears.widgets.AjaxGrid"
def __init__(self, *args, **kw):
super(AjaxGridDesc, self).__init__(*args, **kw)
self.for_widget = AjaxGrid(
refresh_url = "%s/update" % self.full_class_name,
# Dummy default params, just POC
defaults = dict(),
)
self.update_count = itertools.count()
[expose(format="json")]
def update(self):
return dict(
headers = ["N", "fact(N)"],
rows = list(self.facgen(self.update_count.next())),
)
class MyRoot(controllers.RootController):
def testform(self, p_data, tg_errors=None):
if tg_errors:
self.has_errors = True
self.name = p_data['name']
self.age = p_data['age']
testform = turbogears.validate(form=myform)(testform)
testform = turbogears.expose(template="turbogears.tests.othertemplate")(
testform)
def set_errors(self):
self.has_errors = True
def testform_new_style(self, p_data):
self.name = p_data['name']
self.age = p_data['age']
testform_new_style = turbogears.validate(form=myform)(testform_new_style)
testform_new_style = turbogears.error_handler(set_errors)(testform_new_style)
testform_new_style = turbogears.expose()(testform_new_style)
class CaptchaController(controllers.Controller):
def __init__(self):
key = tg.config.get('tgcaptcha.key', 'secret')
if key == 'secret':
log.warning('You need to set the "tgcaptcha.key" value in your '
'config file')
key = sha.new(key).hexdigest()[:32]
random.seed()
self.aes = AES.new(key, AES.MODE_ECB)
self.jpeg_generator = None
# find the jpeg generator
jpeg_gen = tg.config.get('tgcaptcha.jpeg_generator', 'vanasco_dowty')
for ep in iter_entry_points('tgcaptcha2.jpeg_generators', jpeg_gen):
self.jpeg_generator = ep.load()
# find the text generator
self.text_generator = None
txt_gen = tg.config.get('tgcaptcha.text_generator', 'random_ascii')
for ep in iter_entry_points('tgcaptcha2.text_generators', txt_gen):
self.text_generator = ep.load()
def image(self, value):
"Serve a jpeg for the given payload value."
scp = self.model_from_payload(value)
f = StringIO()
if scp.label is not None and scp.label != None:
self.jpeg_generator(scp.label, f)
else:
self.jpeg_generator(scp.plaintext, f)
cherrypy.response.headers['Content-Type'] = 'image/jpeg'
f.seek(0)
return f.read()
image = expose()(image)
def create_payload(self):
"Create a payload that uniquely identifies the captcha."
c = model.Captcha()
c.plaintext = self.text_generator()
if isinstance(c.plaintext, tuple):
c.label = "%i + %i" % (c.plaintext[0], c.plaintext[1])
c.plaintext = str(c.plaintext[0] + c.plaintext[1])
s = c.serialize()
# pad shortfall with multiple Xs
if len(s) % 16:
pad = (16 - (len(s) % 16)) * 'X'
s = "".join((s, pad))
enc = self.aes.encrypt(s)
return base64.urlsafe_b64encode(enc)
def model_from_payload(self, ascii_payload):
"Convert a payload to a SCPayload object."
enc = base64.urlsafe_b64decode(ascii_payload)
s = self.aes.decrypt(enc)
s = s.rstrip('X')
return model.Captcha.deserialize(s)
class FreshRoot(RootController):
"""A small root controller for our session freshness tests"""
[expose()]
def test1(self):
assert session.query(Test).get(1).val == 'a'
return dict()
[expose()]
def test2(self):
session.query(Test).get(1).val = 'b'
return dict()
[expose()]
def test3(self):
assert session.query(Test).get(1).val == 'b'
return dict()
class MyRoot(turbogears.controllers.RootController):
def test(self):
return dict(form1=form1, form2=form2)
test = turbogears.expose(template=".two_forms")(test)
test = turbogears.validate(form=form1)(test)
test = turbogears.error_handler(test)(test)
def test2(self):
return dict(form=form2)
test2 = turbogears.expose(template=".form")(test2)
test2 = turbogears.validate(form=form2)(test2)
test2 = turbogears.error_handler(test2)(test2)
def test3(self):
return dict(form=form1)
test3 = turbogears.expose(template=".form")(test3)
test3 = turbogears.validate(form=form2)(test3)
test3 = turbogears.error_handler(test3)(test3)
class AutoCompleteFieldDesc(CoreWD):
name = "AutoCompleteField"
codes = """AK AL AR AS AZ CA CO CT DC DE FL FM GA GU HI IA ID IL IN KS
KY LA MA MD ME MH MI MN MO MP MS MT NC ND NE NH NJ NM NV NY OH
OK OR PA PR PW RI SC SD TN TX UM UT VA VI VT WA WI WV WY""".split()
states = """Alaska Alabama Arkansas American_Samoa Arizona
California Colorado Connecticut District_of_Columbia
Delaware Florida Federated_States_of_Micronesia Georgia Guam
Hawaii Iowa Idaho Illinois Indiana Kansas Kentucky Louisiana
Massachusetts Maryland Maine Marshall_Islands Michigan
Minnesota Missouri Northern_Mariana_Islands Mississippi
Montana North_Carolina North_Dakota Nebraska New_Hampshire
New_Jersey New_Mexico Nevada New_York Ohio Oklahoma Oregon
Pennsylvania Puerto_Rico Palau Rhode_Island South_Carolina
South_Dakota Tennessee Texas U.S._Minor_Outlying_Islands
Utah Virginia Virgin_Islands_of_the_U.S. Vermont Washington
Wisconsin West_Virginia Wyoming""".split()
states = map(lambda s: s.replace('_', ' '), states)
state_code = dict(zip(codes, states))
template = """
<form xmlns:py="http://purl.org/kid/ns#" onsubmit="if (
this.elements[0].value && this.elements[1].value)
alert('The alpha code for '+this.elements[0].value
+' is '+this.elements[1].value+'.');return false"><table>
<tr><th>State</th><td py:content="for_widget.display()"/>
<td><input type="submit" value="Show alpha code"/></td></tr>
</table></form>
"""
full_class_name = "turbogears.widgets.AutoCompleteField"
def __init__(self, *args, **kw):
super(AutoCompleteFieldDesc, self).__init__(*args, **kw)
self.for_widget = AutoCompleteField(name="state_and_code",
search_controller="%s/search" % self.full_class_name,
search_param="state", result_name="states")
[expose(format="json")]
def search(self, state):
states = []
code = state.upper()
if code in self.state_code:
states.append((self.state_code[code], code))
else:
states.extend([s for s in zip(self.states, self.codes)
if s[0].lower().startswith(state.lower())])
return dict(states=states)
class MyRoot(controllers.RootController):
[expose(template="turbogears.tests.form")]
def index(self):
return dict(form=myform)
[expose(template="turbogears.tests.form")]
def fields(self):
myfields.display = lambda **kw: kw.values()
return dict(form=myfields)
[expose(template="turbogears.tests.form")]
def usemochi(self):
return dict(mochi=mochikit, form=myform)
[expose(template="turbogears.tests.othertemplate")]
[validate(form=myform)]
def testform(self, name, date, age, tg_errors=None):
if tg_errors:
self.has_errors = True
self.name = name
self.age = age
self.date = date
[expose()]
[validate(form=myform)]
def testform_new_style(self, name, date, age):
if cherrypy.request.validation_errors:
self.has_errors = True
self.name = name
self.age = age
self.date = date
class RestrictedArea(Controller, SecureResource):
require = in_group('peon')
[expose()]
def index(self):
return "restricted_index"
[expose()]
[identity.require(in_group('admin'))]
def in_admin_group(self):
return 'in_admin_group'
[expose()]
[identity.require(in_group('other'))]
def in_other_group(self):
return 'in_other_group'
[expose()]
def in_admin_group_explicit_check(self):
if 'admin' not in identity.current.groups:
raise identity.IdentityFailure("You need to be an Admin")
else:
return 'in_admin_group'
[expose()]
def in_other_group_explicit_check(self):
if 'other' not in identity.current.groups:
raise identity.IdentityException
else:
return 'in_other_group'
class RbRoot(RootController):
"""A small root controller for our transaction rollback tests"""
def handerr(self, id):
"""Test error handler"""
Person(id=int(id) + 1)
return dict()
[expose()]
def doerr(self, id, dorb=0):
"""Test controller"""
Person(id=id)
if int(dorb):
cherrypy.request.sa_transaction.rollback()
raise Exception('test')
doerr = errorhandling.exception_handler(handerr)(doerr)
class LinkRemoteFunctionDesc(CoreWD):
name = "AJAX remote function"
states = AutoCompleteFieldDesc.states
template = """
<div id="items">
${for_widget.display("States starting with the letter 'N'", update="items")}
</div>
"""
full_class_name = "turbogears.widgets.LinkRemoteFunction"
def __init__(self, *args, **kw):
super(LinkRemoteFunctionDesc, self).__init__(*args, **kw)
self.for_widget = LinkRemoteFunction(
name="linkrf", action="%s/search_linkrf" % self.full_class_name,
data = dict(state_starts_with="N"))
[expose()]
def search_linkrf(self, state_starts_with):
return '<br/>'.join(filter(
lambda item: item.startswith(state_starts_with), self.states))
class ListFormDesc(CoreWD):
name = "List Form"
full_class_name = "turbogears.widgets.ListForm"
field1 = TextField("name")
field2 = TextField("address")
field3 = TextField("occupation")
field4 = PasswordField("password")
field5 = PasswordField("reserved") # will never show
field6 = HiddenField("hidden_info")
for_widget = ListForm(
"ListForm",
fields=[field1, field2, field3, field4, field5, field6],
action="%s/save" % full_class_name,
submit_text="Submit Me")
template = """
<div>
${for_widget.display(disabled_fields=["reserved"])}
</div>
"""
[expose()]
def save(self, **kw):
return """Received data from ListForm:<br />%r""" % kw
objectName = v['objectName']
obj = self.load_object(objectName)
cols = self.object_columns(objectName)
params = self.extract_parameters(cols,v)
if not params: return self.instances(objectName)
try:
new_object = obj(**params)
except Exception, e:
cherrypy.response.status = 500
return dict(error=str(e))
if not new_object: return self.instances(objectName)
returnlist = self.object_instance(objectName,'%s'% new_object.id)
returnlist["msg"] = "A new instance of %s was created" % objectName
return returnlist
add = turbogears.expose(format="json")(add)
def update(self,**values):
"""Update the objects properties
@param values: dictionary of key and values, as a bare minimum
the name of the object (objectName) and the id
"""
object_name = values.get('objectName','')
id = values.get('id','')
try:
self.update_object(object_name,id,values)
except Exception, e:
cherrypy.response.status = 500
return dict(error=str(e))
returnlist = self.object_instances(object_name)
print "Fail to remove temporary model file: %s" % e
return dict(status=status)
def load_session_list(self):
sessions_directory = pkg_resources.resource_filename(
__name__, os.path.join('static', 'sessions'))
return [
x.replace('.js', '') for x in os.listdir(sessions_directory)
if x.endswith('.js')
]
def session_exists(self):
return os.path.exists(session_file_name)
[expose(format='json')]
def retrieve_sample(self, name):
sessions_directory = pkg_resources.resource_filename(
__name__, os.path.join('static', 'sessions'))
full_path = os.path.join(sessions_directory, '%s.js' % name)
if not os.path.exists(full_path):
return dict()
return dict(session=open(full_path, 'r').read())
[expose(format='json')]
def current_session_model(self):
if not self.session_exists():
return dict()
return dict(session=open(session_file_name, 'r').read())
def wsexpose(*args, **kwargs):
tg_json_expose = expose('wsmejson:',
accept_format='application/json',
content_type='application/json',
tg_format='json')
tg_altjson_expose = expose('wsmejson:',
accept_format='text/javascript',
content_type='application/json')
tg_xml_expose = expose('wsmexml:',
accept_format='text/xml',
content_type='text/xml',
tg_format='xml')
sig = wsme.signature(*args, **kwargs)
def decorate(f):
sig(f)
funcdef = wsme.api.FunctionDefinition.get(f)
@functools.wraps(f)
def callfunction(self, *args, **kwargs):
args, kwargs = wsme.rest.args.get_args(
funcdef, args, kwargs, cherrypy.request.params, None,
cherrypy.request.body,
cherrypy.request.headers['Content-Type'])
if funcdef.pass_request:
kwargs[funcdef.pass_request] = cherrypy.request
try:
result = f(self, *args, **kwargs)
except Exception:
try:
exception_info = sys.exc_info()
orig_exception = exception_info[1]
if isinstance(orig_exception, cherrypy.HTTPError):
orig_code = getattr(orig_exception, 'status', None)
else:
orig_code = getattr(orig_exception, 'code', None)
data = wsme.api.format_exception(exception_info)
finally:
del exception_info
cherrypy.response.status = 500
if data['faultcode'] == 'client':
cherrypy.response.status = 400
elif orig_code and is_valid_code(orig_code):
cherrypy.response.status = orig_code
accept = cherrypy.request.headers.get('Accept', "").lower()
accept = util.simplify_http_accept_header(accept)
decorators = {'text/xml': wsme.rest.xml.encode_error}
return decorators.get(accept,
wsme.rest.json.encode_error)(None, data)
return dict(datatype=funcdef.return_type, result=result)
callfunction = tg_xml_expose(callfunction)
callfunction = tg_altjson_expose(callfunction)
callfunction = tg_json_expose(callfunction)
callfunction._wsme_original_function = f
return callfunction
return decorate
class MyRoot(controllers.RootController):
def index(self):
pass
index = turbogears.expose()(index)
def wsexpose(*args, **kwargs):
tg_json_expose = expose(
'wsmejson:',
accept_format='application/json',
content_type='application/json',
tg_format='json'
)
tg_altjson_expose = expose(
'wsmejson:',
accept_format='text/javascript',
content_type='application/json'
)
tg_xml_expose = expose(
'wsmexml:',
accept_format='text/xml',
content_type='text/xml',
tg_format='xml'
)
sig = wsme.signature(*args, **kwargs)
def decorate(f):
sig(f)
funcdef = wsme.api.FunctionDefinition.get(f)
@functools.wraps(f)
def callfunction(self, *args, **kwargs):
args, kwargs = wsme.rest.args.get_args(
funcdef, args, kwargs,
cherrypy.request.params, None,
cherrypy.request.body,
cherrypy.request.headers['Content-Type']
)
if funcdef.pass_request:
kwargs[funcdef.pass_request] = cherrypy.request
try:
result = f(self, *args, **kwargs)
except:
try:
exception_info = sys.exc_info()
orig_exception = exception_info[1]
if isinstance(orig_exception, cherrypy.HTTPError):
orig_code = getattr(orig_exception, 'status', None)
else:
orig_code = getattr(orig_exception, 'code', None)
data = wsme.api.format_exception(exception_info)
finally:
del exception_info
cherrypy.response.status = 500
if data['faultcode'] == 'client':
cherrypy.response.status = 400
elif orig_code and is_valid_code(orig_code):
cherrypy.response.status = orig_code
accept = cherrypy.request.headers.get('Accept', "").lower()
accept = util.simplify_http_accept_header(accept)
decorators = {'text/xml': wsme.rest.xml.encode_error}
return decorators.get(
accept,
wsme.rest.json.encode_error
)(None, data)
return dict(
datatype=funcdef.return_type,
result=result
)
callfunction = tg_xml_expose(callfunction)
callfunction = tg_altjson_expose(callfunction)
callfunction = tg_json_expose(callfunction)
callfunction._wsme_original_function = f
return callfunction
return decorate
os.remove(tmp_model_path)
except IOError, e:
print "Fail to remove temporary model file: %s" % e
return dict(status=status)
def load_session_list(self):
sessions_directory = pkg_resources.resource_filename(
__name__, os.path.join('static', 'sessions'))
return [x.replace('.js','')
for x in os.listdir(sessions_directory) if x.endswith('.js')]
def session_exists(self):
return os.path.exists(session_file_name)
[expose(format='json')]
def retrieve_sample(self, name):
sessions_directory = pkg_resources.resource_filename(
__name__, os.path.join('static', 'sessions'))
full_path = os.path.join(sessions_directory,'%s.js' % name)
if not os.path.exists(full_path):
return dict()
return dict(session=open(full_path,'r').read())
[expose(format='json')]
def current_session_model(self):
if not self.session_exists():
return dict()
return dict(session=open(session_file_name, 'r').read())
[expose(format='json')]
class IssuerController(controllers.Controller,identity.SecureResource):
require=identity.in_group("issuer")
#auction = AuctionController()
@expose()
def index(self, tg_errors=None, **kw):
if tg_errors:
log.info('***********************************************************')
log.info('TG_ERRORS: ' + str(tg_errors))
log.info('KEYWORDS: ' + str(kw))
log.info('***********************************************************')
return self.__Issuer(tg_errors, **kw)
if(identity.in_group("issuer")):
return self.__Issuer(**kw)
return {}
expose()
def __Issuer(self):
a_fields = auction_fields[:]
auction_grid = DataGrid(fields=a_fields)
auctions = session.query(Auction)
return dict(tg_template="kid:mookii.templates.issuer",
auction_grid = auction_grid,
auctions = auctions,
Issuer_tabber=Tabber(),
now=datetime.today().strftime("%A, %d %b %Y")
)
def default(self):
raise redirect("index")
@expose(template='kid:mookii.controllers.IssuerController.templates.list')
#@paginate('records')
def list(self, **kw):
"""List records in model"""
records = session.query(Auction)
return dict(records = records, modelname=self.modelname)
@expose(template="kid:mookii.controllers.IssuerController.templates.paginate1")
@paginate('auctions')
def paginate1(self):
auctions = session.query(Auction)
return dict(auctions=auctions)
@expose(template="kid:mookii.controllers.IssuerController.templates.paginate2")
@paginate('auctions', default_order='auction_date')
def paginate2(self):
auction_list = PaginateDataGrid(
fields=[
PaginateDataGrid.Column('auction_date', 'auction_date', 'Auction Date'),
PaginateDataGrid.Column('time_start', 'time_start', 'Start of Auction'),
PaginateDataGrid.Column('cut_off', 'cut_off', 'End of Auction'),
PaginateDataGrid.Column('status', 'status', 'Auction Status'),
PaginateDataGrid.Column('created', 'created', 'Created'),
])
sortable_auction_list = PaginateDataGrid(
fields=[
PaginateDataGrid.Column('auction_date', 'auction_date', 'Auction Date',
options=dict(sortable=True, reverse_order=True)),
PaginateDataGrid.Column('status', 'status', 'Auction Status',
options=dict(sortable=True, reverse_order=True)),
])
auctions = session.query(Auction)
return dict(auctions=auctions, list = sortable_auction_list)
try:
os.mkdir(path)
except OSError, e:
print e
return
src = os.path.join(locales,'messages.pot')
dest = os.path.join(path,'messages.po')
shutil.copy(src,dest)
def po_upload(self,myFile,code):
path = os.path.join(self.locales_directory(),code,'LC_MESSAGES','messages.po')
f = codecs.open(path,'wb','utf-8')
f.write(unicode(myFile.file.read(),'utf-8',errors='replace'))
f.close()
raise cherrypy.HTTPRedirect(turbogears.url('language',code=code))
po_upload = turbogears.expose(format='json')(po_upload)
def google_translate(self,code,from_lang,to_lang,args):
path = os.path.join(self.locales_directory(),code,'LC_MESSAGES','messages.po')
for arg in args:
if not 'text_' in arg: continue
msg_id = args[arg]
msg_id = msg_id.decode('utf-8')
translated = turbogears.i18n.utils.google_translate(from_lang,to_lang,msg_id)
translated = translated.encode('utf-8')
catalog.update(path,msg_id,translated)
def update_catalog(self,code,msg_id,msg_text):
path = os.path.join(self.locales_directory(),code,'LC_MESSAGES','messages.po')
catalog.update(path,msg_id,msg_text)
except OSError, e:
print e
return
path = os.path.join(path, 'LC_MESSAGES')
try:
os.mkdir(path)
except OSError, e:
print e
return
src = os.path.join(locales, 'messages.pot')
dest = os.path.join(path, 'messages.po')
shutil.copy(src, dest)
[expose(format='json')]
def po_upload(self, myFile, code):
path = os.path.join(self.locales_directory(),
code, 'LC_MESSAGES', 'messages.po')
f = codecs.open(path, 'wb', 'utf-8')
f.write(unicode(myFile.file.read(), 'utf-8', errors='replace'))
f.close()
raise cherrypy.HTTPRedirect(turbogears.url('language', code=code))
def google_translate(self, code, from_lang, to_lang, args):
path = os.path.join(self.locales_directory(),
code, 'LC_MESSAGES', 'messages.po')
for arg in args:
if not 'text_' in arg:
continue
msg_id = args[arg].strip()
class MyRoot(turbogears.controllers.RootController):
def test(self, lang=None):
return dict(widget=widgets.CalendarDatePicker(calendar_lang=lang))
test = turbogears.expose(template=".widget")(test)
args["disabled"] = 'disabled'
toolbox.append(args)
return toolbox
def arrange_in_pairs(self, tools):
p = [[], []]
for idx, tool in enumerate(tools):
p[idx%2].append(tool)
pairs = zip(p[0], p[1])
if len(p[0]) > len(p[1]):
pairs.append([p[0][-1], None])
if len(p[0]) < len(p[1]):
pairs.append([p[1][-1], None])
return pairs
[expose(template="turbogears.toolbox.main")]
def index(self):
return dict(toolbox = self.arrange_in_pairs(self.toolbox),
project = get_project_name())
[expose()]
def noaccess(self):
return """<h3>No access for %s</h3>
<p>
By default only localhost (127.0.0.1)
has access to the Toolbox
</p>
<p>
You can provide access to your client by passing
your host address to Toolbox as a parameter. Ex:
</p>
class WebConsole(controllers.RootController):
"""Web based Python interpreter"""
__label__ = 'WebConsole'
icon = "/tg_static/images/shell.png"
def __init__(self, width=80):
self.console = None
try:
sys.ps1
except AttributeError:
sys.ps1 = '>>> '
try:
sys.ps2
except AttributeError:
sys.ps2 = '... '
def process_request(self, line):
more, output = self._process_request(line)
return dict(more=more, output=output)
process_request = expose()(process_request)
def process_multiline_request(self, block):
outlines = []
lines = [line for line in block.split('\n')]
for line in lines:
more, output = self._process_request(line)
if output[-1] == '\n': # we'll handle the newlines later.
output = output[:-1]
outlines.append(output)
return dict(more=more, output='\n'.join(outlines))
process_multiline_request = expose()(process_multiline_request)
def _process_request(self, line):
if len(self.console.buffer):
prompt = sys.ps2
else:
prompt = sys.ps1
myout = StringIO.StringIO()
output = "%s%s" % (prompt, line)
# hopefully python doesn't interrupt in this block lest we'll get some curious output.
try:
sys.stdout = myout
sys.stderr = myout
more = self.console.push(line)
finally:
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
stdout = myout.getvalue()
if stdout:
output = '%s\n%s' % (output, stdout)
return more, output.rstrip()
def new_console(self):
locs = dict(__name__='tg-admin',
__doc__=None,
reload_console=self.new_console)
mod = turbogears.util.get_model()
if mod:
locs.update(mod.__dict__)
self.console = InteractiveConsole(locals=locs)
def index(self):
if not self.console:
self.new_console()
return dict()
index = expose(template="turbogears.toolbox.console")(index)
class Designer(controllers.RootController):
"""Designer for SQLObject models.
Create your classes, define your fields and manage your relations.
Visualize and generate code for SQLObject models.
"""
__label__ = "ModelDesigner"
__version__ = "0.1"
__author__ = "Ronald Jaramillo"
__email__ = "*****@*****.**"
__copyright__ = "Copyright 2005 Ronald Jaramillo"
__license__ = "MIT"
baseTemplate = 'turbogears.toolbox.designer'
model = None
icon = "/tg_static/images/designer.png"
def __init__(self):
if not sqlobject:
raise ImportError, ("Cannot run the Model Designer.\n"
"The SQLObject package is not installed.")
def set_model(self, model):
self.model = model
def get_model_name(self):
if not get_project_name():
return False
return get_model()
def register_static_directory(self):
static_directory = pkg_resources.resource_filename(__name__, 'static')
turbogears.config.update({
'/tg_toolbox/designer': {
'static_filter.on': True,
'static_filter.dir': static_directory
}
})
def column_type(self, column):
"""Given a column representation return the column type."""
column_type = '%r' % column
return column_type.split()[0][1:].split('.')[-1]
def column_default(self, column, column_type):
try:
default = column.default
except AttributeError:
return ''
if default == sqlobject.sqlbuilder.NoDefault:
return ''
if column_type in ('SOIntCol', 'SOFloatCol', 'SOStringCol',
'SODecimalCol', 'SOCurrencyCol'):
return default
elif column_type == 'SODateTimeCol':
d = '%s' % default
return ':'.join(d.split(':')[:-1])
elif column_type == 'SODateCol':
d = '%s' % default
return d.split()[0]
return ''
def load_column(self, column_name, column, model_object):
props = {}
props['type'] = self.column_type(column)
props['column_name'] = column_name
props['name'] = column_name
props['column_default'] = self.column_default(column, props['type'])
try:
props['title'] = getattr(column, 'title') or ''
except AttributeError:
props['title'] = ''
if props['type'] == 'SOStringCol':
props['length'] = column.length
props['varchar'] = column.varchar
if props['type'] == 'SOEnumCol':
props['enum_values'] = column.enumValues
if props['type'] == 'SOForeignKey':
props['join_type'] = 'MultipleJoin'
props['other_class_name'] = column.foreignKey
props['other_method_name'] = self.other_method_name(
column, model_object.__name__)
if props['type'] in ('SOMultipleJoin', 'SORelatedJoin'):
props['other_class_name'] = column.otherClassName
props['join_type'] = props['type'].replace('SO', '')
props['other_method_name'] = self.other_method_join_name(
column, model_object.__name__)
props['type'] = props['type'].replace('SO', '')
return props
def other_method_join_name(self, column, model_object_name):
for col in column.otherClass.sqlmeta.columnList:
if type(col) == sqlobject.SOForeignKey:
if col.foreignKey == model_object_name:
return col.origName
return 'id'
def other_method_name(self, column, model_object_name):
other_class_name = column.foreignKey
model_object = getattr(self.get_model_name(), other_class_name)
for col in model_object.sqlmeta.joins:
if col.otherClassName == model_object_name:
return col.joinMethodName
return 'id'
def is_inheritable_base_class(self, obj):
"""Check if the object is a direct subclass of InheritableSQLObject"""
return 'sqlobject.inheritance.InheritableSQLObject' in str(
obj.__bases__)
def load_columns(self, model_object):
columns = {}
# get normal columns
for column_name in model_object.sqlmeta.columns:
column = model_object.sqlmeta.columns[column_name]
origname = column.origName
if model_object._inheritable and column_name == 'childName':
continue
columns[origname] = self.load_column(origname, column,
model_object)
# get join columns
for column in model_object.sqlmeta.joins:
columns[column.joinMethodName] = self.load_column(
column.joinMethodName, column, model_object)
return columns
[expose(format='json')]
def load_current_model(self):
model = self.get_model_name()
current_model = {}
current_model['name'] = get_package_name()
current_model['models'] = {}
current_model['ordered_models'] = []
for m in dir(model):
if m in ('SQLObject', 'InheritableSQLObject'):
continue
model_object = getattr(model, m)
if isinstance(model_object, type) and issubclass(
model_object, sqlobject.SQLObject):
parent_class = 'SQLObject'
if model_object._inheritable:
parent_class = model_object._parentClass.__name__
columns = self.load_columns(model_object)
current_model['ordered_models'].append(m)
current_model['models'][m] = {
'name': m,
'parent_class': parent_class,
'table_name': model_object.sqlmeta.table,
'id_name': model_object.sqlmeta.idName,
'columns': columns,
'relations': {}
}
return dict(model=current_model)
def save_session_as_name(self, name):
# remove non-ascii
if isinstance(name, unicode):
name = name.encode('ascii', 'replace')
# remove punctuation
name = name.translate(string.maketrans('', ''), string.punctuation)
# camelcase to remove spaces
name = ''.join([x.title() for x in name.split()])
sessions_directory = pkg_resources.resource_filename(
__name__, os.path.join('static', 'sessions'))
for idx in range(100):
postfix = idx and '_%d' % idx or ''
test_name = '%s%s.js' % (name, postfix)
full_name = os.path.join(sessions_directory, test_name)
if not os.path.exists(full_name):
return full_name
[expose(format='json')]
def save_state(self, state, name=session_file_name):
if name != session_file_name:
name = self.save_session_as_name(name)
if not name:
return dict(state=False)
f = open(name, 'w')
f.write(state)
f.close()
return dict(state=True)
def model_path(self):
return os.path.abspath(os.path.join(get_package_name(), 'model.py'))
def save_model(self, code):
project_name = get_package_name()
model_text = model_template % (project_name, code)
model_path = self.model_path()
if os.path.exists(model_path):
version_file(model_path)
f = open(model_path, 'w')
f.write(model_text)
f.close()
return True, 'Saved %s' % model_path
else:
return False, 'Failed to save %s' % model_path
def save_and_create_(self, code, order):
model_path = os.path.join(get_project_name(), 'tmp2_model.py')
model_path = os.path.abspath(model_path)
open(model_path, 'w').write(str)
package = __import__(get_package_name(), {}, {}, ["tmp2_model"])
package.tmp2_model.Persona.createTable(ifNotExists=True)
model = self.get_model_name()
model.Persona = package.tmp2_model.Persona
# pk = package.model
# import tmp_model as pk
# pk.Persona.createTable(ifNotExists=True)
return dict(status='Tables ok')
[expose(format='json')]
def save_and_create(self, code, order):
status_code, status = self.save_model(code)
if not status_code:
return dict(status=status)
tmp_name = 'tmp_model'
# copy the model file
model_path = self.model_path()
tmp_model_path = model_path.replace('model.py', '%s.py' % tmp_name)
try:
shutil.copy(model_path, tmp_model_path)
except IOError, e:
return dict(status='Failed to create a temporary model file: %s' %
e)
model = self.get_model_name()
package = __import__(get_package_name(), {}, {}, [tmp_name])
tmp_model = getattr(package, tmp_name)
ok = []
fail = []
classes = order.split(',')
for class_name in classes:
try:
obj = getattr(tmp_model, class_name)
obj.createTable(ifNotExists=True)
setattr(model, class_name, obj)
ok.append('Table created for class %s' % class_name)
except Exception, e:
fail.append('Failed to create table for class %s: %s' %
(class_name, e))
try:
cmd = ['espeak', '%s' % captcha.label, '-w', '%s' % filename]
proc = Popen(cmd, stdout=PIPE, stderr=PIPE)
output, error = proc.communicate()
except Exception, err:
print "ERROR: %s" % err
f = open(filename)
cherrypy.response.headers['Content-Type'] = 'audio/basic'
f.seek(0)
content = f.read()
os.remove(filename)
return content
else:
tg.flash('No audio captcha')
tg.redirect('/user/new')
sound = expose()(sound)
def image(self, value):
"Serve a jpeg for the given payload value."
scp = self.model_from_payload(value)
f = StringIO()
if scp.label is not None and scp.label != None:
self.jpeg_generator(scp.label, f)
else:
self.jpeg_generator(scp.plaintext, f)
cherrypy.response.headers['Content-Type'] = 'image/jpeg'
f.seek(0)
return f.read()
image = expose()(image)
def create_payload(self):
except Exception:
self._connection = sqlobject.sqlhub
except Exception, e:
raise ImportError, (
"CatWalk failed to load your model file.\n" + str(e))
self.browse.catwalk = self
turbogears.config.update({'log_debug_info_filter.on': False})
self.register_static_directory()
def register_static_directory(self):
static_directory = pkg_resources.resource_filename(__name__, 'static')
turbogears.config.update({'/tg_toolbox/catwalk': {
'static_filter.on': True,
'static_filter.dir': static_directory}})
[expose(format="json")]
def error(self, msg=''):
"""Generic error handler for json replies."""
return dict(error=msg)
def load_object(self, object_name):
"""Return a class reference from the models module by name.
@param object_name: name of the object
@type object_name: string
"""
try:
obj = getattr(self.model, object_name)
except:
msg = 'Fail to get reference to object %s' % object_name
class Browse(controllers.Controller):
def __getattr__(self, attrib):
"""Delegate basic methods to CatWalk."""
return getattr(self.catwalk, attrib)
def list_view(sql_class_name,
page_size=10,
offset=10,
fields=[],
filters=[],
sort_by=None):
pass
[
expose(template='turbogears.toolbox.catwalk.browse_grid',
allow_json=True)
]
def index(self,
object_name,
start=0,
page_size=10,
context='',
filters=''):
total = 0
headers = []
rows = []
start = int(start)
page_size = int(page_size)
if not context:
context = object_name
headers = self.column_headers(object_name, context)
headers = [header for header in headers if header['visible']]
total, rows = self.rows_for_model(object_name, start, page_size,
filters)
return dict(object_name=object_name,
start=start,
page_size=page_size,
total=total,
headers=headers,
rows=rows)
[expose(template='turbogears.toolbox.catwalk.columns', allow_json=True)]
def columns(self, object_name, context=''):
if not context:
context = object_name
return dict(object_name=object_name,
context=context,
columns=self.extended_column_headers(object_name, context))
[expose(allow_json=True)]
def save_columns(self, object_name, context, order, hidden_columns,
updated_fk_labels):
self.save_column_order(context, order)
self.hide_columns(context, hidden_columns)
if updated_fk_labels:
for updated_fk_label in updated_fk_labels.split('|'):
obj, column_name = updated_fk_label.split(':')
self.column_label_for_object(obj, column_name)
return ("<script>parent.cat_browse.columns_saved('%s','%s');"
"</script>" % (object_name, context))
def extended_column_headers(self, object_name, context):
cols = [{'name': 'id', 'title': '#', 'type': 'SOInteger'}]
cols.extend(self.column_labels(object_name, extended=True))
cols.extend(self.join_labels(object_name, extended=True))
cols = self.arrange_columns(cols, context)
return cols
def column_headers(self, object_name, context):
cols = [{'name': 'id', 'title': '#'}]
cols.extend(self.column_labels(object_name))
cols.extend(self.join_labels(object_name))
cols = self.arrange_columns(cols, object_name)
return cols
def arrange_columns(self, headers, context):
# arrange order and visibility
hidden_columns = self.load_columns_visibility_state(context)
order = self.load_column_order(context)
for col in headers:
col['visible'] = True
if col['name'] in hidden_columns:
col['visible'] = False
if not order:
return headers
c = {}
for col in headers:
c[col['name']] = col
if col['name'] not in order:
order.append(col['name'])
rearrenged = []
for name in order:
if name not in c.keys():
continue
rearrenged.append(c[name])
return rearrenged
def prepare_filter(self, obj, filter):
for column in obj.sqlmeta.columns.values():
if column.origName == filter[0]:
return getattr(obj.q, column.name) == filter[1]
# if we got so far we couldn't find the column, bark at the moon
msg = ('filter_column_error.'
' Could not find the column for filter: %s' % filter[0])
raise cherrypy.HTTPRedirect(turbogears.url('/error', msg=msg))
def filtered_query(self, obj, filters):
if not ':' in filters: # there should at least be a semicolon
msg = ('filter_format_error.'
' The format is column_name:value, not %s' % filters)
raise cherrypy.HTTPRedirect(turbogears.url('/error', msg=msg))
filters = [filter.split(':') for filter in filters.split(',')]
conditions = tuple(
[self.prepare_filter(obj, filter) for filter in filters])
return obj.select(AND(*conditions))
def rows_for_model(self, object_name, start, page_size, filters):
rows = {}
obj = self.load_object(object_name)
if filters:
query = self.filtered_query(obj, filters)
else:
query = obj.select()
total = query.count()
if page_size:
results = query[start:start + page_size]
else:
results = query[start:]
for result in results:
rows[result.id] = self.fields(object_name, result)
relations = self.relation_values(object_name, rows)
rows = self.merge_relation_values(rows, relations)
rows = self.foreign_key_alias_value(object_name, rows)
return total, rows
def relation_values(self, object_name, rows):
joins = {}
ids = rows.keys()
if not ids:
return joins
obj = self.load_object(object_name)
conn = obj._connection
for column in obj.sqlmeta.joins:
query = None
coltype = self.get_column_type(column)
if coltype in ('SOMultipleJoin', 'SOSQLMultipleJoin'):
query = conn.sqlrepr(
Select([
column.soClass.q.id,
func.Count(column.otherClass.q.id)
],
where=AND(
column.soClass.q.id == self.join_foreign_key(
column), IN(column.soClass.q.id, ids)),
groupBy=column.soClass.q.id))
elif coltype in ('SORelatedJoin', 'SOSQLRelatedJoin'):
d = (column.intermediateTable, column.joinColumn,
column.intermediateTable, column.otherColumn,
column.intermediateTable, column.intermediateTable,
column.joinColumn, ','.join(['%s' % x for x in ids]),
column.intermediateTable, column.joinColumn)
query = ("SELECT %s.%s, Count(%s.%s) FROM %s"
" WHERE %s.%s IN(%s) GROUP BY %s.%s" % d)
elif coltype == 'SOSingleJoin':
alias = self.load_label_column_for_object(
column.otherClassName)
query = conn.sqlrepr(
Select([
column.soClass.q.id,
getattr(column.otherClass.q, alias)
],
where=AND(
column.soClass.q.id == self.join_foreign_key(
column), IN(column.soClass.q.id, ids))))
if not query:
continue
joins[column.joinMethodName] = conn.queryAll(query)
return joins
def foreign_key_alias_value(self, object_name, rows):
for column in self.foreign_key_columns(object_name):
alias = self.load_label_column_for_object(column.foreignKey)
if alias == 'id':
continue
column_name = column.name.replace('ID', '')
fk_values = self.foreign_key_query(column, alias,
[x[column_name] for x in rows])
for row in rows:
row[column_name] = fk_values.get(row[column_name], '')
return rows
def foreign_key_query(self, column, alias, ids):
if not ids:
return {}
sql_object = self.load_object(column.foreignKey)
conn = sql_object._connection
query = conn.sqlrepr(
Select([sql_object.q.id,
getattr(sql_object.q, alias)],
where=IN(sql_object.q.id, ids)))
fk_values = {}
for id, alias in conn.queryAll(query):
fk_values[str(id)] = self.encode_label(alias)
return fk_values
def join_foreign_key(self, column):
try:
try:
foreign_key = column.joinColumn.rsplit('_', 1)[0]
except AttributeError: # Python < 2.4
foreign_key = '_'.join(column.joinColumn.split('_')[0:-1])
return getattr(column.otherClass.q, foreign_key + 'ID')
except AttributeError:
raise AttributeError(
"Key %r in %s pointing to %s not found.\n"
"You may need to rename it or use the joinColumn argument." % (
foreign_key,
column.otherClass.__name__,
column.soClass.__name__,
))
def column_label_options(self, column):
foreign_key_labels = [{'name': 'id', 'title': '#'}]
foreign_key_labels.extend(self.column_labels(column.foreignKey))
return foreign_key_labels
def column_labels(self, object_name, extended=False):
cols = []
sql_object = self.load_object(object_name)
for column_name in sql_object.sqlmeta.columns:
column = sql_object.sqlmeta.columns[column_name]
if sql_object._inheritable and column_name == 'childName':
continue
cols.append({
'name': column.name,
'title': self.column_title(column)
})
col = cols[-1]
if isinstance(column, sqlobject.col.SOForeignKey):
col['name'] = col['name'].replace('ID', '')
if extended:
col['type'] = self.get_column_type(column)
if isinstance(column, sqlobject.col.SOForeignKey):
col['column_label'] = self.load_label_column_for_object(
column.foreignKey)
col['label_options'] = self.column_label_options(column)
col['other_class_name'] = column.foreignKey
return cols
def join_labels(self, object_name, extended=False):
cols = []
sql_object = self.load_object(object_name)
for col in sql_object.sqlmeta.joins:
cols.append({'name': col.joinMethodName, 'title': ''})
if extended:
cols[-1]['type'] = self.get_column_type(col)
cols[-1]['other_class_name'] = col.otherClassName
return cols
def merge_relation_values(self, rows, relations):
for field_name in relations:
for id, value in relations[field_name]:
if id not in rows:
continue
rows[id][field_name] = self.encode_label(value)
keys = rows.keys()
keys.sort()
return [rows[x] for x in keys]
def foreign_key_columns(self, object_name):
foreign_keys = []
sql_object = self.load_object(object_name)
for column_name in sql_object.sqlmeta.columns:
column = sql_object.sqlmeta.columns[column_name]
if sql_object._inheritable and column_name == 'childName':
continue
if isinstance(column, sqlobject.col.SOForeignKey):
foreign_keys.append(column)
return foreign_keys
def field_value(self, result, column):
value = getattr(result, column.name)
if value is not None:
value = self.encode_label(value)
return value
def fields(self, object_name, result):
obj = self.load_object(object_name)
props = {}
props['id'] = result.id
for column_name in obj.sqlmeta.columns:
column = obj.sqlmeta.columns[column_name]
if obj._inheritable and column_name == 'childName':
continue
column_name = column.name
if isinstance(column, sqlobject.col.SOForeignKey):
column_name = column_name.replace('ID', '')
props[column_name] = self.field_value(result, column)
return props.copy()
class MyRoot(turbogears.controllers.RootController):
def test(self):
return dict(form=form)
test = turbogears.expose(template=".form")(test)
