Skip to content

aa.gusti / opensipkd-base

Go to a project
Commit 5bcb5039 by aagusti
Options

move to record

1 parent 59fadecd
Inline Side-by-side
Showing 11 changed files with 112 additions and 641 deletions
opensipkd/base/views/base_views_api.py deleted 100644 → 0
from datetime import datetime
from deform import ValidationFailure, Form, Button
from opensipkd.models import flush, DBSession, Menus
from pyramid_rpc.jsonrpc import JsonRpcError
from opensipkd.tools.form_api import formfield2dict
class BaseApi(object):
def __init__(self, request):
self.request = request
self.url = request.home + '/rpc/pbb/eta'
self.add_schema = {}
self.buttons = ()
self.data = {}
def make_response(self, data, **kwargs):
resp = {"data": data}
code = kwargs.get("code")
message = kwargs.get("message")
if code: resp.update({"code": code})
if message: resp.update({"message": message})
return resp
def get_form(self, class_form, row=None, **kwargs):
bindings = kwargs.get("bindings")
validator = kwargs.get("validator")
self.buttons = kwargs.get("buttons", self.buttons)
if "url" in kwargs:
url = kwargs.get("url", "")
else:
url = self.url
if validator:
schema = class_form(validator=validator)
else:
schema = class_form() # validator=validator
if bindings:
schema = schema.bind(request=self.request, **bindings)
else:
schema = schema.bind(request=self.request)
if row:
schema.deserialize(row)
return Form(schema, url=url, buttons=self.buttons)
def validate_field(self, form):
resp = {}
controls = ((k, v) for k, v in self.data.items())
try:
c = form.validate(controls)
except ValidationFailure as e:
form.set_appstruct(e.cstruct)
resp.update(formfield2dict(form))
message = "\n".join([v for k, v in e.error.asdict().items()])
raise JsonRpcError(message=message, data=resp)
return dict(c)
def get_menu_buttons(self, kode):
qry = Menus.get(kode).order_by(Menus.order_id)
if self.request.user:
qry = qry.filter_by(need_login=1)
else:
qry = qry.filter(Menus.need_login != 1)
buttons = []
for row in qry.all():
if not self.request.user:
if row.need_login:
continue
if row.permissions:
if not self.request.user or not self.request.has_permission(
row.permissions):
continue
buttons.append(Button(row.kode, title=row.title, type="button",
value=row.url, icon=row.icon,))
# attributes=dict(method=row.url)))
return tuple(buttons)
def update_headers(self, headers):
self.request.headers.update(headers)
self.request.response.headers.update(headers)
def _view_add(self, **kwargs):
form = self.get_form(self.add_schema, **kwargs)
self.action = self.data.get("action", "")
if 'save' == self.action:
values = self.validate_field(form)
row = self.save_request(values)
elif "cancel" == self.action or 'batal' == self.action:
self.cancel_act()
else:
next = self.next_add(form)
if next:
return next
# return self.route_list()
values = self.before_add()
form.set_appstruct(values)
return form
def view_add_api(self, **kwargs):
form = self._view_add(**kwargs)
resp = formfield2dict(form)
return dict(data=resp)
def save(self, values, user, row=None):
self.ses["old_email"] = user and user.email or None
if not row:
row = self.table()
row.created = datetime.now()
row.create_uid = user and user.id or None
else:
row.updated = datetime.now()
row.update_uid = user and user.id or None
row.from_dict(values)
row.status = 'status' in values and values['status'] and 1 or 0
flush(row)
return row
def save_request(self, values, row=None):
for k, v in self.request.GET.items():
if k not in values:
if v:
values[k] = v
return self.save(values, self.request.user, row)
def id_not_found(self):
msg = f"Data yang dicari Tidak Ditemukan ID:" \
f" {self.request.matchdict['id']}."
self.request.session.flash(msg, 'error')
return self.route_list()
def next_add(self, form):
"""
Digunakan untuk memverifikasi button yang lainnya
:param form: Object Form
:return:
"""
return ""
def query_id(self):
q = DBSession.query(self.table).filter_by(
id=self.req.matchdict['id'])
if hasattr(self.table, 'company_id') and self.req.user.company_id:
q = q.filter_by(company_id=self.req.user.company_id)
return q
def route_list(self, msg=None, error=""):
if msg:
self.ses.flash(msg, error)
if self.headers:
return HTTPFound(location=self.req.route_url(self.list_route),
headers=self.headers)
else:
return HTTPFound(location=self.req.route_url(self.list_route))
def before_add(self):
return {}
opensipkd/base/views/menus.py
......@@ -7,6 +7,7 @@ from pyramid.view import (view_config, )
from sqlalchemy.orm import aliased
from ..views import ColumnDT, DataTables, BaseView
_ = TranslationStringFactory("opensipkd")
SESS_ADD_FAILED = 'Tambah menu gagal'
......@@ -45,6 +46,14 @@ class AddSchema(colander.Schema):
kode = colander.SchemaNode(colander.String(),
validator=colander.Length(max=32), oid="kode")
nama = colander.SchemaNode(colander.String(), oid="nama")
url = colander.SchemaNode(colander.String(), oid="url",
title="URL/METHOD")
icon = colander.SchemaNode(colander.String(),
missing=colander.drop)
class_name = colander.SchemaNode(colander.String(), oid="url",
missing=colander.drop)
need_login = colander.SchemaNode(colander.Boolean())
title = colander.SchemaNode(colander.String())
status = colander.SchemaNode(colander.Boolean(), oid="status")
def after_bind(self, schema, kwargs):
......
opensipkd/base/views/user_rpc.py
......@@ -14,7 +14,6 @@ from pyramid.i18n import TranslationStringFactory
from pyramid.security import remember, forget
from pyramid_rpc.jsonrpc import jsonrpc_method
from .base_views_api import BaseApi
from .user import EmailValidator as EmailValidatorBase
from .user_group import save as save_groups
from .user_login import (ChangePassword, change_password_validator,
......
opensipkd/dejson/TODO deleted 100644 → 0
TODO
- docs
- column formating (left, right, center)
- numeric formating
- date formating
opensipkd/dejson/__init__.py deleted 100644 → 0
"""Detable."""
import os
from pkg_resources import resource_filename
from . import detable # API
from deform.field import Field # API
from .detable import Button # API
from .detable import DeTable # API
from deform import ZPTRendererFactory # API
from deform import default_renderer # API
deform_templates = resource_filename('deform', 'templates')
path = os.path.dirname(__file__)
path = os.path.join(path, 'templates')
search_path = (path, deform_templates) #,
# renderer = ZPTRendererFactory(search_path)
DeTable.set_zpt_renderer(search_path)
opensipkd/dejson/detable.py deleted 100644 → 0
"""Form."""
# Standard Library
import json
import re
import logging
import colander
import deform
from chameleon.utils import Markup
from deform import compat
from deform import field
from . import widget
log = logging.getLogger(__name__)
class DeTable(field.Field):
"""
Field representing an entire form.
Arguments:
schema
A :class:`colander.SchemaNode` object representing a
schema to be rendered. Required.
action
The table action (inserted into the ``ajax_url`` attribute of
the datatable's scripts tag when rendered). Required.
# method
# The form method (inserted into the ``method`` attribute of
# the form's form tag when rendered). Default: ``POST``.
buttons
A sequence of strings or :class:`deform.form.Button`
objects representing submit buttons that will be placed at
the bottom of the form. If any string is passed in the
sequence, it is converted to
:class:`deform.form.Button` objects.
tableid
The identifier for this table. This value will be used as the
HTML ``id`` attribute of the rendered HTML table. You should
pass a string value for ``tableid`` when more than one Detable
table is placed into a single page and both share the same action.
When one of the tables on the page is posted, your code will to
be able to decide which of those tables was posted based on the
differing values of ``__tableid__``. By default,
``tableid`` is ``detable``.
use_ajax
If this option is ``True``, the form will use AJAX (actually
AJAH); when any submit button is clicked, the DOM node related
to this form will be replaced with the result of the form post
caused by the submission. The page will not be reloaded. This
feature uses the ``jquery.form`` library ``ajaxForm`` feature
as per `http://jquery.malsup.com/form/
<http://jquery.malsup.com/form/>`_. Default: ``False``. If
this option is ``True``, the ``jquery.form.js`` library must be
loaded in the HTML page which embeds the form. A copy of it
exists in the ``static`` directory of the ``deform`` package.
ajax_options
A *string* which must represent a JavaScript object
(dictionary) of extra AJAX options as per
`http://jquery.malsup.com/form/#tab3
<http://jquery.malsup.com/form/#tab3>`_. For
example:
.. code-block:: python
'{"success": function (rText, sText, xhr, form) {alert(sText)};}'
Default options exist even if ``ajax_options`` is not provided.
By default, ``target`` points at the DOM node representing the
form and and ``replaceTarget`` is ``true``.
A success handler calls the ``deform.processCallbacks`` method
that will ajaxify the newly written form again. If you pass
these values in ``ajax_options``, the defaults will be
overridden. If you want to override the success handler, don't
forget to call ``deform.processCallbacks``, otherwise
subsequent form submissions won't be submitted via AJAX.
This option has no effect when ``use_ajax`` is False.
The default value of ``ajax_options`` is a string
representation of the empty object.
The :class:`deform.Form` constructor also accepts all the keyword
arguments accepted by the :class:`deform.Field` class. These
keywords mean the same thing in the context of a Form as they do
in the context of a Field (a Form is just another kind of Field).
"""
css_class = "deform" # bw compat only; pass a widget to override
def __init__(
self,
schema,
action,
action_suffix='/grid/act',
buttons=(),
tableid="detable",
sorts='true',
filters='true',
paginates='true',
params="",
# ajax_options="{}",
# autocomplete=None,
# focus="on",
# cols = None,
**kw
):
params = params and f"?{params}" or ""
btn_close_js = "{window.location = '/'; return false;}"
btn_add_js = "{window.location = o%sUri+'/add%s';}" % (tableid, params)
btn_edit_js = """{
if (m%sID) window.location = o%sUri+'/'+m%sID+'/edit%s';
else alert('Pilih Baris');
}""" % (tableid, tableid, tableid, params)
btn_view_js = "{window.location = o%sUri+'/'+m%sID+'/view%s';}" % (tableid, tableid, params)
btn_delete_js = "{window.location = o%sUri+'/'+m%sID+'/delete%s';}" % (tableid, tableid, params)
btn_csv_js = "{window.location = o%sUri+'/csv/act%s';}" % (tableid, params)
btn_pdf_js = "{window.open(o%sUri+'/pdf/act%s');}" % (tableid, params)
action_suffix = f"{action_suffix}{params}"
field.Field.__init__(self, schema, **kw)
_buttons = []
for button in buttons:
if isinstance(button, compat.string_types):
button = Button(button)
_buttons.append(button)
buttons = _buttons
_buttons = []
_scripts = []
for button in buttons:
_buttons.append(
f"""<button
id="{tableid}{button.name}"
name="{button.name}"
type="{button.type}"
class="btn {button.css_class}">
{button.title} </button>\n
""")
_scripts.append(f'$("#{tableid + button.name}").click(function ()' +
eval('btn_' + button.name + '_js') + ');')
# <span tal:condition="button.icon" class="glyphicon glyphicon-${button.icon}"></span>
self.buttons = "','".join(_buttons).replace('\n', "").replace(';', ';\n')
self.tableid = tableid
self.scripts = ''.join(_scripts).replace(';', ";\n")
table_widget = getattr(schema, "widget", None)
if table_widget is None:
table_widget = widget.TableWidget()
self.widget = table_widget
columns = []
cols2 = []
for f in schema:
d = {'data': f.name}
data = []
if hasattr(f, 'width'):
d["width"] = f.width
data.append(f"width: '{f.width}'")
if hasattr(f, 'aligned'):
d["className"] = f.aligned
data.append(f"className: '{f.aligned}'")
if hasattr(f, 'searchable'):
d["searchable"] = f.searchable
data.append(f"searchable: {f.searchable}")
if hasattr(f, 'visible') :
d["visible"] = f.visible
data.append(f"visible: {f.visible}")
if isinstance(f.widget,deform.widget.HiddenWidget):
d["visible"] = False
if hasattr(f, 'orderable'):
d["orderable"] = f.orderable
data.append(f"orderable: {f.orderable}")
thousand = hasattr(f, 'thousand') and f.thousand or None
separator = thousand and "separator" in thousand and thousand["separator"] or ','
decimal = thousand and "decimal" in thousand and thousand["decimal"] or '.'
point = thousand and "point" in thousand and thousand["point"] or 0
currency = thousand and "currency" in thousand and thousand["currency"] or ""
if thousand or type(f.typ) == colander.Float() or type(f.typ) == colander.Integer():
d["render"] = f"<script>$.fn.dataTable.render.number( '{separator}', '{decimal}', {point}, '{currency}' )</script>"
if 'className' not in d:
d["className"] = "text-right"
# if hasattr(f, "edit_link"):
# s = """function ( data, type, row, meta ) {
# return '<a href="'+data+'">Download</a>';
# }"""
# d["render"] = s
columns.append(d)
cols2.append(data)
# columns.append(dict(title="Action",
# data='id',
# width="40pt",
# orderable=False,
# align="text-center",
# searchable=False))
self.columns = json.dumps(columns)
self.columns = self.columns.replace('"<script>', "").replace('</script>"', "").replace("\n", "")
# self.columns = columns
# self.columns = json.dumps(cols2)
self.url = action
self.url_suffix = action_suffix
self.sorts = sorts
self.paginates = paginates
self.filters = filters
class Button(object):
"""
A class representing a form submit button. A sequence of
:class:`deform.widget.Button` objects may be passed to the
constructor of a :class:`deform.form.Form` class when it is
created to represent the buttons renderered at the bottom of the
form.
Arguments:
name
The string or unicode value used as the ``name`` of the button
when rendered (the ``name`` attribute of the button or input
tag resulting from a form rendering). Default: ``submit``.
title
The value used as the title of the button when rendered (shows
up in the button inner text). Default: capitalization of
whatever is passed as ``name``. E.g. if ``name`` is passed as
``submit``, ``title`` will be ``Submit``.
type
The value used as the type of button. The HTML spec supports
``submit``, ``reset`` and ``button``. A special value of
``link`` will create a regular HTML link that's styled to look
like a button. Default: ``submit``.
value
The value used as the value of the button when rendered (the
``value`` attribute of the button or input tag resulting from
a form rendering). If the button ``type`` is ``link`` then
this setting is used as the URL for the link button.
Default: same as ``name`` passed.
icon
glyph icon name to include as part of button. (Ex. If you
wanted to add the glyphicon-plus to this button then you'd pass
in a value of ``plus``) Default: ``None`` (no icon is added)
disabled
Render the button as disabled if True.
css_class
The name of a CSS class to attach to the button. In the default
form rendering, this string will replace the default button type
(either ``btn-primary`` or ``btn-default``) on the the ``class``
attribute of the button. For example, if ``css_class`` was
``btn-danger`` then the resulting default class becomes
``btn btn-danger``. Default: ``None`` (use default class).
attributes
HTML5 attributes passed in as a dictionary. This is especially
useful for a Cancel button where you do not want the client to
validate the form inputs, for example
``attributes={"formnovalidate": "formnovalidate"}``.
"""
def __init__(
self,
name="view",
oid=None,
title=None,
type="button", # noQA
css_class=None,
icon=None,
attributes=None,
disabled=None
):
if attributes is None:
attributes = {}
if title is None:
title = name.capitalize()
name = re.sub(r"\s", "_", name)
if oid is None:
self.oid = f"detable_btn_{name}"
self.name = name
self.title = title
self.type = type # noQA
self.disabled = disabled
self.css_class = css_class
self.icon = icon
self.attributes = attributes
opensipkd/dejson/i18n.py deleted 100644 → 0
"""I18n."""
from translationstring import TranslationStringFactory
_ = TranslationStringFactory("detable")
opensipkd/dejson/templates/detable.pt deleted 100644 → 0
<div tal:define="style style|field.widget.style;
css_class css_class|string:${field.widget.css_class or field.css_class or 'jarviswidget jarviswidget-color-blueLight'};
item_template item_template|field.widget.item_template;
title title|field.title;
errormsg errormsg|field.errormsg;
description description|field.description;
buttons buttons|field.buttons;
tableid tableid|field.tableid;
columns columns|field.columns;
btnscripts scripts|field.scripts;
url url|field.url;
url_suffix url_suffix|field.url_suffix;
sorts sorts|field.sorts;
filters filters|field.filters;
paginates paginates|field.paginates;
"
tal:attributes="style style;
class css_class;
attributes|field.widget.attributes|{};"
i18n:domain="detable">
<header role="heading" class="txt-color-grayDark">
<h2 tal:condition="title">
<i class="fa fa-fw fa-table"></i>${title}
</h2>
<div role="content">
<div class="widget-body">
<table id="${tableid}"
class="table table-bordered table-hover table-condensed dataTable no-footer">
<thead>
<tr>
<th tal:repeat="child field">${child.title}</th>
<!--? <th>Action</th>-->
</tr>
</thead>
<tbody>
</tbody>
</table>
</div> <!-- widget-body -->
</div>
</header>
<script type="text/javascript">
deform.addCallback(
'${tableid}',
function (oid) {
var m${tableid}ID;
var o${tableid};
var o${tableid}Uri = "${url}";
var o${tableid}Url = o${tableid}Uri + "${url_suffix}";
var tb_array = [
'<div class="btn-group pull-left">',
'${structure:buttons}',
' &nbsp;',
'</div>',
]
var language = {
"search": "Cari: ",
"paginate": {
"first": '<span class="glyphicon glyphicon-step-backward"></span> ',
"last": '<span class="glyphicon glyphicon glyphicon-step-forward"></span> ',
"previous": '<span class="glyphicon glyphicon-backward"></span> ',
"next": '<span class="glyphicon glyphicon-forward"></span> ',
},
"lengthMenu": " _MENU_ baris "
};
o${tableid} = $('#${tableid}').DataTable({
dom: '<"row"<"col-md-8"<"toolbar">Bl><"col-md-4"fr>>tip',
processing: true,
serverSide: true,
ajax: o${tableid}Url,
stateSave: false,
scrollCollapse: true,
sort: ${sorts},
info: false,
filter: ${filters},
autoWidth: false,
paginate: ${paginates},
paginationType: "full_numbers",
lengthMenu: [
[10, 25, 50, 100],
[10, 25, 50, 100]
],
columns: ${structure:columns},
"language": language,
});
var tb = tb_array.join(' ');
$("div.toolbar").html(tb);
$("div.toolbar").attr('style', 'display:block; float: left; margin-bottom:6px; line-height:16px;');
$('#${tableid} tbody').on('click', 'tr', function () {
if ($(this).hasClass('selected')) {
$(this).removeClass('selected');
} else {
var aData = o${tableid}.row(this).data();
o${tableid}.$('tr.selected').removeClass('selected');
$(this).addClass('selected');
m${tableid}ID = aData.id;
// console.log(mID);
o${tableid}.$('tr.row_selected').removeClass('row_selected');
$(this).addClass('row_selected');
}
});
${structure:btnscripts}
});
</script>
</div>
\ No newline at end of file
opensipkd/dejson/widget.py deleted 100644 → 0
"""Widget."""
# Standard Library
import csv
import json
import random
# Pyramid
from colander import Invalid
from colander import Mapping
from colander import SchemaNode
from colander import SchemaType
from colander import Sequence
from colander import String
from colander import null
from iso8601.iso8601 import ISO8601_REGEX
from translationstring import TranslationString
from deform.widget import MappingWidget
from deform.compat import text_
from .i18n import _
_BLANK = text_("")
class TableWidget(MappingWidget):
"""
The top-level widget; represents an entire table.
**Attributes/Arguments**
template
The template name used to render the widget. Default:
``detable``.
"""
template = "detable"
readonly_template = "readonly/detable"
requirements = (("deform", None),
{"js": "opensipkd.base:static/v3/js/plugin/datatables/jquery.dataTables.min.js"})
opensipkd/detable/detable.py
......@@ -162,6 +162,7 @@ class DeTable(field.Field):
self.server_side = server_side
self.data = data
columns = []
headers = []
cols2 = []
for f in schema:
d = {'data': f.name}
......@@ -219,8 +220,17 @@ class DeTable(field.Field):
if 'className' not in d:
d["className"] = "text-right"
columns.append(d)
headers.append(f.title)
cols2.append(data)
# for t in d:
# if "title" in t:
# headers.append(t["title"])
# else:
# headers.append(t)
self.headers = headers
self.head = headers
self.columns = json.dumps(columns)
self.columns = self.columns.replace('"<script>', "").replace(
'</script>"', "").replace("\n", "")
......@@ -229,6 +239,7 @@ class DeTable(field.Field):
self.sorts = sorts
self.paginates = paginates
self.filters = filters
print(self.headers)
class Button(object):
......
opensipkd/models/views/__init__.py 0 → 100644
from sqlalchemy import func
from sqlalchemy.sql import sqltypes
from .. import Base
from opensipkd.tools import round_up
from opensipkd.tools.api import JsonRpcDataNotFoundError
from opensipkd.tools.pbb import FixNop, FixKelurahan, FixBlok
class BaseApiTableFilter(object):
"""Function untuk standarisasi filtering table"""
def __init__(self, orm, data):
self.orm = orm
self.data = data
def filter_nop(self, qry, val):
kode = FixNop(val)
return qry.filter_by(kd_propinsi=kode["kd_propinsi"],
kd_dati2=kode["kd_dati2"],
kd_kecamatan=kode["kd_kecamatan"],
kd_kelurahan=kode["kd_kelurahan"],
kd_blok=kode["kd_blok"],
no_urut=kode["no_urut"],
kd_jns_op=kode["kd_jns_op"])
def filter_desa(self, qry, val):
kode = FixKelurahan(val)
return qry.filter_by(kd_propinsi=kode["kd_propinsi"],
kd_dati2=kode["kd_dati2"],
kd_kecamatan=kode["kd_kecamatan"],
kd_kelurahan=kode["kd_kelurahan"]
)
def filter_blok(self, qry, val):
kode = FixBlok(val)
return qry.filter_by(kd_propinsi=kode["kd_propinsi"],
kd_dati2=kode["kd_dati2"],
kd_kecamatan=kode["kd_kecamatan"],
kd_kelurahan=kode["kd_kelurahan"],
kd_blok=kode["kd_blok"])
def get_data(self):
data = self.data
orm = self.orm
qry = self.orm.query()
if "where" in data:
for w in data["where"]:
if hasattr(orm, w['key']):
key = w["key"]
val = w["val"]
if key == "nop":
qry = self.filter_nop(qry, val)
elif key == "desa":
qry = self.filter_desa(qry, val)
elif key == "blok":
qry = self.filter_blok(qry, val)
else:
key = getattr(orm, key)
if isinstance(key.type, sqltypes.String):
qry = qry.filter(func.trim(key) == val)
else:
qry = qry.filter(key == val)
if "order" in data:
for o in data["order"]:
key = getattr(orm, o)
qry = qry.order_by(key)
page_size = "page_size" in data and int(data["page_size"]) or 20
page = "page" in data and int(data["page"]) or 1
total_page = round_up(qry.count() / page_size)
if total_page and page > total_page:
page = int(total_page)
offset = (page - 1) * page_size
qry = qry.offset(offset).limit(page_size)
return qry, page, total_page
def get_filter(self):
qry, page, total_page = self.get_data()
row = qry.first()
if not row:
raise JsonRpcDataNotFoundError
result = []
for row in qry.all():
result.append(row.to_dict())
return dict(record=result,
total_page=total_page,
page=page)
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!