tekstmelding/tekstmelding.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from flask import Flask, request, g, abort, jsonify
from utils import CustomJSONEncoder, generate_activation_code
import MySQLdb
import MySQLdb.cursors
import datetime
import requests
import sys

import config

app = Flask(__name__)
app.config.from_object('config')
app.json_encoder = CustomJSONEncoder

if not app.debug:
    import logging
    handler = logging.StreamHandler()
    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    handler.setFormatter(formatter)
    handler.setLevel(logging.INFO)
    app.logger.addHandler(handler)

def connect_db():
    """Connects to our database."""
    db = MySQLdb.connect(
        host    = app.config['DATABASE_HOST'],
        user    = app.config['DATABASE_USER'],
        passwd  = app.config['DATABASE_PASS'],
        db      = app.config['DATABASE_NAME'],
        cursorclass = MySQLdb.cursors.DictCursor,
        charset='utf8')
    return db

def get_db():
    """Opens a new database connection if there is none yet for the
    current application context."""
    if not hasattr(g, 'db'):
        g.db = connect_db()
    return g.db

@app.teardown_appcontext
def close_db(error):
    """Closes the database connection at the end of the request."""
    if hasattr(g, 'db'):
        g.db.close()

def query_db(query, args=(), one=False, lastrowid=False):
    """Queries the database.

    Will use an existing or new database connection, create a cursor,
    execute the query, fetch all rows, close the cursor then return the rows.
    """
    assert not (one and lastrowid)

    app.logger.debug("Query: %s\nArgs: %s", query, args)

    cur = get_db().cursor()
    cur.execute(query, args)

    if lastrowid:
        ret = cur.lastrowid
    else:
        rv = cur.fetchall()
        ret = (rv[0] if rv else None) if one else rv

    get_db().commit()
    cur.close()
    return ret

def get_user_by_phone(number):
    user = query_db("""
        SELECT user.*,
               (CASE WHEN (user.expires IS NULL) THEN 1 ELSE 0 END) AS expires_lifelong
        FROM din_user user, din_userphonenumber phone
        WHERE phone.number = %s AND
              user.id = phone.user_id
    """, [number], one=True)
    return user

def log_incoming(**kwargs):
    return query_db("""
        INSERT INTO din_sms_received
            (userid, gsm, codeword, message, operator, shortno, action, IP, simulation)
        VALUES
            (%(userid)s, %(gsm)s, %(codeword)s, %(message)s, %(operator)s, %(shortno)s, %(action)s, %(ip)s, %(simulation)s)
    """, kwargs, lastrowid=True)

def set_incoming_action(**kwargs):
    query_db("""
        UPDATE din_sms_received
        SET action = %(action)s
        WHERE smsid = %(smsid)s
    """, kwargs)

def log_sent(**kwargs):
    query_db("""
        INSERT INTO din_sms_sent
            (response_to, msgid, sender, receiver, countrycode, message, operator, codeword, billing_price, use_dlr, simulation, activation_code)
        VALUES
            (%(response_to)s, %(msgid)s, %(sender)s, %(receiver)s, %(countrycode)s, %(message)s,
             %(operator)s, %(codeword)s, %(billing_price)s, %(use_dlr)s, %(simulation)s, %(activation_code)s)
    """, kwargs)

def is_user_expired(user):
    # A friendly reminder about how the 'expires' column works:
    #   NULL means the membership should never expire
    #   0000-00-00 is the default and means the user has never had a membership
    #   YYYY-MM-DD is the day the membership will or has expired
    #
    # datetime.date does not accept the date 0000-00-00, instead we end
    # up with None. As a workaround we do the NULL comparison with SQL
    # and store the result in 'expires_lifelong'.
    expires = user.get('expires', None)
    expires_lifelong = user.get('expires_lifelong', None)

    # Lifelong membership?
    if expires_lifelong:
        return False

    # Non-expired membership?
    elif type(expires) is datetime.date and expires >= datetime.date.today():
        return False

    # Expired?
    elif not expires or (type(expires) is datetime.date and expires < datetime.date.today()):
        return True

    else:
        assert False, "What a trainwreck, we shouldn't be here"

def get_full_name(user):
    full_name = "%s %s" % (
        user.get('firstname', '').strip(),
        user.get('lastname', '').strip()
    )
    return full_name[:50].strip()

def fix_encoding(message):
    try:
        assert type(message) == unicode
        new_message = message.encode('latin-1', 'ignore')
    except:
        new_message = message
        app.logger.warning("Unicode woes: message_type=%s message=%s exc_info=%s",
            type(message), message, sys.exc_info())
        # Oh, never mind, let's try to send it anyway.
        pass

    return new_message

def send_sms(log_only=False, gsm=None, message=None, response_to=None, billing=False, billing_price=None, operator=None, activation_code=None):
    assert gsm
    assert message

    if billing:
        assert billing_price
        if not operator:
            operator = 'ukjent'

    # The strings in this file are in utf-8, encode to latin-1 before sending
    message_latin = fix_encoding(message)

    # Truncate message if too long
    if len(message_latin) > 160:
        app.logger.warning("Truncated the following message to 160 chars: %s", message_latin)
        message_latin = message_latin[:160]

    params = {
        'bruker': app.config['EB_USER'],
        'passord': app.config['EB_PASSWORD'],
        'avsender': app.config['EB_SENDER_BULK'],
        'land': 47,
        'til': gsm,
        'melding': message_latin,
    }

    if billing:
        params.update({
            'avsender': app.config['EB_SENDER_BILLING'],
            #'dlrurl': app.config['EB_DLR'],
            'ore': billing_price,
            'operator': operator,
            'kodeord': 'DNSMEDLEM',
        })

    if app.config['EB_SIMULATE']:
        params['simulate'] = 1

    app.logger.debug("send_sms params: %s" % params.items())

    msgid = 0

    if not log_only:
        endpoint = app.config['EB_PAYURL'] if billing else app.config['EB_URL']

        try:
            result = requests.get(endpoint, params=params)
        except:
            app.logger.error("Caught exception while attempting to contact Eurobate: %s", sys.exc_info())
            return False

        if result.status_code != requests.codes.ok: # 200
            app.logger.error("Got status code %s from Eurobate", result.status_code)
            return False

        app.logger.debug("Hit URL: %s\nGot result.text: %s", result.url, result.text)
        
        response = result.text.split(' ')
        if response[:3] == ['Meldingen', 'er', 'sendt']:
            if billing and len(response) == 4 and response[3].isdigit():
                msgid = int(response[3])
            if billing and msgid == 0:
                app.logger.warning("Did not get a msgid from Eurobate when billing as response to smsid:%s", response_to)
        else:
            app.logger.error("Message (response_to:%s) was not sent. Eurobate told us: %s", response_to, result.text)
            return False

    log_sent(
        response_to = response_to if response_to else 0,
        msgid = msgid if billing else 0,
        sender = params['avsender'],
        receiver = gsm,
        countrycode = params['land'],
        message = message,
        operator = params['operator'] if billing else 'NULL',
        codeword = params['kodeord'] if billing else 'NULL',
        billing_price = params['ore'] if billing else 0,
        #use_dlr = 1 if billing else 0,
        use_dlr = 0,
        simulation = 1 if app.config['EB_SIMULATE'] else 0,
        activation_code = activation_code if activation_code else 'NULL')

    return True if not billing else msgid

def notify_valid_membership(response_to=None, gsm=None, user=None):
    assert gsm and user

    message = u"Hei %(name)s! Ditt medlemskap er gyldig til %(expires)s. Last ned app: %(app_link)s" % ({
        'name': get_full_name(user),
        'expires': 'verdens undergang' if user.get('expires_lifelong') else str(user.get('expires')),
        'app_link': 'http://snappo.com/app',
    })

    send_sms(log_only=True, response_to=response_to, gsm=gsm, message=message)
    app.logger.info("Sent SMS to gsm:%s with proof of membership and link to app", gsm)
    set_incoming_action(smsid=response_to, action='notify_valid_membership')
    return fix_encoding(message)

def notify_payment_options_new(response_to=None, gsm=None):
    assert gsm

    message = u"Du kan kjøpe medlemskap via SnappOrder: http://snappo.com/app (200,-) eller ved å sende DNSMEDLEM til 2090 (230,-)"
    send_sms(log_only=True, response_to=response_to, gsm=gsm, message=message)
    app.logger.info("Sent SMS to gsm:%s with payment options (new)", gsm)
    set_incoming_action(smsid=response_to, action='notify_payment_options_new')
    return fix_encoding(message)

def notify_payment_options_renewal(response_to=None, gsm=None):
    assert gsm

    message = u"Ditt medlemskap er utløpt. Det kan fornyes via SnappOrder: http://snappo.com/app (200,-) eller ved å sende DNSMEDLEM til 2090 (230,-)"
    send_sms(log_only=True, response_to=response_to, gsm=gsm, message=message)
    app.logger.info("Sent SMS to gsm:%s with payment options (renewal)", gsm)
    set_incoming_action(smsid=response_to, action='notify_payment_options_renewal')
    return fix_encoding(message)

def notify_could_not_charge(response_to=None, gsm=None):
    assert gsm

    app.logger.warning("Attempt to charge gsm:%s as a response to smsid:%s failed", gsm, response_to)
    message = u"Beklager, bestillingen kunne ikke gjennomføres. Spørsmål? medlem@studentersamfundet.no"
    send_sms(log_only=True, response_to=response_to, gsm=gsm, message=message)
    set_incoming_action(smsid=response_to, action='notify_could_not_charge')
    return fix_encoding(message)

def renew_membership(response_to=None, gsm=None, user=None, operator=None):
    assert gsm and user

    new_expire = datetime.date.today() + datetime.timedelta(days=365)

    query_db(
        "UPDATE din_user SET expires = %(expires)s WHERE id = %(id)s", {
            'expires': str(new_expire),
            'id': user['id']
    })

    query_db("""
        INSERT INTO din_userupdate (date, user_id_updated, comment, user_id_updated_by)
        VALUES (%(date)s, %(user_id_updated)s, %(comment)s, %(user_id_updated_by)s)
    """, {
        'date': str(datetime.datetime.now()),
        'user_id_updated': user['id'],
        'comment': "Medlemskap fornyet med SMS.",
        'user_id_updated_by': user['id'],
    })

    message = u"Hei %(name)s! Ditt medlemskap er nå gyldig ut %(new_expire)s. Spørsmål? medlem@studentersamfundet.no" % ({
        'name': get_full_name(user),
        'new_expire': str(new_expire),
    })

    msgid = send_sms(
        response_to = response_to,
        gsm = gsm,
        message = message,
        operator = operator,
        billing = True,
        billing_price = app.config['MEMBERSHIP_PRICE_KR'] * 100,
    )

    if not msgid:
        return notify_could_not_charge(response_to=response_to, gsm=gsm)

    app.logger.info("Membership of user_id:%s gsm:%s was renewed to %s", user['id'], gsm, new_expire)
    set_incoming_action(smsid=response_to, action='renew_membership')
    return fix_encoding(u"Vi vil nå forsøke å fornye medlemskapet ditt...")

def new_membership(response_to=None, gsm=None, operator=None):
    assert gsm

    activation_code = generate_activation_code()

    message = u"Velkommen! Dette er et midlertidig medlemsbevis. Aktiver medlemskapet ditt her: http://s.neuf.no/sms/%(gsm)s/%(activation_code)s" % ({
        'gsm': gsm,
        'activation_code': activation_code,
    })

    msgid = send_sms(
        response_to = response_to,
        gsm = gsm,
        message = message,
        operator = operator,
        activation_code = activation_code,
        billing = True,
        billing_price = app.config['MEMBERSHIP_PRICE_KR'] * 100,
    )

    if not msgid:
        return notify_could_not_charge(response_to=response_to, gsm=gsm)

    app.logger.info("New membership for gsm:%s, activation code sent", gsm)
    set_incoming_action(smsid=response_to, action='new_membership')
    return fix_encoding(u"Vi vil nå forsøke å belaste deg for et medlemskap...")

@app.route('/')
def main():
    return 'Tekstmelding!'

@app.route('/callback')
def callback():
    gsm      = request.args.get('gsm', None)
    operator = request.args.get('operator', 'ukjent')
    codeword = request.args.get('kodeord', None)
    message  = request.args.get('tekst', '')
    shortno  = request.args.get('kortnr', None)
    ip       = request.remote_addr

    if None in (gsm, codeword, shortno):
        abort(400) # Bad Request

    if not gsm.isdigit():
        # What the fuck, man, that's not a phone number, man.
        abort(400) # Bad Request

    if not codeword.strip().upper() in ('DNS', 'DNSMEDLEM'):
        abort(400) # Bad Request

    user = get_user_by_phone("+47%s" % gsm)

    smsid = log_incoming(
        userid     = int(user['id']) if user else None,
        gsm        = gsm,
        codeword   = codeword,
        message    = message,
        operator   = operator,
        shortno    = shortno,
        action     = 'no_action',
        ip         = ip,
        simulation = 0)

    app.logger.info("Incoming SMS from gsm:%s saved with smsid:%s", gsm, smsid)

    if user:
        expired = is_user_expired(user)

        if codeword.strip().upper() == 'DNS':
            if not expired:
                return notify_valid_membership(response_to=smsid, gsm=gsm, user=user)
            elif expired:
                return notify_payment_options_renewal(response_to=smsid, gsm=gsm)
        elif codeword.strip().upper() == 'DNSMEDLEM':
            if not expired:
                return notify_valid_membership(response_to=smsid, gsm=gsm, user=user)
            elif expired:
                return renew_membership(response_to=smsid, gsm=gsm, user=user, operator=operator)
    else:
        if codeword.strip().upper() == 'DNS':
            return notify_payment_options_new(response_to=smsid, gsm=gsm)
        elif codeword.strip().upper() == 'DNSMEDLEM':
            return new_membership(response_to=smsid, gsm=gsm, operator=operator)

@app.route('/dlr')
def dlr():
    return ''

if __name__ == '__main__':
    app.run()

# For WSGI
application = app