500 lines
18 KiB
Python
500 lines
18 KiB
Python
# -*- coding: utf-8 -*-
|
|
#
|
|
# lingo - basket and payment system
|
|
# Copyright (C) 2015 Entr'ouvert
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify it
|
|
# under the terms of the GNU Affero General Public License as published
|
|
# by the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import datetime
|
|
import json
|
|
import logging
|
|
import urlparse
|
|
|
|
from dateutil import parser
|
|
from decimal import Decimal
|
|
|
|
import eopayment
|
|
from jsonfield import JSONField
|
|
|
|
from django import template
|
|
from django.conf import settings
|
|
from django.db import models
|
|
from django.forms import models as model_forms, Select
|
|
from django.utils.translation import ugettext_lazy as _
|
|
from django.utils import timezone
|
|
from django.core.exceptions import ObjectDoesNotExist, PermissionDenied
|
|
from django.utils.http import urlencode
|
|
|
|
from ckeditor.fields import RichTextField
|
|
|
|
from combo.data.models import CellBase
|
|
from combo.data.library import register_cell_class
|
|
from combo.utils import NothingInCacheException, aes_hex_encrypt, requests
|
|
|
|
EXPIRED = 9999
|
|
|
|
|
|
SERVICES = [
|
|
(eopayment.DUMMY, _('Dummy (for tests)')),
|
|
(eopayment.SYSTEMPAY, 'systempay (Banque Populaire)'),
|
|
(eopayment.SIPS, _('SIPS (Atos, France)')),
|
|
(eopayment.SIPS2, _('SIPS (Atos, other countries)')),
|
|
(eopayment.SPPLUS, _('SP+ (Caisse d\'epargne)')),
|
|
(eopayment.OGONE, _('Ingenico (formerly Ogone)')),
|
|
(eopayment.PAYBOX, _('Paybox')),
|
|
(eopayment.PAYZEN, _('PayZen')),
|
|
(eopayment.TIPI, _('TIPI')),
|
|
]
|
|
|
|
def build_remote_item(data, regie):
|
|
return RemoteItem(id=data.get('id'), regie=regie,
|
|
creation_date=data['created'],
|
|
payment_limit_date=data['pay_limit_date'],
|
|
display_id=data.get('display_id'),
|
|
total_amount=data.get('total_amount'),
|
|
amount=data.get('amount'),
|
|
subject=data.get('label'),
|
|
has_pdf=data.get('has_pdf'),
|
|
online_payment=data.get('online_payment'),
|
|
paid=data.get('paid'),
|
|
payment_date=data.get('payment_date'),
|
|
no_online_payment_reason=data.get('no_online_payment_reason'))
|
|
|
|
|
|
class Regie(models.Model):
|
|
label = models.CharField(verbose_name=_('Label'), max_length=64)
|
|
slug = models.SlugField(unique=True)
|
|
description = models.TextField(verbose_name=_('Description'))
|
|
service = models.CharField(verbose_name=_('Payment Service'),
|
|
max_length=64, choices=SERVICES)
|
|
service_options = JSONField(blank=True,
|
|
verbose_name=_('Payment Service Options'))
|
|
is_default = models.BooleanField(verbose_name=_('Default Regie'), default=False)
|
|
webservice_url = models.URLField(_('Webservice URL to retrieve remote items'),
|
|
blank=True)
|
|
payment_min_amount = models.DecimalField(_('Minimal payment amount'),
|
|
max_digits=7, decimal_places=2, default=0)
|
|
|
|
text_on_success = models.TextField(
|
|
verbose_name=_('Custom text displayed on success'),
|
|
blank=True, null=True)
|
|
|
|
def is_remote(self):
|
|
return self.webservice_url != ''
|
|
|
|
class Meta:
|
|
verbose_name = _('Regie')
|
|
ordering = ('label',)
|
|
|
|
def save(self, *args, **kwargs):
|
|
if self.webservice_url and self.webservice_url.endswith('/'):
|
|
self.webservice_url = self.webservice_url.strip('/')
|
|
if self.is_default:
|
|
qs = self.__class__.objects.filter(is_default=True)
|
|
if self.pk:
|
|
qs = qs.exclude(pk=self.pk)
|
|
qs.update(is_default=False)
|
|
elif self.__class__.objects.filter(is_default=True).count() == 0:
|
|
self.is_default = True
|
|
super(Regie, self).save(*args, **kwargs)
|
|
|
|
def natural_key(self):
|
|
return (self.slug,)
|
|
|
|
def __unicode__(self):
|
|
return self.label
|
|
|
|
def get_text_on_success(self):
|
|
if self.text_on_success:
|
|
return self.text_on_success
|
|
return _('Your payment has been succesfully registered.')
|
|
|
|
def get_invoices(self, user, history=False):
|
|
if not self.is_remote():
|
|
return self.basketitem_set.filter(payment_date__isnull=bool(not history), user=user)
|
|
if user:
|
|
url = self.webservice_url + '/invoices/'
|
|
if history:
|
|
url += 'history/'
|
|
items = requests.get(url, user=user, remote_service='auto').json()
|
|
if items.get('data'):
|
|
return [build_remote_item(item, self) for item in items.get('data')]
|
|
return []
|
|
return []
|
|
|
|
def get_invoice(self, user, invoice_id):
|
|
if not self.is_remote():
|
|
return self.basketitem_set.get(pk=invoice_id)
|
|
url = self.webservice_url + '/invoice/%s/' % invoice_id
|
|
response = requests.get(url, user=user, remote_service='auto')
|
|
if response.status_code == 404:
|
|
raise ObjectDoesNotExist()
|
|
response.raise_for_status()
|
|
if response.json().get('data') is None:
|
|
raise ObjectDoesNotExist()
|
|
return build_remote_item(response.json().get('data'), self)
|
|
|
|
def get_invoice_pdf(self, user, invoice_id):
|
|
"""
|
|
downloads item's file
|
|
"""
|
|
if self.is_remote() and user:
|
|
url = self.webservice_url + '/invoice/%s/pdf/' % invoice_id
|
|
return requests.get(url, user=user, remote_service='auto')
|
|
raise PermissionDenied
|
|
|
|
def pay_invoice(self, invoice_id, transaction_id, transaction_date):
|
|
url = self.webservice_url + '/invoice/%s/pay/' % invoice_id
|
|
data = {'transaction_id': transaction_id,
|
|
'transaction_date': transaction_date.strftime('%Y-%m-%dT%H:%M:%S')}
|
|
headers = {'content-type': 'application/json'}
|
|
return requests.post(url, remote_service='auto',
|
|
data=json.dumps(data), headers=headers).json()
|
|
|
|
def as_api_dict(self):
|
|
return {'slug': self.slug,
|
|
'label': self.label,
|
|
'description': self.description}
|
|
|
|
|
|
class BasketItem(models.Model):
|
|
user = models.ForeignKey(settings.AUTH_USER_MODEL)
|
|
regie = models.ForeignKey(Regie)
|
|
subject = models.CharField(verbose_name=_('Subject'), max_length=200)
|
|
source_url = models.URLField(_('Source URL'))
|
|
details = models.TextField(verbose_name=_('Details'), blank=True)
|
|
amount = models.DecimalField(verbose_name=_('Amount'),
|
|
decimal_places=2, max_digits=8)
|
|
user_cancellable = models.BooleanField(default=True)
|
|
creation_date = models.DateTimeField(auto_now_add=True)
|
|
cancellation_date = models.DateTimeField(null=True)
|
|
payment_date = models.DateTimeField(null=True)
|
|
notification_date = models.DateTimeField(null=True)
|
|
|
|
def notify(self, status):
|
|
url = self.source_url + 'jump/trigger/%s' % status
|
|
message = {'result': 'ok'}
|
|
if status == 'paid':
|
|
transaction = self.transaction_set.filter(status=eopayment.PAID)[0]
|
|
message['transaction_id'] = transaction.id
|
|
message['order_id'] = transaction.order_id
|
|
message['bank_transaction_id'] = transaction.bank_transaction_id
|
|
message['bank_data'] = transaction.bank_data
|
|
headers = {'content-type': 'application/json'}
|
|
r = requests.post(url, remote_service='auto',
|
|
data=json.dumps(message), headers=headers, timeout=3)
|
|
r.raise_for_status()
|
|
|
|
def notify_payment(self):
|
|
self.notify('paid')
|
|
self.notification_date = timezone.now()
|
|
self.save()
|
|
|
|
def notify_cancellation(self, skip_notification=False):
|
|
if not skip_notification:
|
|
self.notify('cancelled')
|
|
self.cancellation_date = timezone.now()
|
|
self.save()
|
|
|
|
@property
|
|
def total_amount(self):
|
|
return self.amount
|
|
|
|
|
|
class RemoteItem(object):
|
|
payment_date = None
|
|
|
|
def __init__(self, id, regie, creation_date, payment_limit_date,
|
|
total_amount, amount, display_id, subject, has_pdf,
|
|
online_payment, paid, payment_date, no_online_payment_reason):
|
|
self.id = id
|
|
self.regie = regie
|
|
self.creation_date = parser.parse(creation_date)
|
|
self.payment_limit_date = parser.parse(payment_limit_date)
|
|
self.total_amount = Decimal(total_amount)
|
|
self.amount = Decimal(amount)
|
|
self.display_id = display_id or self.id
|
|
self.subject = subject
|
|
self.has_pdf = has_pdf
|
|
self.online_payment = online_payment
|
|
self.paid = paid
|
|
self.no_online_payment_reason = no_online_payment_reason
|
|
if payment_date:
|
|
self.payment_date = parser.parse(payment_date)
|
|
|
|
@property
|
|
def no_online_payment_reason_details(self):
|
|
reasons = {'litigation': _('This invoice is in litigation.'),
|
|
'autobilling': _('Autobilling has been set for this invoice.'),
|
|
'past-due-date': _('Due date is over.'),
|
|
}
|
|
return settings.LINGO_NO_ONLINE_PAYMENT_REASONS.get(self.no_online_payment_reason,
|
|
reasons.get(self.no_online_payment_reason))
|
|
|
|
@property
|
|
def crypto_id(self):
|
|
return aes_hex_encrypt(settings.SECRET_KEY, str(self.id))
|
|
|
|
|
|
class Transaction(models.Model):
|
|
regie = models.ForeignKey(Regie, null=True)
|
|
items = models.ManyToManyField(BasketItem, blank=True)
|
|
remote_items = models.CharField(max_length=512)
|
|
start_date = models.DateTimeField(auto_now_add=True)
|
|
end_date = models.DateTimeField(null=True)
|
|
bank_data = JSONField(blank=True)
|
|
order_id = models.CharField(max_length=200)
|
|
bank_transaction_id = models.CharField(max_length=200, null=True)
|
|
user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True)
|
|
status = models.IntegerField(null=True)
|
|
amount = models.DecimalField(default=0, max_digits=7, decimal_places=2)
|
|
|
|
def is_remote(self):
|
|
return self.remote_items != ''
|
|
|
|
def is_paid(self):
|
|
return self.status == eopayment.PAID
|
|
|
|
def get_status_label(self):
|
|
return {
|
|
0: _('Running'),
|
|
eopayment.PAID: _('Paid'),
|
|
eopayment.CANCELLED: _('Cancelled'),
|
|
EXPIRED: _('Expired')
|
|
}.get(self.status) or _('Unknown')
|
|
|
|
|
|
class TransactionOperation(models.Model):
|
|
OPERATIONS = [
|
|
('validation', _('Validation')),
|
|
('cancellation', _('Cancellation')),
|
|
]
|
|
transaction = models.ForeignKey(Transaction)
|
|
kind = models.CharField(max_length=65, choices=OPERATIONS)
|
|
amount = models.DecimalField(decimal_places=2, max_digits=8)
|
|
creation_date = models.DateTimeField(auto_now_add=True)
|
|
bank_result = JSONField(blank=True)
|
|
|
|
|
|
@register_cell_class
|
|
class LingoBasketCell(CellBase):
|
|
|
|
class Meta:
|
|
verbose_name = _('Basket')
|
|
|
|
class Media:
|
|
js = ('xstatic/jquery-ui.min.js', 'js/gadjo.js',)
|
|
css = {'all': ('xstatic/themes/smoothness/jquery-ui.min.css', )}
|
|
|
|
@classmethod
|
|
def is_enabled(cls):
|
|
return Regie.objects.count() > 0
|
|
|
|
def is_relevant(self, context):
|
|
if not (getattr(context['request'], 'user', None) and context['request'].user.is_authenticated()):
|
|
return False
|
|
items = BasketItem.objects.filter(
|
|
user=context['request'].user, payment_date__isnull=True
|
|
).exclude(cancellation_date__isnull=False)
|
|
return len(items) > 0
|
|
|
|
def get_badge(self, context):
|
|
if not (getattr(context['request'], 'user', None) and context['request'].user.is_authenticated()):
|
|
return
|
|
items = BasketItem.objects.filter(
|
|
user=context['request'].user, payment_date__isnull=True
|
|
).exclude(cancellation_date__isnull=False)
|
|
if not items:
|
|
return
|
|
total = sum([x.amount for x in items])
|
|
return {'badge': _(u'%d€') % total}
|
|
|
|
def render(self, context):
|
|
basket_template = template.loader.get_template('lingo/combo/basket.html')
|
|
items = BasketItem.objects.filter(
|
|
user=context['request'].user, payment_date__isnull=True
|
|
).exclude(cancellation_date__isnull=False)
|
|
regies = {}
|
|
for item in items:
|
|
if not item.regie_id in regies:
|
|
regies[item.regie_id] = {'items': [], 'regie': item.regie}
|
|
regies[item.regie_id]['items'].append(item)
|
|
|
|
for items in regies.values():
|
|
items['total'] = sum([x.amount for x in items['items']])
|
|
|
|
context['regies'] = regies.values()
|
|
return basket_template.render(context)
|
|
|
|
|
|
@register_cell_class
|
|
class LingoRecentTransactionsCell(CellBase):
|
|
|
|
class Meta:
|
|
verbose_name = _('Recent Transactions')
|
|
|
|
@classmethod
|
|
def is_enabled(cls):
|
|
return Regie.objects.count() > 0
|
|
|
|
def is_relevant(self, context):
|
|
if not (getattr(context['request'], 'user', None) and context['request'].user.is_authenticated()):
|
|
return False
|
|
transactions = Transaction.objects.filter(
|
|
user=context['request'].user,
|
|
start_date__gte=timezone.now()-datetime.timedelta(days=7))
|
|
return len(transactions) > 0
|
|
|
|
def render(self, context):
|
|
recent_transactions_template = template.loader.get_template(
|
|
'lingo/combo/recent_transactions.html')
|
|
context['transactions'] = Transaction.objects.filter(
|
|
user=context['request'].user,
|
|
start_date__gte=timezone.now()-datetime.timedelta(days=7)
|
|
).order_by('-start_date')
|
|
return recent_transactions_template.render(context)
|
|
|
|
|
|
@register_cell_class
|
|
class LingoBasketLinkCell(CellBase):
|
|
user_dependant = True
|
|
|
|
class Meta:
|
|
verbose_name = _('Basket Link')
|
|
|
|
@classmethod
|
|
def is_enabled(cls):
|
|
return Regie.objects.count() > 0
|
|
|
|
def is_relevant(self, context):
|
|
if not (getattr(context['request'], 'user', None) and context['request'].user.is_authenticated()):
|
|
return False
|
|
items = BasketItem.objects.filter(
|
|
user=context['request'].user, payment_date__isnull=True
|
|
).exclude(cancellation_date__isnull=False)
|
|
return len(items) > 0
|
|
|
|
def render(self, context):
|
|
if not (getattr(context['request'], 'user', None) and context['request'].user.is_authenticated()):
|
|
return ''
|
|
try:
|
|
context['basket_url'] = LingoBasketCell.objects.all()[0].page.get_online_url()
|
|
except IndexError:
|
|
return ''
|
|
basket_template = template.loader.get_template('lingo/combo/basket_link.html')
|
|
context['items'] = BasketItem.objects.filter(
|
|
user=context['request'].user, payment_date__isnull=True
|
|
).exclude(cancellation_date__isnull=False)
|
|
context['total'] = sum([x.amount for x in context['items']])
|
|
return basket_template.render(context)
|
|
|
|
|
|
class Items(CellBase):
|
|
regie = models.CharField(_('Regie'), max_length=50, blank=True)
|
|
title = models.CharField(_('Title'), max_length=200, blank=True)
|
|
text = RichTextField(_('Text'), blank=True, null=True)
|
|
|
|
user_dependant = True
|
|
template_name = 'lingo/combo/items.html'
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
|
|
class Media:
|
|
js = ('xstatic/jquery-ui.min.js', 'js/gadjo.js',)
|
|
css = {'all': ('xstatic/themes/smoothness/jquery-ui.min.css', )}
|
|
|
|
@classmethod
|
|
def is_enabled(cls):
|
|
return Regie.objects.exclude(webservice_url='').count() > 0
|
|
|
|
def is_relevant(self, context):
|
|
return (getattr(context['request'], 'user', None) and context['request'].user.is_authenticated())
|
|
|
|
def get_default_form_class(self):
|
|
fields = ['title', 'text']
|
|
widgets = {}
|
|
if Regie.objects.exclude(webservice_url='').count() > 1:
|
|
regies = [('', _('All'))]
|
|
regies.extend([(r.slug, r.label) for r in Regie.objects.exclude(webservice_url='')])
|
|
widgets['regie'] = Select(choices=regies)
|
|
fields.insert(0, 'regie')
|
|
return model_forms.modelform_factory(self.__class__, fields=fields, widgets=widgets)
|
|
|
|
def get_regies(self):
|
|
if self.regie:
|
|
return [Regie.objects.get(slug=self.regie)]
|
|
return Regie.objects.all()
|
|
|
|
def get_invoices(self, user):
|
|
return []
|
|
|
|
def get_cell_extra_context(self, context):
|
|
ctx = super(Items, self).get_cell_extra_context(context)
|
|
ctx.update({'title': self.title, 'text': self.text})
|
|
items = self.get_invoices(user=context['user'])
|
|
items.sort(key=lambda i: i.creation_date, reverse=True)
|
|
ctx.update({'items': items})
|
|
return ctx
|
|
|
|
def render(self, context):
|
|
self.context = context
|
|
if not context.get('synchronous'):
|
|
raise NothingInCacheException()
|
|
return super(Items, self).render(context)
|
|
|
|
|
|
@register_cell_class
|
|
class ItemsHistory(Items):
|
|
|
|
class Meta:
|
|
verbose_name = _('Items History Cell')
|
|
|
|
def get_invoices(self, user):
|
|
items = []
|
|
for r in self.get_regies():
|
|
items.extend(r.get_invoices(user, history=True))
|
|
return items
|
|
|
|
|
|
@register_cell_class
|
|
class ActiveItems(Items):
|
|
|
|
class Meta:
|
|
verbose_name = _('Active Items Cell')
|
|
|
|
def get_invoices(self, user):
|
|
items = []
|
|
for r in self.get_regies():
|
|
items.extend(r.get_invoices(user))
|
|
return items
|
|
|
|
|
|
@register_cell_class
|
|
class SelfDeclaredInvoicePayment(Items):
|
|
user_dependant = False
|
|
template_name = 'lingo/combo/self-declared-invoice-payment.html'
|
|
|
|
class Meta:
|
|
verbose_name = _('Self declared invoice payment')
|
|
|
|
def is_relevant(self, context):
|
|
return self.is_enabled()
|
|
|
|
def render(self, context):
|
|
context['synchronous'] = True
|
|
context['page_path'] = context['request'].path
|
|
return super(Items, self).render(context)
|