def map_visualization(request):
form = ListingsForms()
categories_list = Categories.objects.all()
item_sub_categories = SubCategories.objects.all().filter(categories=1)
services_sub_categories = SubCategories.objects.all().filter(categories=2)
rideshare_sub_categories = SubCategories.objects.all().filter(categories=3)
housing_sub_categories = SubCategories.objects.all().filter(categories=4)
payment_form = AcknowledgementForm(max_ripple=None, initial=request.GET)
categories_list = Categories.objects.all()
subcategories = SubCategories.objects.all()
contact_form = ContactForm()
notification_number = Notification.objects.filter(
status='NEW', recipient=request.profile).count()
return render(
request, 'frontend/plugs/map-visualization.html', {
'listing_form': form,
'categories': categories_list,
'item_sub_categories': item_sub_categories,
'services_sub_categories': services_sub_categories,
'subcategories': subcategories,
'rideshare_sub_categories': rideshare_sub_categories,
'housing_sub_categories': housing_sub_categories,
'payment_form': payment_form,
'contact_form': contact_form,
'notification_number': notification_number
})
def categories_filter(request, category_type):
"""
:param request:
:param category_type:
:return:
"""
listing_type_objects = Listings.objects.all().filter(
subcategories__categories__categories_text=category_type).order_by(
'-created')
form = ListingsForms()
form_listing_settings = FormListingsSettings(initial=request.GET)
categories_list = Categories.objects.all()
item_sub_categories = SubCategories.objects.all().filter(categories=1)
services_sub_categories = SubCategories.objects.all().filter(categories=2)
rideshare_sub_categories = SubCategories.objects.all().filter(categories=3)
housing_sub_categories = SubCategories.objects.all().filter(categories=4)
return render(
request, 'frontend/home.html', {
'listing_form': form,
'listings': listing_type_objects,
'item_sub_categories': item_sub_categories,
'services_sub_categories': services_sub_categories,
'rideshare_sub_categories': rideshare_sub_categories,
'housing_sub_categories': housing_sub_categories,
'categories': categories_list,
'subcategory_name': category_type,
'form_listing_settings': form_listing_settings,
'category_filter': category_type,
'is_listing': True
})
def blank_payment(request):
listing_form = ListingsForms()
received_payments = FeedItem.objects.filter(
recipient_id=request.profile.id,
item_type='acknowledgement').order_by('-date')
made_payments = FeedItem.objects.filter(
poster_id=request.profile.id,
item_type='acknowledgement').order_by('-date')
form = BlankPaymentForm(max_ripple=None, initial=request.GET)
if request.method == 'POST':
if not request.POST['recipient']:
messages.add_message(request, messages.ERROR,
'The recipient is invalid, please verify')
return django_render(request, 'blank_payment.html', {
'form': form,
'listing_form': listing_form
})
recipient = get_object_or_404(Profile,
user__username=request.POST['recipient'])
max_amount = ripple.max_payment(request.profile, recipient)
form = BlankPaymentForm(request.POST, max_ripple=max_amount)
if recipient == request.profile:
messages.add_message(request, messages.ERROR,
'You cant send a payment to yourself')
return django_render(request, 'blank_payment.html', {
'form': form,
'listing_form': listing_form
})
can_ripple = max_amount > 0
if not can_ripple and request.POST['ripple'] == 'routed':
messages.add_message(
request, messages.ERROR,
'There are no available paths through the trust network, '
'so you can only send direct trust')
form = BlankPaymentForm(max_ripple=None, initial=request.GET)
return django_render(request, 'blank_payment.html', {
'form': form,
'listing_form': listing_form
})
payment = form.send_payment(request.profile, recipient, request.POST)
create_notification(notifier=request.profile,
recipient=recipient,
type=Notification.PAYMENT)
# send_payment_notification(payment)
messages.add_message(request, messages.INFO, 'Payment sent.')
return HttpResponseRedirect(reverse('blank_payment_user'))
else:
form = BlankPaymentForm(max_ripple=None, initial=request.GET)
return django_render(
request, 'blank_payment.html', {
'form': form,
'listing_form': listing_form,
'received_payments': received_payments,
'made_payments': made_payments
})
def add_new_listing(request):
if request.method == 'POST':
schema = SubmitListingSchema()
data, errors = schema.load(request.POST)
if not errors:
form = ListingsForms(request.POST, request.FILES)
tags_list = data['tag'].split(',')
if form.is_valid():
try:
listing = form.save(commit=False)
listing.user_id = request.profile.user_id
listing.save()
for tag in tags_list:
new_tag = Tag(name=tag)
try:
new_tag.save()
new_tag.listings_set.add(listing)
update_profile_tags(new_tag, request.profile,
listing)
except IntegrityError as e:
existing_tag = Tag.objects.get(name=tag)
existing_tag.listings_set.add(listing)
update_profile_tags(existing_tag, request.profile,
listing)
# save_document(listing)
return JsonResponse({'msg': 'Success!'})
except Exception as e:
print(e)
return HttpResponseRedirect(reverse('frontend:home'))
else:
return JsonResponse({'errors': errors}, status=400)
else:
form = ListingsForms()
return render(request, 'frontend/home.html', {'form': form})
def submit_listing_api(request):
values = json.loads(request.body.decode('UTF-8'))
schema = SubmitListingSchema()
data, errors = schema.load(values)
if not errors:
listing = ListingsForms()
listing.title = data['title']
listing.listing_type = data['listing_type']
listing.description = data['description']
listing.price = data['price']
listing.subcategories = data['subcategories']
return JsonResponse({'msg': 'Successfully added listing'})
return JsonResponse({'errors': errors}, status=400)
def my_profile(request):
offer_tags = []
request_tags = []
teach_tags = []
learn_tags = []
other_tags = []
listing_form = ListingsForms()
listings = Listings.objects.filter(user_id=request.profile.user_id)
endorsements_received = request.profile.endorsements_received.all()
endorsements_made = request.profile.endorsements_made.all()
profile_tags = ProfilePageTag.objects.filter(profile_id=request.profile.id)
for each_profile_tag in profile_tags:
if each_profile_tag.listing_type == 'OFFER':
offer_tags.append(each_profile_tag)
elif each_profile_tag.listing_type == 'REQUEST':
request_tags.append(each_profile_tag)
elif each_profile_tag.listing_type == 'TEACH':
teach_tags.append(each_profile_tag)
elif each_profile_tag.listing_type == 'LEARN':
learn_tags.append(each_profile_tag)
else:
other_tags.append(each_profile_tag)
referral = Referral.objects.filter(recipient=request.profile)
if referral:
referral_count = referral.count()
else:
referral_count = None
return django_render(
request, 'my_profile.html', {
'profile': request.profile,
'listings': listings,
'endorsements_made': endorsements_made,
'endorsements_received': endorsements_received,
'offer_tags': offer_tags,
'request_tags': request_tags,
'teach_tags': teach_tags,
'learn_tags': learn_tags,
'other_tags': other_tags,
'listing_form': listing_form,
'referral': referral,
'referral_count': referral_count
})
def listing_details(request, listing_id):
endorsement = None
listing_form = ListingsForms()
try:
listing = Listings.objects.get(id=listing_id)
except ObjectDoesNotExist as e:
messages.add_message(
request, messages.ERROR,
'An error ocurred when trying to retrieve the listing info')
return render(request, 'listing_details.html', {'form': listing_form})
trust_form = EndorseForm(instance=endorsement,
endorser=None,
recipient=None)
payment_form = AcknowledgementForm(max_ripple=None, initial=request.GET)
contact_form = ContactForm()
if listing:
return render(
request, 'listing_details.html', {
'listing': listing,
'trust_form': trust_form,
'payment_form': payment_form,
'contact_form': contact_form,
'listing_form': listing_form
})
def home(request,
type_filter=None,
item_type=None,
template='frontend/home.html',
poster=None,
recipient=None,
extra_context=None,
do_filter=False):
"""
url: /home
"""
# max_amount = ripple.max_payment(request.profile, recipient)
user_agent = get_user_agent(request)
if user_agent.is_mobile:
user_agent_type = 'mobile'
else:
user_agent_type = 'desktop'
endorsement = None
if item_type:
form = FeedFilterForm(request.GET, request.profile, request.location,
item_type, poster, recipient, do_filter)
trust_form = EndorseForm(instance=endorsement,
endorser=None,
recipient=None)
if form.is_valid():
feed_items, remaining_count = form.get_results(
form.data.get('radio-low'), form.data.get('radio-high'),
form.data.get('referral-radio'))
if do_filter:
form.update_sticky_filter_prefs()
else:
raise Exception(unicode(form.errors))
if feed_items:
next_page_date = feed_items[-1].date
else:
next_page_date = None
url_params = request.GET.copy()
url_params.pop('d', None)
url_param_str = url_params.urlencode()
if next_page_date:
url_params['d'] = next_page_date.strftime(DATE_FORMAT)
next_page_param_str = url_params.urlencode()
listing_form = ListingsForms()
categories_list = Categories.objects.all()
item_sub_categories = SubCategories.objects.all().filter(categories=1)
services_sub_categories = SubCategories.objects.all().filter(
categories=2)
rideshare_sub_categories = SubCategories.objects.all().filter(
categories=3)
housing_sub_categories = SubCategories.objects.all().filter(
categories=4)
trust_form = EndorseForm(instance=endorsement,
endorser=None,
recipient=None)
payment_form = AcknowledgementForm(max_ripple=None,
initial=request.GET)
contact_form = ContactForm()
notification_number = Notification.objects.filter(
status='NEW', recipient=request.profile).count()
context = locals()
context.update(extra_context or {})
return render(
request, 'frontend/home.html', {
'url_params': url_params,
'feed_items': feed_items,
'next_page_date': next_page_date,
'context': context,
'form': form,
'listing_form': listing_form,
'poster': poster,
'do_filter': do_filter,
'remaining_count': remaining_count,
'item_type': item_type,
'template': template,
'url_param_str': url_param_str,
'next_page_param_str': next_page_param_str,
'extra_context': extra_context,
'recipient': recipient,
'user_agent_type': user_agent_type,
'item_sub_categories': item_sub_categories,
'services_sub_categories': services_sub_categories,
'rideshare_sub_categories': rideshare_sub_categories,
'housing_sub_categories': housing_sub_categories,
'categories': categories_list,
'trust_form': trust_form,
'payment_form': payment_form,
'contact_form': contact_form,
'notification_number': notification_number
})
else:
if request.method == 'POST':
form = ListingsForms(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('frontend:home'))
else:
print(form.errors)
subcategory_name = None
people = None
trusted_only = None
# GET Request
form_listing_settings = FormListingsSettings(request.GET,
request.profile,
request.location,
type_filter, do_filter)
if form_listing_settings.is_valid():
listing_items, remaining_count = form_listing_settings.get_results(
)
if listing_items:
next_page_date = listing_items[-1].date
else:
next_page_date = None
url_params = request.GET.copy()
url_params.pop('d', None)
url_param_str = url_params.urlencode()
if next_page_date:
url_params['d'] = next_page_date.strftime(DATE_FORMAT)
next_page_param_str = url_params.urlencode()
trust_form = EndorseForm(instance=endorsement,
endorser=None,
recipient=None)
payment_form = AcknowledgementForm(max_ripple=None,
initial=request.GET)
contact_form = ContactForm()
form = ListingsForms()
profile = recipient
categories_list = Categories.objects.all()
subcategories = SubCategories.objects.all()
if type_filter in LISTING_TYPE_CHECK:
# is listing_type filter
item_type_name = type_filter
else:
try:
SubCategories.objects.filter(id=type_filter)
# is subcategory id
item_type_name = SubCategories.objects.filter(
id=type_filter).values(
'sub_categories_text')[0]['sub_categories_text']
except:
# is category filter
item_type_name = type_filter
item_sub_categories = SubCategories.objects.all().filter(categories=1)
services_sub_categories = SubCategories.objects.all().filter(
categories=2)
rideshare_sub_categories = SubCategories.objects.all().filter(
categories=3)
housing_sub_categories = SubCategories.objects.all().filter(
categories=4)
notification_number = Notification.objects.filter(
status='NEW', recipient=request.profile).count()
return render(
request, 'frontend/home.html', {
'item_sub_categories': item_sub_categories,
'subcategories': subcategories,
'services_sub_categories': services_sub_categories,
'rideshare_sub_categories': rideshare_sub_categories,
'housing_sub_categories': housing_sub_categories,
'user_agent_type': user_agent_type,
'people': people,
'listing_form': form,
'categories': categories_list,
'trusted_only': trusted_only,
'trust_form': trust_form,
'payment_form': payment_form,
'contact_form': contact_form,
'form_listing_settings': form_listing_settings,
'item_type_name': item_type_name,
'is_listing': True,
'url_params': url_params,
'listing_items': listing_items,
'next_page_date': next_page_date,
'remaining_count': remaining_count,
'next_page_param_str': next_page_param_str,
'listing_type_filter': type_filter,
'notification_number': notification_number
})
def profile(request, username):
offer_tags = []
request_tags = []
teach_tags = []
learn_tags = []
other_tags = []
endorsement = None
profile = get_object_or_404(Profile, user__username=username)
if profile == request.profile:
return HttpResponseRedirect(reverse(my_profile))
else:
listing_form = ListingsForms()
template = 'profile.html'
if request.profile:
profile_endorsements_made = profile.endorsements_made.all()
profile_endorsements_received = profile.endorsements_received.all()
account = profile.account(request.profile)
trust_form = EndorseForm(instance=endorsement,
endorser=None,
recipient=None)
payment_form = AcknowledgementForm(max_ripple=None,
initial=request.GET)
listings = Listings.objects.filter(user_id=profile.user_id)
contact_form = ContactForm()
profile_tags = ProfilePageTag.objects.filter(profile_id=profile.id)
for each_profile_tag in profile_tags:
if each_profile_tag.listing_type == 'OFFER':
offer_tags.append(each_profile_tag)
elif each_profile_tag.listing_type == 'REQUEST':
request_tags.append(each_profile_tag)
elif each_profile_tag.listing_type == 'TEACH':
teach_tags.append(each_profile_tag)
elif each_profile_tag.listing_type == 'LEARN':
learn_tags.append(each_profile_tag)
else:
other_tags.append(each_profile_tag)
referral = Referral.objects.filter(recipient=profile)
if referral:
referral_count = referral.count()
else:
referral_count = None
return django_render(
request, 'profile.html', {
'profile_endorsements_made': profile_endorsements_made,
'profile_endorsements_received':
profile_endorsements_received,
'account': account,
'listing_form': listing_form,
'profile': profile,
'trust_form': trust_form,
'payment_form': payment_form,
'contact_form': contact_form,
'offer_tags': offer_tags,
'request_tags': request_tags,
'teach_tags': teach_tags,
'learn_tags': learn_tags,
'other_tags': other_tags,
'listings': listings,
'referral': referral,
'referral_count': referral_count
})
return locals(), template
def blank_trust(request):
listing_form = ListingsForms()
accounts = ripple.get_user_accounts(request.profile)
form = BlankTrust(endorser=request.profile, recipient=None)
if request.method == 'POST':
if not request.POST['data_profile']:
messages.add_message(request, messages.ERROR,
'The recipient is invalid, please verify')
return django_render(request, 'blank_trust.html', {
'form': form,
'listing_form': listing_form,
'accounts': accounts
})
recipient = get_object_or_404(
Profile, user__username=request.POST['data_profile'])
if recipient == request.profile:
messages.add_message(request, messages.ERROR,
'You cant send a trust to yourself')
return django_render(request, 'blank_trust.html', {
'form': form,
'listing_form': listing_form
})
try:
endorsement = Endorsement.objects.get(endorser=request.profile,
recipient=recipient)
except Endorsement.DoesNotExist:
endorsement = None
if 'delete' in request.POST and endorsement:
endorsement.delete()
messages.add_message(request, messages.INFO, 'Trust deleted')
return django_render(request, 'blank_trust.html', {'form': form})
form = BlankTrust(request.POST,
instance=endorsement,
endorser=request.profile,
recipient=recipient)
if form.is_valid():
endorsement = form.save()
create_notification(notifier=request.profile,
recipient=recipient,
type=Notification.TRUST)
if form.cleaned_data['referral']:
existing_referral = Referral.objects.filter(
referrer=request.profile, recipient=recipient)
if not existing_referral:
new_referral = Referral()
new_referral.referrer = request.profile
new_referral.recipient = recipient
new_referral.save()
send_endorsement_notification(endorsement)
messages.add_message(request, messages.INFO, 'Trust saved!')
return django_render(request, 'blank_trust.html', {
'form': form,
'listing_form': listing_form
})
else:
messages.add_message(request, messages.ERROR,
'An error occurred, please verify.')
return django_render(request, 'blank_trust.html', {
'form': form,
'listing_form': listing_form
})
else:
form = BlankTrust(instance=None,
endorser=request.profile,
recipient=None)
profile = request.profile
return django_render(
request, 'blank_trust.html', {
'form': form,
'listing_form': listing_form,
'accounts': accounts,
'profile': profile
})
def edit_listing(request, listing_id):
listing_form = ListingsForms()
listing = Listings.objects.get(id=listing_id, user_id=request.user.id)
if not request.user.id == listing.user_id:
messages.add_message(request, messages.ERROR,
'You are not allowed to do this')
return HttpResponseRedirect(
reverse('listing_management:manage_listings'))
if not listing:
messages.add_message(request, messages.ERROR,
'No listing has been found with this id')
return HttpResponseRedirect(
reverse('listing_management:manage_listings'))
if request.method == 'POST':
form = ListingsForms(request.POST, request.FILES)
if form.is_valid():
listing.listing_type = form.cleaned_data['listing_type']
listing.title = form.cleaned_data['title']
listing.description = form.cleaned_data['description']
listing.price = form.cleaned_data['price']
listing.subcategories = form.cleaned_data['subcategories']
if form.cleaned_data["photo"]:
listing.photo = form.cleaned_data['photo']
elif listing.photo:
listing.photo = listing.photo
else:
listing.photo = ""
listing.save()
tags_list = form.cleaned_data['tag'].split(',')
if tags_list and tags_list[0] == u'':
tags_to_delete = listing.tag.all()
if tags_to_delete:
for each_tag_delete in tags_to_delete:
Tag.objects.filter(id=each_tag_delete.id).delete()
messages.add_message(request, messages.SUCCESS,
'Listing edited with success.')
return HttpResponseRedirect(
reverse('listing_management:manage_listings'))
else:
listing.tag.all().delete()
for tag in tags_list:
new_tag = Tag(name=tag)
try:
new_tag.save()
new_tag.listings_set.add(listing)
except IntegrityError as e:
existing_tag = Tag.objects.get(name=tag)
existing_tag.listings_set.add(listing)
messages.add_message(request, messages.SUCCESS,
'Listing edited with success.')
return HttpResponseRedirect(
reverse('listing_management:manage_listings'))
else:
messages.add_message(
request, messages.ERROR,
'An error has occurred, please try again later.')
return render(request, 'listing_management/manage_listings.html', {
'form': form,
'listings_form': listing
})
else:
tags_to_template = ''
tags = listing.tag.all().values('name')
if tags:
for each_tag in tags:
tags_to_template = tags_to_template + each_tag['name'].encode(
) + ','
form = ListingsForms(instance=listing,
initial={
'listing_type': listing.listing_type,
'title': listing.title,
'description': listing.description,
'price': listing.price,
'subcategories': listing.subcategories,
'tag': tags_to_template
})
return render(request, 'listing_management/edit_listing.html', {
'form': form,
'listing_id': listing_id
})
messages.add_message(request, messages.ERROR, form.errors)
form = ListingsForms(
initial={
'listing_type': listing.listing_type,
'title': listing.title,
'description': listing.description,
'price': listing.price,
'subcategories': listing.subcategories,
'photo': listing.photo
})
return render(request, 'listing_management/edit_listing.html', {
'form': form,
'listings_form': listing
})