Added generate admin to pramecio2

paramecio2/libraries/generate_admin_class.py

@@ -0,0 +1,273 @@
+from paramecio2.libraries.lists import SimpleList
+from flask import request, redirect, flash
+from paramecio2.libraries.urls import add_get_parameters
+#from paramecio.citoplasma.mtemplates import set_flash_message
+from paramecio2.libraries.formsutils import show_form
+from paramecio2.libraries.i18n import I18n
+from collections import OrderedDict
+
+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=list(model.fields.keys())
+        
+        del self.arr_fields_edit[self.arr_fields_edit.index(model.name_field_id)]
+        
+        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'
+        
+        self.template_verify_delete='utils/verify_delete.phtml'
+
+        self.url_redirect=self.url
+        
+        self.post_update=None
+
+        self.text_home=I18n.lang('common', 'home', 'Home')
+
+    def show(self):
+        
+        op_admin=request.args.get('op_admin', '0')
+        
+        item_id=request.args.get('id', '0')
+        
+        if len(self.model.forms)==0:
+
+            self.model.create_forms()
+        
+        edit_forms=OrderedDict()
+        
+        url_action=self.url
+        
+        for key_form in self.arr_fields_edit:
+            edit_forms[key_form]=self.model.forms[key_form]
+        
+        if op_admin=='1':
+            
+            post=None
+            
+            title_edit=I18n.lang('common', 'add_new_item', 'Add new item')
+            
+            pass_value=False
+            
+            if item_id!='0':
+                post=self.model.select_a_row(item_id, [], True)
+                title_edit=I18n.lang('common', 'edit_new_item', 'Edit item')
+                pass_value=True
+            
+            if post==None or post==False:
+                
+                if item_id=='0':
+                    post={}
+                else:
+                    return ""
+            
+            url_action=add_get_parameters(self.url, op_admin=2, id=item_id)
+            
+            form=show_form(post, edit_forms, self.t, False, pass_value)
+            
+            return self.t.load_template(self.template_insert, admin=self, title_edit=title_edit, form=form, model=self.model, id=item_id, url_action=url_action, enctype=self.model.enctype)
+        
+        elif op_admin=='2':
+            
+            self.model.reset_conditions()
+            
+            insert_row=self.model.insert
+            
+            try:
+                
+                item_id=str(int(request.args.get['id']))
+            
+            except:
+                
+                item_id='0'
+            
+            title_edit=I18n.lang('common', 'add_new_item', 'Add new item')
+                
+            
+            if item_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', [item_id]]
+            
+            post=dict(request.form)
+            
+            if insert_row(post):
+                flash(I18n.lang('common', 'task_successful', 'Task successful'))
+                
+                if self.post_update:
+                    if item_id=='0':
+                        item_id=self.model.insert_id()
+                    self.post_update(self, item_id)                
+                
+                return redirect(self.url_redirect)
+            else:
+                url_action=add_get_parameters(self.url, op_admin=2, id=item_id)
+
+                post=dict(request.form)
+                
+                form=show_form(post, edit_forms, self.t, True)
+                return self.t.load_template(self.template_insert, admin=self, title_edit=title_edit, form=form, model=self.model, id=item_id, url_action=url_action, enctype=self.model.enctype)
+
+            
+            pass
+            
+        elif op_admin=='3':
+            
+            verified=request.args.get('verified', '0')
+            
+            if verified=='1':
+    
+                if item_id!='0':
+                    self.model.conditions=['WHERE `'+self.model.name+'`.`'+self.model.name_field_id+'`=%s', [item_id]]
+                    self.model.delete()
+                    flash(I18n.lang('common', 'task_successful', 'Task successful'))
+                    return redirect(self.url_redirect)
+    
+            else:
+                
+                return self.t.load_template(self.template_verify_delete, url=self.url, item_id=item_id, op_admin=3, verified=1)
+    
+        else:
+            return self.t.load_template(self.template_admin, admin=self)
+
+    """
+    def show_config(self):
+        
+        
+        getpostfiles=GetPostFiles()
+        
+        getpostfiles.obtain_query()        
+        
+        op=getpostfiles.query.get('op', '')
+        
+        object_id=getpostfiles.query.get('id', '0')
+        
+        c=self.model.select_count
+        
+        if op=='':
+            
+            # Show the form
+            
+
+            
+            return self.t.render_template(self.template_insert, admin=self, title_edit=title_edit, form=form, model=self.model, id=object_id)            
+            
+    """
+
+class GenerateConfigClass:
+    
+    def __init__(self, model, url, t):
+
+        self.model_name=''
+        
+        self.model=model
+        
+        self.title_name=model.label
+        
+        self.t=t
+        
+        self.url=url
+        
+        self.url_redirect=self.url
+        
+        self.arr_fields_edit=list(model.fields.keys())
+
+        del self.arr_fields_edit[self.arr_fields_edit.index(model.name_field_id)]
+        
+        self.template_insert='utils/insertform.phtml'
+
+        self.post_update=None
+
+        self.text_home=I18n.lang('common', 'home', 'Home')
+
+    def show(self):
+        
+        op_config=request.args.get('op_config', '0')
+        
+        if len(self.model.forms)==0:
+
+            self.model.create_forms()
+
+        title_edit=I18n.lang('common', 'edit', 'Edit')+' '+self.title_name
+
+        edit_forms=OrderedDict()
+
+        form_values={}
+            
+        for key_form in self.arr_fields_edit:
+            edit_forms[key_form]=self.model.forms[key_form]
+
+        url_action=add_get_parameters(self.url, op_config=1)
+    
+        if op_config=='1':
+            
+            self.model.yes_reset_conditions=False
+            
+            c=self.model.select_count()
+
+            insert_model=self.model.insert
+            
+            if c:
+                insert_model=self.model.update
+
+            post=dict(request.form)
+
+            if insert_model(post):
+                set_flash_message(I18n.lang('common', 'task_successful', 'Task successful'))
+                self.model.yes_reset_conditions=True
+                
+                if self.post_update:
+                    self.post_update(self)                
+                
+                redirect(self.url_redirect)
+                
+                
+            else:
+
+                post=dict(request.form)
+
+                form=show_form(post, edit_forms, self.t, True)
+                self.model.yes_reset_conditions=True
+                return self.t.load_template(self.template_insert, admin=self, title_edit=title_edit, form=form, model=self.model, id='0', url_action=url_action, enctype=self.model.enctype)                
+            
+        else:
+            form_values=self.model.select_a_row_where([], True)
+            
+            pass_values=True
+            
+            if not form_values:
+                form_values={}
+                pass_values=False
+            
+            form=show_form(form_values, edit_forms, self.t, True, pass_values)            
+            
+            return self.t.load_template(self.template_insert, admin=self, title_edit=title_edit, form=form, model=self.model, id=0, url_action=url_action, enctype=self.model.enctype)
+        

paramecio2/libraries/lists.py

@@ -0,0 +1,312 @@
+#By default id is not showed
+
+from paramecio2.libraries.pages import Pages
+from paramecio2.libraries.urls import add_get_parameters
+from paramecio2.libraries.i18n import I18n
+from flask import request, session
+import sys
+import re
+
+class SimpleList:
+    
+    def __init__(self, model, url, t):
+        
+        self.raw_query=True
+        
+        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=['down', 'up']
+        
+        #self.s=get_session()
+        
+        #clean session
+        
+        self.order='0'
+        
+        self.order_field=self.model.name_field_id
+        
+        self.order_by=self.order_defaults[0]
+        
+        self.change_order={}
+        
+        self.yes_search=True
+        
+        self.search_text=''
+        
+        self.initial_num_pages=20
+        
+        self.table_div=False
+        
+        try: 
+        
+            self.begin_page=int(request.args.get('begin_page', '0'))
+            
+        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 />'
+
+        self.ajax=False
+
+    def restore_fields(self):
+        self.fields=self.model.fields.keys()
+    
+    def obtain_order(self):
+        
+        self.order=request.args.get('order', self.order) #self.getpostfiles.get.get('order', self.order)
+        
+        order_k=int(self.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.order=order_k
+    
+    def obtain_field_search(self):
+        
+        self.order_field=request.args.get('order_field', self.order_field)
+        
+        field_k=self.order_field
+        
+        """
+        if 'order_field' in request.query.keys():
+            field_k=request.query.order_field
+        """
+        
+        if field_k in self.model.fields.keys():
+            
+            self.order_field=field_k
+        
+        for field in self.fields:
+            
+            #Initialize foreignkeyfield fields too
+            
+            if type(self.model.fields[field]).__name__=='ForeignKeyField':
+                name_related=self.model.fields[field].related_model.name
+                for k in self.model.fields[field].related_model.fields.keys():
+                    self.change_order[field+'_'+k]=self.order
+            
+            self.change_order[field]=self.order
+        
+        if self.order==0:
+            self.change_order[field_k]=1
+        else:
+            self.change_order[field_k]=0
+        
+        #self.order_field=self.order_field
+        
+    def search(self):
+        
+        self.search_text=request.args.get('search_text', '')
+        
+        self.search_text=self.search_text.replace('"', '&quot;')
+        
+        #self.model.conditions='AND 
+        
+        self.search_field=request.args.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].append('%'+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.model.yes_reset_conditions=False
+        
+        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, order=self.order)
+        
+        begin_page=self.begin_page
+        
+        self.model.order_by='order by '+self.order_field+' '+self.order_by
+
+        if self.limit_pages>0:
+        
+            self.model.limit='limit '+str(begin_page)+','+str(self.limit_pages)
+        
+        list_items=self.model.select(self.fields, self.raw_query)
+        
+        #print(self.model.fields.keys())
+        
+        func_jscript=''
+        
+        if self.ajax==True:
+            func_jscript='get_page()'
+            
+        pages=''
+
+        if self.limit_pages>0:        
+            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)
+        
+        self.model.yes_reset_conditions=True
+        
+        listing=self.t.load_template('utils/list.phtml', simplelist=self, list=list_items, pages=pages, ajax=self.ajax)
+        
+        list_items.close()
+        
+        return listing
+
+    @staticmethod
+    def get_ajax_page(model):
+        
+        
+        
+        pass
+        
+    
+class AjaxList(SimpleList):
+    
+    # Fields example: [[I18n.lang('cuchulu', 'hostname', 'Hostname'), True], ['IP', True], [I18n.lang('cuchulu', 'options', 'Options'), False]]
+    
+    # arr_order_fields=['server.hostname', 'server.ip']
+    
+    # 'select count(servercloud.id) as num_elements from servercloud where servercloud.user_id=%s'
+    # params count_query [s['cu_id']]
+    
+    # str_query no order, no limit -> select server.hostname, server.ip, servercloud.id from server, servercloud where server.id=servercloud.server_id and servercloud.user_id=%s
+    # str_query_params -> [s['cu_id'], begin_page, limit]
+    
+    def __init__(self, db, fields, arr_order_fields, count_query, str_query):
+        
+        self.fields=fields
+        self.arr_order_fields=arr_order_fields
+        self.limit=20
+        self.count_query=count_query[0]
+        self.count_query_params=count_query[1]
+        self.str_query=str_query[0]
+        self.str_query_params=str_query[1]
+        self.initial_num_pages=20
+        self.db=db
+        self.func_fields={}
+        
+    def show(self):
+        
+        begin_page=int(request.args.get('position', 0))
+        order_field=request.args.get('order_field', '')
+        order=request.args.get('order', 0)
+        limit=self.limit
+
+        arr_order=['ASC', 'DESC']
+        
+        order_sql=''
+        order_params=[]
+        
+        if order_field!='':
+            try:
+                order_field=int(order_field)
+                order=int(order)
+                
+                if order_field>=0 and order_field<len(self.arr_order_fields):
+                    order_sql='order by %s' % self.arr_order_fields[order_field]
+                    if order>=0 and order<2:
+                        order_sql+=' %s' % arr_order[order]
+                    
+                    #order_params=[self.arr_order_fields[order_field]]
+                
+            except:
+                order_field=0
+                order=0
+                
+
+        rows=[]
+        
+        with self.db.query(self.count_query, self.count_query_params) as cursor:
+            total_elements=cursor.fetchone()['num_elements']
+        
+        str_query=self.str_query+' '+order_sql
+        
+        if self.limit>0:
+            str_query+=' limit %s, %s'
+        
+        params=self.str_query_params
+        params.append(begin_page)
+        params.append(limit)
+        
+        with self.db.query(str_query, params) as cursor:
+            for row in cursor:
+                """
+                c=len(self.arr_order_fields)
+                for x in range(c, len(row)):
+                    key_field=list(row.keys())[x]
+                    #print(key_field)
+                    pass
+                """    
+            
+                for func_field in self.func_fields:
+                    if func_field in row:
+                        row[func_field]=self.func_fields[func_field](row[func_field], row)
+            
+                rows.append(row)                
+                #{k:d[k] for  in set(d).intersection(l)}
+            
+        pages=Pages()
+        
+        html_pages=pages.show( begin_page, total_elements, limit, '#' ,initial_num_pages=self.initial_num_pages, variable='begin_page', label='', func_jscript='')
+        
+        return {'fields': self.fields, 'rows': rows, 'html_pages': I18n.lang('cuchulu', 'pages', 'Pages')+': '+html_pages}
+        
+        
+    
+    

paramecio2/libraries/mtemplates.py

@@ -8,7 +8,7 @@ from settings import config
 import gettext
 import sys
 from paramecio2.libraries.i18n import I18n
-from paramecio2.libraries.urls import make_url, make_media_url
+from paramecio2.libraries.urls import make_url, make_media_url, add_get_parameters
 from paramecio2.libraries.formsutils import csrf_token
 
 def env_theme(module, cache_enabled=True, cache_impl='', cache_args={}, module_directory="./tmp/modules"):
@@ -58,6 +58,8 @@ class PTemplate:
 
         self.add_filter(csrf_token)
         
+        self.add_filter(add_get_parameters)
+
     """
     def gettext(self, text):
         return gettext.dgettext(self.domain_gettext, text)

paramecio2/libraries/pages.py

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

paramecio2/libraries/templates/utils/admin.phtml

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

paramecio2/libraries/urls.py

@@ -54,6 +54,27 @@ def make_external_url(path, query_args={}):
     
     return path+get_query
 
+def add_get_parameters(url, **args):
+
+    """
+        This is a method for add args to existent url
+        
+        Keyword arguments:
+        url -- The url
+        args -- a ser of get variables for add to url
+        
+    """
+    
+    added_url='&'
+    
+    if url.find('?')==-1:
+        added_url='?'
+    
+    get_query=urllib.parse.urlencode(args)
+    
+    return url+added_url+get_query
+
+
 if config.yes_static==True:
         
     def make_media_url(file_path, module):

paramecio2/modules/admin/admin/ausers.py

@@ -1,5 +1,37 @@
 from settings import config
+from flask import g, url_for
+from paramecio2.modules.admin.models.admin import UserAdmin
+from paramecio2.libraries.generate_admin_class import GenerateAdminClass
+from paramecio2.libraries.i18n import I18n
+from paramecio2.libraries.db.coreforms import SelectForm
 
-def admin():
 
-    return "admin users"
+def admin(**args):
+    
+    t=args['t']
+    
+    connection=g.connection
+    
+    user_admin=UserAdmin(connection)
+    
+    user_admin.fields['privileges'].name_form=SelectForm
+    
+    user_admin.create_forms(['username', 'password', 'email', 'privileges', 'lang'])
+    
+    user_admin.forms['privileges'].arr_select={0: I18n.lang('admin', 'without_privileges', 'Without privileges'), 1: I18n.lang('admin', 'selected_privileges', 'Selected privileges'), 2: I18n.lang('admin', 'administrator', 'Administrator')}
+    
+    user_admin.fields['password'].protected=False
+    
+    url=url_for('.admin', module='ausers')
+    
+    admin=GenerateAdminClass(user_admin, url, t)
+    
+    admin.list.fields_showed=['username', 'privileges']
+    
+    admin.list.search_fields=['username']
+    
+    admin.arr_fields_edit=['username', 'password', 'repeat_password', 'email', 'privileges', 'lang']
+    
+    form_admin=admin.show()
+    
+    return form_admin

paramecio2/modules/admin/app.py

@@ -90,8 +90,8 @@ for app_load in config_admin.values():
         #print(app_load[1])
 
 @admin_app.route('/admin')
-@admin_app.route('/admin/<module>')
-@admin_app.route('/admin/<module>/<submodule>')
+@admin_app.route('/admin/<module>', methods=['GET', 'POST'])
+@admin_app.route('/admin/<module>/<submodule>', methods=['GET', 'POST'])
 def admin(module='', submodule=''):
     
     """
@@ -109,9 +109,15 @@ def admin(module='', submodule=''):
         
         if path_module in arr_modules_admin:
             
-            content=arr_modules_admin[path_module].admin()
+            content=arr_modules_admin[path_module].admin(t=t)
             
-            return t.load_template('content.phtml', title=I18n.lang('admin', 'paramecio_admin', 'Paramecio admin'), contents=content)
+            if type(content).__name__=='str':
+            
+                return t.load_template('content.phtml', title=I18n.lang('admin', 'paramecio_admin', 'Paramecio admin'), contents=content)
+                
+            else:
+                
+                return content
             
         else:
             abort(404)

paramecio2/modules/admin/templates/dashboard.phtml

@@ -60,6 +60,16 @@
         <div class="contents">
             <h1>${title}</h1>
             <div class="content">
+                <%
+                from flask import get_flashed_messages
+                
+                %>
+                % for flash in get_flashed_messages():
+                
+                <div class="flash">${flash}</div>
+                
+                % endfor
+                <script>setTimeout(function () { $(".flash").fadeOut();  }, 3000);</script>
                 <%block name="content">
                 </%block>
             </div>