def requests_change_priority(request):
if request.method == 'POST' and request.is_ajax():
post_dict = {}
if 'increase' in request.POST and request.POST['increase']:
request_object = get_object_or_None(
RequestsLog, pk=request.POST['increase'].encode('utf-8'))
if request_object:
increased_priority = request_object.priority + 1
try:
request_object.priority = increased_priority
request_object.save()
post_dict['result'] = 'success'
post_dict['new_value'] = increased_priority
except:
post_dict['result'] = 'error'
elif 'reduce' in request.POST and request.POST['reduce']:
request_object = get_object_or_None(
RequestsLog, pk=request.POST['reduce'].encode('utf-8'))
if request_object:
reduced_priority = request_object.priority - 1
if reduced_priority >=0:
try:
request_object.priority = reduced_priority
request_object.save()
post_dict['result'] = 'success'
post_dict['new_value'] = reduced_priority
except:
post_dict['result'] = 'error'
else:
post_dict['result'] = 'error'
json = simplejson.dumps(post_dict, ensure_ascii=False)
return HttpResponse(json, mimetype='application/json')
else:
raise Http404
def _get_facility_users(self, bundle):
"""Return a dict mapping facility_user_ids to facility user objs, filtered by the zone id(s), facility_id, or group_id"""
zone_id = bundle.request.GET.get('zone_id')
zone_ids = bundle.request.GET.get('zone_ids')
facility_id = bundle.request.GET.get('facility_id')
group_id = bundle.request.GET.get('group_id')
# They must have a zone_id, and may have a facility_id and group_id.
# Try to filter from most specific, to least
facility_user_objects = []
if group_id:
facility_user_objects = FacilityUser.objects.filter(group__id=group_id)
elif facility_id:
facility_user_objects = FacilityUser.objects.filter(facility__id=facility_id)
elif zone_id:
facility_user_objects = FacilityUser.objects.by_zone(get_object_or_None(Zone, id=zone_id))
elif zone_ids:
# Assume 'all' selected for zone, and a list of zone ids has been passed
zone_ids = zone_ids.split(",")
facility_user_objects = []
for zone_id in zone_ids:
facility_user_objects += FacilityUser.objects.by_zone(get_object_or_None(Zone, id=zone_id))
# TODO(dylanjbarth) errors commented out so we can pass a blank CSV if not found.
# in future, should handle these more gracefully, with a redirect, an AJAX warning,
# and reset the fields. see: https://gist.github.com/1116962/58b7db0364de837ce229cdd8ef524bc9ff6da19f
# else:
# raise BadRequest("Invalid request.")
# if not facility_user_objects:
# raise NotFound("Student not found.")
facility_user_dict = {}
for user in facility_user_objects:
facility_user_dict[user.id] = user
return facility_user_dict
def questionnaire_fill(request, quest_id):
quest = get_object_or_404(Questionnaire, pk=quest_id)
answer_set = get_object_or_None(AnswerSet, user=request.user, questionnaire=quest)
if answer_set is None:
answer_set = AnswerSet(user=request.user, questionnaire=quest)
else:
return redirect("show_answer_set", answer_set_id=answer_set.pk)
questions = Question.objects.filter(questionnaire=quest.pk).order_by('number')
question_parts = []
if request.method == 'POST':
for question in questions:
QuestionForm = question.get_form_class()
answer = get_object_or_None(Answer, answer_set=answer_set.pk, question=question.pk)
form_part = QuestionForm(question, data=request.POST, instance=answer)
question_parts.append((question, form_part))
if all(part[1].is_valid() for part in question_parts):
answer_set.finished = True
answer_set.save()
for part in question_parts:
part[1].save(answer_set)
return redirect("index")
else:
for question in questions:
QuestionForm = question.get_form_class()
answer = get_object_or_None(Answer, answer_set=answer_set.pk, question=question.pk)
form_part = QuestionForm(question, instance=answer)
question_parts.append((question, form_part))
context = RequestContext(request)
return render_to_response('quest/questionnaire_fill.html',
{'quest': quest, 'question_parts': question_parts },
context_instance=context)
def post(self, request):
msg = '<div data-alert class="alert-box %s">%s<a href="#" data-dismiss="alert" class="close">×</a></div>'
project_id = request.POST.get('project_id')
profile_id = request.POST.get('profile_id')
try:
project_id = int(project_id)
except:
self.errors.append(u'Id проекта должно быть числом')
project_id = None
try:
profile_id = int(profile_id)
except:
self.errors.append(u'Id профиля должно быть числом')
profile_id = None
if not project_id and not profile_id:
return HttpResponse(json.dumps(self.response_data))
project = get_object_or_None(UserProject, pk=project_id)
profile = get_object_or_None(UserProfile, pk=profile_id)
if profile and not profile.in_team:
self.messages = msg % ('alert', 'Вы не состоите ни в одной команде.')
elif project and profile:
try:
project.members.remove(profile)
self.success = True
self.messages = msg % ('success', 'Вы покинули команду. Время искать новую!')
except:
self.success = False
self.messages = msg % ('alert', 'Наверное, это не ваша команда.')
else:
self.messages = msg % ('alert', 'Команда не найдена')
#some_signal.send(sender=MyAJAXView, instance=self)
return HttpResponse(json.dumps(self.response_data))
def test_pay_proforma_with_provided_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
proforma.issue()
proforma.save()
url = reverse('proforma-state', kwargs={'pk': 1})
data = {
'state': 'paid',
'paid_date': '2014-05-05'
}
response = self.client.put(url, data=json.dumps(data),
content_type='application/json')
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': timezone.now().date().strftime('%Y-%m-%d'),
'due_date': due_date.strftime('%Y-%m-%d'),
'paid_date': '2014-05-05',
'state': 'paid',
'invoice': 'http://testserver/invoices/1/'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
invoice = get_object_or_None(Invoice, pk=1)
proforma = get_object_or_None(Proforma, pk=1)
assert proforma.invoice == invoice
assert invoice.proforma == proforma
invoice = get_object_or_None(Invoice, proforma=proforma)
def facility_usage(request, facility_id, org_id=None, zone_id=None, frequency=None):
# Basic data
org = get_object_or_None(Organization, pk=org_id) if org_id else None
zone = get_object_or_None(Zone, pk=zone_id) if zone_id else None
facility = get_object_or_404(Facility, pk=facility_id)
groups = FacilityGroup.objects.filter(facility=facility).order_by("name")
students = FacilityUser.objects \
.filter(facility=facility, is_teacher=False) \
.order_by("last_name", "first_name", "username") \
.prefetch_related("group")
teachers = FacilityUser.objects \
.filter(facility=facility, is_teacher=True) \
.order_by("last_name", "first_name", "username") \
.prefetch_related("group")
# Get the start and end date--based on csv. A hack, yes...
if request.GET.get("format", "") == "csv":
frequency = frequency or request.GET.get("fequency", "months")
(period_start, period_end) = _get_date_range(frequency)
else:
(period_start, period_end) = (None, None)
(student_data, group_data) = _get_user_usage_data(students, period_start=period_start, period_end=period_end)
(teacher_data, _) = _get_user_usage_data(teachers, period_start=period_start, period_end=period_end)
return {
"org": org,
"zone": zone,
"facility": facility,
"groups": group_data,
"students": student_data,
"teachers": teacher_data,
"date_range": [period_start, period_end] if frequency else [None, None],
}
def post(self, request):
msg = '<div data-alert class="alert-box %s">%s<a href="#" data-dismiss="alert" class="close">×</a></div>'
project_id = request.POST.get('project_id')
profile_id = request.POST.get('profile_id')
try:
project_id = int(project_id)
except:
self.errors.append(u'Id проекта должно быть числом')
project_id = None
try:
profile_id = int(profile_id)
except:
self.errors.append(u'Id профиля должно быть числом')
profile_id = None
if not project_id and not profile_id:
return HttpResponse(json.dumps(self.response_data))
project = get_object_or_None(UserProject, pk=project_id)
profile = get_object_or_None(UserProfile, pk=profile_id)
if profile and profile.in_team:
self.messages = msg % ('alert', 'Вы уже записаны в команду.')
elif project and profile:
project.members.add(profile)
self.success = True
self.messages = msg % ('success', 'Вы успешно записаны в команду')
else:
self.messages = msg % ('alert', 'Команда не найдена')
#some_signal.send(sender=MyAJAXView, instance=self)
return HttpResponse(json.dumps(self.response_data))
def return_job (request):
print "okay"
if request.method == 'POST':
session_key = request.POST['session_key'] if 'session_key' in request.POST else None
session = get_object_or_None(Session, session_key = session_key)
eval = get_object_or_None(Eval, id=session.get_decoded()['eval_id'])
if eval is not None:
try:
job = Job.objects.filter(processing = False, percent_completed = 0).order_by('id')[0]
job.processing = True
job.percent_completed = 0
job.message = "Processing..."
job.save()
message = "Okay", 0
except:
job = None
message = "Job doesn't exist, try again, later", 1
else:
message = 'Wrong query', 2
job = None
else:
message = 'Wrong query', 2
job = None
return render_to_response('api/return_job.xml',
{'job' : job,
'message' : message,
'updated' : eval.updated if eval is not None else False,
},
context_instance = RequestContext(request)
)
def get_your_score (request):
user = user_auth(request)
problem_id = request.GET['problem_id'] if 'problem_id' in request.GET and request.GET['problem_id'] != '' else None
contest_id = request.GET['contest_id'] if 'contest_id' in request.GET and request.GET['contest_id'] != '' else None
score_only = True if 'score_only' in request.GET else False
if problem_id is None or contest_id is None or user is None:
result = 'N/A'
else:
problem = get_object_or_None(Problem, id = problem_id)
contest = get_object_or_None(Contest, id = contest_id)
if problem is None or contest is None:
result = 'N/A'
elif contest.ended is False and contest.with_open_eval is False:
result = 'N/A'
else:
jobs = Job.objects.filter(user = user, problem = problem, contest = contest).order_by('-id')
if jobs:
result = str(jobs[0].score) if score_only else "%d points" % jobs[0].score
else:
result = 'N/A'
if result == 'N/A':
result = '<span style="font-size: 0.8em; color: #808080;">N/A</span>'
return HttpResponse(result)
def test_merge(self):
self.g1.add_unit([(self.u, 12)])
self.g1.add_unit([(self.u2, 1)])
self.g1.add_unit([(self.u3, 2)])
self.g2.add_unit([(self.u, 100)])
self.g2.add_unit([(self.u2, 5)])
self.g2.add_unit([(self.u4, 5)])
self.g1.merge(self.g2)
self.assertTrue(get_object_or_None(
UnitStack,
group=self.g1,
unit_type=self.u
).number == 112)
self.assertTrue(get_object_or_None(
UnitStack,
group=self.g1,
unit_type=self.u2
).number == 6)
self.assertTrue(get_object_or_None(
UnitStack,
group=self.g1,
unit_type=self.u3
).number == 2)
self.assertTrue(get_object_or_None(
UnitStack,
group=self.g1,
unit_type=self.u4
).number == 5)
def registration_complete(request, username, token):
"""
Validates the token used in activating a user
**Context**
``RequestContext``
``accounts``
An instance of :model:`accounts.RegistrationToken`
``user``
An instance of :model:`auth.user`
***Template:***
:template:`accounts/registration_complete.html`
"""
context = {}
new_user = get_object_or_None(User, username=username)
check_token = get_object_or_None(RegistrationToken, user=new_user, token=token)
success = False
if check_token and new_user:
new_user.is_active = True
new_user.save()
# delete all tokens after activation
RegistrationToken.objects.filter(user=new_user).delete()
success = True
context["success"] = success
return render_to_response("accounts/registration_complete.html", context, RequestContext(request))
def like_photo(request):
data = {
'status': 0
}
# TODO: Check if like already exists
if request.user.is_authenticated() and request.method == 'POST':
post_data = request.POST
photo = get_object_or_None(Photo, pk=post_data['photo_id'])
check_like = get_object_or_None(Like,
owner=request.user.member,
photo=photo
)
if check_like is None:
like = Like(
owner=request.user.member,
photo=photo,
)
like.save()
data['status'] = 1
data = json.dumps(data)
return HttpResponse(data, content_type='application/json')
def get_populations(answers): populations = [] sex = get_gender(answers) if sex: populations.append(sex) if sex and 'sex_partners' in answers and answers['sex_partners']: pop = determine_sexual_orientation(sex,answers['sex_partners']) if pop: populations.append(pop) for key in answers: question = False try: question_id = int(key) question = get_object_or_None(Question,id=question_id) except ValueError: pass if question: answer_id_list = answers[question_id] if type(answer_id_list) != type([]): answer_id_list = [answer_id_list] for answer_id in answer_id_list: answer = get_object_or_None(Answer,id=answer_id) if answer: for population in answer.populations.all(): if population not in populations and not population_is_sex(population): populations.append(population) return populations
def result_received_processor(sender, **kwargs):
from apps.orders.models import Order, OrderStatusChoices, Ticket, TicketStatus
if settings.INTELLECTMONEY_DEBUG == u'TST':
print 'signal works'
print sender
print kwargs
order = get_object_or_None(Order,
pk=sender.orderId,
)
else:
order = get_object_or_None(Order,
pk=sender.orderId,
status__exact=OrderStatusChoices.PAYMENT_PROCESS,
reserved_til__gte=datetime.now(),
)
if order:
paid_sum = kwargs['recipientAmount']
if paid_sum != order.total_plus_fee:
raise ValueError()
order.confirm()
order.save()
order.make_tickets()
order_finished.send(sender=order, order=order)
def handle(self, *args, **options):
upholstery = ProductType.objects.filter(title__in=('sofas', 'loveseats', 'accent chairs', 'sofa chairs', 'daybeds', 'living room sets', 'ottomans', 'recliners', 'sectionals', 'sofa chaises'))
vendors = Vendor.objects.filter(title__in=('Ashley', 'United', 'Jonathan Louis', 'Istikbal'))
mattresses = ProductType.objects.filter(title__in=('mattresses', 'box springs'))
for vendor in Vendor.objects.exclude(title="Guardsman"):
for product in Product.objects.filter(vendor=vendor):
skus = product.sku.strip("'")
skus = skus.split('+')
cost_price = Decimal('0.00')
all_accounted = True
for idx, sku in enumerate(skus):
sku = sku.split('*')
# @ before *
if '@' in sku[0]:
ss = sku[0].split('@')
vp = get_object_or_None(VendorProduct, vendor__title=ss[1], sku=ss[0])
else:
vp = get_object_or_None(VendorProduct, vendor=vendor, sku=sku[0])
try:
qty = sku[1]
except:
qty = '1'
if vp:
cost_price += vp.price * Decimal(qty)
if idx == 0:
product.upc = vp.upc
for tt in GOOGLE_CATEGORIES:
if product.product_type.title == tt[0]:
product.google_category = tt[1]
else:
all_accounted = False
if all_accounted:
product.cost_price = cost_price
if product.product_type in upholstery and product.vendor in vendors:
retail_price = cost_price * Decimal('3.57')
else:
retail_price = cost_price * Decimal('3.25')
if product.product_type in mattresses:
sale_price = retail_price * Decimal('0.5')
else:
sale_price = retail_price * Decimal('0.7')
retail_price = math.ceil(retail_price / 10) * 10 - 0.01
sale_price = math.ceil(sale_price / 10) * 10 - 0.01
# if sale_price <= 200:
# sale_price = math.ceil(sale_price) - 0.01
# else:
# if sale_price % 100 < 50:
# sale_price = math.floor(sale_price / 100) * 100 + 49.99
# else:
# sale_price = math.ceil(sale_price / 100) * 100 - 0.01
product.retail_price = retail_price
product.sale_price = sale_price
product.save()
print '%s updated' % product.sku
else:
print '%s skipped' % product.sku
print 'Price Matched'
def get_revision(self):
"""Get the revision to compare the imported data to.
Four different cases:
- if we are creating a new document, we have nothing to compare to
- if we are modifying an existing revision, get this revision
- if we are creating a new revision and the previous revisions exists,
get this previous revision.
- if we are creating a new revision and the previous revision will
also be created, get the corresponding trs line.
"""
trs_revision = self.object
document = trs_revision.document
metadata = getattr(document, 'metadata', None)
latest_revision = getattr(document, 'current_revision', 0)
# No existing document, document + revision creation
if document is None and trs_revision.revision == 0:
revision = trs_revision
# No existing document, but the previous revision will be created
# before this one
elif document is None and trs_revision.revision > 0:
qs = TrsRevision.objects \
.filter(transmittal=trs_revision.transmittal) \
.filter(document_key=trs_revision.document_key) \
.filter(revision=trs_revision.revision - 1)
revision = get_object_or_None(qs)
# existing revision
elif trs_revision.revision <= latest_revision:
revision = FieldWrapper((
metadata,
metadata.get_revision(trs_revision.revision)))
# next revision creation
elif trs_revision.revision == latest_revision + 1:
revision = FieldWrapper((
metadata,
metadata.latest_revision))
# previous revision will also be created
else:
qs = TrsRevision.objects \
.filter(transmittal=trs_revision.transmittal) \
.filter(document_key=trs_revision.document_key) \
.filter(revision=trs_revision.revision - 1)
revision = get_object_or_None(qs)
if revision is None:
logger.error('No revision to compare to {} / {} / {}'.format(
trs_revision.transmittal.document_key,
trs_revision.document_key,
trs_revision.revision))
revision = {}
return revision
def save_goalmeasurables(request, user_id, session_id):
if request.method == 'POST':
data = request.POST.dict()
user = get_object_or_404(models.UserInfo, pk=user_id)
if session_id is not None:
session = utils.session_for_id(user, session_id)
else:
session_date = datetime.strptime(data.pop('session_date'), '%Y/%m/%d')
session_status = int(data.pop('session_status'))
session_note = data.pop('session_note')
session = utils.session_for_date(user, session_date)
if session is None:
session = models.Session(user=user, date=session_date, status=session_status, note=session_note)
session.save()
print("Created session for user: {}".format(user.id))
else:
print("Using session {} for user: {}".format(session.id, user.id))
custom_gm = defaultdict(dict)
try:
for measurable_id, measurable_value in data.iteritems():
if measurable_id.lower() in ['save', 'csrfmiddlewaretoken', 'submit', 'redirect', 'session']:
continue
elif 'goalsnotes' in measurable_id.lower():
domain_prefix = measurable_id.lower().split('_')[0]
domain = get_object_or_404(models.Domains, name=prefix_to_domain(domain_prefix))
notes = get_object_or_None(models.UserGoalNoteMeasurable, session=session, domain=domain)
if not notes:
notes = models.UserGoalNoteMeasurable(session=session, domain=domain, note=measurable_value)
else:
notes.note = measurable_value
notes.save()
elif 'custom' in measurable_id.lower():
customtag, goal = measurable_id.lower().split('_')
tag = 'text' if 'text' in customtag else 'value'
custom_gm[goal][tag] = measurable_value
else:
measurable = models.GoalsMeasurables.objects.get(pk=measurable_id)
user_measurable = models.UserGoalMeasurables(session=session, goal_measurable=measurable, value=measurable_value)
user_measurable.save()
for goal_id, measurable in custom_gm.iteritems():
if 'text' in measurable and measurable['text'] != '':
goal = get_object_or_None(models.Goals, pk=goal_id)
if not goal:
return HttpResponse(404)
gm = models.GoalsMeasurables(goal=goal, name=measurable['text'], enabled=1, is_custom=1, user=user)
gm.save()
user_measurable = models.UserGoalMeasurables(session=session, goal_measurable=gm, value=measurable['value'])
user_measurable.save()
red = data.get('redirect')
if red:
return redirect(reverse('musictherapy:user_detail', kwargs={'user_id': int(user_id)}) + "?tab={}".format(red[:3]))
return HttpResponse(200)
except Exception as e:
print(e)
return HttpResponse(404)
def play(request):
user = request.user
player = get_object_or_None(Player, user=user)
if player is None:
return redirect("player:new")
context = {
"user": player.user,
"player": player,
}
if player.status == 'C': #Combat
mob = get_object_or_None(Mob, player=player, current_health__gt=0)
template = "game/combat.html"
context["mob"] = mob
elif player.status == 'E': #Event
event_log = get_object_or_None(EventLog, player=player, resolved=False)
#Player is in an Event
template = "game/event.html"
context["event"] = event_log.game_event
elif player.status == 'L': #Location
template = "game/location.html"
context["location"] = player.location
elif player.status == 'R': #Route
#Player is traveling on route
template = "game/route.html"
context["route"] = player.route
context["remaining_miles"] = player.route.distance - player.distance_marker
event_chance = random.randint(1, 100)
if event_chance < player.route.event_chance:
combat_chance = random.randint(1, 100)
if combat_chance < player.route.combat_chance:
mob = random_encounter(player)
player.status = 'C'
player.save()
template = "game/combat.html"
context["mob"] = mob
else:
event = generate_event(player)
player.status = 'E'
player.save()
template = "game/event.html"
context["event"] = event
context["game_messages"] = get_game_messages(player)
return TemplateResponse(request, template, RequestContext(request, context))
def inquire(request, player, service_item_id):
service_item = get_object_or_None(ServiceItemType, pk=service_item_id)
player_npc = get_object_or_None(PlayerNPC, player=player, npc=service_item.service.npc)
result = 'The merchant says "It is a {0}".'.format(service_item.item_type.description)
update_merchant_mood(player_npc)
create_game_message(player, result)
return redirect("game:service:display_service", service_item.service.pk)
def travel(request, route_id):
user = request.user
player = get_object_or_None(Player, user=user)
player.route = get_object_or_None(Route, pk=route_id)
player.distance_marker = 0
player.status = 'R'
player.save()
return redirect("game:play")
def handle(self, *args, **options):
src = get_object_or_None(ForumEvent, id=int(args[0]))
dst = get_object_or_None(ForumEvent, id=int(args[1]))
dst.event_contents.add(
ForumEventContent(name=src.name, language=src.language, place=src.place, moderators=src.moderators, cms_page=src.cms_page),
ForumEventContent(name=dst.name, language=dst.language, place=dst.place, moderators=dst.moderators, cms_page=dst.cms_page),
)
for claim in src.registered.all():
dst.registered.add(claim)
src.delete()
def blog_post(request, username_or_custom_slug):
snipt = get_object_or_404(Snipt, user=request.blog_user,
blog_post=True,
public=True,
publish_date__lte=datetime.datetime.now(),
slug=username_or_custom_slug)
snipts = Snipt.objects.filter(user=request.blog_user,
blog_post=True,
public=True,
publish_date__lte=datetime.datetime.now()) \
.order_by('-publish_date') \
.exclude(title__iexact='Homepage') \
.exclude(title__iexact='Work')
sidebar = get_object_or_None(Snipt, user=request.blog_user,
title='Sidebar', blog_post=True)
header = get_object_or_None(Snipt, user=request.blog_user, title='Header',
blog_post=True)
custom_css = get_object_or_None(Snipt, user=request.blog_user, title='CSS',
lexer='css', blog_post=True)
normal_snipts = Snipt.objects.filter(blog_post=False,
user=request.blog_user,
public=True).order_by('-created')
normal_snipts = normal_snipts.exclude(title__in=[''])
normal_snipts = normal_snipts.exclude(tags__name__in=['tmp'])
normal_snipts = normal_snipts[:3]
if snipt.user != request.user:
snipt.views = snipt.views + 1
snipt.save()
context = {
'blog_user': request.blog_user,
'custom_css': custom_css,
'detail': True,
'has_snipts': True,
'header': header,
'normal_snipts': normal_snipts,
'public': True,
'sidebar': sidebar,
'snipt': snipt,
'snipts': snipts,
}
template = THEME_CHOICES[request.blog_user.profile.blog_theme]
template = '{}/post.html'.format(template)
return render_to_response(template,
context,
context_instance=RequestContext(request))
def blog_list(request, username_or_custom_slug=None):
if username_or_custom_slug:
return blog_post(request, username_or_custom_slug)
snipts = (
Snipt.objects.filter(
user=request.blog_user,
blog_post=True,
public=True,
publish_date__lte=datetime.datetime.now(),
)
.order_by("-publish_date")
.exclude(title__iexact="Homepage")
.exclude(title__iexact="Work")
)
normal_snipts = Snipt.objects.filter(
blog_post=False, user=request.blog_user, public=True
).order_by("-created")
normal_snipts = normal_snipts.exclude(title__in=[""])
normal_snipts = normal_snipts.exclude(tags__name__in=["tmp"])
normal_snipts = normal_snipts[:3]
sidebar = get_object_or_None(
Snipt, user=request.blog_user, title="Sidebar", blog_post=True
)
header = get_object_or_None(
Snipt, user=request.blog_user, title="Header", blog_post=True
)
custom_css = get_object_or_None(
Snipt, user=request.blog_user, title="CSS", lexer="css", blog_post=True
)
context = {
"blog_user": request.blog_user,
"custom_css": custom_css,
"has_snipts": True,
"header": header,
"normal_snipts": normal_snipts,
"public": True,
"sidebar": sidebar,
"snipts": snipts,
}
if "rss" in request.GET:
context["snipts"] = context["snipts"][:20]
return rss(request, context)
template = THEME_CHOICES[request.blog_user.profile.blog_theme]
template = "{}/list.html".format(template)
return render(request, template, context)
def post(self, request, format=None):
if 'country' in request.data:
countryObj = get_object_or_None(Country, name=request.data['country'], code=request.data['country_code'])
country_serializer = CountrySerializer(countryObj, data={'name': request.data['country'], 'code': request.data['country_code']})
if country_serializer.is_valid():
country = country_serializer.save()
else:
return Response(country_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
if 'state' in request.data:
if len(request.data['state_code']) <= 3:
state_code = request.data['state_code']
else:
state_code = request.data['state_code'][0:2]
stateObj = get_object_or_None(State, name=request.data['state'], code=state_code, country=country.id)
state_serializer = StateSerializer(stateObj, data={'name': request.data['state'], 'code': state_code, 'country': country.id})
if state_serializer.is_valid():
state = state_serializer.save()
else:
return Response(state_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
locality = None
if 'locality' in request.data and 'postal_code' in request.data:
localityObj = get_object_or_None(Locality, name=request.data['locality'], postal_code=request.data['postal_code'], state=state.id)
locality_serializer = LocalitySerializer(localityObj, data={'name': request.data['locality'], 'postal_code': request.data['postal_code'], 'state': state.id})
if locality_serializer.is_valid():
locality = locality_serializer.save()
else:
return Response(locality_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
lid = locality.id if locality else None
# @todo if `latitude`, `longitude`, `raw` and `formatted` don't exist in
# the payload, this throws an exception instead of returning a 400.
addressObj = get_object_or_None(Address, latitude=request.data['latitude'], longitude=request.data['longitude'], raw=request.data['formatted'])
address_serializer = AddressSerializer(addressObj, data={
'raw': request.data['raw'],
'latitude': request.data['latitude'],
'longitude': request.data['longitude'],
'locality': lid
})
if addressObj is None:
stat = status.HTTP_201_CREATED
else:
stat = status.HTTP_200_OK
if address_serializer.is_valid():
address_serializer.save()
return Response(address_serializer.data, status=stat)
else:
return Response(address_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_context_data(self, **kwargs):
data = super(Rubrics, self).get_context_data(**kwargs)
data["content_type"] = self.content_type
data["object"] = self.object
data["enable_alignment_scores"] = self.enable_alignment_scores
if isinstance(self.object, (Course, Library, CommunityItem)):
data["toolbar_view_url"] = reverse(
"materials:%s:toolbar_view_item" % self.object.namespace, kwargs=dict(slug=self.object.slug)
)
evaluation = Evaluation.objects.get_or_create(
content_type=self.content_type, object_id=self.object.id, user=self.request.user
)[0]
evaluation.ip = self.request.META["REMOTE_ADDR"]
evaluation.hostname = self.request.COOKIES.get(HOSTNAME_COOKIE, u"")
evaluation.save()
if self.enable_alignment_scores:
tags = AlignmentTag.objects.filter(
id__in=self.object.alignment_tags.values_list("tag__id", flat=True).distinct()
)
data["alignment_tags"] = []
for tag in tags:
score = get_object_or_None(StandardAlignmentScore, evaluation=evaluation, alignment_tag=tag)
if score:
tag.score_value = score.score
tag.scored = True
tag.comment = score.comment
else:
tag.score_value = None
tag.scored = False
tag.comment = u""
data["alignment_tags"].append(tag)
data["alignment_scored"] = data["alignment_tags"] and all(
map(lambda x: x.score_value, data["alignment_tags"])
)
data["alignment_score_values"] = StandardAlignmentScoreValue.objects.all()
data["rubrics"] = []
for rubric in Rubric.objects.all():
score = get_object_or_None(RubricScore, evaluation=evaluation, rubric=rubric)
if score:
rubric.score_value = score.score
rubric.scored = True
rubric.comment = score.comment
else:
rubric.score_value = None
rubric.scored = False
rubric.comment = u""
data["rubrics"].append(rubric)
return data
def post(self, request, *args, **kwargs):
result = dict(status="error")
try:
id = int(request.POST["id"])
except (KeyError, ValueError, TypeError):
return result
evaluation = get_object_or_None(Evaluation, id=id)
if not evaluation:
return result
data = []
for rubric in Rubric.objects.all():
# noinspection PyTypeChecker
k = "r%i" % (rubric.id + 1)
if k in request.POST:
value = request.POST[k].strip() or None
if value is not None:
try:
value = int(value)
except (TypeError, ValueError):
continue
value = get_object_or_None(RubricScoreValue, rubric=rubric, value=value)
if not value:
continue
data.append((rubric, value))
if not data:
return result
object = evaluation.content_object
for rubric, value in data:
score = get_object_or_None(RubricScore, evaluation=evaluation, rubric=rubric)
if score:
score.score = value
score.save()
else:
RubricScore.objects.create(evaluation=evaluation, rubric=rubric, score=value)
if isinstance(object, Indexed):
object.reindex()
result["status"] = "success"
return result
def get_facility_from_request(request):
if "facility" in request.GET:
facility = get_object_or_None(Facility, pk=request.GET["facility"])
if "set_default" in request.GET and request.is_admin and facility:
Settings.set("default_facility", facility.id)
elif "facility_user" in request.session:
facility = request.session["facility_user"].facility
elif Facility.objects.count() == 1:
facility = Facility.objects.all()[0]
else:
facility = get_object_or_None(Facility, pk=Settings.get("default_facility"))
return facility
def device_management(request, device_id, org_id=None, zone_id=None):
org = get_object_or_None(Organization, pk=org_id) if org_id else None
zone = get_object_or_None(Zone, pk=zone_id) if zone_id else None
device = get_object_or_404(Device, pk=device_id)
sync_sessions = SyncSession.objects.filter(client_device=device).order_by("-timestamp")
return {
"org": org,
"zone": zone,
"device": device,
"sync_sessions": sync_sessions,
}
def get_occurrence(request, *args, **kwargs):
from schedule.models import Occurrence
occurrence = None
if 'occurrence_id' in kwargs:
occurrence = get_object_or_None(Occurrence,
id=kwargs['occurrence_id'])
elif request.GET:
occurrence = get_object_or_None(Occurrence,
id=request.GET.get('occurrence_id', None))
elif request.POST:
occurrence = get_object_or_None(Occurrence,
id=request.POST.get('occurrence_id', None))
return occurrence
def clean_username_or_email(self):
username_or_email = self.cleaned_data.get("username_or_email")
user = get_object_or_None(User, username=username_or_email) or get_object_or_None(User, email=username_or_email)
# check, if account is already activated
if user and user.is_active:
raise forms.ValidationError("Account is already activated")
# check, if old activation link is used
if user and not get_object_or_None(UserActivation, user=user):
raise forms.ValidationError("Activation link is incorrect")
return super(ResendActivationMailForm, self).clean_username_or_email()
def clean(self):
super(MeteredFeatureUnitsLog, self).clean()
if self.subscription.state in [Subscription.STATES.ENDED,
Subscription.STATES.INACTIVE]:
if not self.id:
action_type = "create"
else:
action_type = "change"
err_msg = 'You cannot %s a metered feature units log belonging to '\
'an %s subscription.' % (action_type,
self.subscription.state)
raise ValidationError(err_msg)
if not self.id:
start_datetime = self.subscription.bucket_start_datetime()
end_datetime = self.subscription.bucket_end_datetime()
if get_object_or_None(MeteredFeatureUnitsLog, start_datetime=start_datetime,
end_datetime=end_datetime,
metered_feature=self.metered_feature,
subscription=self.subscription):
err_msg = 'A %s units log for the current date already exists.'\
' You can edit that one.' % self.metered_feature
raise ValidationError(err_msg)
def managed_tag_sync_paired_group_memebership_creation(sender, instance,
created, **kwargs):
""" If a managed tag has a paired group and has been assigned (and approved) to a user profile,
create the user's group membership in the paired group if it doesn't exist yet """
try:
target_object = instance.target_object
if instance.approved and target_object and isinstance(
target_object, get_user_profile_model()):
tag = instance.managed_tag
if tag.paired_group:
membership = get_object_or_None(CosinnusGroupMembership,
group=tag.paired_group,
user=target_object.user)
if membership and not membership.status in MEMBER_STATUS:
membership.status = MEMBERSHIP_MEMBER
membership.save()
elif not membership:
CosinnusGroupMembership.objects.create(
group=tag.paired_group,
user=target_object.user,
status=MEMBERSHIP_MEMBER)
except Exception as e:
logger.exception(e)
def search(request):
'''returns search results by user
'''
query = request.GET.get('q', '')
followlist = []
results = User.objects.filter(username__contains=query)
# Check follow status on a result
if request.user.is_authenticated():
for user in results:
queryset = Follow.objects.filter(follower__pk=request.user.id,
following__pk=user.pk)
follow_status = get_object_or_None(queryset)
if follow_status is not None:
followlist.append(user.id)
return render(request, 'boardapp/search.html', {
'results': results,
'followlist': followlist
})
def post(self, request, *args, **kwargs):
if not self.model:
raise ImproperlyConfigured('No model class is set for the pseudo-abstract view DeleteElementView.')
element_ids = request.POST.getlist('element_ids[]', [])
if not (element_ids or self.group):
return HttpResponseBadRequest('Missing POST fields for this request.')
successful_ids = []
for element_id in element_ids:
element = get_object_or_None(self.model, id=element_id, group=self.group)
# check write permission on element
if not check_object_write_access(element, request.user):
continue
if self.delete_element(element):
successful_ids.append(element_id)
data = {
'had_errors': len(successful_ids) != len(element_ids),
'successful_ids': successful_ids,
}
return JsonResponse(data)
def dispatch(self, request, *args, **kwargs):
if not self.request.user.is_authenticated:
return super(PaymentView, self).dispatch(request, *args, **kwargs)
allow_active_subscription = kwargs.get('allow_active_subscription',
False)
if not allow_active_subscription:
active_subscription = Subscription.get_active_for_user(
self.request.user)
if active_subscription:
return redirect('wechange-payments:my-subscription')
else:
kwargs.pop('allow_active_subscription')
processing_payment = get_object_or_None(
Payment,
user=request.user,
status=Payment.STATUS_COMPLETED_BUT_UNCONFIRMED)
if processing_payment:
return redirect(
reverse('wechange-payments:payment-process',
kwargs={'pk': processing_payment.pk}))
return super(PaymentView, self).dispatch(request, *args, **kwargs)
def apply_group_invite_token_for_user(group_invite_token, user):
""" Applies a `CosinnusGroupInviteToken` for a user, making them a member (if not already) of all groups
determined by the invite token object.
@return: True if the user became member of all the groups, False if there was an error """
success = True
with transaction.atomic():
for group in group_invite_token.invite_groups.all():
try:
membership = get_object_or_None(CosinnusGroupMembership, group=group, user=user)
if membership and membership.status not in MEMBER_STATUS:
# if the user had a pending invite, convert them to member
membership.status = MEMBERSHIP_MEMBER
membership.save()
elif not membership:
# make user a member of the group if they hadn't been before
CosinnusGroupMembership.objects.create(group=group, user=user, status=MEMBERSHIP_MEMBER)
# else the user is already in the group
except Exception as e:
logger.error('Error when trying to apply a token group invite',
extra={'exception': force_text(e), 'user': user, 'group': group, 'token': group_invite_token.token})
success = False
return success
def display_ticket(request, ticket_id):
ticket = get_object_or_404(Ticket, id=ticket_id)
user = user_auth(request)
if request.method == 'POST' and user is not None:
form = TicketCommentForm(request.POST)
if form.is_valid():
if 'comment_id' in request.POST:
if request.POST['comment_id'] != "":
comment = get_object_or_None(TicketComment,
id=request.POST['comment_id'])
if comment is None or comment.autogenerated or (
user.is_staff is False and user != comment.author
) or comment.can_be_edited() is False:
return redirect_to_index(
"You can't edit this comment.")
form = TicketCommentForm(request.POST, instance=comment)
if form.is_valid():
form.save()
else:
comment = form.save(commit=False)
comment.ticket, comment.author, comment.date_posted = ticket, user, datetime.datetime.now(
)
comment.save()
else:
form = TicketCommentForm()
else:
form = TicketCommentForm()
return {
'ticket': ticket,
'form': form,
'navigation': {
'main': 'judge',
'other': 'display-ticket',
}
}
def remote_water_quality_monitoring_network_task():
log('Running Remote Water Quality Monitoring Network Parser', 'info')
crawler = remote_water_quality_monitoring_network()
for node in crawler.get():
station = get_object_or_None(models.node, name=node['station'])
if not station:
station = models.node()
station.name = node['station']
station.sourcetype = 'live'
station.devicealias = node['station'].replace(' ', '_').lower()
station.save()
log(
'Station: %s (%s) created' %
(station.name, station.devicealias), 'info')
# insert sensor data
for sensor_type, unit in _SENSOR_UNITS.iteritems():
if sensor_type in ['orp']:
continue
data = models.data()
data.source = station.sourcetype
data.node_name = station.name
data.node_alias = station.devicealias
data.sensor_type = sensor_type
data.sensor_units = unit
data.lat = station.lat
data.long = station.long
if node[sensor_type]:
data.value = round(float(node[sensor_type]), 2)
else:
data.value = 0.0
data.save()
log('Station: %s data updated' % (station.name), 'info')
log('Done', 'success')
def challenge_access_check_required(request, challenge_id):
"""Restrict Access to the Challenge Details."""
print colored("***" * 27, "green")
print colored("*** INSIDE `%s`" % inspect.stack()[0][3], "green")
# -------------------------------------------------------------------------
# --- Retrieve the Challenge with the Organization Privacy Settings:
# 1. Organization is not set;
# 2. Organization is set to Public;
# 3. Organization is set to Private, and:
# a) User is the Organization Staff Member (and/or Author);
# b) User is the Organization Group Member.
# -------------------------------------------------------------------------
challenge = get_object_or_None(
Challenge,
Q(organization=None) |
Q(organization__is_hidden=False) |
Q(
Q(organization__pk__in=OrganizationStaff
.objects.filter(
member=request.user,
).values_list(
"organization_id", flat=True
)) |
Q(organization__pk__in=request.user
.organization_group_members.all().values_list(
"organization_id", flat=True
)),
organization__is_hidden=True,
),
id=challenge_id,
)
if not challenge:
return False
return True
def logout(request):
print "Logout"
try:
datos = json.loads(request.POST['data'])
if comprobar_usuario(datos):
userdjango = get_userdjango_by_token(datos)
user_token = get_object_or_None(Tokenregister, user=userdjango)
if user_token is None:
response_data = {
'result': 'ok',
'message': 'Usuario ya deslogueado'
}
else:
user_token.delete()
response_data = {
'result': 'ok',
'message': 'Usuario ya deslogueado'
}
else:
response_data = {
'result': 'error',
'message': 'Usuario no logueado'
}
return http.HttpResponse(json.dumps(response_data),
content_type="application/json")
except Exception as e:
response_data = {
'errorcode': 'U0002',
'result': 'error',
'message': str(e)
}
return http.HttpResponse(json.dumps(response_data),
content_type="application/json")
def post(self, request, *args, **kwargs):
job = get_object_or_404(Job, random_string=kwargs['job_random_string'])
sender_jobuser = get_object_or_404(JobUser, user=request.user, job=job)
form = self.form(data=request.POST, job=job)
if (form.is_valid()):
receiver = get_object_or_404(User,
username=form.cleaned_data['pay_to'])
receiver_jobuser = get_object_or_404(JobUser,
user=receiver,
job=job)
amount = float(form.cleaned_data['amount'])
sender_jobuser = get_object_or_None(JobUser,
user=request.user,
job=job)
self.pay(request, amount=amount, receiver=receiver)
pay = StripePay.create(jobuser=sender_jobuser,
receiver=receiver_jobuser,
amount=amount)
pay.save()
comment = form.cleaned_data['comment']
if (comment):
update = Update.create(jobuser=sender_jobuser, comment=comment)
update.save()
sender_jobuser.paid = sender_jobuser.paid + amount
sender_jobuser.save()
receiver_jobuser.received = receiver_jobuser.received + amount
receiver_jobuser.save()
job.paid = job.paid + amount
#if (job.get_is_finished()):
# job.set_is_finished(True);
job.save()
return redirect('job:detail', job_random_string=job.random_string)
else:
return render(
request, self.template_name,
self.get_context_data(sender_jobuser=sender_jobuser,
form=form))
def test_submit_6_mo_ultimate_when_user_already_has_it(self):
user = User.objects.create_user('test', '*****@*****.**', 'password')
premium = Generators.premium_subscription(user, 'AstroBin Premium')
premium.expires = datetime(2020, 2, 16)
premium.save()
ultimate = Generators.premium_subscription(user, 'AstroBin Ultimate 2020+')
ultimate.expires = date(2021, 3, 28)
ultimate.save()
self.client.login(username='******', password='******')
response = self.client.post(
reverse('astrobin_apps_premium.data_loss_compensation_request'),
{
'requested_compensation': '6_MO_ULTIMATE'
})
self.assertRedirects(
response,
reverse('astrobin_apps_premium.data_loss_compensation_request_success'),
status_code=302,
target_status_code=200)
compensation_request = DataLossCompensationRequest.objects.get(user=user)
self.assertEquals(compensation_request.requested_compensation, '6_MO_ULTIMATE')
ultimate = get_object_or_None(UserSubscription, user=user, subscription__name='AstroBin Ultimate 2020+')
self.assertIsNotNone(ultimate)
self.assertTrue(ultimate.active)
self.assertTrue(ultimate.cancelled)
self.assertTrue(ultimate.expires > date(2021, 3, 28) + timedelta(days=179))
self.assertTrue(ultimate.expires < date(2021, 3, 28) + timedelta(days=181))
self.assertTrue(is_ultimate_2020(user))
def send_shopper_txconfirmed_email(self, force_resend=False):
BODY_TEMPLATE = 'shopper/cashout_txconfirmed.html'
if get_object_or_None(SentEmail,
btc_transaction=self,
body_template=BODY_TEMPLATE):
if not force_resend:
# Protection against double-sending
return
shopper = self.get_shopper()
if shopper and shopper.email:
merchant = self.get_merchant()
satoshis_formatted = self.format_satoshis_amount()
body_context = {
'salutation': shopper.name,
'satoshis_formatted': satoshis_formatted,
'merchant_name': merchant.business_name,
'exchange_rate_formatted': self.get_exchange_rate_formatted(),
'fiat_amount_formatted': self.get_fiat_amount_formatted(),
'tx_hash': self.txn_hash,
# Verbose, but needed for future internationalizing of templates:
'confirmed_via_blocks': bool(self.met_minimum_confirmation_at),
'confirmed_via_confidence':
bool(self.met_confidence_threshold_at),
'confirmed_via_merchant':
bool(self.min_confirmations_overrode_at),
}
return send_and_log(
subject='%s Confirmed' % satoshis_formatted,
body_template=BODY_TEMPLATE,
to_merchant=None,
to_email=shopper.email,
to_name=shopper.name,
body_context=body_context,
btc_transaction=self,
)
def parse_types(self, response):
# try get all specifications urls and names
try:
types_urls = response.css(
'section.models > div.col-4 > a::attr(href)').extract()
types_names = response.css(
'section.models > div.col-4 > a::attr(title)').extract()
except AttributeError:
# resend request if bad response
logging.error("AttributeError: requesting same url again")
request = scrapy.Request(response.url,
callback=self.parse_types,
dont_filter=True)
request.meta['model_item'] = response.meta['model_item']
yield request
else:
for i in range(0, len(types_urls)):
# parse car types
request = scrapy.Request(types_urls[i],
callback=self.parse_cars,
dont_filter=True)
# if type exist - don't create it
type_django_item = get_object_or_None(CarType,
name=types_names[i])
if type_django_item is None:
type_item = CarTypeItem(
name=types_names[i],
car_model=response.meta['model_item'])
request.meta['type_item'] = type_item.save()
else:
request.meta['type_item'] = type_django_item
yield request
def user_profile(request, username=None):
'''display the `logged user's` profile and uploaded photos
Arguments:
request {[type]} -- [description]
Keyword Arguments:
username {[type]} -- [description] (default: {None})
Returns:
[type] -- [description]
'''
upload_prof_pic_form = MemberPhotoForm()
if username is None:
user = request.user
else:
user = User.objects.get(username=username)
dp_obj = get_object_or_None(Member, user__pk=user.id)
if dp_obj is None:
user_dp = False
else:
user_dp = dp_obj
user_photos = Photo.objects.filter(author__pk=user.id)
photos_count = user_photos.count()
print(photos_count)
return render(
request, 'boardapp/profile.html', {
'user': user,
'user_dp': user_dp,
'photos': user_photos,
'count': photos_count,
'dp_form': upload_prof_pic_form
})
def start_video_download(request):
force_job("videodownload", stop=True, locale=request.language)
"""
API endpoint for launching the videodownload job.
"""
youtube_ids = OrderedSet(
simplejson.loads(request.body or "{}").get("youtube_ids", []))
# One query per video (slow)
video_files_to_create = [
id for id in youtube_ids
if not get_object_or_None(VideoFile, youtube_id=id)
]
# OK to do bulk_create; cache invalidation triggered via save download
for lang_code, lang_youtube_ids in divide_videos_by_language(
video_files_to_create).iteritems():
VideoFile.objects.bulk_create([
VideoFile(youtube_id=id,
flagged_for_download=True,
language=lang_code) for id in lang_youtube_ids
])
# OK to update all, since we're not setting all props above.
# One query per chunk
for chunk in break_into_chunks(youtube_ids):
video_files_needing_model_update = VideoFile.objects.filter(
download_in_progress=False,
youtube_id__in=chunk).exclude(percent_complete=100)
video_files_needing_model_update.update(percent_complete=0,
cancel_download=False,
flagged_for_download=True)
force_job("videodownload", _("Download Videos"), locale=request.language)
return JsonResponseMessageSuccess(
_("Launched video download process successfully."))
def print_testmail(request):
""" Displays a HTML email like it would be sent to a user """
if request and not request.user.is_superuser:
return HttpResponseForbidden('Not authenticated')
subject = 'This is a test mail'
content_html = textfield(
"Detailed testmail test content cannot be shown without a forum group."
)
forum_slug = getattr(settings, 'NEWW_FORUM_GROUP_SLUG', None)
if forum_slug:
from cosinnus_notifications.models import NotificationEvent # noqa
from cosinnus_note.models import Note, Comment # noqa
from cosinnus_notifications.notifications import render_digest_item_for_notification_event
forum = get_object_or_None(get_cosinnus_group_model(),
slug=forum_slug,
portal=CosinnusPortal.get_current())
notes = Note.objects.filter(group=forum)
if notes.count() > 0:
note = notes[0]
comment = Comment(creator=request.user,
text="This is a test comment.",
note=note)
notification_event = NotificationEvent()
notification_event._target_object = comment
notification_event.group = forum
notification_event.notification_id = 'note__note_comment_posted_on_any'
notification_event.user = request.user
content_html = render_digest_item_for_notification_event(
notification_event)
html = render_notification_item_html_mail(request.user, subject,
content_html)
return HttpResponse(html)
def organization_staff_member_required(request, organization_id):
"""Restrict the Manipulations with the Organization.
Only for the Organization Staff Members.
"""
print colored("***" * 27, "green")
print colored("*** INSIDE `%s`" % inspect.stack()[0][3], "green")
# -------------------------------------------------------------------------
# --- Retrieve the Organization.
# Only Organization Author, and the Organization (if set)
# Staff Members are allowed to modify the Organization.
organization = get_object_or_None(
Organization,
Q(author=request.user) | Q(pk__in=OrganizationStaff.objects.filter(
member=request.user, ).values_list("organization_id", flat=True)),
id=organization_id,
is_deleted=False,
)
if not organization:
return False
return True
def answer_detail(request, pk):
try:
answer_id = int(pk)
answer = get_object_or_None(Answer, id=answer_id)
except ValueError:
return JSONError(message="Answer ID value is not an Integer",
code=400,
status=status.HTTP_400_BAD_REQUEST)
if answer is None:
return JSONError(message="Answer is not found",
code=404,
status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
answer_serializer = AnswerSerializer(answer)
return JSONResponse(answer_serializer.data)
elif request.method == 'PUT':
answer_data = JSONParser().parse(request)
if ('text' not in answer_data):
return JSONError(message="'text' is not found in request data",
code=400,
status=status.HTTP_400_BAD_REQUEST)
else:
if (not isinstance(answer_data["text"], (str, unicode))):
return JSONError(message="'text' value is not string",
code=400,
status=status.HTTP_400_BAD_REQUEST)
answer_serializer = AnswerSerializer(answer, data=answer_data)
if answer_serializer.is_valid():
answer_serializer.save()
return JSONResponse(answer_serializer.data)
return JSONResponse(answer_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
answer.delete()
return HttpResponse(status=status.HTTP_204_NO_CONTENT)
def teacher_detail_api(self, factory, teacher_user):
# updating mark_list and changing notification so
scheduled_subject = ScheduledSubject(
class_time=ClassTime.objects.last(),
grade_subject=GradeSubject.objects.filter(
teacher__teacher_user=teacher_user).last(),
date=datetime(2017, 11, 11).date())
mark_list = MarkViewSet.as_view({'post': 'update'})
teacher_request = factory.post('api/v0/marks', {
'value':
11,
'student':
scheduled_subject.grade_subject.grade.student_set.last().id,
'date':
scheduled_subject.date,
'grade_subject':
scheduled_subject.grade_subject.id,
'class_time':
scheduled_subject.class_time.id
},
format='json')
force_authenticate(teacher_request, teacher_user,
teacher_user.auth_token)
response = mark_list(teacher_request, pk=Mark.objects.last().id)
response.render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['value'], 11)
notification = get_object_or_None(
RegisterNotification,
receiver_id=scheduled_subject.grade_subject.grade.student_set.last(
).id,
sender=Teacher.objects.get(teacher_user=teacher_user),
date=scheduled_subject.date,
grade_subject_id=scheduled_subject.grade_subject.id,
class_time_id=scheduled_subject.class_time.id)
self.assertEqual(int(notification.value), 11)
def mutate(self, info, *args, **kwargs):
form = SubmitSubmissionForm(kwargs)
if form.is_valid():
values = form.cleaned_data
problem = get_object_or_None(Problem, slug=values['problem_slug'])
attach_info = SubmissionAttachInfo(
cases_count=DataService.get_cases_count(problem.pk))
result = JudgeResultModel(_result=JudgeResult.PD.full)
sub = Submission(code=values.get('code'),
_language=values.get('language'),
user=info.context.user,
problem=problem)
attach_info.save()
result.save()
sub.attach_info = attach_info
sub.result = result
sub.save()
apply_submission.apply_async(
args=(sub.get_judge_field(), ),
queue=settings.JUDGE.get('task_queue'))
problem.ins_submit_times()
return SubmitSubmission(pk=sub.pk)
else:
raise RuntimeError(form.errors.as_json())
def edit_resource(request, id='', *arg, **kwargs):
resource = get_object_or_None(Resource, pk=id)
geojson = create_geojson([resource], convert=False)
if geojson and geojson.get('features'):
geojson['features'][0]['properties']['userCanEdit'] = True
geojson = to_json(geojson)
def on_get(request, form):
form = FormResourceGeoRef(instance=resource)
form.helper.form_action = reverse('edit_resource', kwargs={'id': id})
return form
def on_after_save(request, obj):
versionate(request.user, obj)
return {'redirect': obj.view_url}
return {
'on_get': on_get,
'on_after_save': on_after_save,
'geojson': geojson,
'resource': resource
}
def get(self, request, *args, **kwargs):
game_id = request.GET.get("game")
if not game_id:
return JsonResponse({})
game = get_object_or_None(Game, id=game_id)
if not game:
return JsonResponse({})
game_scores = Score.objects.filter(game=game).order_by("-date_created")
game_scores_list = []
for game_score in game_scores:
game_scores_list.append({
"game":
game.name,
"score":
game_score.score,
"date":
game_score.date_created,
"playerInitials":
game_score.player.initials
})
response = {"data": game_scores_list}
return JsonResponse(response, safe=False)
def create_or_update_line(sender, instance, **kwargs):
""" """
calendar = instance.calendar
if instance.approved:
line, created = Line.objects.get_or_create(current=instance)
line.save()
else:
# if the current instance is denied has a line remove it
line = get_object_or_None(Line, current=instance)
if line:
line.delete()
"""next_event = calendar.get_next_event(in_datetime=instance.show.date.start)
prev_event = calendar.get_prev_event(in_datetime=instance.show.date.start)
if next_event and prev_event:
events = calendar.get_events_in_range(
start = prev_event.show.date.start,
end = next_event.show.date.start,
)
elif next_event:
events = calendar.get_events_in_range(
end = next_event.show.date.start,
)
elif prev_event:
events = calendar.get_events_in_range(
start = prev_event.show.date.start,
)
else:"""
# TODO: rather inificent to rewrite all the events each time. find a better way to do this
events = calendar.events.filter(approved=True)
events = events.order_by('show__date__start')
prev_event = None
for event in events:
update_line(prev_event, calendar, event)
prev_event = event
update_line(prev_event, calendar)
def test_issue_proforma_with_custom_issue_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
url = reverse('proforma-state', kwargs={'pk': proforma.pk})
data = {'state': 'issued', 'issue_date': '2014-01-01'}
response = self.client.put(url, data=json.dumps(data), content_type='application/json')
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date': '2014-01-01',
'due_date': due_date.strftime('%Y-%m-%d'),
'state': 'issued'
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
assert response.data.get('archived_provider', {}) != {}
assert response.data.get('archived_customer', {}) != {}
assert Invoice.objects.count() == 0
proforma = get_object_or_None(Proforma, pk=1)
def get_or_create_session_id(self, user_id):
session_mapping = get_object_or_None(SessionLookup, user_id=user_id)
# if its missing create a new one.
if session_mapping is None:
session_mapping = SessionLookup.objects.create(
user_id=user_id, session_id=generate_session_id())
else:
session = ussd_session(session_mapping.session_id)
# check inactivity or if session has been closed
inactivity_duration = (
datetime.now() -
session.get(ussd_airflow_variables.last_update,
timezone.make_naive(
session_mapping.updated_at))).total_seconds()
if inactivity_duration > self.expiry or \
session.get(ussd_airflow_variables.expiry):
# update session_mapping with the new session_id
session_mapping.session_id = generate_session_id()
session_mapping.save()
return session_mapping.session_id
def send_merchant_txconfirmed_email(self, force_resend=False):
# TODO: allow for notification settings
BODY_TEMPLATE = 'merchant/shopper_cashout.html'
if get_object_or_None(SentEmail,
btc_transaction=self,
body_template=BODY_TEMPLATE):
if not force_resend:
# Protection against double-sending
return
merchant = self.get_merchant()
shopper = self.get_shopper()
satoshis_formatted = self.format_satoshis_amount()
body_context = {
'satoshis_formatted': satoshis_formatted,
'exchange_rate_formatted': self.get_exchange_rate_formatted(),
'fiat_amount_formatted': self.get_fiat_amount_formatted(),
'tx_hash': self.txn_hash,
'coinsafe_tx_uri': reverse('merchant_transactions'),
# Verbose, but needed for future internationalizing of templates:
'confirmed_via_blocks': bool(self.met_minimum_confirmation_at),
'confirmed_via_confidence': bool(self.met_confidence_threshold_at),
'confirmed_via_merchant': bool(self.min_confirmations_overrode_at),
}
subject = '%s Received' % satoshis_formatted
if shopper and shopper.name:
subject += 'from %s' % shopper.name
body_context['shopper_name'] = shopper.name
return send_and_log(
body_template=BODY_TEMPLATE,
subject='%s Received' % satoshis_formatted,
to_merchant=merchant,
body_context=body_context,
btc_transaction=self,
)
def test_pay_proforma_with_provided_date(self):
provider = ProviderFactory.create()
customer = CustomerFactory.create()
proforma = ProformaFactory.create(provider=provider, customer=customer)
proforma.issue()
url = reverse('proforma-state', kwargs={'pk': proforma.pk})
data = {'state': 'paid', 'paid_date': '2014-05-05'}
response = self.client.put(url,
data=json.dumps(data),
content_type='application/json')
proforma.refresh_from_db()
assert response.status_code == status.HTTP_200_OK
due_date = timezone.now().date() + timedelta(days=PAYMENT_DUE_DAYS)
mandatory_content = {
'issue_date':
timezone.now().date().strftime('%Y-%m-%d'),
'due_date':
due_date.strftime('%Y-%m-%d'),
'paid_date':
'2014-05-05',
'state':
'paid',
'invoice':
'http://testserver/invoices/%s/' % proforma.related_document.pk
}
assert response.status_code == status.HTTP_200_OK
assert all(item in response.data.items()
for item in mandatory_content.iteritems())
invoice = Invoice.objects.all()[0]
assert proforma.related_document == invoice
assert invoice.related_document == proforma
invoice = get_object_or_None(Invoice, related_document=proforma)
def map_detail(request, map_id):
map_obj = get_object_or_404(Map.objects.select_related(), pk=map_id)
best_runs = BestRun.objects.filter(map=map_obj).extra(select={
'position':
"SELECT COUNT(*)+1 FROM race_bestrun s "
"WHERE s.map_id = race_bestrun.map_id AND s.time < race_bestrun.time"
}, )[:5]
latest_runs = Run.objects.filter(map=map_obj).order_by('-created_at')[:5]
if request.user.is_authenticated():
user_latest_runs = Run.objects.filter(user=request.user, map=map_obj) \
.order_by('-created_at')[:5]
user_bestrun = get_object_or_None(BestRun,
user=request.user,
map=map_obj)
else:
user_latest_runs = None
user_bestrun = None
return {
'map': map_obj,
'best_runs': best_runs,
'latest_runs': latest_runs,
'user_latest_runs': user_latest_runs,
'user_bestrun': user_bestrun,
}
def parse(self, response):
# get all brands urls and names
brands_urls = response.css(
'div.models > div.col-2.center > a::attr(href)').extract()
brands_names = response.css(
'div.models > div.col-2.center > a::attr(title)').extract()
# scrap brands
for i in range(0, len(brands_urls)):
# parse models of the brand from urls
request = scrapy.Request(brands_urls[i],
callback=self.parse_models,
dont_filter=True)
# if brand exist - don't create it
brand_django_item = get_object_or_None(Brand, name=brands_names[i])
if brand_django_item is None:
brand_item = BrandItem(name=brands_names[i])
request.meta['brand_item'] = brand_item.save()
else:
request.meta['brand_item'] = brand_django_item
yield request
