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