def test_called_method_indication(self):
""" werden die aufgerufenen Methoden richtig angezeigt? """
mock = MockWithUtils()
SetApiResourceMock('robotRock/Customer', mock)
settings.SHOULD_MOCK_API = True
rsrc = CreateApiResource('robotRock/Customer', '*****@*****.**', 'foobar')
rsrc.read()
self.assertTrue(mock.ctor_was_called('*****@*****.**', 'foobar'))
self.assertFalse(mock.ctor_was_called('*****@*****.**', 'carcdr'))
self.assertTrue(mock.method_was_called('read'))
def credit(self):
"""Gibt den 'Rest-Kredit' des Kunden zurück.
Das entspricht dem Kreditlimit abzgl. Offener Posten.
Erwartet, dass die interne Kundennr der SoftM Kundennr entspricht.
"""
api = CreateApiResource('bookkeeping/CreditConsumption')
credit = api.read(self.kundennr)
return credit
def show(request, order_id, document_name):
""" liefert das angefrage Zusatzdokument als PDF zurueck """
api = CreateApiResource('robotRock/Documents')
pdf = api.read(request.customer, order_id, document_name)
if not pdf:
raise Http404
resp = HttpResponse(mimetype='application/pdf')
resp['Content-Disposition'] = 'inline; filename=%s' % document_name
resp.write(pdf)
return resp
def cancel(request, order_id):
""" storniert einen Auftrag """
try:
api = CreateApiResource('robotRock/Order')
order = api.read(request.customer, order_id)
if api.storno(request.customer, order):
return render_to_json({'result': 'ok'})
else:
return render_to_json({'result': 'error', 'msg': 'Der Auftrag konnte nicht storniert werden.'})
except:
return render_to_json({'result': 'error', 'msg': 'Allgemeiner Fehler beim Stornieren.'})
def show(request, order_designator):
""" liefert die Details fuer einen Auftrag zur Anzeige """
api = CreateApiResource('robotRock/Order')
order = api.read(request.customer, order_designator)
texts = OrderFreitext.objects.filter(order_designator=order.designator)
freitext = texts[0].text if len(texts)>0 else None
for line in order.orderlines:
artnr = line['artnr']
return render_to_response_with_request(request, 'beliza/orders/show.html', {'order': order,
'freitext': freitext,
'trackingdata': trackingnummern(order.designator)})
def test_mock_calling(self):
""" koennen wir Funktionen im Mock aufrufen? """
mock = MockWithUtils()
mock.read.return_value = Customer()
mock.read.return_value['name1'] = 'Heinz Mueller'
mock.read.return_value['name2'] = 'Entenhausen Corp.'
SetApiResourceMock('robotRock/Customer', mock)
settings.SHOULD_MOCK_API = True
rsrc = CreateApiResource('robotRock/Customer', '*****@*****.**', 'foobar')
customer = rsrc.read()
self.assertTrue(dict(customer))
self.assertEquals('Heinz Mueller, Entenhausen Corp.', customer.name())
def authenticate(self, username=None, password=None): # pylint: disable=R0201
""" versucht den Benutzer ueber RobotRock zu authentifizieren """
# koennen wir ueberhaupt Daten zum Benutzer abrufen? Wenn ja suchen wir uns
# den richtigen Benutzer aus allen Benutzern, die der Kunde hat.
try:
resource = CreateApiResource('robotRock/Customer', username, password)
customer = resource.read()
if not customer:
return None
realname = ''
for user in customer.users:
if user['username'] == username:
realname = ' '.join([user['first_name'], user['last_name']])
break
except Exception as exc:
return None
# jetzt gucken wir, ob wir solchen Benutzer schon in der Datenbank haben,
# wenn nicht muessen wir einen neuen Datensatz fuer den Benutzer anlegen.
users = User.objects.filter(username=username)
if len(users) > 1:
raise RuntimeError("Duplicate user %s" % username)
elif len(users) < 1:
user = User.objects.create(username=username, email=username)
user.set_unusable_password()
else:
user = users[0]
# jetzt aktualisieren wir die Attribute des Benutzers mit den neuesten
# Werten von RobotRock, falls sich da was geaendert haben sollte
user.first_name = realname
user.last_name = customer.name1
user.password = password
user.is_staff = True
user.save()
# und jetzt noch die OAuth-Credentials speichern
try:
user_data = UserProfile.objects.get(user__id__exact=user.id)
except:
user_data = UserProfile()
user_data.user = user
user_data.email = username
user_data.password = password
user_data.save()
# das war's, Benutzer zurueckliefern, damit ist Login geglueckt
return user
def nnnotifications(request):
"""View für Seite zur Änderung der (E-Mail-)Benachrichtigungen"""
def add_notification(**kwargs):
result = api.create(customer=kwargs['customer'],
recipient=kwargs['recipient'],
status=kwargs['status'],
means='email') # kwargs['means']
return result
def remove_notification(customer, designator):
result = api.remove(customer=customer,
designator=designator)
return result
api = CreateApiResource('robotRock/Notification')
notifications = api.read(request.customer.kundennr)
if request.method == "POST":
form = NotificationCreationForm(request.POST)
# Hinzufügen oder Löschen von Notifications?
if 'delete' in request.POST:
for designator in request.POST.getlist('notification_designator'):
remove_notification(request.customer.kundennr, designator)
return redirect('account.notifications')
elif 'add' in request.POST:
if form.is_valid():
add_notification(customer=request.customer.kundennr, **form.cleaned_data)
return redirect('account.notifications')
else:
form = NotificationCreationForm()
return render_to_response('beliza/customers/notifications.html',
{'form': form, 'notifications': notifications},
context_instance=RequestContext(request))
return render_to_json({'result': 'ok'})
# sollen wir eine Aktion durchfuehren?
if request.method == "POST":
what = request.POST.get('what')
if what == 'create':
return add_notification(request.POST)
elif what == 'delete':
return delete_notifications(request.POST.getlist('ids[]'))
else:
return render_to_json({'result': 'error', 'msg': 'Ungueltige Aktion!'})
# oder nur die Seite anzeigen?
api = CreateApiResource('robotRock/Notification')
notifications = []
for notification in api.read(request.customer.kundennr):
notifications.append({'designator': notification.designator,
'email': notification.recipient,
'event': NOTIFICATION_EVENTS.get(notification.status, '(Unbekanntes Ereignis)')})
paginator = Paginator(request, 10, len(notifications))
return render_to_response('beliza/customers/notifications.html',
{'notifications': notifications[paginator.start():paginator.stop()],
'paginator': paginator},
context_instance=RequestContext(request))
@breadcrumb(u'Benutzerverwaltung')
def users(request):
# Check if given user is admin for customer
def add_user(data):
