Added new files

citoplasma/check_i18n.py

@@ -0,0 +1,49 @@
+#!/usr/bin/python3
+
+import os
+import re
+
+pattern=re.compile('^\w+\.py$')
+
+ignored=re.compile('^[__|\.].*$')
+
+lang_p=re.compile()
+
+def start():
+    
+    scandir('.')
+    
+    pass
+
+def scandir(path):
+    
+    list=os.listdir(path)
+    
+    for name in list:
+        
+        new_path=path+'/'+name
+        
+        if os.path.isdir(new_path):           
+            if ignored.match(name)==None:
+                scandir(new_path)
+        elif pattern.match(name)!=None and ignored.match(name)==None:
+            
+            f=open(new_path)
+            
+            
+            
+            f.close()
+            
+            #print('archivo->'+path+'/'+name)
+            # Open file
+            # obtain modules, keys, and default text
+
+    # Open all files in a loop with modules from dictionary created from open files, if module not exists, the file is in i18n
+    
+    # Load array from file, if file not exists, is created
+    
+    # If not exists the key with text, add them in arrays loaded from created array
+    
+    # Rewrite the file with the new arrys and close the file. Open next file
+    
+    

citoplasma/filterip.py

@@ -0,0 +1,18 @@
+#!/usr/bin/python3
+
+# A simple utility for filter ips. Only use this if you don't use a server with blocking ips system
+
+from settings import config
+from bottle import request
+
+def filterip():
+    #Check ip
+    ip = request.environ.get('REMOTE_ADDR')
+    
+    if ip in config.allowed_ips:
+    
+        return True
+    else:
+        
+        return False
+    

citoplasma/generate_admin_class.py

@@ -0,0 +1,118 @@
+from citoplasma.lists import SimpleList
+from bottle import request, redirect 
+from citoplasma.urls import add_get_parameters
+from citoplasma.templates import set_flash_message
+from cromosoma.formsutils import show_form
+from citoplasma.i18n import I18n
+from citoplasma.httputils import GetPostFiles
+
+class GenerateAdminClass:
+    
+    def __init__(self, model, url, t):
+        
+        self.model_name=''
+        
+        self.model=model
+        
+        self.t=t
+
+        self.list=SimpleList(model, url, t)
+        
+        self.arr_fields_edit=model.fields.keys()
+        
+        self.url=url
+        
+        self.safe=0;
+        
+        self.arr_links={}
+        
+        self.hierarchy=None
+        
+        self.text_add_item=''
+        
+        self.no_insert=False
+        
+        self.no_delete=False
+        
+        self.title=''
+        
+        self.id=0
+        
+        self.template_insert='utils/insertform.phtml'
+        
+        self.template_admin='utils/admin.phtml'
+
+    def show(self):
+        
+        GetPostFiles.obtain_get()
+        
+        GetPostFiles.get['op_admin']=GetPostFiles.get.get('op_admin', '0')
+        
+        GetPostFiles.get['id']=GetPostFiles.get.get('id', '0')
+        
+        if GetPostFiles.get['op_admin']=='1':
+            
+            post=None
+            
+            if len(self.model.forms)==0:
+                self.model.create_forms(self.arr_fields_edit)
+            
+            title_edit=I18n.lang('common', 'add_new_item', 'Add new item')
+            
+            if GetPostFiles.get['id']!='0':
+                post=self.model.select_a_row(GetPostFiles.get['id'])
+                title_edit=I18n.lang('common', 'edit_new_item', 'Edit item')
+            
+            if post==None:
+                post={}
+            
+            form=show_form(post, self.model.forms, self.t, False)
+                
+            return self.t.load_template(self.template_insert, admin=self, title_edit=title_edit, form=form, model=self.model, id=GetPostFiles.get['id'])
+        
+        elif GetPostFiles.get['op_admin']=='2':
+            
+            GetPostFiles.obtain_post()
+            
+            post=GetPostFiles.post
+            
+            insert_row=self.model.insert
+            
+            try:
+                
+                GetPostFiles.get['id']=str(int(GetPostFiles.get['id']))
+            
+            except:
+                
+                GetPostFiles.get['id']='0'
+            
+            title_edit=I18n.lang('common', 'add_new_item', 'Add new item')
+                
+            
+            if GetPostFiles.get['id']!='0':
+                insert_row=self.model.update
+                title_edit=I18n.lang('common', 'edit_new_item', 'Edit item')
+                self.model.conditions=['WHERE `'+self.model.name+'`.`'+self.model.name_field_id+'`=%s', [GetPostFiles.get['id']]]
+            
+            if insert_row(post):
+                set_flash_message(I18n.lang('common', 'task_successful', 'Task successful'))
+                redirect(self.url)
+            else:
+
+                form=show_form(post, self.model.forms, self.t, True)
+                return self.t.load_template(self.template_insert, admin=self, title_edit=title_edit, form=form, model=self.model, id=GetPostFiles.get['id'])
+
+            
+            pass
+            
+        elif GetPostFiles.get['op_admin']=='3':
+    
+            if GetPostFiles.get['id']!='0':
+                self.model.conditions=['WHERE `'+self.model.name+'`.`'+self.model.name_field_id+'`=%s', [GetPostFiles.get['id']]]
+                self.model.delete()
+                set_flash_message(I18n.lang('common', 'task_successful', 'Task successful'))
+                redirect(self.url)
+    
+        else:
+            return self.t.load_template(self.template_admin, admin=self)
+

citoplasma/gunicornssl.py

@@ -0,0 +1,31 @@
+#!/usr/bin/python3
+
+# This module is suitable for create ssl apis that don't need much performance, if you need more performance use nginx or apache proxiying for generate https content and Paramecio with gunicorn or others wsgi servers for generate the html/json content.
+
+from bottle import ServerAdapter
+import ssl
+
+class GunicornServerSSL(ServerAdapter):
+    """ Untested. See http://gunicorn.org/configure.html for options. """
+
+    cert_pem=''
+    privkey_pem=''
+    workers=2
+
+    def run(self, handler):
+        from gunicorn.app.base import Application
+
+        #'ciphers': 'TLSv1'
+        #, 'ssl_version': ssl.PROTOCOL_TLSv1
+
+        config = {'bind': "%s:%d" % (self.host, int(self.port)), 'workers': self.workers, 'keyfile': self.privkey_pem, 'certfile': self.cert_pem, 'ssl_version': ssl.PROTOCOL_TLSv1}
+        config.update(self.options)
+
+        class GunicornApplication(Application):
+            def init(self, parser, opts, args):
+                return config
+
+            def load(self):
+                return handler
+
+        GunicornApplication().run()

citoplasma/hierarchy_links.py

@@ -0,0 +1,76 @@
+#/usr/bin/python3
+
+class HierarchyLinks:
+
+    def __init__(arr_links):
+
+        self.arr_links=arr_links
+        
+        self.arr_indexes={}
+    
+    def update_links(self, link_father, link_son, text):
+    
+        self.arr_links[link_father][link_son]=text
+    
+    
+    def calculate_indexes():
+    
+        #oreach(self.arr_links as $father_link => $arr_child_links)
+        for father_link, arr_child_links in self.arr_links.items():
+            
+            #foreach($arr_child_links as $link => $text)
+            for link, text in self.arr_child_links.items():
+                
+                self.arr_indexes[link]=father_link
+
+    
+    def result(last_link, arr_result=[], yes_last_link=0):
+    
+        self.calculate_indexes()
+        
+        if last_link in self.arr_indexes:
+            
+            father=self.arr_indexes[last_link]
+            
+            arr_last_link[0]=self.no_link
+            
+            arr_last_link[1]=self.yes_link
+            
+            yes_link_func=arr_last_link[yes_last_link]
+            
+            if father!='':
+                
+                arr_result.append(self.yes_link_func(last_link, self.arr_links[father][last_link]))
+                
+                yes_last_link=1
+                
+                arr_result=self.result(father, arr_result, yes_last_link)
+                
+                return arr_result
+            
+            else:
+                
+                arr_result.append(self.yes_link_func(last_link, self.arr_links[father][last_link]))
+                
+                return arr_result
+        
+        return arr_result
+    
+    
+    def show(link, separator='>>', class_link=''):
+    
+        arr_result=self.result(link)
+        
+        arr_result=array_reverse(arr_result)
+        
+        return ' '+separator+' '.join(arr_result)
+    
+    def yes_link(link, text):
+    
+        return '<a href="'+link+'">'+text+'</a>'
+
+    
+    def no_link(link, text):
+    
+        return text
+

citoplasma/httputils.py

@@ -0,0 +1,31 @@
+#!/usr/bin/python3
+
+from bottle import request
+
+class GetPostFiles:
+
+    # Need this for obtain utf8 valid values
+    get={}
+    
+    post={}
+    
+    files=None
+
+    @staticmethod
+    def obtain_get():
+        
+        GetPostFiles.get={}
+        
+        GetPostFiles.get=request.query.decode()
+    
+    @staticmethod
+    def obtain_post():
+        
+        GetPostFiles.post={}
+        
+        GetPostFiles.post=request.forms.decode()
+    
+    @staticmethod
+    def obtain_files():
+        
+        GetPostFiles.files=request.files

citoplasma/i18n.py

@@ -0,0 +1,32 @@
+#!/usr/bin/python3
+
+from settings import config
+
+def load_lang(*args):
+    
+    for module in args:
+        
+        if module in config.modules:
+    
+            lang_path=config.base_modules+'.'+module+'.i18n'
+            
+        else:
+            lang_path='i18n'
+
+       # here load the language 
+        
+
+class I18n:
+    
+    l={}
+    
+    @staticmethod
+    def lang(module, symbol, text_default):
+        
+        I18n.l[module]=I18n.l.get(module, {})
+        
+        I18n.l[module][symbol]=I18n.l[module].get(symbol, text_default)
+        
+        return I18n.l[module][symbol]
+
+

citoplasma/lists.py

@@ -0,0 +1,178 @@
+#By default id is not showed
+
+from citoplasma.pages import Pages
+from citoplasma.urls import add_get_parameters
+from citoplasma.sessions import get_session
+from citoplasma.i18n import I18n
+from bottle import request
+import sys
+
+class SimpleList:
+    
+    def __init__(self, model, url, t):
+        
+        self.t=t
+        
+        self.model=model
+        
+        if len(self.model.forms)==0:
+        
+            self.model.create_forms()
+        
+        self.fields=model.fields.keys()
+        
+        self.fields_showed=self.fields
+        
+        self.url=url
+        
+        self.limit_pages=20
+        
+        self.order_defaults=['ASC', 'DESC']
+        
+        self.order_class=['up', 'down']
+        
+        self.s=get_session()
+        
+        #self.s['order']=self.s.get('order', 0)
+        
+        self.order_by=self.order_defaults[0]
+        
+        self.change_order={}
+        
+        self.yes_search=True
+        
+        self.search_text=''
+        
+        self.initial_num_pages=20
+        
+        request.query.get('begin_page', '0')
+        
+        try: 
+        
+            self.begin_page=int(request.query.begin_page)
+            
+        except ValueError:
+            self.begin_page=0
+        
+        if self.begin_page<0:
+            self.begin_page=0
+        
+        self.search_fields=self.fields
+        
+        #self.yes_options=True
+        
+        self.arr_extra_fields=[I18n.lang('common', 'options', 'Options')]
+        
+        self.arr_extra_options=[SimpleList.standard_options]
+        
+        self.jln='<br />'
+
+    def restore_fields(self):
+        self.fields=self.model.fields.keys()
+    
+    def obtain_order(self):
+        
+        self.s['order']=self.s.get('order', 0)
+        
+        order_k=self.s['order']
+        
+        #Obtain from get
+        
+        if 'order' in request.query.keys():
+            
+            order_k=int(request.query.get('order', 0))
+        
+        if order_k>1 or order_k<0:
+            order_k=0
+        
+        self.order_by=self.order_defaults[ order_k ]
+        
+        self.s['order']=order_k
+        
+        self.s.save()
+    
+    def obtain_field_search(self):
+        
+        self.s['order_field']=self.s.get('order_field', self.model.name_field_id)
+        
+        field_k=self.s['order_field']
+        
+        if 'order_field' in request.query.keys():
+            field_k=request.query.order_field
+        
+        if field_k in self.model.fields.keys():
+            
+            self.s['order_field']=field_k
+        
+        for field in self.fields:
+            self.change_order[field]=self.s['order']
+        
+        if self.s['order']==0:
+            self.change_order[field_k]=1
+        else:
+            self.change_order[field_k]=0
+            
+        self.s.save()
+        
+        self.order_field=self.s['order_field']
+        
+    def search(self):
+        
+        request.query.get('search_text', '')
+        
+        self.search_text=request.query.search_text
+        
+        self.search_text=self.search_text.replace('"', '&quot;')
+        
+        #self.model.conditions='AND 
+        
+        self.search_field=request.query.get('search_field', '')
+        
+        if self.search_field not in self.model.fields.keys():
+            self.search_field=''
+        
+        if self.search_field!='' and self.search_text!='':
+            self.model.conditions[0]+=' AND '+self.search_field+' LIKE %s'
+            self.model.conditions[1]=['%'+self.search_text+'%']
+        
+        pass
+    
+    def set_options(self, options_func, arr_row):
+        #SimpleList.standard_options(arr_row)
+        return self.jln.join(options_func(self.url, arr_row[self.model.name_field_id], arr_row)) 
+    
+    @staticmethod
+    def standard_options(url, id, arr_row):
+        options=[]
+        options.append('<a href="'+add_get_parameters(url, op_admin=1, id=id)+'">'+I18n.lang('common', 'edit', 'Edit')+'</a>')
+        options.append('<a href="'+add_get_parameters(url, op_admin=3, id=id)+'">'+I18n.lang('common', 'delete', 'Delete')+'</a>')
+        return options
+    
+    def show(self):
+        
+        self.obtain_order()
+        
+        self.obtain_field_search()
+        
+        self.search()
+        
+        total_elements=self.model.select_count()
+        
+        num_elements=self.limit_pages
+        
+        link=add_get_parameters(self.url, search_text=self.search_text, search_field=self.search_field)
+        
+        begin_page=self.begin_page
+        
+        self.model.order_by='order by '+self.order_field+' '+self.order_by
+        
+        self.model.limit='limit '+str(begin_page)+','+str(self.limit_pages)
+        
+        list_items=self.model.select(self.fields)
+        
+        pages=Pages.show( begin_page, total_elements, num_elements, link ,initial_num_pages=self.initial_num_pages, variable='begin_page', label='', func_jscript='')
+        
+        self.begin_page=str(self.begin_page)
+        
+        return self.t.load_template('utils/list.phtml', simplelist=self, list=list_items, pages=pages)
+    

citoplasma/mtemplates.py

@@ -0,0 +1,189 @@
+#!/usr/bin/python
+
+from mako.template import Template
+from mako.lookup import TemplateLookup
+from paramecio.citoplasma.urls import make_url, make_media_url, make_media_url_module, add_get_parameters
+from paramecio.citoplasma.i18n import I18n
+from paramecio.citoplasma.sessions import get_session
+from settings import config
+from os import path
+
+# Preparing envs for views of modules, and views of 
+
+""" A simple function for load views from themes using jinja2 
+
+Env use loader = FileSystemLoader(['/path/to/templates', '/other/path'])
+env = Environment(loader=FileSystemLoader(['/path/to/templates', '/other/path']))
+template = env.get_template('mytemplate.html')
+"""
+
+class ptemplate:
+    
+    def __init__(self, module):
+        
+        module=path.dirname(module)
+        
+        self.autoescape_ext=('html', 'htm', 'xml', 'phtml')
+        
+        self.env=self.env_theme(module)
+        
+        self.filters={}
+        
+        #Adding basic filters for urls
+        self.add_filter(make_url)
+        
+        self.add_filter(make_media_url)
+        
+        self.add_filter(make_media_url_module)
+        
+        self.add_filter(add_get_parameters)
+        
+        I18n_lang=I18n.lang
+        
+        self.add_filter(I18n.lang)
+        
+        self.add_filter(add_css_home)
+        
+        self.add_filter(add_js_home)
+        
+        self.add_filter(add_header_home)
+        
+        #self.auto_reload=True
+        
+        # Clean HeaderHTML
+        
+        HeaderHTML.css=[]
+        HeaderHTML.js=[]
+        HeaderHTML.header=[]
+        HeaderHTML.cache_header=[]
+    
+    def clean_header_cache(self):
+        
+        HeaderHTML.css=[]
+        HeaderHTML.js=[]
+        HeaderHTML.header=[]
+        HeaderHTML.cache_header=[]
+    
+    def guess_autoescape(self, template_name):
+        
+        if template_name is None or '.' not in template_name:
+            return False
+        
+        ext = template_name.rsplit('.', 1)[1]
+        return ext in self.autoescape_ext
+
+    def env_theme(self, module):
+
+        theme_templates='themes/'+config.theme+'/templates'
+
+        module_templates=module+'/templates'
+
+        return TemplateLookup(directories=[theme_templates, module_templates], default_filters=['h'], input_encoding='utf-8', encoding_errors='replace')
+
+        #return Environment(autoescape=self.guess_autoescape, auto_reload=True, loader=FileSystemLoader([theme_templates, module_templates]))
+
+    def load_template(self, template_file, **arguments):
+        
+        template = self.env.get_template(template_file)
+        
+        arguments['HeaderHTML']=HeaderHTML
+        
+        arguments['show_flash_message']=show_flash_message
+        
+        for filter_name, filter_ in self.filters.items():
+            arguments[filter_name]=filter_
+        
+        #Will be nice add hooks here
+        
+        return template.render(**arguments)
+
+    def add_filter(self, filter_name):
+
+        self.filters[filter_name.__name__]=filter_name
+
+
+class HeaderHTML:
+    
+    css=[]
+    js=[]
+    header=[]
+    cache_header={}
+
+    def header_home():
+        
+        final_header="\n".join(HeaderHTML.header)
+        
+        HeaderHTML.header=[]
+        
+        return final_header
+
+    def js_home():
+
+        final_js=[]
+        
+        for js in HeaderHTML.js:
+            final_js.append('<script language="Javascript" src="'+make_media_url('js/'+js)+'"></script>')
+        
+        return "\n".join(final_js)
+
+    def css_home():
+        
+        final_css=[]
+        
+        for css in HeaderHTML.css:
+            final_css.append('<link href="'+make_media_url('css/'+css)+'" rel="stylesheet" type="text/css"/>')
+
+        return "\n".join(final_css)
+
+
+def add_header_home(variable, only_one_time=False):
+        
+        
+        if only_one_time==True:
+            HeaderHTML.cache_header.get(variable, 0)
+            
+            if cache_header[variable]==1:
+                return ''
+        #HeaderHTML.cache_header[variable]=1
+        
+        HeaderHTML.header.append(variable)
+        
+        return ''
+
+def add_css_home(css):
+    
+    if not css in HeaderHTML.css:
+        HeaderHTML.css.append(css)
+    
+    return ""
+    
+def add_js_home(js):
+    
+    if not js in HeaderHTML.js:
+        HeaderHTML.js.append(js)
+    
+    return ""
+
+def set_flash_message(message):
+    
+    s=get_session()
+    
+    s['flash']=s.get('flash', "")
+    
+    s['flash']=message
+    
+def show_flash_message():
+    
+    message=""
+    
+    s=get_session()
+    
+    s['flash']=s.get('flash', "")
+    
+    if s['flash']!="":
+        message='<div class="flash">'+s['flash']+'</div>'
+    
+    s['flash']=''
+    
+    return message
+    

citoplasma/pages.py

@@ -0,0 +1,72 @@
+#!/usr/bin/python3
+
+from math import ceil, floor
+from citoplasma.urls import add_get_parameters
+from citoplasma.i18n import I18n
+
+class Pages: 
+
+    css_class='link_pages'
+
+    @staticmethod
+    def show( begin_page, total_elements, num_elements, link ,initial_num_pages=20, variable='begin_page', label='', func_jscript=''):
+        
+        pages='';
+
+        if begin_page>total_elements:
+            begin_page=0
+
+        # Calculamos el total de todas las páginas
+
+        total_page=ceil(total_elements/num_elements)
+        
+        # Calculamos en que página nos encontramos
+
+        actual_page=ceil(begin_page/num_elements)
+
+        # Calculamos el total de intervalos
+
+        total_interval=ceil(total_page/initial_num_pages)
+
+        # Calculamos el intervalo en el que estamos
+
+        actual_interval=floor(actual_page/initial_num_pages)
+
+        # Calculamos el elemento de inicio del intervalo
+
+        initial_page=ceil(actual_interval*initial_num_pages*num_elements)
+
+        last_page=ceil(actual_interval*initial_num_pages*num_elements)+ceil(initial_num_pages*num_elements)
+
+        if last_page>total_elements:
+            last_page=total_elements
+
+        if initial_page>0:
+            initial_link=add_get_parameters(link, **{variable: '0'});
+            middle_link=add_get_parameters(link, **{variable: str((initial_page-num_elements)) } );
+            pages += "<a class=\""+Pages.css_class+"\" href=\""+initial_link+"\" onclick=\"func_jscript\">1</a> <a class=\""+Pages.css_class+"\" href=\""+middle_link+"\">&lt;&lt;</a> "
+
+        arr_pages={}
+
+        #for(x=initial_page;x<last_page;x+=num_elements)
+        for x in range(initial_page, last_page, num_elements):
+            
+            middle_link=add_get_parameters(link, **{variable: str(x)} )
+
+            num_page=ceil(x/num_elements)+1;
+            arr_pages[x]="<a class=\""+Pages.css_class+"\" href=\""+middle_link+"\" onclick=\"func_jscript\">"+str(num_page)+"</a> "
+            arr_pages[begin_page]='<span class="selected_page">'+str(num_page)+'</span> ';
+            pages += arr_pages[x]
+
+        
+        if last_page<total_elements:
+
+            middle_link=add_get_parameters(link, **{variable: str(x+num_elements)} );
+            last_link=add_get_parameters(link, **{variable: str( ( ( total_page*num_elements ) - num_elements) ) } )
+
+            pages += "<a class=\""+Pages.css_class+"\" href=\""+middle_link+"\" onclick=\"func_jscript\">&gt;&gt;</a> <a class=\"link_pages\" href=\""+last_link+"\" onclick=\"func_jscript\">"+I18n.lang('common', 'last', 'Last')+"</a>"
+
+        
+        return pages
+
+

citoplasma/sessions.py

@@ -0,0 +1,7 @@
+#!/usr/bin/python3
+
+from bottle import request
+from settings import config
+
+def get_session():
+        return request.environ.get(config.cookie_name)

citoplasma/templates.py

@@ -0,0 +1,172 @@
+#!/usr/bin/python
+
+from jinja2 import Template, Environment, FileSystemLoader
+from citoplasma.urls import make_url, make_media_url, make_media_url_module, add_get_parameters
+from citoplasma.i18n import I18n
+from citoplasma.sessions import get_session
+from settings import config
+
+# Preparing envs for views of modules, and views of 
+
+""" A simple function for load views from themes using jinja2 
+
+Env use loader = FileSystemLoader(['/path/to/templates', '/other/path'])
+env = Environment(loader=FileSystemLoader(['/path/to/templates', '/other/path']))
+template = env.get_template('mytemplate.html')
+"""
+
+class ptemplate:
+    
+    def __init__(self, module):
+        
+        self.autoescape_ext=('html', 'htm', 'xml', 'phtml')
+        
+        self.env=self.env_theme(module)
+        
+        #Adding basic filters for urls
+        
+        self.add_filter(make_url)
+        
+        self.add_filter(make_media_url)
+        
+        self.add_filter(make_media_url_module)
+        
+        self.add_filter(add_get_parameters)
+        
+        I18n_lang=I18n.lang
+        
+        self.add_filter(I18n.lang)
+        
+        self.add_filter(add_css_home)
+        
+        self.add_filter(add_js_home)
+        
+        self.add_filter(add_header_home)
+        
+        self.auto_reload=True
+        
+        # Clean HeaderHTML
+        
+        HeaderHTML.css=[]
+        HeaderHTML.js=[]
+        HeaderHTML.header=[]
+        HeaderHTML.cache_header=[]
+    
+    def guess_autoescape(self, template_name):
+        
+        if template_name is None or '.' not in template_name:
+            return False
+        
+        ext = template_name.rsplit('.', 1)[1]
+        return ext in self.autoescape_ext
+
+    def env_theme(self, module):
+
+        theme_templates='themes/'+config.theme+'/templates'
+
+        module_templates=config.base_modules+'/'+module+'/templates'
+
+        return Environment(autoescape=self.guess_autoescape, auto_reload=True, loader=FileSystemLoader([theme_templates, module_templates]))
+
+    def load_template(self, template_file, **arguments):
+        
+        template = self.env.get_template(template_file)
+        
+        arguments['HeaderHTML']=HeaderHTML
+        
+        arguments['show_flash_message']=show_flash_message
+        
+        #Will be nice add hooks here
+        
+        return template.render(arguments)
+
+    def add_filter(self, filter_name):
+
+        self.env.filters[filter_name.__name__]=filter_name
+
+
+class HeaderHTML:
+    
+    css=[]
+    js=[]
+    header=[]
+    cache_header={}
+
+    def header_home():
+        
+        final_header="\n".join(HeaderHTML.header)
+        
+        HeaderHTML.header=[]
+        
+        return final_header
+
+    def js_home():
+
+        final_js=[]
+        
+        for js in HeaderHTML.js:
+            final_js.append('<script language="Javascript" src="'+make_media_url('js/'+js)+'"></script>')
+        
+        return "\n".join(final_js)
+
+    def css_home():
+        
+        final_css=[]
+        
+        for css in HeaderHTML.css:
+            final_css.append('<link href="'+make_media_url('css/'+css)+'" rel="stylesheet" type="text/css"/>')
+
+        return "\n".join(final_css)
+
+
+def add_header_home(variable, only_one_time=False):
+        
+        
+        if only_one_time==True:
+            HeaderHTML.cache_header.get(variable, 0)
+            
+            if cache_header[variable]==1:
+                return ''
+        #HeaderHTML.cache_header[variable]=1
+        
+        HeaderHTML.header.append(variable)
+        
+        return ''
+
+def add_css_home(css):
+    
+    if not css in HeaderHTML.css:
+        HeaderHTML.css.append(css)
+    
+    return ""
+    
+def add_js_home(js):
+    
+    if not js in HeaderHTML.js:
+        HeaderHTML.js.append(js)
+    
+    return ""
+
+def set_flash_message(message):
+    
+    s=get_session()
+    
+    s['flash']=s.get('flash', "")
+    
+    s['flash']=message
+    
+def show_flash_message():
+    
+    message=""
+    
+    s=get_session()
+    
+    s['flash']=s.get('flash', "")
+    
+    if s['flash']!="":
+        message='<div class="flash">'+s['flash']+'</div>'
+    
+    s['flash']=''
+    
+    return message
+    

citoplasma/urls.py

@@ -0,0 +1,55 @@
+#!/usr/bin/python3
+
+from settings import config
+
+#Simple method for make urls
+
+def make_url(path, query_args={}):
+    
+    """
+        This is a method for create urls for the system
+        
+       
+        Keyword arguments:
+        module -- The module where search code to execute
+        controller -- The controller where search code to execute
+        method -- The method to execute
+        query_args -- a ser of get variables for add to url
+        
+    """
+    
+    get_query=''
+    
+    if len(query_args)>0:
+        
+        get_query='?'+"&".join( [x+'='+y for x,y in query_args.items()] )
+    
+    return config.base_url+path+get_query
+
+def add_get_parameters(url, **args):
+    
+    added_url='&'
+    
+    if url.find('?')==-1:
+        added_url='?'
+    
+    return url+added_url+"&".join( [x+'='+str(y) for x,y in args.items()] )
+
+if config.yes_static==True:
+    
+    def make_media_url(file_path):
+        
+        return '/media/'+file_path
+        
+    def make_media_url_module(file_path, module):
+        
+        return '/mediafrom/'+module+'/'+file_path
+else:
+    
+    def make_media_url(file_path):
+
+        return config.media_url+'media/'+file_path
+    
+    def make_media_url_module(file_path, module):
+
+        return config.media_url+'media/'+module+'/'+file_path