def build_url(year): return '{}?q_filter={}'.format( lv_url, qfilter_serializer.dumps( Q(user=user.id) & Q(creation_date__year=year)), )
TrafficTicket.objects.bulk_create(ticket_batch) ticket_batch = [] print('{} of {}'.format(i, len(raw_tickets))) if __name__ == "__main__": # inicio el entorno de django parent_dir = os.path.dirname( os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) os.sys.path.insert(0, parent_dir) os.environ.setdefault("DJANGO_SETTINGS_MODULE", "madrid_geodjango.settings") django.setup() from madrid.models import TrafficTicket, MultasRaw # Paso 1: cargo las multas que contenían x,y raw_fines = MultasRaw.objects.filter(~Q(coordenada_x=' ')) print('Updating {} fines with existing x, y'.format(len(raw_fines))) # update_fines(raw_fines) # Paso 2: cargo las multas geolocalizadas con el geocoder raw_fines = MultasRaw.objects.filter( Q(coordenada_x=' ') & ~Q(coordenada_y=' ') & ~Q(coordenada_y='1a vuelta - nada')) print('Updating {} geocoded fines'.format(len(raw_fines))) update_fines(raw_fines, geocoder_info=True) print('The end')
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # ensure it only ever fetches objects which are not in the recycle bin self.query.add_q(Q(deleted_at__isnull=True, activated_at__isnull=False))
def validate_conflict_join_envs(env_ip, equipments): models_env = get_app('ambiente', 'models') models_vrf = get_app('api_vrf', 'models') nums_vlan_rel_ip = [vlan.num_vlan for vlan in env_ip.vlans] for equipment in equipments: # Equipment without environment related, do not need validate # Validate if equipment is not in related in environment if equipment.id not in list(env_ip.eqpts): # Validate if equipment has environments related for env_rel in equipment.environments: env_rel_eqpt = env_rel.ambiente use_filter = True if env_rel_eqpt.filter != env_ip.filter: use_filter = False # Exists differents filters, so is need to validate # all equipments eqpts = env_rel_eqpt.filtered_eqpts \ if use_filter else env_rel_eqpt.eqpts eqpts_env_ip = env_ip.filtered_eqpts \ if use_filter else env_ip.eqpts # Verify if vlans of environment of IP make conflict in # new relationship nums_vlan_rel_eqpt = [ vlan.num_vlan for vlan in env_rel_eqpt.vlans ] vlans_conflict = list( set(nums_vlan_rel_eqpt) & set(nums_vlan_rel_ip)) if vlans_conflict: msg = 'VLANs {} already registred with same ' \ 'number in equipments of environment: {}' msg = msg.format(vlans_conflict, env_rel_eqpt.name) log.error(msg) raise models_env.IpErrorV3(msg) # Verify if networks of environment of IP make conflict in new # relationship for vlan_rel_ip in env_ip.vlans: # Get vrfs of 1 vlan of environment of IP vrfs_vlan_rel_ip = models_vrf.Vrf.objects.filter( Q( Q(vrfvlanequipment__equipment__in=eqpts) & Q(vrfvlanequipment__vlan__id=vlan_rel_ip.id)) | Q(id=vlan_rel_ip.ambiente.default_vrf_id)) # Get vrfs of 1 vlan of environment related with # equipment for vlan_rel_eqpt in env_rel_eqpt.vlans: vrfs_vlan_rel_eqpt = models_vrf.Vrf.objects.filter( Q( Q(vrfvlanequipment__equipment__in=eqpts_env_ip) & Q(vrfvlanequipment__vlan__id=vlan_rel_eqpt.id)) | Q(id=vlan_rel_eqpt.ambiente.default_vrf_id)) # Validate conflict of network if has intersect # of vrfs vrfs_intersect = list( set(vrfs_vlan_rel_ip) & set(vrfs_vlan_rel_eqpt)) if vrfs_intersect: netv4 = vrfs_vlan_rel_eqpt\ .networkipv4_set.filter() netv6 = vrfs_vlan_rel_eqpt\ .networkipv6_set.filter() netv4_eqpt = [ IPNetwork(net.networkv4) for net in netv4 ] netv6_eqpt = [ IPNetwork(net.networkv6) for net in netv6 ] netv4 = vrfs_vlan_rel_ip.networkipv4_set.filter() netv6 = vrfs_vlan_rel_ip.networkipv6_set.filter() netv4_ip = [ IPNetwork(net.networkv4) for net in netv4 ] netv6_ip = [ IPNetwork(net.networkv6) for net in netv6 ] verify_networks(netv4_ip, netv4_eqpt) verify_networks(netv6_ip, netv6_eqpt)
def do_archiviazione(user, end_date): # if settings.DEBUG: # raise Exception("Per archiviare devi uscire dal DEBUG mode.") filtroViaggi = Q(data__lt=end_date, padre__isnull=True) to_archive = Viaggio.objects.select_related( "da", "a", "cliente", "conducente", "passeggero").filter(filtroViaggi) # Optimizations: mi faccio dare solo i modelli che mi interessano # Rimovo l'ordinamento di default logAction("K", instance=user, description="Archiviazione fino al %s" % end_date, user=user) logger.debug("Archiviazione fino al %s cominciata" % end_date) # disabilita il log delle operazioni: cancello viaggi e cambio conducenti stopLog(Viaggio) stopLog(Conducente) ricordi = {} # ricordi[conducente_id] = {chiaveClassifica=valore} archiviati = 0 chunkSize = 500 total = to_archive.count() logger.debug(u"Archivio %d viaggi padre." % total) # to_archive = to_archive[:1] # TODO: temp debug 1 viaggio while to_archive: # split viaggi padre in chucks viaggi_chunk, to_archive = to_archive[:chunkSize], to_archive[ chunkSize:] with transaction.atomic(): with transaction.atomic(using='archive'): for viaggiopadre in viaggi_chunk: archivio_viaggiopadre = archiveFromViaggio(viaggiopadre) daRicordareDelViaggio(ricordi, viaggiopadre) archivio_viaggiopadre.save() archiviati += 1 for figlio in viaggiopadre.viaggio_set.select_related( "da", "a", "cliente", "conducente", "passeggero").order_by().all(): archivio_viaggiofiglio = archiveFromViaggio(figlio) archivio_viaggiofiglio.padre = archivio_viaggiopadre daRicordareDelViaggio(ricordi, figlio) archivio_viaggiofiglio.save() # archiviati += 1 viaggiopadre.delete() logger.debug("Modifico le classifiche e commit %d/%d" % (archiviati, total)) applyRicordi(ricordi) logger.debug("fine archiviazione") if archiviati: vacuum_db() logDaEliminare = ActionLog.objects.filter(data__lt=end_date) contaLog = logDaEliminare.count() if contaLog: logger.debug("Ora cancello tutti i vecchi LOG.") logDaEliminare.delete() vacuum_db(using='modellog') # riabilita il log delle operazioni startLog(Conducente) startLog(Viaggio) logger.debug("Archiviazione fino al %s completata." % end_date.strftime("%d/%m/%Y"))
def save_assistance_record(self, record): if self.payroll_period.payroll_group.checker_type == PayrollGroup.CHECKER_TYPE_AUTOMATIC: employee_key = record[self.ElementPosition.ATM_EMPLOYEE_KEY_COL] record_date = record[self.ElementPosition.ATM_DATE_COL] entry_time_record = record[self.ElementPosition.ATM_ENTRY_COL] exit_time_record = record[self.ElementPosition.ATM_EXIT_COL] print "Automatic Assistance Upload" else: employee_key = record[self.ElementPosition.MANUAL_EMPLOYEE_KEY_COL] record_date = record[self.ElementPosition.MANUAL_DATE_COL] entry_time_record = record[self.ElementPosition.MANUAL_ENTRY_COL] exit_time_record = record[self.ElementPosition.MANUAL_EXIT_COL] print "Manual Assistance Upload" entry_time_record = datetime.datetime.strptime(entry_time_record.encode('ascii','ignore'), '%H:%M:%S').time() exit_time_record = datetime.datetime.strptime(exit_time_record.encode('ascii','ignore'), '%H:%M:%S').time() # Obtaining the related employee by theit key number. If the given employeee does not exist, # the system will throw an exception. employee_to_save = self.validate_employee_key(employee_key) # Validates that the given date is found between the limits of the selected payroll period. date_to_save = self.validate_date(record_date, employee_to_save.employee_key) # Validates the given fromat for the entry and exit time. entry_time_to_save = self.validate_entry_and_exit_time(entry_time_record, employee_to_save.employee_key) exit_time_to_save = self.validate_entry_and_exit_time(exit_time_record, employee_to_save.employee_key) employee_was_absent = self.check_if_absent(employee_to_save, entry_time_to_save, exit_time_to_save) # To check if the assistance exists before saving it. assistance_existed = EmployeeAssistance.objects.filter( Q(record_date = date_to_save) & Q(employee = employee_to_save) & Q(payroll_period=self.payroll_period)) if len(assistance_existed) > 0: # If the assistance already existed, lets update the information. assistance_obj = assistance_existed[0] assistance_obj.entry_time = entry_time_to_save assistance_obj.exit_time = exit_time_to_save assistance_obj.absence = employee_was_absent # Maybe add a message that says that some records where updated. assistance_obj.save() else: assistance_obj = EmployeeAssistance( entry_time=entry_time_to_save, exit_time=exit_time_to_save, record_date = date_to_save, employee = employee_to_save, payroll_period=self.payroll_period, absence=employee_was_absent ) assistance_obj.save()
def check_instance_pools(self): instance_pools = InstancePool.objects.all() # Process all instance pools for pool in instance_pools: if not pool.isEnabled: continue current_delta = timezone.datetime.now() - timezone.timedelta( seconds=stats_delta_secs) entries = PoolUptimeDetailedEntry.objects.filter( pool=pool, created__gte=current_delta) # We should never have more than one entry per time-delta assert (len(entries) < 2) if entries: current_delta_entry = entries[0] else: # Create a new entry current_delta_entry = PoolUptimeDetailedEntry() current_delta_entry.pool = pool current_delta_entry.target = pool.config.flatten().size actual = len( Instance.objects.filter(pool=pool).filter( Q(status_code=INSTANCE_STATE['pending']) | Q(status_code=INSTANCE_STATE['running']))) if current_delta_entry.actual == None or actual < current_delta_entry.actual: current_delta_entry.actual = actual # This will only save if necessary, i.e. if the entry already existed and the values # have not changed, this will not cause I/O on the database with Django >=1.5 current_delta_entry.save() # Now check if we need to aggregate some of the detail entries we have entries = PoolUptimeDetailedEntry.objects.filter( pool=pool).order_by('created') n = len(entries) - (stats_total_detailed * 60 * 60) / stats_delta_secs if n > 0: # We need to aggregate some entries entriesAggr = entries[0:n] for entry in entriesAggr: # Figure out if we have an aggregated entry already with the same date created = entry.created.date() day_entries = PoolUptimeAccumulatedEntry.objects.filter( pool=pool).filter(created__year=created.year, created__month=created.month, created__day=created.day) # We should never have more than one entry per day assert (len(day_entries) < 2) if day_entries: day_entry = day_entries[0] else: day_entry = PoolUptimeAccumulatedEntry() day_entry.pool = pool day_entry.created = entry.created day_entry.uptime_percentage = 0.0 entry_percentage = 100 if entry.target > 0: entry_percentage = (float(entry.actual) / entry.target) * 100 new_uptime_percentage = ( (float(day_entry.uptime_percentage) * day_entry.accumulated_count) + entry_percentage) / (day_entry.accumulated_count + 1) day_entry.uptime_percentage = new_uptime_percentage day_entry.accumulated_count = day_entry.accumulated_count + 1 day_entry.save() # We can now delete our entry entry.delete() # Finally check if we need to expire some accumulated entries entries = PoolUptimeAccumulatedEntry.objects.filter( pool=pool).order_by('created') n = len(entries) - stats_total_accumulated if n > 0: for entry in entries[0:n]: entry.delete()
def to_python(self, value): return Q(**{'{}__icontains'.format(self.cell.value): value }) if value else Q()
def _build_q_from_operations(self, operations): return Q( **{ '{}__{}'.format(self.cell.value, op): number for op, number in operations })
def date_clashes(self, start, end): return CalendarEvent.objects.filter( Q(start__range=(start, end) | Q(end__range=(start, end)))).exists()
def to_python(self, value): return Q()
def favorites(self): faves = Fave.objects.get_for_user(self.user) post_ct = ContentType.objects.get_for_model(Post).pk tag_ct = ContentType.objects.get_for_model(Tag).pk # userprofile_ct = ContentType.objects.get_for_model(UserProfile).pk userpost_ct = ContentType.objects.get_for_model(User).pk favorites_list = { post_ct: [], tag_ct: [], # userprofile_ct:[], userpost_ct: [], } itypes = InteractionType.objects.filter( name='read', content_type__in=favorites_list).values('content_type_id', 'pk') ctypes = dict((i["pk"], i["content_type_id"]) for i in itypes) for f in faves: favorites_list[f.content_type_id].append(f.object_id) fave_list = dict( (i["pk"], favorites_list[i["content_type_id"]]) for i in itypes) q = Q() for itype, f in fave_list.iteritems(): q = q | (Q(interaction_type=itype) & Q(object_id__in=f)) last_interactions = {} for li in self.interactions.filter(q): try: ct = ctypes[li.interaction_type_id] if not last_interactions.has_key(ct): last_interactions[ct] = {} last_interactions[ct][li.object_id] = li except KeyError: pass faved_objects = {} faved_objects[post_ct] = dict((o.pk, { 'last': o.last_reply, 'obj': o, 'type': 'post' }) for o in Post.objects.filter(pk__in=favorites_list[post_ct])) faved_objects[tag_ct] = dict((o.pk, { 'last': o.timestamp, 'obj': o, 'type': 'tag' }) for o in Tag.objects.filter(pk__in=favorites_list[tag_ct])) # faved_objects[userprofile_ct] = dict((o.pk, {'last':o.last_reply, 'obj':o, 'type':'userprofile'}) for o in UserProfile.objects.filter(pk__in = favorites_list[userprofile_ct])) faved_objects[userpost_ct] = dict((o.pk, { 'last': o.get_profile().last_post_id, 'obj': o.get_profile(), 'type': 'user' }) for o in User.objects.filter(pk__in=favorites_list[userpost_ct])) link_prefix = { post_ct: '¶', tag_ct: '.', userpost_ct: '@', # userpost_ct:'by: ', } for f in faves: ct = f.content_type_id oid = f.object_id fo = faved_objects[ct][oid] obj = fo['obj'] try: #TODO: Should we link to the last interaction or to the starting point? f.link_start = int( last_interactions[ct][oid].value.split(';')[0]) except KeyError: #This shouldn't actually ever happen, because there _should_ be an interaction of sorts. f.link_start = 0 f.link_href = obj.get_absolute_url() f.link_title = link_prefix[ct] + getattr(obj, 'title', obj.__unicode__()) f.current = fo['last'] f.fresh = fo.get('op', operator.lt)(f.link_start, f.current) f.remove = reverse('unfave_object', kwargs={ 'fave_type_slug': 'star', 'content_type_id': ct, 'object_id': oid }) return faves
def manage_users(request): if not request.user.has_perms(['can_view_user']): raise PermissionDenied('permission denied') message = '' admin_form = AdminUserForm() if request.is_ajax(): table = request.POST.get('table', False) search = request.POST.get('search', False) if table and table == 'users': accounts = User.objects.filter( ~Q(user_status='pending'), Q(account_id__icontains=search) | Q(first_name__icontains=search) | Q(last_name__icontains=search)) data = {} if accounts: for account in accounts: d = { 'account_id': account.account_id, 'first_name': account.first_name, 'last_name': account.last_name, 'address': account.address, 'email': account.email, 'contact': account.contact, 'username': account.username, 'user_type': account.user_type, 'is_superuser': account.is_superuser, 'user_status': account.user_status, 'date_joined': date.strftime(account.date_joined, "%b. %d, %Y, %I:%M %P"), } data[str(account.date_joined)] = d return JsonResponse(data) else: return JsonResponse(data) if request.POST: admin_form = AdminUserForm(request.POST, request.FILES) try: my_user = User.objects.get(account_id=request.POST['account_id']) except User.DoesNotExist: my_user = '' if my_user: perms = get_corrected_permissions(my_user) if not request.POST.get('is_super_user', False): for perm in perms: my_user.user_permissions.remove(perm) admin_form = AdminUserForm(request.POST, request.FILES, instance=my_user) current_password = my_user.password if admin_form.is_valid(): updataed_model = admin_form.save() updataed_model.password = current_password updataed_model.save() admin_form = AdminUserForm() message = 'user Information has been updated' elif admin_form.is_valid(): admin_form.save() admin_form = AdminUserForm() message = 'New user has been registered and is active' old_users_list = User.objects.filter(~Q(user_status='pending')) new_users_list = User.objects.filter(Q(user_status='pending')) return render( request, 'users/user_form_admin.html', { 'title': "User Manager", 'search_table': 'users', 'to_print': 'Members List', 'what_to_print': 'users', 'form': admin_form, 'new_users': new_users_list, 'old_users': old_users_list, 'message': message, })
def get(self, request): user = self.get_object(request) if user is None: return Response( {'status': 'Unauthorized', 'message': 'You are not logged in'}, status=status.HTTP_401_UNAUTHORIZED ) user_fields = ['first_name', 'last_name', 'avatar_url'] profile_fields = ['skills', 'bio', 'country', 'city', 'street', 'plot_number', 'postal_code'] optional_fields = ['skills', 'bio', 'avatar_url', 'phone_number', 'tel_number'] if request.user.is_developer or request.user.is_project_manager: profile_fields.extend(['id_document', 'phone_number']) elif user.is_project_owner and user.tax_location == 'europe': profile_fields.extend(['name', 'vat_number', 'tel_number']) missing_required = [] missing_optional = [] for group in [ [request.user, user_fields], [request.user.is_project_owner and request.user.company or request.user.profile, profile_fields] ]: for field in group[1]: if not getattr(group[0], field, None): if field in optional_fields: missing_optional.append(field) else: missing_required.append(field) running_projects = Project.objects.filter( Q(user=request.user) | Q(pm=request.user) | Q(owner=request.user) | ( Q(participation__user=request.user) & Q(participation__status__in=[STATUS_INITIAL, STATUS_ACCEPTED]) ), archived=False ).distinct() today_end = datetime.datetime.utcnow().replace(hour=23, minute=59, second=59, microsecond=999999) unpaid_invoices = Invoice.objects.filter( user=request.user, paid=False, issued_at__lte=today_end ).order_by('issued_at')[:5] upcoming_progress_events = ProgressEvent.objects.filter( ( Q(project__pm=request.user) & Q(type__in=[PROGRESS_EVENT_PM, PROGRESS_EVENT_MILESTONE]) ) | ( Q(project__participation__user=request.user) & Q(project__participation__status=STATUS_ACCEPTED) & Q(type__in=[PROGRESS_EVENT_DEVELOPER, PROGRESS_EVENT_MILESTONE]) ), ~Q(progressreport__user=request.user), due_at__gt=datetime.datetime.utcnow() - relativedelta(hours=24) ).order_by('due_at').distinct()[:4] progress_reports = ProgressReport.objects.filter( Q(event__project__user=request.user) | Q(event__project__pm=request.user) | Q(event__project__owner=request.user), user__type=USER_TYPE_DEVELOPER, event__type__in=[PROGRESS_EVENT_DEVELOPER, PROGRESS_EVENT_MILESTONE] ).distinct()[:4] raw_activities = Action.objects.filter( ~Q(id__in=[int(item.notification_id) for item in NotificationReadLog.objects.filter(user=user, type=NOTIFICATION_TYPE_ACTIVITY)]) & ( Q(projects__in=running_projects) | Q(progress_events__project__in=running_projects) ), action_object_content_type__in=[ ContentType.objects.get_for_model(model) for model in [Document, Participation, Invoice, FieldChangeLog] ], ) invoice_type = ContentType.objects.get_for_model(Invoice) cleaned_activities = [] is_client = not (user.is_admin or user.is_project_manager or user.is_developer) for activity in raw_activities: if (not is_client) or activity.action_object_content_type != invoice_type or activity.action_object.is_due: cleaned_activities.append(activity) cleaned_activities = cleaned_activities[:15] cleared_notifications = [ item.notification_id for item in NotificationReadLog.objects.filter( user=user, type=NOTIFICATION_TYPE_PROFILE ) ] return Response( { 'profile': dict( required=missing_required, optional=missing_optional, cleared=cleared_notifications ), 'projects': [dict( id=project.id, title=project.title ) for project in running_projects], 'invoices': [dict( id=invoice.id, title=invoice.title, full_title=invoice.full_title, issued_at=invoice.issued_at, due_at=invoice.due_at, is_overdue=invoice.is_overdue, project=dict( id=invoice.project.id, title=invoice.project.title ) ) for invoice in unpaid_invoices], 'events': [dict( id=event.id, title=event.title, type=event.type, due_at=event.due_at, project=dict( id=event.project.id, title=event.project.title ) ) for event in upcoming_progress_events], 'reports': [dict( id=report.id, created_at=report.created_at, status=report.status, percentage=report.percentage, user=dict( id=report.user.id, username=report.user.username, display_name=report.user.display_name ), event=dict( id=report.event.id, title=report.event.title, type=report.event.type, due_at=report.event.due_at, ), project=dict( id=report.event.project.id, title=report.event.project.title ), ) for report in progress_reports], 'activities': ActivitySerializer(instance=cleaned_activities, many=True, context=dict(request=request)).data }, status=status.HTTP_200_OK )
def access( request, wid: Optional[int], select_related: Optional[Union[str, List]] = None, prefetch_related: Optional[Union[str, List]] = None, ) -> Optional[Workflow]: """Verify that the workflow stored in the request can be accessed. :param request: HTTP request object :param wid: ID of the workflow that is being requested :param select_related: Field to add as select_related query filter :param prefetch_related: Field to add as prefetch_related query filter :return: Workflow object or raise exception with message """ # Lock the workflow object while deciding if it is accessible or not to # avoid race conditions. sid = request.session.get('ontask_workflow_id') if wid is None and sid is None: # No key was given and none was found in the session (anomaly) return None if wid is None: # No WID provided, but the session contains one, carry on # with this one wid = sid elif sid != wid: Workflow.unlock_workflow_by_id(sid) with cache.lock('ONTASK_WORKFLOW_{0}'.format(wid)): # Step 1: Get the workflow that is being accessed workflow = Workflow.objects.filter(id=wid).filter( Q(user=request.user) | Q(shared__id=request.user.id), ) if not workflow: return None # Apply select and prefetch if given if select_related: if isinstance(select_related, list): workflow = workflow.select_related(*select_related) else: workflow = workflow.select_related(select_related) if prefetch_related: if isinstance(prefetch_related, list): workflow = workflow.prefetch_related(*prefetch_related) else: workflow = workflow.prefetch_related(prefetch_related) # Now get the unique element from the query set workflow = workflow.first() # Step 2: If the workflow is locked by this user session, return # correct result (the session_key may be None if using the API) if request.session.session_key == workflow.session_key: # Update nrows. Asynch execution of plugin may have modified it store_workflow_nrows_in_session(request, workflow) return workflow # Step 3: If the workflow is unlocked, LOCK and return if not workflow.session_key: # Workflow is unlocked. Proceed to lock return wf_lock_and_update(request, workflow, create_session=True) # Step 4: The workflow is locked by a session different from this one. # See if the session locking it is still valid session = Session.objects.filter( session_key=workflow.session_key, ).first() if not session: # The session stored as locking the # workflow is no longer in the session table, so the user can # access the workflow return wf_lock_and_update(request, workflow, create_session=True) # Get the owner of the session locking the workflow user_id = session.get_decoded().get('_auth_user_id') if not user_id: # Session has no user_id, so proceed to lock the workflow return wf_lock_and_update(request, workflow) owner = get_user_model().objects.get(id=user_id) # Step 5: The workflow is locked by a session that is valid. See # if the session locking happens to be from the same user (a # previous session that has not been properly closed, or an API # call from the same user) if owner == request.user: return wf_lock_and_update(request, workflow) # Step 6: The workflow is locked by an existing session. See if the # session is valid if session.expire_date >= timezone.now(): raise OnTaskException( _('The workflow is being modified by user {0}').format( owner.email), ) # The workflow is locked by a session that has expired. Take the # workflow and lock it with the current session. return wf_lock_and_update(request, workflow)
def _get_q_for_choice(self, choice_value): return Q(**{self.cell.value: choice_value})
def get_slides(cls, lang=None): ogeler = cls.objects.filter(active=True).select_related() if lang: ogeler = ogeler.filter(Q(dil_kodu=lang)|Q(dil_kodu__isnull=True)) return ogeler
def _get_q_for_null_choice(self): return Q(**{'{}__isnull'.format(self.cell.value): True})
def merge_contacts(c1, c2): details = ContactDetail.objects.filter(owner=c1) for d in details: d.owner = c2 d.save() uas = UserAccount.objects.filter(company=c1) for ua in uas: ua.company = c2 ua.save() # company account try: ca = CompanyAccount.objects.get(contact=c1) ca.delete() except CompanyAccount.DoesNotExist: pass def move(clazz): txns = clazz.objects.filter(Q(supplier=c1) | Q(customer=c1)) for t in txns: if t.supplier == c1: t.supplier = c2 t.save() elif t.customer == c1: t.customer = c2 t.save() # orders move(Order) # bill move(Bill) # payment move(Payment) # expense es = Expense.objects.filter(Q(owner=c1) | Q(contact=c1)) for e in es: if e.owner == c1: e.owner = c2 e.save() elif e.contact == c1: e.contact = c2 e.save() # trade account # copy over debt and credit tas1 = TradeAccount.objects.filter(Q(supplier=c1) | Q(customer=c1)) for ta1 in tas1: if ta1.supplier == c1: try: ta2 = TradeAccount.objects.get(supplier=c2, customer=ta1.customer) ta2.debt += ta1.debt ta2.credit += ta1.credit ta2.save() ta1.delete() except TradeAccount.DoesNotExist: ta1.supplier = c2 ta1.save() elif ta1.customer == c1: try: ta2 = TradeAccount.objects.get(customer=c2, supplier=ta1.supplier) ta2.debt += ta1.debt ta2.credit += ta1.credit ta2.save() ta1.delete() except TradeAccount.DoesNotExist: ta1.customer = c2 ta1.save() # location # copy over 'Default', otherwise doble try: l1 = c1.locations.get(name=Location.DEFAULT) except Location.DoesNotExist: l1 = None try: l2 = c2.locations.get(name=Location.DEFAULT) except: l2 = None if l1 and l2: merge_locations(l1, l2) elif l1: l1.owner = c2 c1.delete()
def to_python(self, value): return Q(**{'{}__header_filter_search_field__icontains'.format(self.cell.value): value}) \ if value else \ super().to_python(value=value)
def get_all_users_stats_except(self): this_user = get_object_or_404(User, username=self.username) all_user_stats = get_list_or_404(UserStatistics, ~Q(user=this_user)) print(all_user_stats) return all_user_stats
def get_context_data(self, **kwargs): user = User.objects.get(username=self.request.user.username) pk = user.id context = super(DashBoard, self).get_context_data(**kwargs) cursor = connection.cursor() cursor.execute("SELECT EXTRACT(WEEK FROM tw.date) AS regweek,date_trunc('week',tw.date),SUM(tw.time_spent) FROM timetracking_timesheetweekdata tw INNER JOIN timetracking_timesheetdata td ON tw.timesheet_id = td.id where td.user_id = %s GROUP BY regweek,date_trunc('week',tw.date) ORDER BY regweek ",[pk]) results = cursor.fetchall() total_time = [] for result in results: start_date = result[1] end_date = start_date+timedelta(days = 6) start_date = start_date.strftime('%m/%d/%Y') end_date = end_date.strftime('%m/%d/%Y') time_list = {'week': '', 'time': '', 'start_date': '', 'end_date': ''} time_list['week'] = int(result[0]) - 1 time_list['start_date'] = start_date time_list['end_date'] = end_date time_list['time'] = int(result[2]) total_time.append(time_list) context['results'] = total_time cursor.execute("SELECT td.user_id,EXTRACT(WEEK FROM tw.date) AS regweek,date_trunc('week',tw.date),SUM(tw.time_spent) FROM timetracking_timesheetweekdata tw INNER JOIN timetracking_timesheetdata td ON tw.timesheet_id = td.id GROUP BY td.user_id,regweek,date_trunc('week',tw.date) ORDER BY regweek ") users_week_time = cursor.fetchall() total_time_user = [] for result in users_week_time: start_date = result[2] end_date = start_date+timedelta(days=6) start_date = start_date.strftime('%m/%d/%Y') end_date = end_date.strftime('%m/%d/%Y') time_list = {'id': '', 'week': '', 'time': '', 'start_date': '', 'end_date': ''} time_list['id'] = int(result[0]) time_list['week'] = int(result[1]) - 1 time_list['start_date'] = start_date time_list['end_date'] = end_date time_list['time'] = int(result[3]) total_time_user.append(time_list) user = User.objects.get(username= self.request.user.username) project = Project.objects.filter(projectassignment__assigned_to=user, projectassignment__admin_flag=True) team_members = User.objects.filter(projectassignment__project=project, projectassignment__admin_flag=False) context['timesheet_flag'] = "" if TimeSheetData.objects.filter(user=self.request.user): context['timesheet_flag'] = True context['team_admin'] = "" context['org_admin'] = "" context['project_assigned'] = ProjectAssignment.objects.filter(assigned_to=self.request.user.id) if ProjectAssignment.objects.filter(assigned_to=user.id, admin_flag=True): context['team_admin'] = "True" context['users_week_time'] = total_time_user context['team_members'] = team_members context['members'] = User.objects.filter(projectassignment__project=project, projectassignment__admin_flag=False).distinct() context['projects'] = project if user.user_type == 1: context['org_admin'] = "True" context['users_week_time'] = total_time_user context['all_members'] = User.objects.filter(~Q(id=self.request.user.id)) context['members'] = User.objects.filter(~Q(id=self.request.user.id)) context['projects'] = Project.objects.all() if TimeSheetData.objects.filter(user=user): timesheet = TimeSheetData.objects.filter(user=user) context['timesheet'] = timesheet context['weekdata'] = TimeSheetWeekData.objects.filter(timesheet__user=user).order_by('date') return context
def get_extra_filter(self): q = [] for field in self.extra_params_values: q.append(Q(**{field :self.extra_params_values[field]})) return reduce(operator.and_, q)
def filter_search(self, queryset, name, value): return queryset.filter( Q(archival_unit__title__icontains=value) | Q(archival_unit_legacy_name__icontains=value) | Q(title__icontains=value))
def articleSearch(request): search = request.GET.get('search') articles = Article.objects.filter( Q(title__icontains=search) | Q(content__icontains=search)) context = {'articles': articles, 'search': search} return render(request, 'articleSearch.html', context)
def __and__(self, other): if getattr(self, 'conditional', False) and getattr(other, 'conditional', False): return Q(self) & Q(other) raise NotImplementedError( "Use .bitand() and .bitor() for bitwise logical operations." )
def filter_list_queryset(self, request, queryset, view): return queryset.filter( Q(from_user=request.user) | Q(to__user=request.user))
def get_visible_pages(request, pages, site=None): """ This code is basically a many-pages-at-once version of Page.has_view_permission. pages contains all published pages check if there is ANY restriction that needs a permission page visibility calculation """ is_setting_public_all = settings.CMS_PUBLIC_FOR == 'all' is_setting_public_staff = settings.CMS_PUBLIC_FOR == 'staff' is_auth_user = request.user.is_authenticated() visible_page_ids = [] restricted_pages = defaultdict(list) pages_perms_q = Q() for page in pages: # taken from for_page as multiple at once version page_q = Q(page__tree_id=page.tree_id) & ( Q(page=page) | (Q(page__level__lt=page.level) & (Q(grant_on=ACCESS_DESCENDANTS) | Q(grant_on=ACCESS_PAGE_AND_DESCENDANTS))) | (Q(page__level=page.level - 1) & (Q(grant_on=ACCESS_CHILDREN) | Q(grant_on=ACCESS_PAGE_AND_CHILDREN)))) pages_perms_q |= page_q pages_perms_q &= Q(can_view=True) page_permissions = PagePermission.objects.filter( pages_perms_q).select_related('page', 'group__users') for perm in page_permissions: # collect the pages that are affected by permissions if perm is not None and perm not in restricted_pages[perm.page.pk]: # affective restricted pages gathering # using mptt functions # add the page with the perm itself if perm.grant_on in [ ACCESS_PAGE, ACCESS_PAGE_AND_CHILDREN, ACCESS_PAGE_AND_DESCENDANTS ]: restricted_pages[perm.page.pk].append(perm) # add children if perm.grant_on in [ACCESS_CHILDREN, ACCESS_PAGE_AND_CHILDREN]: child_ids = perm.page.get_children().values_list('id', flat=True) for id in child_ids: restricted_pages[id].append(perm) # add descendants elif perm.grant_on in [ ACCESS_DESCENDANTS, ACCESS_PAGE_AND_DESCENDANTS ]: child_ids = perm.page.get_descendants().values_list('id', flat=True) for id in child_ids: restricted_pages[id].append(perm) # anonymous # no restriction applied at all if (not is_auth_user and is_setting_public_all and not restricted_pages): return [page.pk for page in pages] if site is None: site = current_site(request) # authenticated user and global permission if is_auth_user: global_page_perm_q = Q( Q(user=request.user) | Q(group__user=request.user)) & Q(can_view=True) & Q( Q(sites__in=[site.pk]) | Q(sites__isnull=True)) global_view_perms = GlobalPagePermission.objects.filter( global_page_perm_q).exists() #no page perms edgcase - all visible if ((is_setting_public_all or (is_setting_public_staff and request.user.is_staff)) and not restricted_pages and not global_view_perms): return [page.pk for page in pages] #no page perms edgcase - none visible elif (is_setting_public_staff and not request.user.is_staff and not restricted_pages and not global_view_perms): return [] def has_global_perm(): if has_global_perm.cache < 0: has_global_perm.cache = 1 if request.user.has_perm( 'cms.view_page') else 0 return bool(has_global_perm.cache) has_global_perm.cache = -1 def has_permission_membership(page): """ PagePermission user group membership tests """ user_pk = request.user.pk page_pk = page.pk has_perm = False for perm in restricted_pages[page_pk]: if perm.user_id == user_pk: has_perm = True if not perm.group_id: continue group_user_ids = perm.group.user_set.values_list('pk', flat=True) if user_pk in group_user_ids: has_perm = True return has_perm for page in pages: to_add = False # default to false, showing a restricted page is bad # explicitly check all the conditions # of settings and permissions is_restricted = page.pk in restricted_pages # restricted_pages contains as key any page.pk that is # affected by a permission grant_on if is_auth_user: # a global permission was given to the request's user if global_view_perms: to_add = True # setting based handling of unrestricted pages elif not is_restricted and (is_setting_public_all or (is_setting_public_staff and request.user.is_staff)): # authenticated user, no restriction and public for all # or # authenticated staff user, no restriction and public for staff to_add = True # check group and user memberships to restricted pages elif is_restricted and has_permission_membership(page): to_add = True elif has_global_perm(): to_add = True # anonymous user, no restriction elif not is_restricted and is_setting_public_all: to_add = True # store it if to_add: visible_page_ids.append(page.pk) return visible_page_ids
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # ensure it only ever fetches objects that are in the recycle bin self.query.add_q(Q(deleted_at__isnull=False))
def posicao_em(self, data_hora): """Retora a posição do jogador na ladder na data/hora especificada""" # Verificar Season para data/hora season = Season.objects.filter( data_inicio__lte=data_hora.date()).order_by('-data_inicio')[0] # Buscar última remoção da ladder, posição será definida a partir de sua data if RemocaoJogador.objects.filter( jogador=self, data__lt=data_hora, data__gte=season.data_hora_inicio).exists(): data_inicial = RemocaoJogador.objects.filter( jogador=self).order_by('-data')[0].data desafios_validados_considerando_remocao = DesafioLadder.validados.na_season( season).filter(data_hora__gt=data_inicial) else: data_inicial = None desafios_validados_considerando_remocao = DesafioLadder.validados.na_season( season) # Buscar último desafio participado desafio_mais_recente = None if desafios_validados_considerando_remocao.filter( data_hora__lt=data_hora).filter( Q(desafiante=self) | Q(desafiado=self)).exists(): desafio_mais_recente = desafios_validados_considerando_remocao.filter(data_hora__lt=data_hora) \ .filter(Q(desafiante=self) | Q(desafiado=self)).annotate( posicao=Case(When(Q(desafiante=self) & Q(score_desafiante__gt=F('score_desafiado')), then=F('posicao_desafiado')), When(Q(desafiante=self) & Q(score_desafiante__lt=F('score_desafiado')), then=F('posicao_desafiante')), When(Q(desafiado=self) & Q(score_desafiante__gt=F('score_desafiado')), then=F('posicao_desafiado') + 1), When(Q(desafiado=self) & Q(score_desafiante__lt=F('score_desafiado')), then=F('posicao_desafiado')))) \ .order_by('-data_hora')[0] if desafio_mais_recente: # print(f'Desafio mais recente de {self}: {desafio_mais_recente.id} com {desafio_mais_recente.desafiante} VS {desafio_mais_recente.desafiado}') posicao = desafio_mais_recente.posicao # Buscar alterações feitas por remoções de outros jogadores posicao += (ResultadoRemocaoJogador.objects.filter(remocao__data__range=[desafio_mais_recente.data_hora, data_hora], jogador=self) \ .exclude(remocao__data=data_hora).aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0) # print(self, ResultadoDesafioLadder.objects.filter(jogador=self, desafio_ladder__data_hora__range=[desafio_mais_recente.data_hora, data_hora]) \ # .exclude(desafio_ladder=desafio_mais_recente).exclude(desafio_ladder__data_hora=data_hora) \ # .aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0) # Buscar alterações feitas por desafios de outros jogadores posicao += (ResultadoDesafioLadder.objects.filter(jogador=self, desafio_ladder__data_hora__range=[desafio_mais_recente.data_hora, data_hora]) \ .filter(desafio_ladder__admin_validador__isnull=False, desafio_ladder__cancelamentodesafioladder__isnull=True) \ .exclude(desafio_ladder=desafio_mais_recente).exclude(desafio_ladder__data_hora=data_hora) \ .aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0) # Buscar alterações feitas por decaimentos de outros jogadores posicao += (ResultadoDecaimentoJogador.objects.filter(jogador=self, decaimento__data__range=[desafio_mais_recente.data_hora, data_hora]) \ .exclude(decaimento__data=data_hora) \ .aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0) return posicao # Se não houver desafios cadastrados, verificar última ladder # Definir ultima ladder mes, ano = mes_ano_ant(data_hora.month, data_hora.year) if HistoricoLadder.objects.filter(ano=ano, mes=mes).exists(): # Se houver remoção e ela ocorrer no mês atual, ignorar busca e retornar como novo entrante if data_inicial and data_inicial.month == data_hora.month and data_inicial.year == data_hora.year: return 0 ultima_ladder = HistoricoLadder.objects.filter(ano=ano, mes=mes) else: # Se houver remoção, ignorar busca por ladder inicial if data_inicial: return 0 ultima_ladder = InicioLadder.objects.all() if ultima_ladder.filter(jogador=self).exists(): posicao = ultima_ladder.get(jogador=self).posicao # print(self, ResultadoDesafioLadder.objects.filter(jogador=self, desafio_ladder__data_hora__lt=data_hora) \ # .aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0) # Buscar alterações feitas por alterações de outros jogadores if HistoricoLadder.objects.filter(ano=ano, mes=mes).exists(): # Remoções posicao += (ResultadoRemocaoJogador.objects.filter(remocao__data__lt=data_hora, jogador=self) \ .filter(remocao__data__month=data_hora.month, remocao__data__year=data_hora.year) .aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0) # posicao -= RemocaoJogador.objects.filter(data__lt=data_hora, posicao_jogador__lt=posicao) \ # .filter(data__month=data_hora.month, data__year=data_hora.year).count() # Desafios posicao += (ResultadoDesafioLadder.objects.filter(jogador=self, desafio_ladder__data_hora__lt=data_hora) \ .filter(desafio_ladder__data_hora__month=data_hora.month, desafio_ladder__data_hora__year=data_hora.year, desafio_ladder__admin_validador__isnull=False, desafio_ladder__cancelamentodesafioladder__isnull=True) \ .aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0) # Decaimentos posicao += (ResultadoDecaimentoJogador.objects.filter(jogador=self, decaimento__data__lt=data_hora) \ .filter(decaimento__data__month=data_hora.month, decaimento__data__year=data_hora.year) .aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0) else: # Remoções # posicao -= RemocaoJogador.objects.filter(data__lt=data_hora, posicao_jogador__lt=posicao).count() posicao += (ResultadoRemocaoJogador.objects.filter(remocao__data__lt=data_hora, remocao__data__gte=season.data_hora_inicio, jogador=self).aggregate(alteracao_total= \ Sum('alteracao_posicao'))['alteracao_total'] or 0) # Desafios posicao += (ResultadoDesafioLadder.objects.filter(jogador=self, desafio_ladder__data_hora__lt=data_hora, desafio_ladder__data_hora__gte=season.data_hora_inicio, desafio_ladder__admin_validador__isnull=False, desafio_ladder__cancelamentodesafioladder__isnull=True) \ .aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0) # Decaimentos posicao += (ResultadoDecaimentoJogador.objects.filter(jogador=self, decaimento__data__lt=data_hora, decaimento__data__gte=season.data_hora_inicio) \ .aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0) return posicao # Novos entrantes começam na posição 0 return 0