def to_dict(self, use_value_dict=False): """ Method: to_dict Encodes the whole graph as dictionary. Returns: {dict} the graph as dictionary """ node_set = self.nodes.filter(deleted=False) edge_set = self.edges.filter(deleted=False) group_set = self.groups.filter(deleted=False) nodes = [node.to_dict(use_value_dict) for node in node_set] edges = [edge.to_dict(use_value_dict) for edge in edge_set] groups = [group.to_dict(use_value_dict) for group in group_set] node_seed = self.nodes.aggregate(Max('client_id'))['client_id__max'] edge_seed = self.edges.aggregate(Max('client_id'))['client_id__max'] group_seed = self.groups.aggregate(Max('client_id'))['client_id__max'] return { 'id': self.pk, 'seed': max(node_seed, edge_seed, group_seed), 'name': self.name, 'type': self.kind, 'readOnly': self.read_only, 'nodes': nodes, 'edges': edges, 'nodeGroups': groups }
def test_aggregations(self): for age, birthday in ( [4, (2007, 12, 25)], [4, (2006, 1, 1)], [1, (2008, 12, 1)], [4, (2006, 6, 1)], [12, (1998, 9, 1)], ): Person.objects.create(age=age, birthday=datetime(*birthday)) aggregates = Person.objects.aggregate(Min('age'), Max('age'), avgage=Avg('age')) self.assertEqual(aggregates, { 'age__min': 1, 'age__max': 12, 'avgage': 5.0 }) # With filters and testing the sqlaggregates->mongoaggregate # conversion. aggregates = Person.objects.filter(age__gte=4).aggregate( Min('birthday'), Max('birthday'), Avg('age'), Count('id')) self.assertEqual( aggregates, { 'birthday__max': datetime(2007, 12, 25, 0, 0), 'birthday__min': datetime(1998, 9, 1, 0, 0), 'age__avg': 6.0, 'id__count': 4, })
def handle(self, *args, **options): qs = PeerLink.objects.all() normalised_count_max = log( qs.aggregate(Max('count'))['count__max'] * settings.PEER_NORMALISATION_FACTOR) site_map = {} for site in qs: site_map[site.domain] = ( log(site.count * settings.PEER_NORMALISATION_FACTOR) / normalised_count_max) * settings.PEER_FACTOR qs = UserLink.objects.all() normalised_count_max = log( qs.aggregate(Max('count'))['count__max'] * settings.USER_NORMALISATION_FACTOR) for site in qs: site_map[site.domain] += ( log(site.count * settings.USER_NORMALISATION_FACTOR) / normalised_count_max) * settings.USER_FACTOR for key, value in site_map.items(): site_map[key] += settings.OFFSET_FACTOR # remove www from start if any xkey = re.sub('^www.', '', key) + '/*' formatted_string = '{domain}\t_cse_e3hycfajgt0\t{factor:1.6f}'.format( domain=xkey, factor=value + settings.OFFSET_FACTOR) self.stdout.write(self.style.SUCCESS(formatted_string)) xml_parser = Parser(label='_cse_e3hycfajgt0') xml_parser.parse(site_map) xml_parser.write_file()
def team_rank(team, round_name=None): """Returns the rank of the team across all groups.""" if not round_name: round_name = challenge_mgr.get_round_name() aggregate = ScoreboardEntry.objects.filter( profile__team=team, round_name=round_name).aggregate(points=Sum("points"), last=Max("last_awarded_submission")) points = aggregate["points"] or 0 last_awarded_submission = aggregate["last"] # Group by teams, filter out other rounds, and annotate. annotated_teams = ScoreboardEntry.objects.values("profile__team").filter( round_name=round_name).annotate( team_points=Sum("points"), last_awarded=Max("last_awarded_submission")) count = annotated_teams.filter(team_points__gt=points).count() # If there was a submission, tack that on to the count. if last_awarded_submission: count = count + annotated_teams.filter( team_points=points, last_awarded_submission__gt=last_awarded_submission).count() return count + 1
def define_prices(self): return self.aggregate( ads_count=Count('id'), max_price_uzs=Max('price_uzs'), min_price_uzs=Min('price_uzs'), avg_price_uzs=Avg('price_uzs'), max_price_usd=Max('price_usd'), min_price_usd=Min('price_usd'), avg_price_usd=Avg('price_usd'), )
def get_users_with_trial_subscription(self): return self.filter(owner__is_active=True).values('owner').annotate( sub_count=Count('id'), state=Max('state'), date=Max('expiration_date')).values( 'owner__email', 'owner__first_name', 'owner__last_name').filter( sub_count=1, date__gte=datetime.date.today(), state=SUBSCRIPTION_STATE_TRIAL).distinct()
def get_users_with_trial_subscription_expiring_in(self, days=7): return self.all().values('owner').annotate( sub_count=Count('id'), state=Max('state'), date=Max('expiration_date')).values( 'owner__email', 'owner__first_name', 'owner__last_name').filter( sub_count=1, date=datetime.date.today() + datetime.timedelta(days), state=SUBSCRIPTION_STATE_TRIAL).distinct().order_by( 'owner__email')
def get_users_with_expired_subscription(self): return self.filter(owner__is_active=True)\ .values('owner')\ .annotate(max_date=Max('expiration_date'), max_state=Max('state'))\ .values('owner__email', 'owner__first_name', 'owner__last_name')\ .filter(max_date__lt=datetime.date.today(), max_state__lt=SUBSCRIPTION_STATE_FREE)\ .distinct()
def get_queryset(self, request: HttpRequest) -> QuerySet: return super().get_queryset(request).annotate( title_ukr=Subquery(self.title_ukr_query[:1]), title_eng=Subquery(self.title_eng_query[:1]), title_not_ukr=Subquery(self.title_not_ukr_query), max_season=Max('posts__seasons__season'), max_year=Max('posts__years__year'), max_registered_on=Max('posts__raw_post__registered_on'), ).order_by('-max_year', '-max_registered_on', 'title_ukr').exclude( title_ukr=None, title_not_ukr=None, )
def stats(cls, events=None): ''' Returns stats on the events queryset provided. :param events: A queryset of events, that have the fields sessions, games, players ''' if events is None: events = cls.implicit() if events: # Tailwind's Median aggregator does not work on Durations (PostgreSQL Intervals) # So we have to convert it to Epoch time. Extract is a Django method that can extract # 'epoch' which is the documented method of casting a PostgreSQL interval to epoch time. # https://www.postgresql.org/message-id/19495.1059687790%40sss.pgh.pa.us # Django does not document 'epoch' alas but it works: # https://docs.djangoproject.com/en/4.0/ref/models/database-functions/#extract # We need a Django ExpressionWrapper to cast the uration field to DurationField as # for some reason even though it's a PostgreSQL interval, Django still thinks of it # as a DateTimeField (from the difference of two DateTimeFields I guess and a bug/feature) # that fails tor ecast a difference of DateTimeFiled's as DurationField. epoch_duration = Extract(ExpressionWrapper(F('duration'), output_field=DurationField()), lookup_name='epoch') epoch_gap = Extract(ExpressionWrapper(F('gap_time'), output_field=DurationField()), lookup_name='epoch') result = events.aggregate(Min('sessions'), Avg('sessions'), Median('sessions'), Max('sessions'), Min('games'), Avg('games'), Median('games'), Max('games'), Min('players'), Avg('players'), Median('players'), Max('players'), duration__min=Min('duration'), duration__avg=Avg('duration'), duration__median=Median(epoch_duration), duration__max=Max('duration'), gap__min=Min('gap_time'), gap__avg=Avg('gap_time'), gap__median=Median(epoch_gap), gap__max=Max('gap_time')) # Aggregate is a QuerySet enpoint (i.e results in evaluation of the Query and returns # a standard dict. To wit we can cast teh Epch times back to Durations for the consumer. result['duration__median'] = timedelta(seconds=result['duration__median']) result['gap__median'] = timedelta(seconds=result['gap__median']) else: result = None return result
def all_notifications(request): user_info_obj = User_info.objects.filter(user_id=request.user.id) """ wish notifications """ wish_id_list = Wish.objects.filter(user=user_info_obj).values('id') rewish_notify_obj = Feed.objects.filter(wish__in=wish_id_list).filter( status='A', feed_type__in=('RW', 'RO', 'RR')).exclude(user=user_info_obj).order_by("-added") """ talk notifications """ id_list = Talk_comment.objects.filter(user=user_info_obj).values( 'user', 'talk').annotate(Max('id')).values('id__max') talk_notify_obj = Talk_comment.objects.filter(pk__in=id_list).exclude( notify_count=0).order_by("-added") """ friend requests received """ invitations = FriendshipInvitation.objects.filter( to_user=request.user).order_by("-sent") """ friendships accepted """ accepted_obj = Friendship.objects.filter( from_user=request.user).order_by("-added") """ talks test """ talk_list = Talk.objects.filter(user=user_info_obj).values('id') comment_list = Talk_comment.objects.filter(talk__in=talk_list).filter( user=user_info_obj).values('talk').distinct() #my_talk_obj = Talk.objects.filter(pk__in=talk_list).exclude(pk__in=comment_list) my_talk_obj = Talk.objects.filter(user=user_info_obj).exclude( talk_comment__user=user_info_obj).exclude( talk_comment__user=None).order_by('-talk_comment__added') if request.method == 'POST': if 'wish_read_id' in request.POST: """ Make clicked rewish notification as RR(Rewish Read) """ Feed.objects.filter(id=request.POST['wish_read_id']).update( feed_type='RR') if 'wishes' in request.POST: """ Make all rewish notification as RO(Rewish Observed) on click on Wishes tab """ Feed.objects.filter(wish__in=wish_id_list).filter( feed_type='RW').update(feed_type='RO') if 'talks' in request.POST: """ Make notify_count of my top comment in all my talks as 0 """ Talk_comment.objects.filter(user=user_info_obj).values( 'user', 'talk').annotate(Max('id')).update(notify_count=0) return render_to_response('notifications.html', { 'rewish_notify_obj': rewish_notify_obj, 'talk_notify_obj': talk_notify_obj, 'invitations': invitations, 'accepted_obj': accepted_obj, 'my_talk_obj': my_talk_obj }, context_instance=RequestContext(request))
def get_next_few_days_of_tiled_overlays(cls): # Pick how many days into the future and past we want to display overlays for #TODO put in the ISBASE next_few_days_of_overlays = Overlay.objects.filter( applies_at_datetime__gte=timezone.now()-timedelta(hours=2), applies_at_datetime__lte=timezone.now()+timedelta(days=4), is_tiled=True, ) next_few_days_of_sst_overlays = next_few_days_of_overlays.filter(definition_id__in=[1, 3]) next_few_days_of_wave_overlays = next_few_days_of_overlays.filter(definition_id=4) # Get the newest overlay for each Model type and time. This assumes that for a certain model date, # a larger ID value # indicates a more recently-created (and hence more accurate) overlay. # Note that a higher ID does NOT by itself indicate a more recent MODEL date # because a datafile's time indexes get plotted asynchronously. I.e. tomorrow at 1 PM and tomorrow at 5 PM do not # get plotted in that order, but two days' past forecast for tomorrow 1 PM will always get plotted before # yesterday's forecast for tomorrow 1 PM. and_the_newest_for_each_wave = next_few_days_of_wave_overlays.values('definition_id', 'applies_at_datetime')\ .annotate(newest_id=Max('id')) wave_ids = and_the_newest_for_each_wave.values_list('newest_id', flat=True) and_the_newest_for_each_sst = next_few_days_of_sst_overlays.values('definition_id', 'applies_at_datetime')\ .annotate(newest_id=Max('id')) sst_ids = and_the_newest_for_each_sst.values_list('newest_id', flat=True) # Filter out only the most recent overlay for each type and time newest_sst_overlays_to_display = next_few_days_of_sst_overlays.filter(id__in=sst_ids).order_by('definition', 'applies_at_datetime') newest_wave_overlays_to_display = next_few_days_of_wave_overlays.filter(id__in=wave_ids).order_by('definition', 'applies_at_datetime') wave_dates = newest_wave_overlays_to_display.values_list( 'applies_at_datetime', flat=True) sst_dates = newest_sst_overlays_to_display.values_list( 'applies_at_datetime', flat=True) #Get the distinct dates where there is an SST, currents, and also a wave overlay date_overlap = next_few_days_of_overlays.filter(applies_at_datetime__in=list(sst_dates))\ .filter(applies_at_datetime__in=list(wave_dates)).values_list('applies_at_datetime', flat=True).distinct() # Now get the actual overlays where there is an overlap overlapped_sst_items_to_display = newest_sst_overlays_to_display.filter(applies_at_datetime__in=list(date_overlap)) overlapped_wave_items_to_display = newest_wave_overlays_to_display.filter(applies_at_datetime__in=list(date_overlap)) #Join the two sets all_items_to_display = overlapped_sst_items_to_display | overlapped_wave_items_to_display # Send the items back to the SharkEyesCore/views.py file, which preps the main page to be loaded. return all_items_to_display
def get_queryset(self): queryset = LogGame.objects.all().values('pname').annotate( score=Max('score')).order_by('-score') pnames = [item['pname'] for item in queryset] scores = [item['score'] for item in queryset] return LogGame.objects.filter(pname__in=pnames, score__in=scores).order_by('-score')
def commit_pending(self, reason, request, skip_push=False, force=False): """Commit any pending changes.""" if not force and not self.unit_set.filter(pending=True).exists(): return False self.log_info('committing pending changes (%s)', reason) with self.component.repository.lock: while True: # Find oldest change break loop if there is none left try: unit = self.unit_set.filter(pending=True).annotate( Max('change__timestamp')).order_by( 'change__timestamp__max')[0] except IndexError: break # Get last change metadata author, timestamp = unit.get_last_content_change(request) author_name = author.get_author_name() # Flush pending units for this author self.update_units(author_name, author.id) # Commit changes self.git_commit(request, author_name, timestamp, skip_push=skip_push) # Update stats (the translated flag might have changed) self.invalidate_cache() return True
def filter_last_counselor_usernames(self, qs, field_name, value): qs = qs.annotate( max_transfer_date=Max("takeover__transfer_date")).filter( takeover__transfer_date=F("max_transfer_date"), takeover__counselor__username__in=value, ) return qs
def form_valid(self, form): current_parent = self.object.parent current_lvl = self.object.lvl updated_menu_obj = form.save(commit=False) if updated_menu_obj.parent != current_parent: if updated_menu_obj.parent.id == updated_menu_obj.id: return JsonResponse({ 'error': True, 'message': 'you can not choose the same as parent' }) menu_count = Menu.objects.filter( parent=updated_menu_obj.parent).count() updated_menu_obj.lvl = menu_count + 1 menu_max_lvl = Menu.objects.filter( parent=current_parent).aggregate(Max('lvl'))['lvl__max'] if menu_max_lvl != 1: for i in Menu.objects.filter(parent=current_parent, lvl__gt=current_lvl, lvl__lte=menu_max_lvl): i.lvl = i.lvl - 1 i.save() if updated_menu_obj.url[-1] != '/': updated_menu_obj.url = updated_menu_obj.url + '/' updated_menu_obj.save() messages.success(self.request, 'Successfully updated menu') return JsonResponse({ 'error': False, 'response': 'Successfully updated menu' })
def save(self, commit=True): max_index = self.sample.grain_set.aggregate(Max('index'))['index__max'] if not max_index: max_index = 0 self.instance.index = max_index + 1 max_w = 0 max_h = 0 for f in self.cleaned_data['files']: w = f['width'] if max_w < w: max_w = w h = f['height'] if max_h < h: max_h = h self.instance.image_width = max_w self.instance.image_height = max_h self.instance.sample = self.sample region = Region(grain=self.instance, shift_x=0, shift_y=0) x_margin = int(max_w / 20) y_margin = int(max_h / 20) v0 = Vertex(region=region, x=x_margin, y=y_margin) v1 = Vertex(region=region, x=x_margin, y=max_h - y_margin) v2 = Vertex(region=region, x=max_w - x_margin, y=max_h - y_margin) v3 = Vertex(region=region, x=max_w - x_margin, y=y_margin) inst = super().save(commit) if commit: region.save() v0.save() v1.save() v2.save() v3.save() return inst
def rows(self): del_data = [] if 'data_config' in self.config: data_config = self.config['data_config'] delivered = data_config.delivery_data_total.get('received', 0) not_delivered = data_config.delivery_data_total.get( 'not_received', 0) del_data.append( GroupSummary(title=SupplyPointStatusTypes.DELIVERY_FACILITY, responded=delivered + not_delivered, on_time=delivered + not_delivered, complete=delivered, total=data_config.delivery_data_total.get( 'total', 0))) return del_data if self.config['org_summary']: try: data = GroupSummary.objects.filter( title=SupplyPointStatusTypes.DELIVERY_FACILITY, org_summary__in=self.config['org_summary']).aggregate( Avg('responded'), Avg('on_time'), Avg('complete'), Max('total')) del_data.append( GroupSummary( title=SupplyPointStatusTypes.DELIVERY_FACILITY, responded=data['responded__avg'], on_time=data['on_time__avg'], complete=data['complete__avg'], total=data['total__max'])) except GroupSummary.DoesNotExist: return del_data return del_data
def test_object_create_with_aggregate(self): # Aggregates are not allowed when inserting new data with self.assertRaisesMessage(FieldError, 'Aggregate functions are not allowed in this query'): Company.objects.create( name='Company', num_employees=Max(Value(1)), num_chairs=1, ceo=Employee.objects.create(firstname="Just", lastname="Doit", salary=30), )
def CallDictFunc(request): profile_list = Profile.objects.all() #print(profile_list) for row in profile_list.values_list(): print(row) print(Profile.objects.aggregate(Avg('age'))) print(Profile.objects.aggregate(Max('age'))) print(Profile.objects.aggregate(Sum('age'))) print(Profile.objects.aggregate(Count('age'))) print(Profile.objects.filter(name='홍길동').aggregate( Count('age'))) # filter로 where 조건을 나타낸다. #이름이 홍길동인 튜플들 갯수 출력 print(len(profile_list)) # values() + aggregate() 그룹별 평균 나이는? qs = Profile.objects.values('name').annotate( Avg('age')) # name별로 그룹을 묶어서 age의 평균을 출력. for r in qs: print(r) # 결과를 list로 감싸서 dict type으로 클라이언트에게 출력하기 pro_list = [] for pro in profile_list: pro_dict = {} pro_dict['name'] = pro.name pro_dict['age'] = pro.age pro_list.append(pro_dict) print(pro_list) context = {'pro_dicts': pro_list} return render(request, 'abc.html', context)
def save(self, *args, **kwargs): if self.parent and self.share_of: raise ValueError("Can't be both a reply and a share!") self.cache_data() if self.parent: self.content_type = ContentType.REPLY # Ensure replies have sane values self.visibility = self.parent.visibility self.pinned = False elif self.share_of: self.content_type = ContentType.SHARE if not self.pk: if not self.guid: self.guid = uuid4() if self.pinned: max_order = Content.objects.top_level().filter( author=self.author).aggregate(Max("order"))["order__max"] if max_order is not None: # If max_order is None, there is likely to be no content yet self.order = max_order + 1 self.fix_local_uploads() super().save(*args, **kwargs) self.cache_related_object_data()
def hits_per_interval(request, days=1): """ hits per day to facebook.html or """ context = {} rows = [] logs = Log.objects.order_by('time').all() # should include the timezone info in this dates = Log.objects.aggregate(Max('time'), Min('time')) min_date = dates['time__min'].date() max_date = dates['time__max'].date() dates = date_range(min_date, max_date, days) for from_date, to_date in pair_inter(dates): count = Log.objects.filter( Q(time__gte=from_date) & Q(time__lt=to_date) & (Q(request__startswith='GET /facebook.htm') | Q(request__startswith='GET /fb.htm'))).count() row = Object() row.date = from_date row.hits = count rows.append(row) context['rows'] = rows context['use_tabs'] = request.GET.get('use_tabs') in ['1', 'true', 'True'] return render_to_response('analytics/hits.html', context, mimetype='text')
def max_pk(): """Returns the sum of all the highest PKs for each submodel.""" return reduce( lambda x, y: x + y, [int(p.objects.aggregate(Max('pk')).values()[0] or 0) for p in AbstractPage.__subclasses__()], )
def test_fail_update(self): """Window expressions can't be used in an UPDATE statement.""" msg = 'Window expressions are not allowed in this query' with self.assertRaisesMessage(FieldError, msg): Employee.objects.filter(department='Management').update( salary=Window(expression=Max('salary'), partition_by='department'), )
def handle(self, *args, **options): print() print("==========================================================#\n" "# #\n" "# EOS Block History Scanner #\n" "# (C) 2019 Privex Inc. Released under GNU AGPLv3 #\n" "# #\n" "# github.com/Privex/EOSHistory #\n" "# #\n" "#=========================================================#\n") print() log.info( ' >>> Started SYNC_BLOCKS Django command. Booting up AsyncIO event loop. ' ) last_block, start_type = options['start_block'], options['start_type'] if options['start_block'] is None: last_block = settings.EOS_START_BLOCK if EOSBlock.objects.count() > 0: last_block = EOSBlock.objects.aggregate( Max('number'))['number__max'] start_type = 'exact' log.info( 'Found existing blocks. Starting from block %d (changed start_type to exact)', last_block) asyncio.run( self.sync_blocks(start_block=last_block, start_type=start_type))
def welcome(request): latest_setname = {} latest_date = {} envts = [] link_title = None ck = make_template_fragment_key('welcome_all') p = cache.get(ck) if p is None: link_title = getParam('LINKS_TITLE') envts = Environment.objects_active.annotate(latest_reconfiguration=Max( 'component_instances__configurations__id')).order_by('name') for e in envts: if e.latest_reconfiguration: cic = ComponentInstanceConfiguration.objects.select_related( 'result_of__belongs_to_set').get( pk=e.latest_reconfiguration) latest_setname[e.name] = cic.result_of.belongs_to_set.name latest_date[e.name] = cic.created_on return render( request, 'ref/welcome.html', { 'team_links_title': link_title, 'team_links': Link.objects.all(), 'latest_setname': latest_setname, 'latest_date': latest_date, 'envts': envts, 'templates': Environment.objects.filter(template_only=True) })
def rows(self): soh_data = [] if 'data_config' in self.config: data_config = self.config['data_config'] late = data_config.soh_data_total.get('late', 0) on_time = data_config.soh_data_total.get('on_time', 0) soh_data.append( GroupSummary(title=SupplyPointStatusTypes.SOH_FACILITY, responded=late + on_time, on_time=on_time, complete=late + on_time, total=len(data_config.descendants))) return soh_data if self.config['org_summary']: try: sohs = GroupSummary.objects.filter( title=SupplyPointStatusTypes.SOH_FACILITY, org_summary__in=self.config['org_summary']).aggregate( Avg('responded'), Avg('on_time'), Avg('complete'), Max('total')) soh_data.append( GroupSummary(title=SupplyPointStatusTypes.SOH_FACILITY, responded=sohs['responded__avg'], on_time=sohs['on_time__avg'], complete=sohs['complete__avg'], total=sohs['total__max'])) except GroupSummary.DoesNotExist: return soh_data return soh_data
def add_company_holidays(request): if not request.user.is_authenticated: return HttpResponseRedirect(reverse('login')) user_id = request.user.id system_access = True system_user = models.Profile.objects.all().filter(user_id=user_id) if request.user.username != "system_admin" and not system_user.exists(): system_access = False all_user = models.Profile.objects.all().filter(user_id=user_id, access__access_level='All') abs_user = models.Profile.objects.all().filter( user_id=user_id, access__access_level='Absences') if request.user.username != "system_admin" and not all_user.exists( ) and not abs_user.exists(): return HttpResponseRedirect(reverse('home')) if 'export_holidays' in request.POST: return export_holidays() now = datetime.datetime.now() upcoming_holidays = models.company_holidays.objects.filter( is_finalized=True, holiday_date__gte=now).order_by('holiday_date', 'location') control_date = models.company_holidays.objects.all().filter(is_finalized=True) \ .values('location__location') \ .annotate(max_holiday_date=Max('holiday_date')) context = { 'control_date': control_date, 'upcoming_holidays': upcoming_holidays, 'system_access': system_access, } return render(request, 'absences/add_company_holidays.html', context)
def commit_pending(self, reason, request, skip_push=False): """Commit any pending changes.""" if not self.unit_set.filter(pending=True).exists(): return False self.log_info('committing pending changes (%s)', reason) with self.component.repository.lock: while True: # Find oldest change break loop if there is none left try: unit = self.unit_set.filter( pending=True, change__action__in=Change.ACTIONS_CONTENT, change__user__isnull=False, ).annotate(Max('change__timestamp')).order_by( 'change__timestamp__max')[0] except IndexError: break # Can not use get as there can be more with same timestamp change = unit.change_set.content().filter( timestamp=unit.change__timestamp__max)[0] author_name = change.author.get_author_name() # Flush pending units for this author self.update_units(author_name, change.author.id) # Commit changes self.git_commit(request, author_name, change.timestamp, skip_push=skip_push) return True
def clean(self): are_numar_sfarsit = "numar_sfarsit" in self.cleaned_data and self.cleaned_data['numar_sfarsit'] if are_numar_sfarsit and self.cleaned_data['numar_sfarsit'] <= self.cleaned_data['numar_inceput']: raise ValidationError(u"Numărul de sfârșit poate să fie mai mare decât numărul de început") intervale = self.get_intervale() interval_deschis = intervale.filter(numar_sfarsit__isnull = True) if are_numar_sfarsit: # daca exista deja registre cu interval deschis if interval_deschis.count() and self.cleaned_data["numar_sfarsit"] >= interval_deschis[0].numar_inceput: raise ValidationError(u"Suprapunere de numere cu registrul #%d" % interval_deschis[0].id) range_kwargs = {"numar_inceput__range" : (self.cleaned_data['numar_inceput'], self.cleaned_data['numar_sfarsit']), "numar_sfarsit__range" : (self.cleaned_data['numar_inceput'], self.cleaned_data['numar_sfarsit'])} intervale_suprapuse = intervale.filter(**range_kwargs) if intervale_suprapuse.count(): raise ValidationError(u"Suprapunere de numere cu %d alte registre, te rog să reverifici" % intervale_suprapuse.count()) else: if interval_deschis.count(): raise ValidationError(u"Nu se pot defini două registre cu numerotare deschisă (fără număr sfârșit) pe aceeași serie") else: if intervale.count(): if self.cleaned_data['numar_inceput'] <= intervale.aggregate(Max("numar_sfarsit")).get("numar_sfarsit__max"): raise ValidationError(u"Suprapunere de numerotare cu un registru!") return self.cleaned_data