From 8256c96ffbaf1dfe7979dd2326a5ad66d17ddbb5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Aur=C3=A9lien=20Delobelle?= Date: Sun, 14 Aug 2016 19:59:36 +0200 Subject: [PATCH] K-Psul - Historique + synchronisation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Ajoute l'affichage de l'historique dans K-Psul - Ajoute la synchronisation du montant des caisses et de l'historique entre les interfaces K-Psul ouvertes par le package 'channels' et l'utilisation de websockets - Corrige l'obligation de l'article sur K-Psul (pas d'article pour les charges et retraits) - Corrige type renvoyé par perms_to_perform_operations - Rangement de js.cookie.js dans static/kfet/js/ - Ajout de dépendances --- cof/routing.py | 3 + kfet/consumers.py | 20 + kfet/forms.py | 3 +- kfet/models.py | 2 +- kfet/routing.py | 8 + kfet/static/kfet/{ => js}/js.cookie.js | 0 kfet/static/kfet/js/reconnecting-websocket.js | 365 ++++++++++++++++++ kfet/static/kfet/js/ws4redis.js | 167 ++++++++ kfet/templates/kfet/kpsul.html | 168 +++++++- kfet/urls.py | 2 + kfet/views.py | 99 ++++- requirements.txt | 6 +- 12 files changed, 834 insertions(+), 9 deletions(-) create mode 100644 cof/routing.py create mode 100644 kfet/consumers.py create mode 100644 kfet/routing.py rename kfet/static/kfet/{ => js}/js.cookie.js (100%) create mode 100644 kfet/static/kfet/js/reconnecting-websocket.js create mode 100644 kfet/static/kfet/js/ws4redis.js diff --git a/cof/routing.py b/cof/routing.py new file mode 100644 index 00000000..7949ee3a --- /dev/null +++ b/cof/routing.py @@ -0,0 +1,3 @@ +from kfet.routing import channel_routing as kfet_channel_routings + +channel_routing = kfet_channel_routings diff --git a/kfet/consumers.py b/kfet/consumers.py new file mode 100644 index 00000000..fc67a512 --- /dev/null +++ b/kfet/consumers.py @@ -0,0 +1,20 @@ +from channels import Group +from channels.generic.websockets import JsonWebsocketConsumer + +class KPsul(JsonWebsocketConsumer): + + # Set to True if you want them, else leave out + strict_ordering = False + slight_ordering = False + + def connection_groups(self, **kwargs): + return ['kfet.kpsul'] + + def connect(self, message, **kwargs): + pass + + def receive(self, content, **kwargs): + pass + + def disconnect(self, message, **kwargs): + pass diff --git a/kfet/forms.py b/kfet/forms.py index a9fdfbb7..5cd4f470 100644 --- a/kfet/forms.py +++ b/kfet/forms.py @@ -146,7 +146,8 @@ class KPsulCheckoutForm(forms.Form): class KPsulOperationForm(forms.ModelForm): article = forms.ModelChoiceField( - queryset=Article.objects.select_related('category').all()) + queryset=Article.objects.select_related('category').all(), + required=False) class Meta: model = Operation fields = ['type', 'amount', 'is_checkout', 'article', 'article_nb'] diff --git a/kfet/models.py b/kfet/models.py index 3b0fc06a..241fb39b 100644 --- a/kfet/models.py +++ b/kfet/models.py @@ -111,7 +111,7 @@ class Account(models.Model): # Checking is cash account if self.is_cash: # Yes, so no perms and no stop - return [], False + return set(), False # Checking is frozen account if self.is_frozen: perms.add('kfet.override_frozen_protection') diff --git a/kfet/routing.py b/kfet/routing.py new file mode 100644 index 00000000..a1f1c676 --- /dev/null +++ b/kfet/routing.py @@ -0,0 +1,8 @@ +from channels.routing import route, route_class +from kfet import consumers + +channel_routing = [ + route_class(consumers.KPsul, path=r"^/k-fet/k-psul/$"), + #route("websocket.connect", ws_kpsul_history_connect), + #route('websocket.receive', ws_message) +] diff --git a/kfet/static/kfet/js.cookie.js b/kfet/static/kfet/js/js.cookie.js similarity index 100% rename from kfet/static/kfet/js.cookie.js rename to kfet/static/kfet/js/js.cookie.js diff --git a/kfet/static/kfet/js/reconnecting-websocket.js b/kfet/static/kfet/js/reconnecting-websocket.js new file mode 100644 index 00000000..0cd4332d --- /dev/null +++ b/kfet/static/kfet/js/reconnecting-websocket.js @@ -0,0 +1,365 @@ +// MIT License: +// +// Copyright (c) 2010-2012, Joe Walnes +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +/** + * This behaves like a WebSocket in every way, except if it fails to connect, + * or it gets disconnected, it will repeatedly poll until it successfully connects + * again. + * + * It is API compatible, so when you have: + * ws = new WebSocket('ws://....'); + * you can replace with: + * ws = new ReconnectingWebSocket('ws://....'); + * + * The event stream will typically look like: + * onconnecting + * onopen + * onmessage + * onmessage + * onclose // lost connection + * onconnecting + * onopen // sometime later... + * onmessage + * onmessage + * etc... + * + * It is API compatible with the standard WebSocket API, apart from the following members: + * + * - `bufferedAmount` + * - `extensions` + * - `binaryType` + * + * Latest version: https://github.com/joewalnes/reconnecting-websocket/ + * - Joe Walnes + * + * Syntax + * ====== + * var socket = new ReconnectingWebSocket(url, protocols, options); + * + * Parameters + * ========== + * url - The url you are connecting to. + * protocols - Optional string or array of protocols. + * options - See below + * + * Options + * ======= + * Options can either be passed upon instantiation or set after instantiation: + * + * var socket = new ReconnectingWebSocket(url, null, { debug: true, reconnectInterval: 4000 }); + * + * or + * + * var socket = new ReconnectingWebSocket(url); + * socket.debug = true; + * socket.reconnectInterval = 4000; + * + * debug + * - Whether this instance should log debug messages. Accepts true or false. Default: false. + * + * automaticOpen + * - Whether or not the websocket should attempt to connect immediately upon instantiation. The socket can be manually opened or closed at any time using ws.open() and ws.close(). + * + * reconnectInterval + * - The number of milliseconds to delay before attempting to reconnect. Accepts integer. Default: 1000. + * + * maxReconnectInterval + * - The maximum number of milliseconds to delay a reconnection attempt. Accepts integer. Default: 30000. + * + * reconnectDecay + * - The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. Accepts integer or float. Default: 1.5. + * + * timeoutInterval + * - The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. Accepts integer. Default: 2000. + * + */ +(function (global, factory) { + if (typeof define === 'function' && define.amd) { + define([], factory); + } else if (typeof module !== 'undefined' && module.exports){ + module.exports = factory(); + } else { + global.ReconnectingWebSocket = factory(); + } +})(this, function () { + + if (!('WebSocket' in window)) { + return; + } + + function ReconnectingWebSocket(url, protocols, options) { + + // Default settings + var settings = { + + /** Whether this instance should log debug messages. */ + debug: false, + + /** Whether or not the websocket should attempt to connect immediately upon instantiation. */ + automaticOpen: true, + + /** The number of milliseconds to delay before attempting to reconnect. */ + reconnectInterval: 1000, + /** The maximum number of milliseconds to delay a reconnection attempt. */ + maxReconnectInterval: 30000, + /** The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. */ + reconnectDecay: 1.5, + + /** The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. */ + timeoutInterval: 2000, + + /** The maximum number of reconnection attempts to make. Unlimited if null. */ + maxReconnectAttempts: null, + + /** The binary type, possible values 'blob' or 'arraybuffer', default 'blob'. */ + binaryType: 'blob' + } + if (!options) { options = {}; } + + // Overwrite and define settings with options if they exist. + for (var key in settings) { + if (typeof options[key] !== 'undefined') { + this[key] = options[key]; + } else { + this[key] = settings[key]; + } + } + + // These should be treated as read-only properties + + /** The URL as resolved by the constructor. This is always an absolute URL. Read only. */ + this.url = url; + + /** The number of attempted reconnects since starting, or the last successful connection. Read only. */ + this.reconnectAttempts = 0; + + /** + * The current state of the connection. + * Can be one of: WebSocket.CONNECTING, WebSocket.OPEN, WebSocket.CLOSING, WebSocket.CLOSED + * Read only. + */ + this.readyState = WebSocket.CONNECTING; + + /** + * A string indicating the name of the sub-protocol the server selected; this will be one of + * the strings specified in the protocols parameter when creating the WebSocket object. + * Read only. + */ + this.protocol = null; + + // Private state variables + + var self = this; + var ws; + var forcedClose = false; + var timedOut = false; + var eventTarget = document.createElement('div'); + + // Wire up "on*" properties as event handlers + + eventTarget.addEventListener('open', function(event) { self.onopen(event); }); + eventTarget.addEventListener('close', function(event) { self.onclose(event); }); + eventTarget.addEventListener('connecting', function(event) { self.onconnecting(event); }); + eventTarget.addEventListener('message', function(event) { self.onmessage(event); }); + eventTarget.addEventListener('error', function(event) { self.onerror(event); }); + + // Expose the API required by EventTarget + + this.addEventListener = eventTarget.addEventListener.bind(eventTarget); + this.removeEventListener = eventTarget.removeEventListener.bind(eventTarget); + this.dispatchEvent = eventTarget.dispatchEvent.bind(eventTarget); + + /** + * This function generates an event that is compatible with standard + * compliant browsers and IE9 - IE11 + * + * This will prevent the error: + * Object doesn't support this action + * + * http://stackoverflow.com/questions/19345392/why-arent-my-parameters-getting-passed-through-to-a-dispatched-event/19345563#19345563 + * @param s String The name that the event should use + * @param args Object an optional object that the event will use + */ + function generateEvent(s, args) { + var evt = document.createEvent("CustomEvent"); + evt.initCustomEvent(s, false, false, args); + return evt; + }; + + this.open = function (reconnectAttempt) { + ws = new WebSocket(self.url, protocols || []); + ws.binaryType = this.binaryType; + + if (reconnectAttempt) { + if (this.maxReconnectAttempts && this.reconnectAttempts > this.maxReconnectAttempts) { + return; + } + } else { + eventTarget.dispatchEvent(generateEvent('connecting')); + this.reconnectAttempts = 0; + } + + if (self.debug || ReconnectingWebSocket.debugAll) { + console.debug('ReconnectingWebSocket', 'attempt-connect', self.url); + } + + var localWs = ws; + var timeout = setTimeout(function() { + if (self.debug || ReconnectingWebSocket.debugAll) { + console.debug('ReconnectingWebSocket', 'connection-timeout', self.url); + } + timedOut = true; + localWs.close(); + timedOut = false; + }, self.timeoutInterval); + + ws.onopen = function(event) { + clearTimeout(timeout); + if (self.debug || ReconnectingWebSocket.debugAll) { + console.debug('ReconnectingWebSocket', 'onopen', self.url); + } + self.protocol = ws.protocol; + self.readyState = WebSocket.OPEN; + self.reconnectAttempts = 0; + var e = generateEvent('open'); + e.isReconnect = reconnectAttempt; + reconnectAttempt = false; + eventTarget.dispatchEvent(e); + }; + + ws.onclose = function(event) { + clearTimeout(timeout); + ws = null; + if (forcedClose) { + self.readyState = WebSocket.CLOSED; + eventTarget.dispatchEvent(generateEvent('close')); + } else { + self.readyState = WebSocket.CONNECTING; + var e = generateEvent('connecting'); + e.code = event.code; + e.reason = event.reason; + e.wasClean = event.wasClean; + eventTarget.dispatchEvent(e); + if (!reconnectAttempt && !timedOut) { + if (self.debug || ReconnectingWebSocket.debugAll) { + console.debug('ReconnectingWebSocket', 'onclose', self.url); + } + eventTarget.dispatchEvent(generateEvent('close')); + } + + var timeout = self.reconnectInterval * Math.pow(self.reconnectDecay, self.reconnectAttempts); + setTimeout(function() { + self.reconnectAttempts++; + self.open(true); + }, timeout > self.maxReconnectInterval ? self.maxReconnectInterval : timeout); + } + }; + ws.onmessage = function(event) { + if (self.debug || ReconnectingWebSocket.debugAll) { + console.debug('ReconnectingWebSocket', 'onmessage', self.url, event.data); + } + var e = generateEvent('message'); + e.data = event.data; + eventTarget.dispatchEvent(e); + }; + ws.onerror = function(event) { + if (self.debug || ReconnectingWebSocket.debugAll) { + console.debug('ReconnectingWebSocket', 'onerror', self.url, event); + } + eventTarget.dispatchEvent(generateEvent('error')); + }; + } + + // Whether or not to create a websocket upon instantiation + if (this.automaticOpen == true) { + this.open(false); + } + + /** + * Transmits data to the server over the WebSocket connection. + * + * @param data a text string, ArrayBuffer or Blob to send to the server. + */ + this.send = function(data) { + if (ws) { + if (self.debug || ReconnectingWebSocket.debugAll) { + console.debug('ReconnectingWebSocket', 'send', self.url, data); + } + return ws.send(data); + } else { + throw 'INVALID_STATE_ERR : Pausing to reconnect websocket'; + } + }; + + /** + * Closes the WebSocket connection or connection attempt, if any. + * If the connection is already CLOSED, this method does nothing. + */ + this.close = function(code, reason) { + // Default CLOSE_NORMAL code + if (typeof code == 'undefined') { + code = 1000; + } + forcedClose = true; + if (ws) { + ws.close(code, reason); + } + }; + + /** + * Additional public API method to refresh the connection if still open (close, re-open). + * For example, if the app suspects bad data / missed heart beats, it can try to refresh. + */ + this.refresh = function() { + if (ws) { + ws.close(); + } + }; + } + + /** + * An event listener to be called when the WebSocket connection's readyState changes to OPEN; + * this indicates that the connection is ready to send and receive data. + */ + ReconnectingWebSocket.prototype.onopen = function(event) {}; + /** An event listener to be called when the WebSocket connection's readyState changes to CLOSED. */ + ReconnectingWebSocket.prototype.onclose = function(event) {}; + /** An event listener to be called when a connection begins being attempted. */ + ReconnectingWebSocket.prototype.onconnecting = function(event) {}; + /** An event listener to be called when a message is received from the server. */ + ReconnectingWebSocket.prototype.onmessage = function(event) {}; + /** An event listener to be called when an error occurs. */ + ReconnectingWebSocket.prototype.onerror = function(event) {}; + + /** + * Whether all instances of ReconnectingWebSocket should log debug messages. + * Setting this to true is the equivalent of setting all instances of ReconnectingWebSocket.debug to true. + */ + ReconnectingWebSocket.debugAll = false; + + ReconnectingWebSocket.CONNECTING = WebSocket.CONNECTING; + ReconnectingWebSocket.OPEN = WebSocket.OPEN; + ReconnectingWebSocket.CLOSING = WebSocket.CLOSING; + ReconnectingWebSocket.CLOSED = WebSocket.CLOSED; + + return ReconnectingWebSocket; +}); diff --git a/kfet/static/kfet/js/ws4redis.js b/kfet/static/kfet/js/ws4redis.js new file mode 100644 index 00000000..6d973920 --- /dev/null +++ b/kfet/static/kfet/js/ws4redis.js @@ -0,0 +1,167 @@ +/** + * options.uri - > The Websocket URI + * options.connected -> Callback called after the websocket is connected. + * options.connecting -> Callback called when the websocket is connecting. + * options.disconnected -> Callback called after the websocket is disconnected. + * options.receive_message -> Callback called when a message is received from the websocket. + * options.heartbeat_msg -> String to identify the heartbeat message. + * $ -> JQuery instance. + */ +function WS4Redis(options, $) { + 'use strict'; + var opts, ws, deferred, timer, attempts = 1, must_reconnect = true; + var heartbeat_interval = null, missed_heartbeats = 0; + + if (this === undefined) + return new WS4Redis(options, $); + if (options.uri === undefined) + throw new Error('No Websocket URI in options'); + if ($ === undefined) + $ = jQuery; + opts = $.extend({ heartbeat_msg: null }, options); + connect(opts.uri); + + function connect(uri) { + try { + if (ws && (is_connecting() || is_connected())) { + console.log("Websocket is connecting or already connected."); + return; + } + + if ($.type(opts.connecting) === 'function') { + opts.connecting(); + } + + console.log("Connecting to " + uri + " ..."); + deferred = $.Deferred(); + ws = new WebSocket(uri); + ws.onopen = on_open; + ws.onmessage = on_message; + ws.onerror = on_error; + ws.onclose = on_close; + timer = null; + } catch (err) { + try_to_reconnect(); + deferred.reject(new Error(err)); + } + } + + function try_to_reconnect() { + if (must_reconnect && !timer) { + // try to reconnect + console.log('Reconnecting...'); + var interval = generate_inteval(attempts); + timer = setTimeout(function() { + attempts++; + connect(ws.url); + }, interval); + } + } + + function send_heartbeat() { + try { + missed_heartbeats++; + if (missed_heartbeats > 3) + throw new Error("Too many missed heartbeats."); + ws.send(opts.heartbeat_msg); + } catch(e) { + clearInterval(heartbeat_interval); + heartbeat_interval = null; + console.warn("Closing connection. Reason: " + e.message); + if ( !is_closing() && !is_closed() ) { + ws.close(); + } + } + } + + function on_open() { + console.log('Connected!'); + // new connection, reset attemps counter + attempts = 1; + deferred.resolve(); + if (opts.heartbeat_msg && heartbeat_interval === null) { + missed_heartbeats = 0; + heartbeat_interval = setInterval(send_heartbeat, 5000); + } + if ($.type(opts.connected) === 'function') { + opts.connected(); + } + } + + function on_close(evt) { + console.log("Connection closed!"); + if ($.type(opts.disconnected) === 'function') { + opts.disconnected(evt); + } + try_to_reconnect(); + } + + function on_error(evt) { + console.error("Websocket connection is broken!"); + deferred.reject(new Error(evt)); + } + + function on_message(evt) { + if (opts.heartbeat_msg && evt.data === opts.heartbeat_msg) { + // reset the counter for missed heartbeats + missed_heartbeats = 0; + } else if ($.type(opts.receive_message) === 'function') { + return opts.receive_message(evt.data); + } + } + + // this code is borrowed from http://blog.johnryding.com/post/78544969349/ + // + // Generate an interval that is randomly between 0 and 2^k - 1, where k is + // the number of connection attmpts, with a maximum interval of 30 seconds, + // so it starts at 0 - 1 seconds and maxes out at 0 - 30 seconds + function generate_inteval(k) { + var maxInterval = (Math.pow(2, k) - 1) * 1000; + + // If the generated interval is more than 30 seconds, truncate it down to 30 seconds. + if (maxInterval > 30*1000) { + maxInterval = 30*1000; + } + + // generate the interval to a random number between 0 and the maxInterval determined from above + return Math.random() * maxInterval; + } + + this.send_message = function(message) { + ws.send(message); + }; + + this.get_state = function() { + return ws.readyState; + }; + + function is_connecting() { + return ws && ws.readyState === 0; + } + + function is_connected() { + return ws && ws.readyState === 1; + } + + function is_closing() { + return ws && ws.readyState === 2; + } + + function is_closed() { + return ws && ws.readyState === 3; + } + + + this.close = function () { + clearInterval(heartbeat_interval); + must_reconnect = false; + if (!is_closing() || !is_closed()) { + ws.close(); + } + } + + this.is_connecting = is_connecting; + this.is_connected = is_connected; + this.is_closing = is_closing; + this.is_closed = is_closed; +} diff --git a/kfet/templates/kfet/kpsul.html b/kfet/templates/kfet/kpsul.html index 040435fe..5480344e 100644 --- a/kfet/templates/kfet/kpsul.html +++ b/kfet/templates/kfet/kpsul.html @@ -2,7 +2,8 @@ {% load staticfiles %} {% block extra_head %} - + + {% endblock %} {% block title %}K-Psul{% endblock %} @@ -44,6 +45,19 @@ {{ operation_formset.as_p }} + + + + + + + + + + + +
NomCatégoriePrixStock
+
@@ -53,6 +67,9 @@ +
+
+ diff --git a/kfet/urls.py b/kfet/urls.py index 591b5c02..a28abcba 100644 --- a/kfet/urls.py +++ b/kfet/urls.py @@ -103,4 +103,6 @@ urlpatterns = [ name = 'kfet.kpsul.perform_operations'), url('^k-psul/cancel_operations$', views.kpsul_cancel_operations, name = 'kfet.kpsul.cancel_operations'), + url('^k-psul/history$', views.kpsul_history, + name = 'kfet.kpsul.history'), ] diff --git a/kfet/views.py b/kfet/views.py index c8515dd6..3a9872dc 100644 --- a/kfet/views.py +++ b/kfet/views.py @@ -17,6 +17,9 @@ from kfet.models import (Account, Checkout, Article, Settings, AccountNegative, CheckoutStatement) from kfet.forms import * from collections import defaultdict +from channels import Group +from kfet import consumers +from datetime import timedelta @login_required def home(request): @@ -450,6 +453,22 @@ def kpsul_checkout_data(request): raise http404 return JsonResponse(data) +@permission_required('kfet.is_team') +def kpsul_articles_data(request): + articles_old = request.GET.get('articles', []) + data = { 'articles' : {'new': [], 'deleted': [], 'updated': []} } + + articles = (Article.objects + .annotate(category_name=F('category__name')) + .values('id', 'name', 'price', 'stock', 'category_name') + .select_related('category') + .filter(is_sold=True) + ) + for article in articles: + if article['id'] not in articles_old['id']: + pass + return JsonResponse(data) + def get_missing_perms(required_perms, user): missing_perms_codenames = [ (perm.split('.'))[1] for perm in required_perms if not user.has_perm(perm)] @@ -462,7 +481,7 @@ def get_missing_perms(required_perms, user): @permission_required('kfet.is_team') def kpsul_perform_operations(request): # Initializing response data - data = { 'operation_group': 0, 'operations': [], + data = { 'operationgroup': 0, 'operations': [], 'warnings': {}, 'errors': {} } # Checking operationgroup @@ -505,7 +524,7 @@ def kpsul_perform_operations(request): if is_addcost: operation.addcost_for = addcost_for operation.addcost_amount = addcost_amount * operation.article_nb - operation.amount -= operation.addcost_amounty + operation.amount -= operation.addcost_amount to_addcost_for_balance += operation.addcost_amount if operationgroup.on_acc.is_cash: to_checkout_balance += -operation.amount @@ -584,6 +603,38 @@ def kpsul_perform_operations(request): Article.objects.filter(pk=article.pk).update( stock = F('stock') + to_articles_stocks[article]) + # Websocket data + websocket_data = {} + websocket_data['opegroups'] = [{ + 'add': True, + 'id': operationgroup.pk, + 'amount': operationgroup.amount, + 'checkout__name': operationgroup.checkout.name, + 'at': operationgroup.at, + 'valid_by__trigramme': ( operationgroup.valid_by and + operationgroup.valid_by.trigramme or None), + 'on_acc__trigramme': operationgroup.on_acc.trigramme, + 'opes': [], + }] + for operation in operations: + ope_data = { + 'id': operation.pk, 'type': operation.type, 'amount': operation.amount, + 'addcost_amount': operation.addcost_amount, + 'addcost_for': addcost_for.trigramme, + 'is_checkout': operation.is_checkout, + 'article__name': operation.article and operation.article.name or None, + 'article_nb': operation.article_nb, + 'group_id': operationgroup.pk, + 'canceled_by__trigramme': None, 'canceled_at': None, + } + websocket_data['opegroups'][0]['opes'].append(ope_data) + operationgroup.checkout.refresh_from_db() + websocket_data['checkouts'] = [{ + 'id': operationgroup.checkout.pk, + 'balance': operationgroup.checkout.balance, + }] + print(operationgroup.checkout.balance) + consumers.KPsul.group_send('kfet.kpsul', websocket_data) return JsonResponse(data) @permission_required('kfet.is_team') @@ -668,10 +719,12 @@ def kpsul_cancel_operations(request): data['errors']['negative'] = True return JsonResponse(data, status=403) + canceled_by = required_perms and request.user.profile.account_kfet or None + canceled_at = timezone.now() + with transaction.atomic(): - canceled_by = required_perms and request.user.profile.account_kfet or None (Operation.objects.filter(pk__in=opes) - .update(canceled_by=canceled_by, canceled_at=timezone.now())) + .update(canceled_by=canceled_by, canceled_at=canceled_at)) for account in to_accounts_balances: Account.objects.filter(pk=account.pk).update( balance = F('balance') + to_accounts_balances[account]) @@ -685,7 +738,45 @@ def kpsul_cancel_operations(request): Article.objects.filter(pk=article.pk).update( stock = F('stock') + to_articles_stocks[article]) + # Websocket data + websocket_data = { 'opegroups': [], 'opes': [] } + for opegroup in to_groups_amounts: + websocket_data['opegroups'].append({ + 'cancellation': True, + 'id': opegroup.pk, + 'amount': OperationGroup.objects.get(pk=opegroup.pk).amount, + }) + for ope in opes: + websocket_data['opes'].append({ + 'cancellation': True, + 'id': ope, + 'canceled_by__trigramme': canceled_by.trigramme, + 'canceled_at': canceled_at, + }) + consumers.KPsul.group_send('kfet.kpsul', websocket_data) + data['canceled'] = opes if opes_already_canceled: data['warnings']['already_canceled'] = opes_already_canceled return JsonResponse(data) + +@permission_required('kfet.is_team') +def kpsul_history(request): + opegroups_list = (OperationGroup.objects + .values( + 'id', 'amount', 'at', 'checkout_id', + 'valid_by__trigramme', 'on_acc__trigramme') + .select_related('valid_by', 'on_acc') + .filter(at__gt=timezone.now()-timedelta(hours=4))) + opegroups = { opegroup['id']:opegroup for opegroup in opegroups_list } + for opegroup in opegroups: + opegroups[opegroup]['opes'] = [] + opes = (Operation.objects + .values( + 'id', 'type', 'amount', 'addcost_amount', 'is_checkout', + 'article__name', 'canceled_by__trigramme', 'canceled_at', + 'addcost_for__trigramme', 'article_nb', 'group_id') + .filter(group__in=opegroups.keys())) + for ope in opes: + opegroups[ope['group_id']]['opes'].append(ope) + return JsonResponse({ 'opegroups': opegroups }) diff --git a/requirements.txt b/requirements.txt index 140f5f67..1446cdfb 100644 --- a/requirements.txt +++ b/requirements.txt @@ -12,4 +12,8 @@ six==1.10.0 unicodecsv==0.14.1 icalendar==3.10 django-bootstrap-form==3.2.1 -django-rest-framework==3.4.0 +asgiref==0.14.0 +daphne==0.14.3 +channels==0.17.2 +asgi-redis==0.14.0 +channels=0.17.2