def save(self):
response = reply_object()
try:
post = Post.objects.get(pk = self.cleaned_data["post_id"])
reply = Reply.objects.create(description =
self.cleaned_data["reply_description"],
user = get_me(self.request),
created_date = datetime.now(),
post = post,
comment_number = 0,
vote_number = 0
)
reply.save()
post.reply_number = post.reply_number + 1
post.save()
response["code"] = settings.FORUM_CODE["SAVED"]
response["reply_number"] = post.reply_number
response["new_reply"] = render_to_string("forum/new_reply.html",
context_instance = RequestContext(self.request,
{"reply" : reply}))
except:
response["code"] = settings.FORUM_CODE["SYSTEM ERROR"]
return response
def check_access(request, permission):
"""
Checks defined access
"""
access_parameters = reply_object()
access_parameters["redirect_url"] = "access_denied"
access_parameters["allow_access"] = False
if not request.user.is_authenticated():
access_parameters["redirect_url"] = "login"
return access_parameters
if permission == "user":
access_parameters["allow_access"] = True
return access_parameters
if permission == "admin":
me = request.user
if me.is_superuser:
access_parameters["allow_access"] = True
if permission == "client":
me = request.user
if me.is_staff or me.is_superuser:
access_parameters["allow_access"] = True
if permission == settings.APP_USER_TYPE["SELLER"]:
me = request.user
profile = me.get_profile()
if profile.user_type == settings.APP_USER_TYPE["SELLER"]:
access_parameters["allow_access"] = True
if permission == settings.APP_USER_TYPE["BUYER"]:
me = request.user
profile = me.get_profile()
if profile.user_type == settings.APP_USER_TYPE["BUYER"]:
access_parameters["allow_access"] = True
return access_parameters
return access_parameters
def update_item(self):
"""
Called from save function. Updates an existing item
Exception handled in parent function
"""
response = reply_object()
item_type = object_or_none("ItemType", self.cleaned_data["item_type"])
company = object_or_none("Company", self.cleaned_data["company"])
location = object_or_none("ItemLocation", self.cleaned_data["location"])
showroom = object_or_none("ShowRoom", self.cleaned_data["showroom"])
unit = object_or_none("ItemUnit", self.cleaned_data["item_unit"])
item = Item.objects.get(pk = self.cleaned_data["item_object_id"])
item.name = self.cleaned_data["name"]
item.cost_price = self.cleaned_data["cost_price"]
item.selling_price = self.cleaned_data["selling_price"]
item.purchase_date = self.cleaned_data["purchase_date"]
item.sold_date = self.cleaned_data["sold_date"]
item.item_type = item_type
item.item_code = self.generate_item_code()
item.location = location
item.guarantee_period_months = \
self.cleaned_data["guarantee_period_months"]
item.guarantee_start_date = \
self.cleaned_data["guarantee_start_date"]
item.paid = self.cleaned_data["paid"]
item.sold = self.cleaned_data["sold"]
item.company = company
item.showroom = showroom
item.unit = unit
item.save()
response["code"] = settings.APP_CODE["UPDATED"]
response["item_object_id"] = item.id
return response
def update_contract(self):
response = reply_object()
seller_item = SellerItem.objects.get(
pk=self.cleaned_data["item_object_id"])
user_type = self.request.user.get_profile().user_type
buyer_accept = False
seller_accept = False
if user_type == settings.APP_USER_TYPE['BUYER']:
contract_status = settings.APP_CONTRACT_STATUS["BUYER ACCEPTED"]
buyer_accept = True
elif user_type == settings.APP_USER_TYPE['SELLER']:
contract_status = settings.APP_CONTRACT_STATUS["SELLER ACCEPTED"]
seller_accept = True
item_contract = Contract.objects.get(pk=self.cleaned_data["object_id"])
item_contract.order_quantity = self.cleaned_data["order_quantity"]
item_contract.price = self.cleaned_data["price"]
item_contract.estimated_ship_time = self.cleaned_data[
"estimated_ship_time"]
item_contract.order_description = self.cleaned_data[
'order_description']
item_contract.buyer_accept = buyer_accept
item_contract.seller_accept = seller_accept
item_contract.contract_status = contract_status
item_contract.save()
seller_item = SellerItem.objects.get(pk=item_contract.seller_item.id)
response["code"] = settings.APP_CODE['SERVER MESSAGE']
response["server_message"] = "Contract has been updated"
return response
def create_item(self):
response = reply_object()
item_category = Category.objects.get(pk=self.cleaned_data["category"])
price_contact_seller = False
if self.cleaned_data["contact_seller"] == 'on':
price_contact_seller = True
item = SellerItem.objects.create(
title=self.cleaned_data["title"],
sub_title=self.cleaned_data["sub_title"],
minimum_order_quantity=self.cleaned_data["minimum_order_quantity"],
maximum_order_quantity=self.cleaned_data["maximum_order_quantity"],
description=self.cleaned_data["description"],
category=item_category,
price=self.cleaned_data["price"],
contact_seller=price_contact_seller,
user=get_me(self.request))
item.save()
#Handle file uploads
self.save_image("image1", item)
self.save_image("image2", item)
self.save_image("image3", item)
self.save_image("image4", item)
self.save_image("image5", item)
response["code"] = settings.APP_CODE["SAVED"]
response["object_id"] = item.id
return response
def calculate_price(request):
"""
Price calculator while booking
"""
try:
response = reply_object()
start = request.GET["start"]
end = request.GET["end"]
(h, m, s) = str(parser.parse(end) - parser.parse(start)).split(':')
decimal_time = int(h) * 3600 + int(m) * 60 + int(s)
billable_hours = decimal_time / (60 * 60)
price_per_hour = PriceModel.objects.get(
price_type=settings.PRICE_TYPE["PRICE_PER_HOUR"])
response["price"] = price_per_hour.price_per_hour * billable_hours
except:
response["price"] = 0
response["code"] = settings.APP_CODE["CALLBACK"]
return HttpResponse(simplejson.dumps(response),
mimetype="applicaiton/json")
def save(self):
response = reply_object()
#try:
if True:
if self.cleaned_data["id"] == 0 or\
self.cleaned_data["id"] == u'' or\
self.cleaned_data["id"] == None:
album = self.save_album()
image = self.handle_uploaded_file(
self.request.FILES['cover_photo'])
cover = self.create_cover_photo(image)
album.cover_photo = cover
album.image = image
album.save()
response["code"] = settings.APP_CODE["SAVED"]
response["id"] = album.id
else:
album = self.update_album()
if "cover_photo" in self.request.FILES:
old_image = album.image
image = self.handle_uploaded_file(
self.request.FILES['cover_photo'])
cover = self.create_cover_photo(image)
album.cover_photo = cover
album.image = image
album.save()
self.delete_file(old_image, ["cover"])
response["code"] = settings.APP_CODE["UPDATED"]
response["id"] = album.id
#except:
# response["code"] = settings.APP_CODE["SYSTEM ERROR"]
return response
def list_stream(request):
response = reply_object()
streams = Stream.objects.filter(owner=request.user)
response["page"] = render_to_string("stream/stream_list.html",
{"streams": streams})
response["code"] = settings.APP_CODE["PAGE LOADED"]
return HttpResponse(simplejson.dumps(response))
def save_user(self):
"""
Creates a new user
"""
response = reply_object()
try:
seller_request = SellerRequest.objects.get(
approval_key=self.cleaned_data["approval_key"])
# create new user
new_user = User.objects.create(
username=self.cleaned_data["username"],
email=seller_request.email)
new_user.set_password(self.cleaned_data["password1"])
new_user.save()
# create user profile
user_profile = UserProfile.objects.create(
user=new_user,
name=seller_request.name,
address_line1=seller_request.address_line1,
city=seller_request.city,
country=seller_request.country,
phone=seller_request.phone,
user_type=settings.APP_USER_TYPE["SELLER"]
)
user_profile.save()
# update status
seller_request.status = settings.SELLER_REQUEST_STATUS["SIGNEDUP"]
seller_request.save()
response["code"] = settings.APP_CODE["CALLBACK"]
response["user_id"] = new_user.id
except:
response["code"] = settings.APP_CODE["SYSTEM ERROR"]
return response
def save_decision(self):
response = reply_object()
#try:
if True:
seller_request = SellerRequest.objects.get(
pk=self.cleaned_data["seller_request_id"])
if self.cleaned_data["decision"] == settings.\
SELLER_REQUEST_STATUS["APPROVED"]:
key_object = create_key(seller_request.email, 2)
seller_request.approval_key = key_object["key"]
seller_request.key_expires = key_object["expiry"]
seller_request.status = settings.SELLER_REQUEST_STATUS[
"APPROVED"]
seller_request.save()
response["request_status"] = settings.SELLER_REQUEST_STATUS[
"APPROVED"]
response["code"] = settings.APP_CODE["CALLBACK"]
send_seller_approval_email(seller_request.email,
key_object["key"])
elif self.cleaned_data["decision"] == settings.\
SELLER_REQUEST_STATUS["REJECTED"]:
seller_request.status = settings.SELLER_REQUEST_STATUS[
"REJECTED"]
seller_request.save()
response["request_status"] = settings.SELLER_REQUEST_STATUS[
"REJECTED"]
response["code"] = settings.APP_CODE["CALLBACK"]
else:
response["code"] = settings.APP_CODE["INVALID REQUEST"]
#except:
# response["code"] = settings.APP_CODE["SYSTEM ERROR"]
return response
def save_vote(self):
response = reply_object()
try:
post = Post.objects.get(pk=self.cleaned_data["stream_post_id"])
if PostVote.objects.filter(post=post, user=self.request.user).\
exists():
post_vote = PostVote.objects.get(post=post,
user=self.request.user)
post_vote.vote = self.cleaned_data["vote"]
post_vote.save()
else:
post_vote = PostVote.objects.create(
post=post,
user=self.request.user,
vote=self.cleaned_data["vote"])
post_vote.save()
total_votes = PostVote.objects.filter(
post=post).aggregate(Sum('vote'))
post.total_votes = total_votes["vote__sum"]
post.points = PostProcess(post=post).points()
post.save()
response["code"] = settings.APP_CODE["CALLBACK"]
response["post_id"] = post.id
response["total_votes"] = total_votes["vote__sum"]
except:
response["code"] = settings.APP_CODE["SYSTEM ERROR"]
return response
def change_password(self):
response = reply_object()
user = self.request.user
user.set_password(self.cleaned_data['password'])
user.save()
response["code"] = settings.APP_CODE["UPDATED"]
return response
def update_post(self):
response = reply_object()
try:
if self.request.user.is_superuser:
stream_post = StreamPost.objects.get\
(id=self.cleaned_data["object_id"])
else:
stream_post = StreamPost.objects.get\
(id=self.cleaned_data["object_id"],
user = self.request.user.id)
permalink = settings.SITE_URL + "/news/post/" +\
stream_post.id.__str__()+ "/" +\
stream_post.title.replace(" ", "-")+"/"
stream_post.title = self.cleaned_data["title"]
stream_post.description = self.cleaned_data["description"]
if self.cleaned_data["post_url"] == "" or\
self.cleaned_data["post_url"] == None:
stream_post.post_url = permalink
else:
stream_post.post_url = self.cleaned_data["post_url"]
stream_post.post_type = self.cleaned_data["post_type"]
stream_post.permalink = permalink
stream_post.save()
response["code"] = settings.APP_CODE["UPDATED"]
except:
response["code"] = settings.APP_CODE["SYSTEM ERROR"]
return response
def save_post(self):
response = reply_object()
stream_process = StreamProcess()
stream_process.save_stream_post(self.cleaned_data["stream_command"],
self.request.user)
response["code"] = settings.APP_CODE["SAVED"]
return response
def check_access(request, permission):
"""
Checks defined access
"""
access_parameters = reply_object()
access_parameters["redirect_url"] = "access_denied"
access_parameters["allow_access"] = False
if not request.user.is_authenticated():
access_parameters["redirect_url"] = "login"
return access_parameters
if permission == "user":
access_parameters["allow_access"] = True
return access_parameters
if permission == "admin":
me = request.user
if me.is_superuser:
access_parameters["allow_access"] = True
if permission == "client":
me = request.user
if me.is_staff or me.is_superuser:
access_parameters["allow_access"] = True
return access_parameters
return access_parameters
def save_post(self):
response = reply_object()
try:
stream_post = StreamPost(title = self.cleaned_data["title"],
description = self.cleaned_data["description"],
user = self.request.user.id,
author_name = self.request.user.first_name\
+ self.request.user.last_name,
created_date = datetime.now(),
points = 0,
post_url = self.cleaned_data["post_url"],
post_type = self.cleaned_data["post_type"]
)
stream_post.save()
permalink = settings.SITE_URL + "/news/post/" +\
stream_post.id.__str__()+ "/" +\
stream_post.title.replace(" ", "-")+"/"
if self.cleaned_data["post_url"] == "" or\
self.cleaned_data["post_url"] == None:
stream_post.post_url = permalink
stream_post.permalink = permalink
stream_post.save()
response["code"] = settings.APP_CODE["SAVED"]
response["object_id"] = stream_post.id.__str__()
except:
response["code"] = settings.APP_CODE["SYSTEM ERROR"]
return response
def check_access(request, permission):
"""
Checks defined access
"""
access_parameters = reply_object()
access_parameters["redirect_url"] = "access_denied"
access_parameters["allow_access"] = False
if not request.user.is_authenticated():
access_parameters["redirect_url"] = "login"
return access_parameters
if permission == "user":
access_parameters["allow_access"] = True
return access_parameters
if permission == "admin":
me = request.user
if me.is_superuser:
access_parameters["allow_access"] = True
if permission == "client":
me = request.user
if me.is_staff or me.is_superuser:
access_parameters["allow_access"] = True
return access_parameters
return access_parameters
def create_user(self):
"""
Creates a new user
"""
response = reply_object()
new_user = User.objects.create(
username=self.cleaned_data["username"],
email=self.cleaned_data["email"],
first_name=self.cleaned_data["username"])
new_user.set_password(self.cleaned_data["password1"])
if settings.EMAIL_VERIFICATION_REQUIRED:
new_user.is_active = False
else:
new_user.is_active = True
new_user.save()
# create user profile
user_profile = UserProfile.objects.create(
user=new_user,
user_type=settings.APP_USER_TYPE["BUYER"]
)
user_profile.save()
response["code"] = settings.APP_CODE["REGISTERED"]
response["user_id"] = new_user.id
return response
def calculate_price(request):
"""
Price calculator while booking
"""
try:
response = reply_object()
start = request.GET["start"]
end = request.GET["end"]
(h, m, s) = str(parser.parse(end) - parser.parse(start)).split(':')
decimal_time = int(h) * 3600 + int(m) * 60 + int(s)
billable_hours = decimal_time/(60 * 60)
price_per_hour = PriceModel.objects.get(
price_type=settings.PRICE_TYPE["PRICE_PER_HOUR"])
response["price"] = price_per_hour.price_per_hour * billable_hours
except:
response["price"] = 0
response["code"] = settings.APP_CODE["CALLBACK"]
return HttpResponse(simplejson.dumps(response),
mimetype="applicaiton/json")
def reply(self):
response = reply_object()
message = Message.objects.get(pk=self.cleaned_data["object_id"],
to_user=self.request.user)
message.reply(self.cleaned_data["message_text"], self.request)
response["code"] = settings.APP_CODE["MESSAGE SENT"]
return response
def item_edit_page(request, item_id):
response = reply_object()
try:
property_form = ItemPropertyForm()
item = Item.objects.get(pk = item_id)
item_properties = describe_item_pretty(item.id)
item_form = ItemForm(
initial = {"name" : item.name,
"cost_price" : item.cost_price,
"selling_price" : item.selling_price,
"purchase_date" : format_date(item.purchase_date),
"sold_date" : format_date(item.sold_date),
"item_type" : item.item_type.id,
"item_code" : item.item_code,
"location" : item.location.id,
"guarantee_period_months" : item.guarantee_period_months,
"guarantee_start_date" :
format_date(item.guarantee_start_date),
"paid" : item.paid,
"sold" : item.sold,
"company" : item.company.id,
"showroom" : item.showroom.id,
"item_object_id" : item_id,
"unit" : item.unit})
page = render_to_string("item.html",
{"item_form" : item_form,
"property_form" : property_form,
"properties" : item_properties.iteritems()})
response["code"] = settings.APP_CODE["PAGE LOADED"]
response["page"] = page
except:
response["code"] = settings.APP_CODE["SYSTEM ERROR"]
response["page"] = "An error has occured while loading this page"
return HttpResponse(simplejson.dumps(response))
def get_post_types(request, page):
response = reply_object()
try:
named_form = NamedObjectForm(initial = {"named_object_type" : "PostType"})
name_list = PostType.objects.all()
generic_links = get_generic_links('PostType')
generic_links['edit_onclick'] = 'App.NamedObject.show_form'
generic_links['delete_onclick'] = 'App.NamedObject.delete_object'
print generic_links['add_new_link']
generic_list_dict = generic_list_page_dict(name_list,
["name"],
generic_links,
per_page = 20,
url="#/property/name/",
page = page)
print generic_links['add_new_link']
page = render_to_string("generic_list_page.html",
{"generic_list_dict" : generic_list_dict,
"generic_links" : generic_links,
"named_form" : named_form})
response["code"] = settings.APP_CODE["PAGE LOADED"]
response["page"] = page
except:
response["code"] = settings.APP_CODE["SYSTEM ERROR"]
return HttpResponse(simplejson.dumps(response))
def save_item(self):
"""
Called from save function. Creates a new item
Exception handled in parent function
"""
response = reply_object()
item_type = object_or_none("ItemType", self.cleaned_data["item_type"])
company = object_or_none("Company", self.cleaned_data["company"])
location = object_or_none("ItemLocation", self.cleaned_data["location"])
showroom = object_or_none("ShowRoom", self.cleaned_data["showroom"])
unit = object_or_none("ItemUnit", self.cleaned_data["item_unit"])
item = Item.objects.create(name = self.cleaned_data["name"],
cost_price = self.cleaned_data["cost_price"],
selling_price = self.cleaned_data["selling_price"],
purchase_date = self.cleaned_data["purchase_date"],
sold_date = self.cleaned_data["sold_date"],
item_type = item_type,
item_code = self.generate_item_code(),
location = location,
guarantee_period_months = \
self.cleaned_data["guarantee_period_months"],
guarantee_start_date = \
self.cleaned_data["guarantee_start_date"],
paid = self.cleaned_data["paid"],
sold = self.cleaned_data["sold"],
company = company,
showroom = showroom,
unit = unit)
item.save()
response["code"] = settings.APP_CODE["SAVED"]
response["item_object_id"] = item.id
return response
def manage_campaign(request, object_id):
response = reply_object()
#try:
if True:
camp = Campaign.objects.get(id=object_id)
c_form = CampaignForm\
(initial={"name":camp.name,
"object_id":camp.id,
"total_budget":camp.total_budget,
"daily_budget":camp.daily_budget,
"start_date":format_date(camp.start_date),
"end_date":format_date(camp.end_date)})
sn_form = SocialNetworkForm\
(initial={"network_name":camp.social_networks})
l_form = LocationForm(object_id=object_id)
ad_form = CreateAdForm()
adv_params = get_adv_parameters(request, 1, camp)
page = render_to_string\
("campaigns_manager.html",
context_instance=\
RequestContext(request,
{"c_form":c_form,
"sn_form":sn_form,
"l_form":l_form,
"ad_form":ad_form,
"advs":adv_params["advs"],
"adv_paginator":adv_params["adv_paginator"]}))
response["page"] = page
response["code"] = settings.APP_CODE["PAGE LOADED"]
#except:
# response["code"] = settings.APP_CODE["SYSTEM ERROR"]
return HttpResponse(simplejson.dumps(response))
def save_new_password(self):
response = reply_object()
user = self.request.user
user.set_password(self.cleaned_data['password'])
user.save()
response["code"] = settings.APP_CODE["CALLBACK"]
return response
def create_contract(self):
response = reply_object()
contract_status = settings.APP_CONTRACT_STATUS["NEW"]
user_type = self.request.user.get_profile().user_type
buyer_accept = False
seller_accept = False
seller_item = SellerItem.objects.get(
pk=self.cleaned_data["item_object_id"])
if user_type == settings.APP_USER_TYPE['BUYER']:
contract_status = settings.APP_CONTRACT_STATUS["BUYER ACCEPTED"]
buyer_accept = True
elif user_type == settings.APP_USER_TYPE['SELLER']:
contract_status = settings.APP_CONTRACT_STATUS["SELLER ACCEPTED"]
seller_accept = True
new_contract = Contract.objects.create(
seller_item=seller_item,
buyer=self.request.user,
order_quantity=self.cleaned_data["order_quantity"],
price=self.cleaned_data["price"],
estimated_ship_time=self.cleaned_data["estimated_ship_time"],
order_description=self.cleaned_data['order_description'],
contract_status=contract_status,
buyer_accept=buyer_accept,
seller_accept=seller_accept
)
response["code"] = settings.APP_CODE['SERVER MESSAGE']
response["server_message"] = "Contract has been sent"
seller_item.new_contract_message(
"New contract request:%s/contract/view/%s" % (settings.SITE_URL,
str(new_contract.id)),
self.request)
return response
def save_new_password(self):
response = reply_object()
user = self.request.user
user.set_password(self.cleaned_data['password'])
user.save()
response["code"] = settings.APP_CODE["CALLBACK"]
return response
def update_item(self):
response = reply_object()
item_category = Category.objects.get(pk=self.cleaned_data["category"])
price_contact_seller = False
if self.cleaned_data["contact_seller"] == 'on':
price_contact_seller = True
item = SellerItem.objects.get(pk=self.cleaned_data["object_id"],
user=get_me(self.request))
item.title = self.cleaned_data["title"]
item.sub_title = self.cleaned_data["sub_title"]
item.minimum_order_quantity = self.cleaned_data[
"minimum_order_quantity"]
item.maximum_order_quantity = self.cleaned_data[
"maximum_order_quantity"]
item.description = self.cleaned_data["description"]
item.category = item_category
item.price = self.cleaned_data["price"]
item.contact_seller = price_contact_seller
item.save()
self.update_image("image1", item)
self.update_image("image2", item)
self.update_image("image3", item)
self.update_image("image4", item)
self.update_image("image5", item)
response["code"] = settings.APP_CODE["UPDATED"]
response["object_id"] = item.id
return response
def action(self):
response = reply_object()
if self.cleaned_data["do"] == "save":
response = self.save()
elif self.cleaned_data["do"] == "delete":
response = self.delete_object()
return response
def save_category(self):
response = reply_object()
parent = self.get_parent()
album_category = AlbumCategory.objects.create(
name=self.cleaned_data["name"], parent=parent)
album_category.save()
response["code"] = settings.APP_CODE["SAVED"]
return response
def save(self):
response = reply_object()
post_id = self.cleaned_data["object_id"]
if post_id == "" or post_id == None:
response = self.save_post()
else:
response = self.update_post()
return response
def password_change_form(request):
response = reply_object()
change_form = PasswordChangeForm()
page = render_to_string("password_change.html",
{"change_form": change_form})
response["page"] = page
response["code"] = settings.APP_CODE["PAGE LOADED"]
return HttpResponse(simplejson.dumps(response))
def album_category_save(request):
response = reply_object()
form = CategoryForm(request.POST)
if form.is_valid():
response = form.save()
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def album_category_delete(request):
response = reply_object()
form = ObjectModForm(request.POST, model="AlbumCategory")
if form.is_valid():
response = form.delete_object()
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def new_message(self):
response = reply_object()
seller_item = SellerItem.objects.get(
pk=self.cleaned_data["item_object_id"])
seller_item.save_message(self.cleaned_data["message_text"],
self.request)
response["code"] = settings.APP_CODE["SAVED"]
response["code"] = settings.APP_CODE["MESSAGE SENT"]
return response
def generic_mod_action(request, model_name):
response = reply_object()
form = GenericModForm(request.POST, model=model_name)
if form.is_valid():
response = form.action()
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def save_price_perhour(request):
form = PriceForm(request.POST)
response = reply_object()
if form.is_valid():
response = form.save_price_per_hour()
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def delete_image(self):
response = reply_object()
image = AlbumImage.objects.get(pk=self.cleaned_data["image_id"])
delete_album_image_files(image)
image.delete()
response["id"] = self.cleaned_data["image_id"]
response["cid"] = self.cleaned_data["image_cid"]
response["code"] = settings.APP_CODE["DELETED"]
return response
def save_contact(self):
response = reply_object()
contact = Contact.objects.create(name=self.cleaned_data["name"],
email=self.cleaned_data["email"],
inquiry=self.cleaned_data["inquiry"])
contact.save()
send_contact_email(contact.name, contact.email, contact.inquiry)
response["code"] = settings.APP_CODE["CALLBACK"]
return response
def contact_submit(request):
response = reply_object()
form = ContactForm(request.POST)
if form.is_valid():
response = form.save_contact()
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def update_category(self):
response = reply_object()
parent = self.get_parent()
album_category = AlbumCategory.objects.get(pk=self.cleaned_data["object_id"])
album_category.parent = parent
album_category.name = self.cleaned_data["name"]
album_category.save()
response["code"] = settings.APP_CODE["UPDATED"]
return response
def album_image_delete(request):
response = reply_object()
form = AlbumImageModForm(request.POST)
if form.is_valid():
response = form.delete_image()
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def password_reset_submit_email(request):
response = reply_object()
form = PasswordEmailForm(request.POST)
if form.is_valid():
response = form.send_reset_link()
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def save_availability(request):
response = reply_object()
form = AvailabilityForm(request.POST, event_type="availability")
if form.is_valid():
event_object = form.save()
response["code"] = settings.APP_CODE["SAVED"]
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def remove_availability(request):
response = reply_object()
form = AvailabilityModForm(request.POST)
if form.is_valid():
response = form.delete_availability()
response["code"] = settings.APP_CODE["DELETED"]
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def album_image(request):
response = reply_object()
if request.POST:
form = AlbumImageForm(request.POST, request.FILES, request=request)
if form.is_valid():
response = form.save()
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def delete_album(self):
response = reply_object()
album = Album.objects.get(pk=self.cleaned_data["id"])
album_images = AlbumImage.objects.filter(album=album)
for album_image in album_images:
delete_album_image_files(album_image)
delete_uploaded_file(album.image)
delete_uploaded_file(album.cover_photo)
album.delete()
response["code"] = settings.APP_CODE["DELETED"]
return response
def save(self):
response = reply_object()
object_id = self.cleaned_data["object_id"]
if object_id == 0 or\
object_id == u'' or\
object_id == None:
response = self.save_category()
else:
response = self.update_category()
return response
def album_category_get(request):
response = reply_object()
category = AlbumCategory.objects.get(pk=request.GET["object_id"])
response["code"] = settings.APP_CODE["CALLBACK"]
response["name"] = category.name
response["object_id"] = category.id
if not category.parent:
response["parent"] = 0
else:
response["parent"] = category.parent.id
return HttpResponse(simplejson.dumps(response),
mimetype="application/json")
def generic_mod_get(request, model_name):
response = reply_object()
generic_model = get_model('app', model_name)
generic_obj = generic_model.objects.get(pk=request.GET["object_id"])
generic_dict = {}
generic_dict["object_id"] = generic_obj.id
generic_dict["name"] = generic_obj.name
generic_dict["url"] = generic_obj.url
response["code"] = settings.APP_CODE["CALLBACK"]
response["object"] = generic_dict
return HttpResponse(simplejson.dumps(response),
mimetype="application/json")
def password_reset_submit_password(request):
response = reply_object()
form = PasswordResetForm(request.POST, request=request)
if form.is_valid():
response = form.save_new_password()
response["code"] = settings.APP_CODE["CALLBACK"]
response["redirect"] = reverse('home')
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def vote(request):
"""
Voting request handler for albums and photos
"""
response = reply_object()
form = VoteForm(request.POST, request=request)
if form.is_valid():
response = form.do_vote()
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def book_event(request):
"""
Request Handler for booking event
"""
response = reply_object()
form = BookingForm(request.POST, request=request)
if form.is_valid():
response = form.start_booking_session()
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def update_user(self):
"""
Updates a registered user. Can be used for updating profile
"""
response = reply_object()
user = User.objects.get(pk=self.cleaned_data["user_id"])
user.username = self.cleaned_data["username"]
user.email = self.cleaned_data["email"]
user.set_password(self.cleaned_data["password1"])
user.save()
response["code"] = settings.APP_CODE["UPDATED"]
response["user_id"] = user.id
return response
def save_object(self):
response = reply_object()
if self.cleaned_data["url"] == "":
url = self.cleaned_data["name"]
else:
url = self.cleaned_data["url"]
new_object = self.model.objects.create(name=self.cleaned_data["name"],
url=url)
new_object.save()
response["code"] = settings.APP_CODE["SAVED"]
response["object_id"] = new_object.id
response["name"] = new_object.name
return response
def start_booking_session(self):
response = reply_object()
event_object = self.save()
order_key = unique_name(self.request.META['REMOTE_ADDR'])
event_booking = EventBooking.objects.create(
event=event_object,
order_key=order_key,
status=settings.EVENT_BOOKING_STATUS["PENDING"])
event_booking.save()
response["code"] = settings.APP_CODE["REDIRECT"]
response["redirect_url"] = "/payment"
return response
def add_user(request):
"""
Registration request handler
"""
response = reply_object()
form = CreateUserForm(request.POST)
if form.is_valid():
response = form.save_user()
response["success_page"] = reverse('registration_success')
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
