message.py

import os
from datetime import (
    date,
    datetime,
    timedelta,
    )
from base64 import (
    b64encode,
    b64decode,
    )
from sqlalchemy import (
    or_,
    not_,
    )
from pkg_resources import resource_filename
from pyramid.view import view_config
from pyramid.httpexceptions import (
    HTTPFound,
    HTTPNotFound,
    )
from pyramid.i18n import TranslationStringFactory
import colander
from deform import (
    Form,
    widget,
    ValidationFailure,
    Button,
    ZPTRendererFactory,
    )
from paginate_sqlalchemy import SqlalchemyOrmPage
from ..models import DBSession
from ..models.ziggurat import User
from ..models.imgw import (
    Jalur,
    Selesai,
    Antrian,
    Agent,
    Modem,
    ModemPengirim,
    )
from ..tools.msisdn import get_msisdn
from ..tools.waktu import (
    date_from_str,
    create_datetime,
    )


_ = TranslationStringFactory('message')


########
# List #
########
@colander.deferred
def jalur_widget(node, kw):
    values = kw.get('jalur_list')
    return widget.SelectWidget(values=values)
 

@colander.deferred
def kirim_widget(node, kw):
    values = kw.get('kirim_list')
    return widget.SelectWidget(values=values)


class FilterSchema(colander.Schema):
    awal = colander.SchemaNode(colander.Date())
    akhir = colander.SchemaNode(colander.Date())
    pesan = colander.SchemaNode(colander.String(), missing=colander.drop)
    jalur = colander.SchemaNode(
        colander.String(), missing=colander.drop, widget=jalur_widget)
    kirim = colander.SchemaNode(
        colander.String(), missing=colander.drop, widget=kirim_widget,
        title=_('direction', default='Kirim / terima'))
    identitas = colander.SchemaNode(
        colander.String(), missing=colander.drop,
        title=_('sender-recipient-identity', default='Pengirim / penerima'))


deform_templates = resource_filename('deform', 'templates')
here = os.path.abspath(os.path.dirname(__file__))
my_templates = os.path.join(here, 'templates', 'message')
search_path = [my_templates, deform_templates]
my_renderer = ZPTRendererFactory(search_path)
 

def get_filter_form():
    btn_show = Button('lihat', _('Lihat'))
    jalur_list = [
        ('', ''),
        ('1', _('SMS')),
        ('1 ussd', _('USSD')),
        ('6', _('Mail')),
        ]
    kirim_list = [
        ('', ''),
        ('0', _('msg-received', default='Penerimaan')),
        ('1', _('msg-sent', default='Pengiriman')),
        ('1 0', _('msg-sent-ok', default='Pengiriman berhasil')),
        ('1 -1', _('msg-sent-failed', default='Pengiriman gagal')),
        ('1 1', _('msg-sent-process', default='Pengiriman masih proses')),
        ]
    schema = FilterSchema()
    schema = schema.bind(jalur_list=jalur_list, kirim_list=kirim_list)
    return Form(
        schema, buttons=(btn_show,), renderer=my_renderer)


def route_list(request, p={}):
    return HTTPFound(location=request.route_url('message', _query=p))


def get_query(p):
    d = p['awal']
    awal = create_datetime(d.year, d.month, d.day)
    d = p['akhir'] + timedelta(1)
    akhir = create_datetime(d.year, d.month, d.day)
    q = DBSession.query(Selesai).filter(
            Selesai.tgl >= awal, Selesai.tgl < akhir)
    if 'jalur' in p:
        t = p['jalur'].split()
        jalur_id = int(t[0])
        q = q.filter_by(jalur=jalur_id)
        if t[1:]:
            q = q.filter(Selesai.penerima == None)  # USSD
        else:
            q = q.filter(Selesai.penerima != None)  # SMS
    if 'kirim' in p:
        t = p['kirim'].split()
        kirim = t[0] == '1'
        q = q.filter_by(kirim=kirim)
        if t[1:]:
            status = t[1]
            if status == '0':
                q = q.filter_by(status=0)
            elif status == '-1':
                q = q.filter(or_(Selesai.status < 0, Selesai.status == 4))
            else:
                q = q.filter(Selesai.status > 0)
    if 'identitas' in p:
        q = q.filter(
            or_(
                Selesai.pengirim.ilike('%' + p['identitas'] + '%'),
                Selesai.pengirim.ilike('%' + p['identitas'].lstrip('0') + '%'),
                Selesai.penerima.ilike('%' + p['identitas'] + '%'),
                Selesai.penerima.ilike('%' + p['identitas'].lstrip('0') + '%')))
    if 'pesan' in p:
        q = q.filter(
                or_(
                    Selesai.pesan.ilike('%' + p['pesan'] + '%'),
                    Selesai.jawaban.ilike('%' + p['pesan'] + '%')))
    return q 


@view_config(
    route_name='message', renderer='templates/message/list.pt',
    permission='view')
def view_list(request):
    def url_maker(page):
        p['page'] = page
        return request.route_url('message', _query=p)

    if not request.GET and not request.POST:
        p = dict(awal=date.today())
        p['akhir'] = p['awal']
        return route_list(request, p)    
    if request.POST:
        form = get_filter_form()
        items = request.POST.items()
        try:
            c = form.validate(items)
        except ValidationFailure as e:
            resp['form'] = e.render()
            return resp
        p = dict(c.items())
        p['lihat'] = 1 
        return route_list(request, p)
    resp = dict(title=_('Pesan'))
    form = get_filter_form()
    items = request.GET.items()
    p = dict(items)
    p['awal'] =  date_from_str(p['awal'])
    p['akhir'] =  date_from_str(p['akhir'])
    resp['form'] = form.render(appstruct=p)
    if 'lihat' not in request.GET:
        return resp
    q = get_query(p)
    resp['count'] = count = q.count()
    if not count:
        return resp
    d = dict(request.GET)
    del d['lihat']
    from_url = request.route_url('message', _query=d)
    resp['from_url'] = b64encode(from_url.encode('utf-8'))
    q = q.order_by(Selesai.id.desc())
    page = request.GET.get('page')
    page = page and int(page) or 1
    resp['rows'] = SqlalchemyOrmPage(
        q, page=page, items_per_page=10, item_count=count,
        url_maker=url_maker)
    return resp
    
########
# Send #
########
def form_validator(form, value):
    t = value['pengirim'].split()
    jalur_id = int(t[0])
    if jalur_id != 1:
        return
    if 'penerima' not in value:
        if not t[1:]:  # USSD tapi tidak ada pengirim ?
            raise colander.Invalid(
                form, _(
                    'missing-ussd-sender',
                    default='Pesan USSD harus ada pengirimnya.'))
        return
    msisdn = value['penerima']
    if msisdn[0] in ['0', '+']:
        msisdn = get_msisdn(msisdn)
        if not msisdn:
            raise colander.Invalid(
                form, _(
                    'invalid-recipient-phone-number',
                    default='Nomor penerima tidak benar.'))
        return
    # Siapa tahu shortcode
    try:
        int(msisdn)
    except ValueError:
        raise colander.Invalid(
            form, _(
                'invalid-recipient-msisdn',
                default='Nomor penerima tidak benar.'))
            

@colander.deferred
def pengirim_widget(node, kw):
    values = kw.get('pengirim_list')
    return widget.SelectWidget(values=values)


class MessageSchema(colander.Schema):
    pengirim = colander.SchemaNode(
                colander.String(), widget=pengirim_widget)
    penerima = colander.SchemaNode(
                colander.String(), missing=colander.drop,
                description=_(
                    'desc-penerima',
                    default='Bisa nomor HP atau email, sesuai Pengirim. '\
                            'Kosongkan bila mengirim USSD.'))
    pesan = colander.SchemaNode(
                colander.String(),
                widget=widget.TextAreaWidget(rows=5, cols=60))


def save(request, values):
    p = dict(pesan=values['pesan'],
             kirim=True)
    t = values['pengirim'].split()
    p['jalur'] = int(t[0])           
    if p['jalur'] == 1 and values['penerima'].find('0') == 0:
        p['penerima'] = get_msisdn(values['penerima'])
    elif values['penerima']:
        p['penerima'] = values['penerima']
    if t[1:]:
        p['pengirim'] = t[1]
    outbox = Antrian()
    outbox.from_dict(p)
    DBSession.add(outbox)
    request.session.flash(
        _('message-sent', default='Pesan sudah masuk antrian.'))


def get_pengirim_list():
    r = []
    q = DBSession.query(Jalur).filter(Jalur.id.in_([1, 4, 6]))
    for row in q.order_by(Jalur.id):
        r.append((row.id, row.nama))
    q = DBSession.query(Agent)
    for row in q.order_by(Agent.jalur, Agent.id):
        if row.jalur == 1 and row.modem:
            agent_id = row.modem.msisdn
        else:
            agent_id = row.id
        key = '{} {}'.format(row.jalur, agent_id)
        if row.status == 0:
            if row.jalur == 1:
                status = '{}%'.format(row.modem.signal)
            else:
                status = 'ON'
        else:
            status = 'OFF'
        value = '{} {} {}'.format(row.jalur_ref.nama, agent_id, status)
        r.append((key, value))
    return r
    

def get_add_form():
    schema = MessageSchema(validator=form_validator)
    schema = schema.bind(pengirim_list=get_pengirim_list())
    btn_kirim = Button('kirim', 'Kirim')
    buttons = (btn_kirim,)
    return Form(schema, buttons=buttons)


@view_config(
    route_name='message-add', renderer='templates/message/add.pt',
    permission='add-message')
def view_add(request):
    form = get_add_form()
    resp = dict(title=_('add-message', default='Kirim pesan'))
    form = get_add_form()
    if not request.POST:
        resp['form'] = form.render()
        return resp
    items = request.POST.items()
    try:
        c = form.validate(items)
    except ValidationFailure as e:
        resp['form'] = e.render()
        return resp
    save(request, dict(c.items()))
    return route_list(request)


##########
# Resend #
##########
def resender_list(jalur):
    r = [('', _('auto-resender', default='Auto'))]
    q = DBSession.query(Agent).filter_by(jalur=jalur)
    for row in q.order_by(Agent.jalur, Agent.id):
        if row.jalur == 1 and row.modem:
            agent_id = row.modem.msisdn
        else:
            agent_id = row.id
        if row.status == 0:
            if row.jalur == 1:
                status = '{}%'.format(row.modem.signal)
            else:
                status = 'ON'
        else:
            status = 'OFF'
        value = '{} {} {}'.format(row.jalur_ref.nama, agent_id, status)
        r.append((row.id, value))
    return r


@colander.deferred
def resender_widget(node, kw):
    values = kw.get('resender_list')
    return widget.SelectWidget(values=values)


class ResendSchema(colander.Schema):
    pengirim = colander.SchemaNode(
            colander.String(), missing=colander.drop, widget=resender_widget)
    tgl = colander.SchemaNode(
            colander.String(), missing=colander.drop,
            widget=widget.TextInputWidget(readonly=True))                
    penerima = colander.SchemaNode(
                colander.String(), missing=colander.drop,
                widget=widget.TextInputWidget(readonly=True))
    pesan = colander.SchemaNode(
                colander.String(), missing=colander.drop,
                widget=widget.TextAreaWidget(readonly=True))                


def get_resend_form(row):
    schema = ResendSchema()
    schema = schema.bind(resender_list=resender_list(row.jalur))
    btn_submit = Button('submit', _('Resend'))
    btn_cancel = Button('cancel', _('Cancel'))
    buttons = (btn_submit, btn_cancel)
    return Form(schema, buttons=buttons)


def save_resend(request, row, values):
    outbox = Antrian()
    outbox.jalur = row.jalur
    outbox.penerima = row.penerima
    outbox.pesan = row.pesan
    outbox.kirim = row.kirim
    outbox.parser = row.parser
    if 'pengirim' in values:
        outbox.pengirim = values['pengirim']
    DBSession.add(outbox)
    row.status = 4
    DBSession.add(row)
    data = dict(penerima=row.penerima)
    ts = _(
            'resend-done',
            default='Pesan untuk ${penerima} sudah dikirim ulang.',
            mapping=data)
    request.session.flash(ts)

    
@view_config(
    route_name='message-resend', renderer='templates/message/resend.pt',
    permission='add-message')
def view_resend(request):
    q = DBSession.query(Selesai).filter_by(id=request.matchdict['id'])
    row = q.first()
    if not row or not row.kirim:
        return HTTPNotFound()
    resp = dict(title=_('Resend'))
    form = get_resend_form(row)
    if not request.POST:
        p = row.to_dict()
        p['tgl'] = p['tgl'].strftime('%-d %B %Y %H:%M')
        resp['form'] = form.render(appstruct=p)
        return resp
    if 'submit' in request.POST:
        items = request.POST.items()
        try:
            c = form.validate(items)
        except ValidationFailure as e:
            resp['form'] = e.render()
            return resp
        save_resend(request, row, dict(c.items()))
    if 'from_url' in request.GET:
        from_url = b64decode(request.GET['from_url']).decode('utf-8')
        return HTTPFound(location=from_url)
    return route_list(request)