def add_item(request, params, user):
"""
Add an item to a list
"""
if not List.objects.filter(id=params['id']).exists():
response = {
'status': 'FAIL',
'error': 'LIST_NOT_FOUND',
'message': 'The list doesn\'t exist.'
}
return json_response(response)
lt = List.objects.get(id=params['id'])
profile = lt.owner
# Check if the user is a manager of the profile
if not Profile_manager.objects.filter(profile=profile, user=user).exists():
response = {
'status': 'FAIL',
'error': 'NOT_A_MANAGER',
'message': 'You don\'t have permission for the list.'
}
return json_response(response)
# Check email format
if not REGEX_EMAIL.match(params['email']):
response = {
'status': 'FAIL',
'error': 'INVALID_EMAIL',
'message': 'Email format is invalid.'
}
return json_response(response)
# Check if the name is valid
if (not REGEX_NAME.match(params['first_name'])
or not REGEX_NAME.match(params['last_name'])):
response = {
'status': 'FAIL',
'error': 'INVALID_NAME',
'message': 'First or last name contain illegal characters.'
}
return json_response(response)
if len(params['first_name']) > 50 or len(params['last_name']) > 50:
response = {
'status': 'FAIL',
'error': 'NAME_TOO_LONG',
'message': 'First or last name is too long.'
}
return json_response(response)
item, created = List_item.objects.get_or_create(_list=lt,
email=params['email'])
item.first_name = params['first_name']
item.last_name = params['last_name']
if params['note']:
item.note = params['note']
item.save()
response = {
'status': 'OK',
'list': serialize_one(lt),
'item': serialize_one(item)
}
return json_response(response)
def edit(request, params, user):
"""
Edit a list
"""
if not List.objects.filter(id=params['id'], is_deleted=False).exists():
response = {
'status': 'FAIL',
'error': 'LIST_NOT_FOUND',
'message': 'The list doesn\'t exist.'
}
return json_response(response)
lt = List.objects.get(id=params['id'])
profile = lt.owner
# Check if the user is a manager of the profile
if not Profile_manager.objects.filter(profile=profile, user=user).exists():
response = {
'status': 'FAIL',
'error': 'NOT_A_MANAGER',
'message': 'You don\'t have permission for the list.'
}
return json_response(response)
if params['name'] is not None:
params['name'] = cgi.escape(params['name'])
if len(params['name']) > 50:
response = {
'status': 'FAIL',
'error': 'INVALID_NAME',
'message': 'The name must be within 50 characters.'
}
return json_response(response)
else:
lt.name = params['name']
lt.save()
response = {'status': 'OK', 'list': serialize_one(lt)}
return json_response(response)
def delete(request, params, user):
"""
Delete List
"""
if not List.objects.filter(id=params['id'], is_deleted=False).exists():
response = {
'status': 'FAIL',
'error': 'LIST_NOT_FOUND',
'message': 'The list doesn\'t exist.'
}
return json_response(response)
lt = List.objects.get(id=params['id'])
profile = lt.owner
# Check if the user is a manager of the profile
if not Profile_manager.objects.filter(profile=profile, user=user).exists():
response = {
'status': 'FAIL',
'error': 'NOT_A_MANAGER',
'message': 'You don\'t have permission for the list.'
}
return json_response(response)
lt.is_deleted = True
lt.save()
response = {'status': 'OK', 'list': serialize_one(lt)}
return json_response(response)
def create(request, params, user):
"""
Create an empty list
"""
if not Profile.objects.filter(id=params['profile']).exists():
response = {
'status': 'FAIL',
'error': 'PROFILE_NOT_FOUND',
'message': 'The profile doesn\'t exist.'
}
return json_response(response)
profile = Profile.objects.get(id=params['profile'])
# Check if the user is a manager of the profile
if not Profile_manager.objects.filter(profile=profile, user=user).exists():
response = {
'status': 'FAIL',
'error': 'NOT_A_MANAGER',
'message': 'You don\'t have permission for the profile.'
}
return json_response(response)
params['name'] = cgi.escape(params['name'])
if len(params['name']) > 50:
response = {
'status': 'FAIL',
'error': 'INVALID_NAME',
'message': 'The name must be within 50 characters.'
}
return json_response(response)
lt = List(owner=profile,
name=params['name'],
is_hidden=params['is_hidden'])
lt.save()
response = {'status': 'OK', 'list': serialize_one(lt)}
return json_response(response)
def upload_csv(request, params):
"""
Upload a CSV that is stored temporarily
"""
if not request.FILES.has_key('csv_file'):
return HttpResponseBadRequest('Bad request.')
rawCsv = request.FILES['csv_file']
csv_filename = rawCsv.name
csvExt = str(rawCsv.name).split('.')[-1].lower()
if not csvExt == 'csv':
response = {
'status': 'FAIL',
'error': 'INVALID_FORMAT',
'message': 'Must Be A .csv File'
}
return json_response(response)
if rawCsv._size > IMAGE_SIZE_LIMIT:
response = {
'status': 'FAIL',
'error': 'FILE_TOO_BIG',
'message': 'The csv cannot be over 2.5MB.'
}
return json_response(response)
csvUid = uuid.uuid4().hex
rawCsv.name = '%s.%s' % (csvUid, csvExt)
csv = Csv(source=rawCsv)
csv.save()
response = {
'status': 'OK',
'file': serialize_one(csv),
'filename': csv_filename
}
return json_response(response)
def create_project(request, params, user):
"""
Create Designs Project and, if logged in, a checkout
"""
paymentAccount = Payment_account.objects.get(id=43)
if params['services'] is '':
response = {
'status': 'FAIL',
'error': 'NO_SERVICE_SELECTED',
'message': 'You must select at least one service'
}
return json_response(response)
designer = Designer.objects.all()[0]
project = Project(description=params['description'], designer=designer)
project.save()
if params['assets'] and params['assets'] is not '':
assetsRaw = params['assets'].split(",")
for asset in assetsRaw:
if Asset.objects.filter(id=asset).exists():
assetObj = Asset.objects.get(id=asset)
project.images.add(assetObj)
servicesRaw = params['services'].split(",")
amount = 0
for service in servicesRaw:
if Service.objects.filter(id=service).exists():
serviceObj = Service.objects.get(id=service)
project.services.add(serviceObj)
amount += serviceObj.price * 100
if user:
project.owner = user
checkout = Checkout(payer=user,
payee=paymentAccount,
amount=amount,
description='Bazaarboy Designs')
checkout.save()
project.checkout = checkout
project.save()
response = {
'status': 'OK',
'project': serialize_one(project),
'price': amount,
'publishable_key': paymentAccount.publishable_key
}
else:
response = {'status': 'WAIT', 'project': serialize_one(project)}
return json_response(response)
def add_from_csv(request, params, user):
"""
Add items from a csv file
"""
if not List.objects.filter(id=params['id'], is_deleted=False).exists():
response = {
'status': 'FAIL',
'error': 'LIST_NOT_FOUND',
'message': 'The list doesn\'t exist.'
}
return json_response(response)
lt = List.objects.get(id=params['id'])
profile = lt.owner
# Check if the user is a manager of the profile
if not Profile_manager.objects.filter(profile=profile, user=user).exists():
response = {
'status': 'FAIL',
'error': 'NOT_A_MANAGER',
'message': 'You don\'t have permission for the list.'
}
return json_response(response)
# Check if CSV Exists
if not Csv.objects.filter(id=params['csv']).exists():
response = {
'status': 'FAIL',
'error': 'CSV_NOT_FOUND',
'message': 'The csv doesn\'t exist.'
}
return json_response(response)
csv_file = Csv.objects.get(id=params['csv'])
csvfile = csv_file.source.file
reader = csv.reader(csvfile)
# Load Format {field_type:col}
format = json.loads(params['format'])
added = 0
duplicates = 0
for num, row in enumerate(reader):
if 'email' in format and len(
row) >= format['email'] and REGEX_EMAIL.match(
row[format['email']]):
if not List_item.objects.filter(
_list=lt, email=row[format['email']]).exists():
item = List_item(_list=lt, email=row[format['email']])
item.first_name = row[format['first_name']]
if 'last_name' in format:
item.last_name = row[format['last_name']]
item.save()
added += 1
else:
duplicates += 1
response = {
'status': 'OK',
'list': serialize_one(lt),
'added': added,
'duplicates': duplicates
}
return json_response(response)
def crop_image(request, params):
"""
Crop an image by a viewport
"""
if not Image.objects.filter(id=params['id']).exists():
response = {
'status': 'FAIL',
'error': 'IMAGE_NOT_FOUND',
'message': 'The image doesn\'t exist.'
}
return json_response(response)
image = Image.objects.get(id=params['id'])
viewport = params['viewport'].split(',')
try:
for i in range(0, 4):
viewport[i] = int(viewport[i])
if viewport[i] < 0:
raise ValueError()
except (ValueError, IndexError):
response = {
'status': 'FAIL',
'error': 'INVALID_VIEWPORT',
'message': 'The viewport is invalid.'
}
return json_response(response)
imageUrl = image.source.url
imageName = imageUrl.split('/')[-1].split('?')[0]
imageExt = imageName.split('.')[-1].lower()
imageFormat = 'jpeg' if imageExt == 'jpg' else imageExt
imageContentType = IMAGE_CONTENT_TYPES[imageExt]
left = viewport[0]
upper = viewport[1]
right = left + viewport[2]
lower = upper + viewport[3]
box = left, upper, right, lower
imageFile = PIL.Image.open(StringIO(image.source.read()))
croppedImageFile = imageFile.crop(box)
croppedImageIO = StringIO()
croppedImageFile.save(croppedImageIO, format=imageFormat)
croppedImage = InMemoryUploadedFile(file=croppedImageIO,
field_name=None,
name=imageName,
content_type=imageContentType,
size=croppedImageIO.len,
charset=None)
image.source.delete(save=False)
image.source = croppedImage
image.save()
response = {'status': 'OK', 'image': serialize_one(image)}
return json_response(response)
def finalize_project(request, params, user):
if user:
if Project.objects.filter(code=params['code'],
id=params['project']).exists():
project = Project.objects.get(code=params['code'],
id=params['project'])
else:
response = {
'status': 'FAIL',
'error': 'PROJECT_DOESNT_EXIST',
'message': 'This project id or code is incorrect.'
}
return json_response(response)
project.owner = user
amount = 0
for service in project.services.all():
amount += service.price * 100
paymentAccount = Payment_account.objects.get(id=43)
checkout = Checkout(payer=user,
payee=paymentAccount,
amount=amount,
description='Bazaarboy Designs')
checkout.save()
project.checkout = checkout
project.save()
response = {
'status': 'OK',
'project': serialize_one(project),
'price': amount,
'publishable_key': paymentAccount.publishable_key
}
return json_response(response)
else:
response = {
'status': 'FAIL',
'error': 'NOT_LOGGED_IN',
'message': 'You must be logged in to finalize your project'
}
return json_response(response)
def auth(request, params):
"""
Authenticate an admin
"""
# Check if admin session exists
if request.session.has_key('admin'):
return HttpResponseForbidden('Access forbidden.')
# Authenticate name/password combination
if Admin.objects.filter(name=params['name']).exists():
admin = Admin.objects.get(name=params['name'])
saltedPassword = admin.salt + params['password']
if admin.password == hashlib.sha512(saltedPassword).hexdigest():
# Name and password match, start admin session
sessionAdmin = serialize_one(admin, ('id', 'name', 'role'))
request.session['admin'] = sessionAdmin
response = {'status': 'OK'}
return json_response(response)
# Validate failed
response = {
'status': 'FAIL',
'message': 'Invalid name and password combination.'
}
return json_response(response)
def upload_image(request, params):
"""
Upload a image that is stored temporarily
"""
isFromRedactor = False
if request.FILES.has_key('file'):
request.FILES['image_file'] = request.FILES['file']
del request.FILES['file']
isFromRedactor = True
if not request.FILES.has_key('image_file'):
return HttpResponseBadRequest('Bad request.')
rawImage = request.FILES['image_file']
imageExt = str(rawImage.name).split('.')[-1].lower()
if not imageExt in IMAGE_TYPES:
response = {
'status': 'FAIL',
'error': 'INVALID_FORMAT',
'message': 'The image format is not supported.'
}
return json_response(response)
if rawImage._size > IMAGE_SIZE_LIMIT:
response = {
'status': 'FAIL',
'error': 'FILE_TOO_BIG',
'message': 'The image cannot be over 2.5MB.'
}
return json_response(response)
imageUid = uuid.uuid4().hex
rawImage.name = '%s.%s' % (imageUid, imageExt)
image = Image(source=rawImage)
image.save()
response = {'status': 'OK', 'image': serialize_one(image)}
if isFromRedactor:
redactorImage = image.source.url.split("?", 1)
response = {'filelink': redactorImage[0]}
return json_response(response)
def upload_asset(request, params):
"""
Upload a asset that is stored temporarily
"""
if request.FILES.has_key('file'):
request.FILES['image_file'] = request.FILES['file']
del request.FILES['file']
if not request.FILES.has_key('image_file'):
return HttpResponseBadRequest('Bad request.')
rawAsset = request.FILES['image_file']
assetExt = str(rawAsset.name).split('.')[-1].lower()
if rawAsset._size > ASSET_SIZE_LIMIT:
response = {
'status': 'FAIL',
'error': 'FILE_TOO_BIG',
'message': 'The file cannot be over 2.5MB.'
}
return json_response(response)
assetUid = uuid.uuid4().hex
rawAsset.name = '%s' % (assetUid[0:5] + '_' + rawAsset.name)
asset = Asset(source=rawAsset)
asset.save()
response = {'status': 'OK', 'image': serialize_one(asset)}
return json_response(response)
def edit_criteria(request, params, user):
"""
Edit a criteria for sponsorship
"""
if not Criteria.objects.filter(id = params['id']).exists():
response = {
'status':'FAIL',
'error':'CRITERIA_NOT_FOUND',
'message':'The criteria doesn\'t exist.'
}
return json_response(response)
criteria = Criteria.objects.get(id = params['id'])
event = criteria.event
if not Organizer.objects.filter(event = event,
profile__managers = user).exists():
response = {
'status':'FAIL',
'error':'NOT_A_MANAGER',
'message':'You don\'t have permission for the criteria.'
}
return json_response(response)
if params['name'] is not None:
params['name'] = cgi.escape(params['name'])
if len(params['name']) > 50:
response = {
'status':'FAIL',
'error':'NAME_TOO_LONG',
'message':'Criteria name must be under 50 characters.'
}
return json_response(response)
else:
criteria.name = params['name']
if params['description'] is not None:
params['description'] = cgi.escape(params['description'])
if len(params['description']) > 150:
response = {
'status':'FAIL',
'error':'DESCRIPTION_TOO_LONG',
'message':'Criteria description must be under 150 characters.'
}
return json_response(response)
else:
criteria.description = params['description']
if params['price_low'] is not None:
if params['price_low'] == 'none':
criteria.price_low = None
else:
params['price_low'] = float(params['price_low'])
if params['price_low'] < 0:
response = {
'status':'FAIL',
'error':'INVALID_PRICE_RANGE',
'message':'Price range is invalid.'
}
return json_response(response)
else:
criteria.price_low = params['price_low']
if params['price_high'] is not None:
if params['price_high'] == 'none':
criteria.price_high = None
else:
params['price_high'] = float(params['price_high'])
if params['price_high'] < 0:
response = {
'status':'FAIL',
'error':'INVALID_PRICE_RANGE',
'message':'Price range is invalid.'
}
return json_response(response)
else:
criteria.price_high = params['price_high']
if criteria.price_high is not None:
if criteria.price_low is None:
criteria.price_low = 0
else:
if criteria.price_low > criteria.price_high:
response = {
'status':'FAIL',
'error':'INVALID_PRICE_RANGE',
'message':'Price range is invalid.'
}
return json_response(response)
if params['quantity'] is not None:
if params['quantity'].lower() == 'none':
criteria.quantity = None
else:
params['quantity'] = int(params['quantity'])
if params['quantity'] <= 0:
response = {
'status':'FAIL',
'error':'INVALID_QUANTITY',
'message':'Quantity is invalid.'
}
return json_response(response)
else:
criteria.quantity = params['quantity']
criteria.save()
response = {
'status':'OK',
'criteria':serialize_one(criteria)
}
return json_response(response)
def create(request, params, user):
"""
Create a sponsorship
"""
if not Event.objects.filter(id = params['event'],
is_deleted = False).exists():
response = {
'status':'FAIL',
'error':'EVENT_NOT_FOUND',
'message':'The event doesn\'t exist.'
}
return json_response(response)
event = Event.objects.get(id = params['event'])
if not Organizer.objects.filter(event = event,
profile__managers = user).exists():
response = {
'status':'FAIL',
'error':'NOT_A_MANAGER',
'message':'You don\'t have permission for the event.'
}
return json_response(response)
profile = None
if params['profile'] is not None:
# Existing profile
if not Profile.objects.filter(id = params['profile']).exists():
response = {
'status':'FAIL',
'error':'PROFILE_NOT_FOUND',
'message':'The profile doesn\'t exist.'
}
return json_response(response)
profile = Profile.objects.get(id = params['profile'])
name = None
description = None
image = None
if params['name'] is not None:
params['name'] = cgi.escape(params['name'])
if not (0 < len(params['name']) <= 100):
response = {
'status':'FAIL',
'error':'INVALID_NAME',
'message':'The name must be within 100 characters.'
}
return json_response(response)
name = params['name']
if params['description'] is not None:
params['description'] = cgi.escape(params['description'])
if not (0 < len(params['description']) <= 500):
response = {
'status':'FAIL',
'error':'INVALID_DESCRIPTION',
'message':'The description must be within 500 characters.'
}
return json_response(response)
description = params['description']
if params['image'] is not None:
if not Image.objects.filter(id = params['image']).exists():
response = {
'status':'FAIL',
'error':'IMAGE_NOT_FOUND',
'message':'The image doesn\'t exist.'
}
return json_response(response)
else:
image = Image.objects.get(id = params['image'])
image.is_archived = True
image.save()
if profile is not None:
name = profile.name
description = '' if description is None else description
image = None if image is None else profile.image
if profile is None and name is None:
response = {
'status':'FAIL',
'error':'INCOMPLETE_INFO',
'message':'You must provide the name for the sponsor!'
}
return json_response(response)
sponsorship = Sponsorship(owner = profile, event = event, name = name,
description = description, image = image)
sponsorship.save()
response = {
'status':'OK',
'sponsorship':serialize_one(sponsorship)
}
return json_response(response)
def create_criteria(request, params, user):
"""
Create a criteria for sponsorship
"""
if not Event.objects.filter(id = params['event'],
is_deleted = False).exists():
response = {
'status':'FAIL',
'error':'EVENT_NOT_FOUND',
'message':'The event doesn\'t exist.'
}
return json_response(response)
event = Event.objects.get(id = params['event'])
if not Organizer.objects.filter(event = event,
profile__managers = user).exists():
response = {
'status':'FAIL',
'error':'NOT_A_MANAGER',
'message':'You don\'t have permission for the event.'
}
return json_response(response)
params['name'] = cgi.escape(params['name'])
if len(params['name']) > 50:
response = {
'status':'FAIL',
'error':'NAME_TOO_LONG',
'message':'Criteria name must be within 50 characters.'
}
return json_response(response)
params['description'] = cgi.escape(params['description'])
criteria = Criteria(event = event, name = params['name'],
description = params['description'])
if params['price_low'] is not None:
params['price_low'] = float(params['price_low'])
if params['price_low'] < 0:
response = {
'status':'FAIL',
'error':'INVALID_PRICE_RANGE',
'message':'Price range is invalid.'
}
return json_response(response)
else:
criteria.price_low = params['price_low']
if params['price_high'] is not None:
params['price_high'] = float(params['price_high'])
if params['price_high'] < 0:
response = {
'status':'FAIL',
'error':'INVALID_PRICE_RANGE',
'message':'Price range is invalid.'
}
return json_response(response)
else:
criteria.price_high = params['price_high']
if criteria.price_high is not None:
if criteria.price_low is None:
criteria.price_low = 0
else:
if criteria.price_low > criteria.price_high:
response = {
'status':'FAIL',
'error':'INVALID_PRICE_RANGE',
'message':'Price range is invalid.'
}
return json_response(response)
if params['quantity'] is not None:
params['quantity'] = int(params['quantity'])
if params['quantity'] <= 0:
response = {
'status':'FAIL',
'error':'INVALID_QUANTITY',
'message':'Quantity is invalid.'
}
return json_response(response)
criteria.save()
response = {
'status':'OK',
'criteria':serialize_one(criteria)
}
return json_response(response)
def edit(request, params, user):
"""
Edit a bonus
"""
if not Bonus.objects.filter(id=params['id']).exists():
response = {
'status': 'FAIL',
'error': 'BONUS_NOT_FOUND',
'message': 'The bonus doesn\'t exist.'
}
return json_response(response)
bonus = Bonus.objects.get(id=params['id'])
if not Organizer.objects.filter(event=bonus.event,
profile__managers=user).exists():
response = {
'status': 'FAIL',
'error': 'NOT_A_MANAGER',
'message': 'You don\'t have permission for the bonus.'
}
return json_response(response)
if bonus.is_sent:
response = {
'status': 'FAIL',
'error': 'READ_ONLY',
'message': 'You cannot make changes to a sent bonus.'
}
return json_response(response)
if params['name'] is not None:
params['name'] = cgi.escape(params['name'])
if not (0 < len(params['name']) <= 50):
response = {
'status': 'FAIL',
'error': 'NAME_TOO_LONG',
'message': 'Criteria name must be within 50 characters.'
}
return json_response(response)
else:
bonus.name = params['name']
if params['description'] is not None:
params['description'] = cgi.escape(params['description'])
if not (0 < len(params['description']) <= 150):
response = {
'status': 'FAIL',
'error': 'DESCRIPTION_TOO_LONG',
'message': 'The description must be within 150 characters.'
}
return json_response(response)
else:
bonus.description = params['description']
if params['image'] is not None:
if params['image'] == 'none':
if bonus.image is not None:
oldImage = Image.objects.get(id=bonus.image.id)
oldImage.delete()
bonus.image = None
elif not Image.objects.filter(id=params['image']).exists():
response = {
'status': 'FAIL',
'error': 'IMAGE_NOT_FOUND',
'message': 'The image doesn\'t exist.'
}
return json_response(response)
else:
image = Image.objects.get(id=params['image'])
if bonus.image is not None:
oldImage = Image.objects.get(id=bonus.image.id)
oldImage.delete()
image.is_archived = True
image.save()
bonus.image = image
if params['quantity'] is not None:
params['quantity'] = int(params['quantity'])
if params['quantity'] <= 0:
response = {
'status': 'FAIL',
'error': 'INVALID_QUANTITY',
'message': 'Quantity must be a positive number.'
}
return json_response(response)
else:
bonus.quantity = params['quantity']
if params['code'] is not None:
params['code'] = cgi.escape(params['code'])
if len(params['code']) > 255:
response = {
'status': 'FAIL',
'error': 'INVALID_CODE',
'message': 'The code must be within 255 characters.'
}
return json_response(response)
else:
bonus.code = params['code']
if params['expiration_time'] is not None:
if params['expiration_time'] <= timezone.now():
response = {
'status': 'FAIL',
'error': 'EXPIRED_ALREADY',
'message': 'The expiration time is past due.'
}
return json_response(response)
else:
bonus.expiration_time = params['expiration_time']
bonus.save()
response = {'status': 'OK', 'bonus': serialize_one(bonus)}
return json_response(response)
def create(request, params, user):
"""
Create bonus
"""
if not Event.objects.filter(id=params['event'], is_deleted=False).exists():
response = {
'status': 'FAIL',
'error': 'EVENT_NOT_FOUND',
'message': 'The event doesn\'t exist.'
}
return json_response(response)
event = Event.objects.get(id=params['event'])
if not Organizer.objects.filter(event=event,
profile__managers=user).exists():
response = {
'status': 'FAIL',
'error': 'NOT_A_MANAGER',
'message': 'You don\'t have permission for the event.'
}
return json_response(response)
params['name'] = cgi.escape(params['name'])
if len(params['name']) > 50:
response = {
'status': 'FAIL',
'error': 'NAME_TOO_LONG',
'message': 'Criteria name must be within 50 characters.'
}
return json_response(response)
params['description'] = cgi.escape(params['description'])
if len(params['description']) > 150:
response = {
'status': 'FAIL',
'error': 'DESCRIPTION_TOO_LONG',
'message': 'The description must be within 150 characters.'
}
return json_response(response)
bonus = Bonus(event=event,
name=params['name'],
description=params['description'])
if params['image'] is not None:
if not Image.objects.filter(id=params['image']).exists():
response = {
'status': 'FAIL',
'error': 'IMAGE_NOT_FOUND',
'message': 'The image doesn\'t exist.'
}
return json_response(response)
else:
image = Image.objects.get(id=params['image'])
image.is_archived = True
image.save()
bonus.image = image
if params['quantity'] is not None:
params['quantity'] = int(params['quantity'])
if params['quantity'] <= 0:
response = {
'status': 'FAIL',
'error': 'INVALID_QUANTITY',
'message': 'Quantity must be a positive number.'
}
return json_response(response)
else:
bonus.quantity = params['quantity']
if params['code'] is not None:
params['code'] = cgi.escape(params['code'])
if len(params['code']) > 255:
response = {
'status': 'FAIL',
'error': 'INVALID_CODE',
'message': 'The code must be within 255 characters.'
}
return json_response(response)
else:
bonus.code = params['code']
if params['expiration_time'] is not None:
if params['expiration_time'] <= timezone.now():
response = {
'status': 'FAIL',
'error': 'EXPIRED_ALREADY',
'message': 'The expiration time is past due.'
}
return json_response(response)
else:
bonus.expiration_time = params['expiration_time']
bonus.save()
response = {'status': 'OK', 'bonus': serialize_one(bonus)}
return json_response(response)
def add_from_event(request, params, user):
"""
Add items from an event
"""
if not List.objects.filter(id=params['id'], is_deleted=False).exists():
response = {
'status': 'FAIL',
'error': 'LIST_NOT_FOUND',
'message': 'The list doesn\'t exist.'
}
return json_response(response)
lt = List.objects.get(id=params['id'])
profile = lt.owner
if not Profile_manager.objects.filter(profile=profile, user=user).exists():
response = {
'status': 'FAIL',
'error': 'NOT_A_MANAGER',
'message': 'You don\'t have permission for the list.'
}
return json_response(response)
if not Event.objects.filter(id=params['event'], is_deleted=False).exists():
response = {
'status': 'FAIL',
'error': 'EVENT_NOT_FOUND',
'message': 'The event doesn\'t exist.'
}
return json_response(response)
event = Event.objects.get(id=params['event'])
if not Organizer.objects.filter(event=event,
profile__managers=user).exists():
response = {
'status': 'FAIL',
'error': 'NOT_A_MANAGER',
'message': 'You don\'t have permission for the event.'
}
return json_response(response)
purchases = Purchase.objects.filter(Q(checkout = None) |
Q(checkout__isnull = False,
checkout__is_charged = True),
event = event,
is_expired = False) \
.prefetch_related('owner')
added = 0
duplicates = 0
for purchase in purchases:
if not List_item.objects.filter(_list=lt,
email=purchase.owner.email).exists():
item = List_item(_list=lt,
email=purchase.owner.email,
first_name=purchase.owner.first_name,
last_name=purchase.owner.last_name)
item.save()
added += 1
else:
duplicates += 1
response = {
'status': 'OK',
'list': serialize_one(lt),
'added': added,
'duplicates': duplicates
}
return json_response(response)
return json_response(response)
try:
ch = stripe.Charge.retrieve(checkout.checkout_id)
re = ch.refund()
except stripe.CardError, e:
response = {
'status': 'FAIL',
'error': 'REFUND_FAILED',
'message': 'The refund did not go through.'
}
return json_response(response)
else:
checkout.is_refunded = True
checkout.save()
sendRefundConfirmationEmail(purchase, re.amount_refunded)
response = {'status': 'OK', 'purchase': serialize_one(purchase)}
return json_response(response)
@login_check()
@validate('POST', ['invite', 'stripe_token', 'amount'])
def charge_invite(request, params, user):
"""
Charge for invitation
"""
if not Invite.objects.filter(id=params['invite']).exists():
response = {
'status': 'FAIL',
'error': 'INVITE_NOT_FOUND',
'message': 'The invitation doesn\'t exist.'
}
