Subversion Repositories SmartDukaan

'''

Created on 26-Aug-2010

@author: ashish

'''

import datetime

import sys

from elixir import *

from sqlalchemy import or_

from shop2020.thriftpy.payments.ttypes import PaymentException

from shop2020.payments.impl.DataService import Payment, PaymentGateway,\

    PaymentAttribute

from shop2020.thriftpy.payments.ttypes import PaymentStatus

from shop2020.utils.Utils import to_py_date

from sqlalchemy.sql.expression import select, func

def create_payment(userId, txnId, amount, gatewayId):

    if not userId:

        raise PaymentException(101, "User cannot be null")

    if not txnId:

        raise PaymentException(101, "Transaction cannot be null")

    if not amount:

        raise PaymentException(101, "Amount cannot be null")

    if not gatewayId:

        raise PaymentException(101, "Gateway cannot be null")

    payment = Payment()

    payment.gatewayId = gatewayId

    payment.userId = userId

    payment.merchantTxnId = txnId

    payment.amount = amount

    payment.initTimestamp = datetime.datetime.now()

    payment.status = PaymentStatus.INIT

    session.commit()

    return payment.id

def build_payment_query(from_time, to_time, status, gateway_id):

    query = Payment.query

    if from_time:

        from_date = to_py_date(from_time)

        query = query.filter(Payment.initTimestamp >= from_date)

    if to_time:

        to_date = to_py_date(to_time)

        if status != PaymentStatus.INIT:

            query = query.filter(or_(Payment.successTimestamp <= to_date, Payment.errorTimestamp <= to_date))

        else:

            query = query.filter(Payment.initTimestamp <= to_date)

    if status is not None:

        query = query.filter(Payment.status == status)

    if gateway_id:

        query = query.filter(Payment.gatewayId == gateway_id)

    return query

def get_payments_for_user(user_id, from_time, to_time, status, gateway_id):

    if not user_id:

        raise PaymentException(101, "user cannot be null")

    query = build_payment_query(from_time, to_time, status, gateway_id)

    query = query.filter_by(userId=user_id)

    try:

        return query.all()

    except:

        print "Unexpected error:", sys.exc_info()[0]

        return []

def get_payments(from_time, to_time, status, gateway_id):

    query = build_payment_query(from_time, to_time, status, gateway_id)

    try:

        return query.all()

    except:

        print "Unexpected error:", sys.exc_info()[0]

        return []

def get_payment_gateway(id):

    try:

        return PaymentGateway.get_by(id=id)

    except:

        raise PaymentException(102, "No such payment gateway")

def get_payment(id):

    try:

        return Payment.get_by(id=id)

    except:

        raise PaymentException(101, "No such payment")

def get_payment_for_txn(txnId):

    try:

        return Payment.query.filter_by(merchantTxnId=txnId).one()

    except:

        raise PaymentException(103, "Unable to get payment for the given transaction")

def get_max_payment_amount():

    payments = Payment.query.filter(Payment.status == PaymentStatus.SUCCESS).all()

    payment_amounts = [p.amount for p in payments]

    return max(payment_amounts)

def get_min_payment_amount():

    payments = Payment.query.filter(Payment.status == PaymentStatus.SUCCESS).all()

    payment_amounts = [p.amount for p in payments]

    return min(payment_amounts)

def update_payment_details(id, gatewayPaymentId, sessionId, gatewayTxnStatus, description, gatewayTxnId, authCode, referenceCode, errorCode, status, gatewayTxnDate, attributes):

    if not id:

        raise PaymentException(101, "Can't update a payment without an id")

    try:

        payment = Payment.get_by(id=id)

        if gatewayPaymentId:

            payment.gatewayPaymentId = gatewayPaymentId

        if sessionId:

            payment.sessionId = sessionId    

        if gatewayTxnStatus:

            payment.gatewayTxnStatus = gatewayTxnStatus

        if description:

            payment.description = description

        if gatewayTxnId:

            payment.gatewayTxnId = gatewayTxnId

        if authCode:

            payment.authCode = authCode

        if referenceCode:

            payment.referenceCode = referenceCode

        if errorCode:

            payment.errorCode = errorCode

        if gatewayTxnDate:

            payment.gatewayTxnDate = gatewayTxnDate

        if status:

            payment.status = status

            if status == PaymentStatus.SUCCESS:

                payment.successTimestamp = datetime.datetime.now()

            if status == PaymentStatus.FAILED:

                payment.errorTimestamp = datetime.datetime.now()

        if attributes: 

            for attr in attributes:

                payment_attr =  PaymentAttribute.query.filter_by(payment=payment, name=attr.name).first()

                if payment_attr:

                    payment_attr.value = attr.value

                else:

                    payment_attr = PaymentAttribute(payment=payment, name = attr.name, value = attr.value)

        session.commit()

        return True

    except:

        return False

def close_session():

    if session.is_active:

        print "session is active. closing it."

        session.close()