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)