def getPaginationData(self, current_page, total_pages, url_template):
if total_pages <= Config.TOTAL_PAGE_DISPLAY():
page_range = range(1, total_pages + 1)
else:
pages_up_down = int(math.ceil((Config.TOTAL_PAGE_DISPLAY() - 1) / 2))
# Determine if the lower limit is based on the minimum page (1)
# or on the current page - the TOTAL_PAGE_DISPLAY
if (current_page - pages_up_down) < 1:
lower_page = 1
else:
lower_page = (current_page - pages_up_down)
# Determine if upper limit is based on the total pages
# or on the current page + the TOTAL_PAGE_DISPLAY
if (current_page + pages_up_down) > total_pages:
upper_page = (total_pages + 1)
else:
upper_page = (current_page + pages_up_down + 1)
page_range = range(lower_page, upper_page)
page_data = []
for page_numer in page_range:
page_data.append(['active' if (page_numer == current_page) else '', url_template % page_numer, page_numer])
return page_data
def getReturnVars(self):
return_vars_key = 'return_vars'
if self.getSessionVar(return_vars_key) and self.getSessionVar(return_vars_key) != 'unset':
self.return_vars = json.loads(self.getSessionVar(return_vars_key))
self.setSessionVar(return_vars_key, 'unset')
else:
self.return_vars = {
'error': None,
'warning': None,
'info': None,
'app_name': Config.APP_NAME(),
'page_name': self.name,
'debug': Config.DEVEL()
}
def processPage(self):
"""Set variables for displaying the credit page"""
self.return_vars['user'] = self.getCurrentUserObject()
self.return_vars['enable_custom'] = Config.ENABLE_CUSTOM_PAYMENT()
self.return_vars[
'inventory'] = Inventory.getAvailableItemsByPopularity()
shared_user_data = []
for user in User.objects.filter(shared=True):
shared_user_data.append([user.id, user.shared_name])
self.return_vars['shared_user_data'] = json.dumps(
shared_user_data).replace("'", r"\'")
def processPage(self):
"""Obtains required variables for history page"""
transaction_history = self.getTransactionHistory()
url_parts = HistoryBase.getUrlParts(self.request_handler)
self.return_vars['page_data'] = []
if len(transaction_history) > Config.TRANSACTION_PAGE_SIZE():
# Attempt to retrieve page number from URL, default to 1
page_number = 1
if len(url_parts) == (self.pagination_itx + 1):
try:
page_number = int(url_parts[self.pagination_itx])
except ValueError:
pass
total_pages = int(
ceil((len(transaction_history) - 1) /
Config.TRANSACTION_PAGE_SIZE())) + 1
self.return_vars['page_data'] = self.getPaginationData(
page_number, total_pages, '%s/%%s' % self.URL)
array_start = (page_number - 1) * Config.TRANSACTION_PAGE_SIZE()
array_end = page_number * Config.TRANSACTION_PAGE_SIZE()
transaction_history = transaction_history[array_start:array_end]
self.return_vars['transaction_history'] = transaction_history
def get_connection(self):
credentials = Config.SKYPE_CREDENTIALS()
if credentials is None:
raise Exception('No skype credentials available')
if Skype.SKYPE_CONNECTION is None:
try:
Skype.SKYPE_CONNECTION = SkypeAPI(credentials[0],
credentials[1])
except:
time.sleep(3)
Skype.SKYPE_CONNECTION = SkypeAPI(credentials[0],
credentials[1])
return Skype.SKYPE_CONNECTION
def test_list_items(self):
"""Tests the credit page, ensuring that the
correct items are displayed on the page"""
# Perform request to page
credit_page = getPageObject(Credit,
path='',
unittest=self,
headers={'Cookie': self.cookie})
credit_page.processRequest(post_request=False)
# Ensure that the correct user object has been passed to the template
self.assertEqual(credit_page.return_vars['user'], self.user_object)
# Ensure that the enable custom option matches to the configuration
self.assertEqual(credit_page.return_vars['enable_custom'],
Config.ENABLE_CUSTOM_PAYMENT())
# Ensure that the current user credit is 0 and the string shown to the user is correct
self.assertEqual(self.user_object.getCurrentCredit(), -124)
self.assertEqual(self.user_object.getCreditString(),
'<font style="color: red">-£1.24</font>')
# Assert that this has been passed to the template
self.assertTrue(self.user_object.getCreditString() in
credit_page.request_handler.output)
# Ensure that the items are passed to the return vars
self.assertTrue(
self.test_items[0] in credit_page.return_vars['inventory'])
self.assertTrue(
self.test_items[1] in credit_page.return_vars['inventory'])
# Ensure that the archived item is not present
self.assertTrue(
self.test_items[2] not in credit_page.return_vars['inventory'])
# Ensure that the available items are displayed on the page
self.assertTrue(
self.test_items[0].name in credit_page.request_handler.output)
self.assertTrue(self.test_items[0].getSalePriceString() in
credit_page.request_handler.output)
self.assertTrue(
self.test_items[1].name in credit_page.request_handler.output)
self.assertTrue(self.test_items[1].getSalePriceString() in
credit_page.request_handler.output)
self.assertTrue(
self.test_items[2].name not in credit_page.request_handler.output)
self.assertTrue(self.test_items[2].getSalePriceString() not in
credit_page.request_handler.output)
def login(username, password):
from tuckshop.core.config import Config
from tuckshop.app.models import User
if 'TUCKSHOP_DEVEL' in environ and environ['TUCKSHOP_DEVEL']:
# If tuckshop in development mode, match all passwords
# again 'password'
if password != 'password':
return False
else:
# Otherwise authenticate against LDAP server
ldap_obj = ldap.initialize('ldap://%s:389' % Config.LDAP_SERVER())
dn = 'uid=%s,%s' % (username, Config.LDAP_USER_BASE())
try:
# Attempt to bind to LDAP
ldap_obj.simple_bind_s(dn, password)
except:
# If the connection throws an exception, return False
return False
# Create user object for currently logged in user
user_object = User.objects.filter(uid=username)
# If a user object does not exist, create a new one
if (not len(user_object)):
user_object = User(uid=username)
user_object.save()
else:
user_object = user_object[0]
# Determine if the user account is a shared account.
# If it is, do not allow the user to login
if user_object.shared:
return False
# Return user object
return user_object
def processPost(self):
"""Process post requests to credit page"""
# Obtain post variables
available_actions = ['pay']
if Config.ENABLE_CUSTOM_PAYMENT():
available_actions.append('pay_custom')
action = self.getPostVariable(name='action',
possible_values=available_actions)
user_object = self.getCurrentUserObject()
if action == 'pay':
use_shared_user = self.getPostVariable(name='use_shared_user',
var_type=str,
default=None,
set_default=True)
# Obtain variables to item purchase
item_id = self.getPostVariable(
name='item_id',
var_type=int,
special=[VariableVerificationTypes.POSITIVE])
original_price = self.getPostVariable(
name='sale_price',
var_type=int,
special=[VariableVerificationTypes.NON_NEGATIVE])
inventory_object = Inventory.objects.get(pk=item_id)
current_user = self.getCurrentUserObject()
payment_arguments = {
'inventory': inventory_object,
'verify_price': original_price,
'author': current_user,
'affect_float': False
}
if use_shared_user:
payment_arguments['description'] = self.getPostVariable(
name='description',
var_type=str,
message=
'Description must be provided and be less than 255 characters',
special=[VariableVerificationTypes.NOT_EMPTY])
shared_account_ids = [
account.id for account in User.objects.filter(shared=True)
]
shared_account_id = self.getPostVariable(
name='shared_account',
var_type=int,
possible_values=shared_account_ids)
target_user = User.objects.get(pk=shared_account_id)
else:
target_user = current_user
# Perform purchase
target_user.removeCredit(**payment_arguments)
elif action == 'pay_custom':
# Handle custom payment
amount = self.getPostVariable(
name='amount',
var_type=int,
special=[VariableVerificationTypes.POSITIVE])
description = self.getPostVariable(
name='description',
var_type=str,
default=None,
set_default=True,
message='Description must be less than 255 characters')
user_object.removeCredit(amount=amount,
description=description,
author=user_object,
affect_float=False)