Added setup.py

paramecio/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
+    
+    

paramecio/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
+    

paramecio/citoplasma/generate_admin_class.py

@@ -0,0 +1,118 @@
+from paramecio.citoplasma.lists import SimpleList
+from bottle import request, redirect 
+from paramecio.citoplasma.urls import add_get_parameters
+from paramecio.citoplasma.mtemplates import set_flash_message
+from paramecio.cromosoma.formsutils import show_form
+from paramecio.citoplasma.i18n import I18n
+from paramecio.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)
+

paramecio/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()

paramecio/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
+

paramecio/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

paramecio/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]
+
+

paramecio/citoplasma/lists.py

@@ -0,0 +1,178 @@
+#By default id is not showed
+
+from paramecio.citoplasma.pages import Pages
+from paramecio.citoplasma.urls import add_get_parameters
+from paramecio.citoplasma.sessions import get_session
+from paramecio.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)
+    

paramecio/citoplasma/mtemplates.py

@@ -0,0 +1,231 @@
+#!/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_css_home_local)
+        
+        self.add_filter(add_js_home_local)
+        
+        self.add_filter(add_header_home)
+        
+        #self.auto_reload=True
+        
+        # Clean HeaderHTML
+        
+        HeaderHTML.css=[]
+        HeaderHTML.js=[]
+        HeaderHTML.header=[]
+        HeaderHTML.cache_header=[]
+        HeaderHTML.css_local={}
+        HeaderHTML.js_local={}
+    
+    def clean_header_cache(self):
+        
+        HeaderHTML.css=[]
+        HeaderHTML.js=[]
+        HeaderHTML.css_local={}
+        HeaderHTML.js_local={}
+        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'
+        
+        #Standard templates
+        
+        standard_templates=path.dirname(__file__)+'/templates'
+        #print(standard_templates)
+        return TemplateLookup(directories=[theme_templates, module_templates, standard_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>')
+        
+        for module, arr_js in HeaderHTML.js_local.items():
+            for js in arr_js:
+                final_js.append('<script language="Javascript" src="'+make_media_url_module('js/'+js, module)+'"></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"/>')
+
+        for module, arr_css in HeaderHTML.css_local.items():
+            
+            for css in arr_css:
+            
+                final_css.append('<link href="'+make_media_url_module('css/'+css, module)+'" 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 add_css_home_local(css, module):
+    
+    if not css in HeaderHTML.css_local:
+        
+        HeaderHTML.css_local[module]=HeaderHTML.css_local.get(module, [])
+        
+        HeaderHTML.css_local[module].append(css)
+
+    return ''
+
+def add_js_home_local(js, module):
+    
+    if not js in HeaderHTML.js_local:
+        
+        HeaderHTML.js_local[module]=HeaderHTML.js_local.get(module, [])
+        
+        HeaderHTML.js_local[module].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
+    

paramecio/citoplasma/pages.py

@@ -0,0 +1,72 @@
+#!/usr/bin/python3
+
+from math import ceil, floor
+from paramecio.citoplasma.urls import add_get_parameters
+from paramecio.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
+
+

paramecio/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)

paramecio/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
+    

paramecio/citoplasma/templates/admin/content.html

@@ -0,0 +1,4 @@
+<%inherit file="home.html" />
+<%block name="content">
+${content_index|n}
+</%block>

paramecio/citoplasma/templates/admin/home.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+<title>${title}</title>
+<!--<link href="{{'css/admin/admin.css'|make_media_url}}" rel="stylesheet" type="text/css"/>
+<link href="{{'css/font-awesome.min.css'|make_media_url}}" rel="stylesheet" type="text/css"/>-->
+${add_css_home_local('admin.css', 'admin')}
+${add_css_home_local('font-awesome.min.css', 'admin')}
+${HeaderHTML.css_home()|n}
+${add_js_home_local('jquery.min.js', 'admin')}
+${HeaderHTML.js_home()|n}
+${HeaderHTML.header_home()|n}
+</head>
+<body>
+<div id="languages_general">
+</div>
+<div id="logout">
+<a href="${make_url('admin/logout')}">Logout</a>
+</div>
+
+<div id="center_body">
+    <div id="header"><span id="title_phango">Paramecio</span> <span id="title_framework">Framework!</span> </div>
+    <div class="content_admin">
+        <div id="menu">
+            <div class="menu_title">${lang('admin', 'applications', 'Applications')}</div>
+            % for module in sorted(menu):
+                % if type(menu[module]).__name__=='list':
+                    <a href="${make_url('admin/'+module)}">${menu[module][0]}</a>
+                % else:
+                    <div class="father_admin">${menu[module]}</div>
+                % endif
+            % endfor
+        </div>
+        <div class="contents">
+            <h1>${title}</h1>
+            <%block name="content">
+            </%block>
+        </div>
+    </div>
+</div>
+<div id="loading_ajax">
+</div>
+</body>
+</html>

paramecio/citoplasma/templates/admin/index.html

@@ -0,0 +1,9 @@
+<%inherit file="home.html"/>
+<%block name="content">
+<div class="title">
+Bienvenido al administrador
+</div>
+<div class="cont">
+Desde aquí podrá administrar su site
+</div>
+</%block>

paramecio/citoplasma/templates/admin/login.phtml

@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html>
+    <head>
+    <title><%block name="title">${lang('admin', 'login', 'Paramecio Login')}</%block></title>
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+    <link href='https://fonts.googleapis.com/css?family=Open+Sans' rel='stylesheet' type='text/css'>
+    ${add_js_home_local('jquery.min.js', 'admin')}
+    ${add_css_home_local('login.css', 'admin')}
+    ${add_css_home_local('font-awesome.min.css', 'admin')}
+    ${HeaderHTML.css_home()|n}
+    ${HeaderHTML.js_home()|n}
+    <%block name="ajax">
+    <script language="javascript">
+        $(document).ready( function () {
+        
+            $('#login_submit').click( function () {
+            
+                $('#loading').show();
+            
+                $.ajax({
+                url: "${make_url('admin/login')}",
+                method: "POST",
+                dataType: "json",
+                data: {'username': $('#username_form').val(), 'password': $('#password_form').val()}
+                }).done(function(data) {
+                
+                    if(data.error==0)
+                    {
+                        
+                        window.location.href="${make_url('admin')}";
+                    
+                    }
+                    else
+                    {
+                    
+                        $('#loading').hide('slow');
+
+                        $('#username_error').html("${lang('common', 'error_login', 'Error, wrong username or password')}");
+                        
+                    }
+                
+                });
+                
+                return false;
+            
+            });
+        
+        });
+    </script>
+    </%block>
+    </head>
+    <body>
+        <%block name="content">
+        <form id="login">
+            <div id="title">
+                ${lang('admin', 'login', 'Paramecio Login')}
+            </div>
+            ${forms|n}
+            <div id="submit_block">
+                <input type="submit" value="${lang('common', 'login', 'Login')}" class="submit" id="login_submit"/>
+                <span id="loading">&nbsp;</span>
+            </div>
+        </form>
+        </%block>
+    </body>
+</html>

paramecio/citoplasma/templates/admin/register.phtml

@@ -0,0 +1,60 @@
+<%inherit file="login.phtml"/>
+<%block name="ajax">
+    <script language="Javascript">
+        $(document).ready( function () {
+            
+            $("#register_submit").click( function () {
+                
+                $.ajax({
+                url: "${make_url('admin/register')}",
+                method: "POST",
+                dataType: "json",
+                data: {'username': $('#username_form').val(), 'email': $('#email_form').val(), 'password': $('#password_form').val(), 'repeat_password': $('#repeat_password_form').val()}
+                }).done(function(data) {
+                //$( this ).addClass( "done" );
+                //Redirect if register
+                
+                    if(data.error==0)
+                    {
+                    
+                        //$('#result_register').html('Done!. Redirecting...');
+                        $('#loading').show();
+                        
+                        window.location.href="${make_url('admin/login')}";
+                    
+                    }
+                    else
+                    {
+                        //alert(JSON.stringify(data));
+                        //$('#result_register').html('Error');
+                        $('#username_error').html(data.username);
+                        $('#email_error').html(data.email);
+                        $('#password_error').html(data.password);
+                        
+                        $('#repeat_password_error').html(data.password_repeat);
+                    }
+                
+                });
+                
+                return false;
+                
+            });
+            
+        
+        });
+    </script>
+</%block>
+<%block name="title">${lang('admin', 'sign_up', 'Paramecio Sign up')}</%block>
+<%block name="content">
+<form id="login">
+    <div id="title">
+                ${lang('admin', 'sign_up', 'Paramecio Sign up')}
+    </div>
+    ${forms|n}
+    <div id="result_register"></div>
+    <div id="submit_block">
+        <input type="submit" value="${lang('common', 'sign_up', 'Sign up')}" class="submit" id="register_submit"/>
+        <span id="loading">&nbsp;</span>
+    </div>
+</form>
+</%block>

paramecio/citoplasma/templates/forms/modelform.html

@@ -0,0 +1,5 @@
+<div class="form">
+    {% for form in forms.values() %}
+        <p><label>{{form.label|safe}}</label>{{form.form()}}</p>
+    {% endfor %}
+</div>

paramecio/citoplasma/templates/forms/modelform.phtml

@@ -0,0 +1,14 @@
+<%def name="check_required(required)">
+    % if required: 
+        ${'*'}
+    % endif
+</%def>
+<div class="form">
+    % for form in forms.values():
+        % if form.type!='hidden':
+            <p><label>${form.label} ${check_required(form.required)}</label>${form.form()|n} <span class="error" id="${form.name}_error">${form.txt_error}</span></p>
+        % else:
+            ${form.form()|n}
+        % endif
+    % endfor
+</div>

paramecio/citoplasma/templates/utils/admin.phtml

@@ -0,0 +1,4 @@
+${show_flash_message()|n}
+<h1>${admin.title}</h1>
+<a href="${add_get_parameters(admin.url, op_admin='1')}">${lang('common', 'add_item', 'Add new item')}</a>
+${admin.list.show()|n}

paramecio/citoplasma/templates/utils/insertform.phtml

@@ -0,0 +1,13 @@
+<p><a href="${admin.url}">${lang('common', 'home', 'Home')}</a> &gt;&gt; 
+% if id!='0':
+    ${title_edit}
+%else:
+    ${title_edit}
+%endif 
+</p>
+<form method="post" action="${add_get_parameters(admin.url, op_admin=2, id=id)}">
+    <h2>${title_edit}</h2>
+    <span class="error">${model.query_error}</span>
+    ${ form|n }
+    <p><input type="submit" value="${lang('common', 'send', 'Send') }"></p>
+</form>

paramecio/citoplasma/templates/utils/list.phtml

@@ -0,0 +1,53 @@
+<!--{% set header_js_list %}
+    <script language="Javascript">
+        /*alert('pepe');*/
+    </script>
+{% endset %}
+{{ header_js_list|add_header_home() }}-->
+<%def name="select_field()">
+    % if simplelist.search_field==field:
+        selected
+    % endif
+</%def>
+<%def name="set_css_arrow(simplelist, field)">
+    % if simplelist.order_field==field:
+        fa fa-arrow-circle-${simplelist.order_class[simplelist.s['order']]}
+    % endif
+</%def>
+% if simplelist.yes_search:
+<div class="form">
+<form method="get" action="{{simplelist.url}}">
+    ${lang('common','search', 'Search')}: <input type="text" name="search_text" value="${simplelist.search_text|n}"> 
+    <select name="search_field">
+    % for field in simplelist.search_fields:
+        <option value="${simplelist.model.forms[field].name}" ${select_field()}>${simplelist.model.forms[field].label}</option>
+    % endfor 
+    </select>
+    <input type="submit" value="${lang('common', 'search', 'Search')}" />
+</form>
+</div>
+% endif
+<table class="table_list">
+    <tr class="title_list">
+        % for field in simplelist.fields_showed:
+            <td><a href="${add_get_parameters(simplelist.url, order_field=simplelist.model.fields[field].name, begin_page=simplelist.begin_page, order=simplelist.change_order[field], search_text=simplelist.search_text, search_field=simplelist.search_field)}" class="${set_css_arrow(simplelist, field)}">${simplelist.model.fields[field].label}</a></td>
+        % endfor 
+        % for extra_field in simplelist.arr_extra_fields:
+            <td>${ extra_field }</td>
+        % endfor
+    </tr>
+    % for row in list:
+    <tr class="row_list">
+        % for field in simplelist.fields_showed:
+            <td>${simplelist.model.fields[field].show_formatted(row[field])}</td>
+        % endfor
+        
+        % for extra_field_func in simplelist.arr_extra_options:
+            <td>${ simplelist.set_options(extra_field_func, row)|n }</td>
+        % endfor 
+    </tr>
+    % endfor 
+</table>
+<p>
+${pages|n}
+</p>

paramecio/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