def add_activity(request): if not request.method == 'POST': return http.HttpResponseForbidden() if 'action_object_pk' in request.POST.keys(): action_object = shortcuts.get_object_or_404( get_model( request.POST['action_object_app'], request.POST['action_object_class'] ), pk=request.POST['action_object_pk'] ) else: action_object = None if 'action_object_pk' in request.POST.keys(): action_object = shortcuts.get_object_or_404( get_model( request.POST['action_object_app'], request.POST['action_object_class'] ), pk=request.POST['action_object_pk'] ) else: action_object = None action.send( request.user, request.POST['verb'], action_object=action_object, target=action_object ) return http.HttpResponse('success')
def report_all(request): response = HttpResponse(content_type='text/csv') response['Content-Disposition'] = 'attachment; filename="report_products.csv"' writer = csv.writer(response) writer.writerow([u'Продукт'.encode('utf-8', 'ignore'), u'Общо продадени'.encode('utf-8', 'ignore'), u'Единична Цена'.encode('utf-8', 'ignore'), u'Общо Цена'.encode('utf-8', 'ignore')]) products = models.get_model('pos', 'Product').objects.all(); for product in products: orderitems = models.get_model('pos', 'OrderItem').objects.filter(product=product) sum = 0 price = 0 for orderitem in orderitems: sum = sum + orderitem.quantity price = price + orderitem.quantity*product.price product.orderCount = sum product.totalPrice = price name = product.name.encode('utf-8', 'ignore') writer.writerow([name, sum, product.price, price]) return response
def updateVocabulary(vocab): def findAgeValue(graph, subj, boundaryPredicate): positionPred = rdflib.term.URIRef("http://resource.geosciml.org/schema/cgi/trs/3.0/position") valuePred = rdflib.term.URIRef("http://def.seegrid.csiro.au/isotc211/iso19108/2006/temporalobject/value") boundaries = [obj for obj in graph.objects(subj, boundaryPredicate)] if len(boundaries) > 0: boundary = boundaries[0] positions = [obj for obj in graph.objects(boundary, positionPred)] if len(positions) > 0: position = positions[0] values = [obj for obj in graph.objects(position, valuePred)] if len(values) > 0: return str(values[0]) return "None" vocab.vocabularyconcept_set.all().delete() vocab.ageterm_set.all().delete() definitionPredicate = rdflib.term.URIRef('http://www.w3.org/2004/02/skos/core#definition') typePredicate = rdflib.term.URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#type") eraObj = rdflib.term.URIRef("http://resource.geosciml.org/schema/cgi/gts/3.0/GeochronologicEra") classifierPrefix = "http://resource.geosciml.org/classifier/" g = rdflib.Graph() g.parse(vocab.url) if vocab.name == "ICSTimeScale": subjects = set([ subj for subj, pred, obj in g if pred == typePredicate and obj == eraObj ]) newClass = get_model("ncgmp", "AgeTerm") else: subjects = set([subj for subj, pred, obj in g if str(subj).startswith(classifierPrefix)]) newClass = get_model("ncgmp", "VocabularyConcept") concepts = [] for s in subjects: newKwargs = { "uri": str(s), "label": "none", "vocabulary": vocab} try: labels = [l for p, l in g.preferredLabel(s) if l.language == 'en'] if len(labels) > 0: newKwargs["label"] = str(labels[0]) except UnicodeEncodeError: newKwargs["label"] = "Character encoding error" try: definitions = [obj for obj in g.objects(subject=s, predicate=definitionPredicate)] if len(definitions) > 0: newKwargs["definition"] = str(definitions[0]) except UnicodeEncodeError: newKwargs["definition"] = "Character encoding error" if vocab.name == "ICSTimeScale": startPred = rdflib.term.URIRef("http://resource.geosciml.org/schema/cgi/trs/3.0/start") endPred = rdflib.term.URIRef("http://resource.geosciml.org/schema/cgi/trs/3.0/end") newKwargs["olderage"] = findAgeValue(g, s, startPred) newKwargs["youngerage"] = findAgeValue(g, s, endPred) if newKwargs['label'] != 'none': concepts.append(newClass(**newKwargs)) newClass.objects.bulk_create(concepts)
def version_and_file_transformer(apps): """Attach all the versions and files to the apps.""" if not apps: return # Avoids circular imports and uses Django's app cache. Version = models.get_model('versions', 'Version') File = models.get_model('files', 'File') ids = set(app.id for app in apps) versions = (Version.uncached.filter(addon__in=ids) .select_related('addon')) vids = [v.id for v in versions] files = (File.uncached.filter(version__in=vids) .select_related('version')) # Attach the files to the versions. f_dict = dict((k, list(vs)) for k, vs in amo.utils.sorted_groupby(files, 'version_id')) for version in versions: version.all_files = f_dict.get(version.id, []) # Attach the versions to the apps. v_dict = dict((k, list(vs)) for k, vs in amo.utils.sorted_groupby(versions, 'addon_id')) for app in apps: app.all_versions = v_dict.get(app.id, []) return apps
def report_waiter(request): w = None if request.GET.has_key('w'): w = request.GET['w'] if w == None: return render(request, 'pos/empty.html') orders = models.get_model('pos', 'Order').objects.all() orders = orders.filter(operatedBy=w).filter(reported=False) waiter = models.get_model('auth', 'user').objects.all().get(id=int(w)) total = 0 for o in orders: if o.status == False: return render(request, 'pos/error.html') total += o.total try: printReport(waiter.first_name, total) except Exception, err: c = template.RequestContext(request, { 'error' : err }) return render_to_response(['pos/print-error.html'], c) pass
def handle(self, *args, **options): fields_data = [] if len(args) != 0: for arg in args: field_spec = arg.split('.') if len(field_spec) == 1: app = get_app(field_spec[0]) models = get_models(app) for model in models: fields_data += all_fsm_fields_data(model) elif len(field_spec) == 2: model = get_model(field_spec[0], field_spec[1]) fields_data += all_fsm_fields_data(model) elif len(field_spec) == 3: model = get_model(field_spec[0], field_spec[1]) fields_data.append((model._meta.get_field_by_name(field_spec[2])[0], model)) else: for app in get_apps(): for model in get_models(app): fields_data += all_fsm_fields_data(model) dotdata = generate_dot(fields_data) if options['outputfile']: self.render_output(dotdata, **options) else: print(dotdata)
def get_changes(self): # Get the model defs so we can use them for the yield later model_defs = freeze_apps([self.migrations.app_label()]) # Make the model changes for model_name in self.added_models: model = models.get_model(self.migrations.app_label(), model_name) real_fields, meta, m2m_fields = self.split_model_def(model, model_defs[model_key(model)]) yield ("AddModel", { "model": model, "model_def": real_fields, }) # And the field changes for field_desc in self.added_fields: try: model_name, field_name = field_desc.split(".") except (TypeError, ValueError): raise ValueError("%r is not a valid field description." % field_desc) model = models.get_model(self.migrations.app_label(), model_name) real_fields, meta, m2m_fields = self.split_model_def(model, model_defs[model_key(model)]) yield ("AddField", { "model": model, "field": model._meta.get_field_by_name(field_name)[0], "field_def": real_fields[field_name], }) # And the indexes for field_desc in self.added_indexes: try: model_name, field_name = field_desc.split(".") except (TypeError, ValueError): print("%r is not a valid field description." % field_desc) model = models.get_model(self.migrations.app_label(), model_name) yield ("AddIndex", { "model": model, "fields": [model._meta.get_field_by_name(field_name)[0]], })
def trocaEstado(self, vIDCurriculo, vIDEstado, vIDUsuario=None): try: iCurriculo= Curriculo().obtemCurriculoPeloID(vIDCurriculo, vIDUsuario) if vIDUsuario != None: iUsuario= Usuario().obtemUsuario(vIDUsuario) Usuario().verificaPermissaoDoUsuario(iUsuario.empresa.id, iCurriculo.vaga.empresa.id) iCurriculo.estado= Estado_do_Curriculo().obtemEstadoDoCurriculoPeloID(vIDEstado) iCurriculo.save() if vIDUsuario != None: iEmail= None mWorkflow= get_model('workflow', 'Workflow') if vIDEstado == constantes.cntEstadoDoCurriculoContratado: iEmail= mWorkflow().obtemEtapaDoWorkflowDaEmpresa(iCurriculo.vaga.empresa, constantes.cntWorkflowOrdemEtapaContratacao).email_aprovado elif vIDEstado == constantes.cntEstadoDoCurriculoRejeitado: iEtapaAtual= mWorkflow().obtemEtapaAtualDoCurriculo(iCurriculo) iEmail= iEtapaAtual.email_reprovado if iEmail != None: mEmail= get_model('comunicacao', 'Email') mEmail().criaEEnviaEmail(iEmail.assunto, iEmail.texto, [iCurriculo.candidato.id], vIDUsuario, iCurriculo.vaga.empresa) return True except Exception, e: Erro().registraLog('trocaEstado', 'models.py', 'curriculo', str(e), constantes.cntTipoLogErro) return False
def decode_object(ref): decoded = ref.split(".") if len(decoded) == 4: app, name, pk, msgid = decoded return get_model(app, name).objects.get(pk=pk), msgid app, name, pk = decoded return get_model(app, name).objects.get(pk=pk), None
def get_model(model=DEFAULT_MODEL, app=DEFAULT_APP): """ >>> from django.db import connection >>> connection.close() >>> get_model('WikiI').__name__.startswith('WikiItem') True >>> connection.close() >>> isinstance(get_model('master'), models.base.ModelBase) True >>> connection.close() >>> get_model(get_model('CaseMaster', DEFAULT_APP)).objects.count() >= 0 True """ # print 'get_model' + repr(model) + ' app ' + repr(app) if isinstance(model, models.base.ModelBase): return model app = get_app(app) try: model_object = models.get_model(app, model) if model_object: return model_object except: pass app = get_app(app) if not app: return None model_names = [mc.__name__ for mc in models.get_models(app)] if app and model and model_names: return models.get_model(app.__package__.split('.')[-1], fuzzy.extractOne(str(model), model_names)[0])
def incidencia_despres_de_posar(instance): Missatge = get_model( 'missatgeria','Missatge') #Lògica de negoci: #tipusIncidencia if not instance.tipus.es_informativa: #Si aquest alumne ja té tres incidències cal expulsar-lo --> Envio missatge al professor. import datetime as t fa_30_dies = instance.dia_incidencia - t.timedelta( days = +30) Incidencia = get_model( 'incidencies','Incidencia') nIncidenciesAlumneProfessor = Incidencia.objects.filter( es_vigent = True, tipus__es_informativa = False, professional = instance.professional, alumne = instance.alumne, dia_incidencia__gt = fa_30_dies ).count() if nIncidenciesAlumneProfessor > 2: txt = u"""A l'alumne {0} ja li has posat {1} incidències en els darrers 30 dies. Segons la normativa del Centre has de tramitar una expulsió per acumulació d'incidències.""".format( instance.alumne, nIncidenciesAlumneProfessor ) msg = Missatge( remitent = instance.professional.getUser(), text_missatge = txt ) msg.enllac = '/incidencies/posaExpulsioPerAcumulacio/' + str( instance.pk ) if nIncidenciesAlumneProfessor > 5: msg.importancia = 'VI' msg.envia_a_usuari(instance.professional) #Cal que els professors i tutors sàpiguen que aquest alumne ha tingut incidència --> Envio missatge remitent = instance.professional text_missatge = u"""Ha posat una incidència {0}a {1} ({2}) el dia {3}. El text de la incidència és: {4}""".format( #tipusIncidencia 'informativa ' if instance.tipus.es_informativa else '', instance.alumne, instance.alumne.grup, instance.dia_incidencia, instance.descripcio_incidencia) msg1 = Missatge( remitent = remitent.getUser(), text_missatge = text_missatge ) #si és una unitat formativa envio a tots: es_unitat_formativa = False try: from aula.apps.assignatures.models import TipusDAssignatura uf = TipusDAssignatura.objects.get( tipus_assignatura__startswith = 'Unitat Formativa' ) es_unitat_formativa = \ instance.control_assistencia and \ instance.control_assistencia.impartir.horari.assignatura.tipus_assignatura == uf except: pass if es_unitat_formativa: Professor = get_model( 'usuaris','Professor') professors_que_tenen_aquest_alumne_a_classe = Professor.objects.filter( horari__impartir__controlassistencia__alumne = instance.alumne ).exclude( pk = instance.professional.pk ).distinct() for professor in professors_que_tenen_aquest_alumne_a_classe: esTutor = True if professor in instance.alumne.tutorsDeLAlumne() else False importancia = 'VI' if esTutor else 'PI' msg1.envia_a_usuari( professor.getUser(), importancia ) else: professors_tutors_de_l_alumne = [ p for p in instance.alumne.tutorsDeLAlumne() ] for professor in professors_tutors_de_l_alumne: importancia = 'PI' msg1.envia_a_usuari( professor.getUser(), importancia )
def handle_query_flight(self): """return a QueryFlight model object""" QueryFlight = models.get_model("skyscanner_scraper", "QueryFlight") query_info = self.route_date_dict.get("Query", {}) query_id = query_info['RequestId'] #get the origin stations, can be multiple if the origin is city with many airport or a country origin_stations_id = query_info["OriginPlaceInfo"].get("AirportIds", list()) origin_stations_qs = models.get_model("skyscanner_scraper", "Station").objects.all().filter(code__in=origin_stations_id) #get the destination stations, destination_stations_id = query_info["DestinationPlaceInfo"].get("AirportIds", list()) destination_stations_qs = models.get_model("skyscanner_scraper", "Station").objects.all().filter(code__in=destination_stations_id) outbound_date = self._get_datetime(query_info.get("OutboundDate")).date() inbound_date = None inbound_datetime = self._get_datetime(query_info.get("InboundDate")) #outbound date can me None if the flight is a one way if inbound_datetime: inbound_date = inbound_datetime.date() defaults = { "inbound_date":inbound_date, "outbound_date":outbound_date, } query_flight, created, merged = merge_or_create( QueryFlight, request_id = query_id, defaults = defaults, ) query_flight.origin_station_set = origin_stations_qs query_flight.destination_station_set = destination_stations_qs self.query_flight = query_flight return query_flight
def parse_related_tag(bits): if len(bits) < 6: raise template.TemplateSyntaxError, "{% related N [app_label.Model, ...] for object as var_name %}" if not bits[1].isdigit(): raise template.TemplateSyntaxError, "Count must be an integer." if bits[-2] != 'as': raise template.TemplateSyntaxError, "Tag must end with as var_name " if bits[-4] != 'for': raise template.TemplateSyntaxError, "Tag must end with for object as var_name " mods = [] for m in bits[2:-4]: if m == ',': continue if ',' in m: ms = m.split(',') for msm in ms: if not msm: continue try: mods.append(models.get_model(*msm.split('.'))) except: raise template.TemplateSyntaxError, "%r doesn't represent any model." % msm else: try: mods.append(models.get_model(*m.split('.'))) except: raise template.TemplateSyntaxError, "%r doesn't represent any model." % m return bits[-3], int(bits[1]), bits[-1], mods
def getFinancialConditions(self): """Get financial condition for this client by profil @return: ((profil1, avgrate1), (profil2, avgrate2)...)""" FinancialCondition = get_model("staffing", "FinancialCondition") ConsultantProfile = get_model("people", "ConsultantProfile") data = {} rates = [] for profil in ConsultantProfile.objects.all(): data[profil] = [] #for profil in ConsultantProfile for fc in FinancialCondition.objects.filter(mission__lead__client=self, consultant__timesheet__charge__gt=0, # exclude null charge consultant__timesheet=models.F("mission__timesheet") # Join to avoid duplicate entries ).select_related(): data[fc.consultant.profil].append(fc.daily_rate) # compute average for profil, profilRates in data.items(): if len(profilRates) > 0: avg = sum(profilRates) / len(profilRates) else: avg = None rates.append((profil, avg)) # Sort by profil rates.sort(key=lambda x: x[0].level) return rates
def clear_orphaned_result(self, item=None): """Verifies and, if required, deletes the result of a 'PENDING' order on the EDC that has no result items and the result is NEW. Args: item: can be either a Result instance or an order_identifier. """ Result = apps.get_model('lab_clinic_api', 'result') LisResultItem = apps.get_model('lab_result_item', 'resultitem') if isinstance(item, Result): result = item elif Result.objects.filter(order__order_identifier=item).exists(): result = Result.objects.get(order__order_identifier=item, status='NEW') else: result = None if result: # result is on EDC # is it on the django-lis? if not LisResult.objects.using('lab_api').filter(result_identifier=result.result_identifier).exists(): lis_result = LisResult.objects.using('lab_api').get(result_identifier=result.result_identifier) # ...with resultitems? if not LisResultItem.objects.using('lab_api').filter(result=lis_result).exists(): lis_order = lis_result.order lis_order.status = 'WITHDRAWN' logger.info(' refreshing order status on django-lis for order {0}'.format(lis_order.order_identifier)) lis_order.save() logger.info(' deleting orphaned result on django-lis (no items) for order {0}'.format(lis_result.order.order_identifier)) lis_result.delete() # does it have resultitems on the EDC? ResultItem = apps.get_model('lab_clinic_api', 'resultitem') if not ResultItem.objects.filter(result=result).exists(): order = result.order logger.info(' refreshing order status on EDC for order {0}'.format(order.order_identifier)) order.save() logger.info(' deleting orphaned result (no items) on EDC for order {0}'.format(result.order.order_identifier)) result.delete()
def handle_get(self, request, user, *args, **kwargs): """Treat requests GET to list all Equipment Type. URL: equipmenttype/all """ try: TipoEquipamento = get_model('equipamento', 'TipoEquipamento') EquipamentoError = get_model('equipamento', 'EquipamentoError') self.log.info('GET to list all Equipment Type') # User permission if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.READ_OPERATION): self.log.error( u'User does not have permission to perform the operation.') raise UserNotAuthorizedError(None) map_list = [] for equipment_type in TipoEquipamento.objects.all(): eq_tp = { 'id': equipment_type.id, 'nome': equipment_type.tipo_equipamento} map_list.append(eq_tp) return self.response(dumps_networkapi({'equipment_type': map_list})) except UserNotAuthorizedError: return self.not_authorized() except EquipamentoError: return self.response_error(1)
def find_versions(self, name, txn=None): res = self.all() CollectorRun = models.get_model('rds', 'CollectorRun') Snapshot = models.get_model('rds', 'Snapshot') collector_run = CollectorRun.objects.get_or_create(collector=name)[0] if collector_run.collector == 'parameter_group': db_table = 'param_groups' elif collector_run.collector == 'db_instance': db_table = 'db_instances' elif collector_run.collector == 'config_file': db_table = 'config_files' latest_txn = None try: latest_txn = Snapshot.objects.filter(collector_run__id=collector_run.id).order_by('-txn')[0].txn except Exception: latest_txn = Snapshot.objects.head() if isinstance(txn, int) and txn < 0: txn = latest_txn txn = 0 if txn < 0 else txn elif isinstance(txn, int) and txn > latest_txn: txn = latest_txn elif txn == 'latest': txn = latest_txn res = res.extra( tables = ['snapshots'], where = ['snapshots.collector_run_id=%s %s AND %s.id=snapshots.statistic_id' % (str(collector_run.id), '' if txn is None else 'AND snapshots.txn=%s' % (str(txn)), db_table)] ) return res
def num_times_used(self): ctype = self.content_type page_count = get_model('promotions', 'PagePromotion').objects.filter(content_type=ctype, object_id=self.id).count() keyword_count = get_model('promotions', 'KeywordPromotion').objects.filter(content_type=ctype, object_id=self.id).count() return page_count + keyword_count
def laby(request): player = get_model('labyrinth', 'player') labyrinth = get_model('labyrinth', 'labyrinth') results = [] success = False plr = player() lab = labyrinth() qs = request.META['QUERY_STRING'] if qs is not None: path = list(qs) for waypoint in path: if waypoint not in ['V', 'R', 'H', 'L']: break point = lab.checkMove(plr, waypoint) results.append(point) if point == '0': break elif point == 'E': success = True break return render_to_response('labyrinth.html', {'results': results, 'success': success, 'lab': lab, 'plr': plr})
def handle(self, *args, **options): Feed = models.get_model('planet', 'feed') Post = models.get_model('planet', 'post') import feedparser from dateutil.parser import parse as date_parse feeds = Feed.objects.filter(is_active=True) for feed in feeds: d = feedparser.parse(feed.feed_url) if not d['status'] == 200: feed.is_active = False feed.save() break for entry in d.entries: post, created = Post.objects.get_or_create(guid=entry.guid, defaults={ 'feed': feed }) if created: post.title = entry.title post.link = entry.link post.content = entry.description post.guid = entry.guid if entry.get('author_detail', None): post.author = entry.author_detail.name post.author_email = entry.author_detail.email post.date_modified = date_parse(entry.updated) post.save()
def get_profile_model(profile_slug=None): """ Return the model class for the profile module identified by the given ``profile_slug``, as defined in the ``AUTH_PROFILE_MODULE`` or ``IDIOS_PROFILE_MODULES`` settings. If ``profile_slug`` is not provided, return the default profile model. If no matching profile model is found, return None. If no default profile model is found, raise ``django.contrib.auth.models.SiteProfileNotAvailable``. """ if profile_slug is None: module = idios.settings.DEFAULT_PROFILE_MODULE if module is None: raise SiteProfileNotAvailable model = get_model(*module.split(".")) if model is None: raise SiteProfileNotAvailable else: for module in idios.settings.PROFILE_MODULES: model = get_model(*module.split(".")) if model and profile_slug == model.profile_slug: break else: model = None return model
def send_updated_log(request): timestamp = request.GET.get('timestamp', None) if not timestamp: #for testing purpose timestamp = '2012-03-10 12:06:04' CocoUser = get_model('dashboard','CocoUser') CocoUserVillages = get_model('dashboard','CocoUser_villages') ServerLog = get_model('dashboard','ServerLog') Village = get_model('dashboard', 'village') if request.user.id == 1: #admin account partner_id = None villages = Village.objects.all().values_list('id', flat=True) else: coco_user = CocoUser.objects.get(user_id=request.user.id) partner_id = coco_user.partner_id villages = CocoUserVillages.objects.filter(cocouser_id = coco_user.id).values_list('village_id', flat = True) if timestamp: if partner_id: rows = ServerLog.objects.filter(timestamp__gte = timestamp, village__in = villages, partner = partner_id ) else: rows = ServerLog.objects.filter(timestamp__gte = timestamp, village__in = villages) else: if partner_id: rows = ServerLog.objects.filter(village__in = villages, partner = partner_id ) else: rows = ServerLog.objects.filter(village__in = villages) print len(rows) if rows: from django.core import serializers data = serializers.serialize('json', rows, fields=('action','entry_table','model_id', 'timestamp')) return HttpResponse(data, mimetype="application/json") else: return HttpResponse("0")
def _check_groups(self, user, perm, obj, model_perm_query, object_flag): # jedna negujaca - nie ma uprawnienia, jedna pozytywne i brak negujacych - pozytywne positive = False for group in get_model("flags", "Group").objects.filter(members__exact=user): model_exists = ( get_model("flags", "GroupContentFlag") .objects.filter(group__exact=group, content_flag__in=model_perm_query) .exists() ) if object_flag: obj_exists = ( get_model("flags", "GroupContentFlag") .objects.filter(group__exact=group, content_flag__exact=object_flag) .exists() ) else: obj_exists = False if model_exists or obj_exists: result = model_exists ^ obj_exists # jesli zabronione to koniec if not result: return result else: positive = True if positive: return positive return None
def convert_to_impact_project(self): """ When a project is converted to an RSR Impact project, it is not possible to edit the actual values of the indicators and the actual values should be converted to updates. """ for result in self.results.all(): for indicator in result.indicators.all(): for period in indicator.periods.all(): if period.actual_value: try: update_value = Decimal(period.actual_value) - period.baseline except (InvalidOperation, TypeError): continue period.actual_value = str(period.baseline) period.save(update_fields=['actual_value']) get_model('rsr', 'ProjectUpdate').objects.create( project=self, # TODO: What user should we link to a 'system' update? # We could make sure that the 1st user in the database is a 'system' # user. user=get_model('rsr', 'user').objects.all()[0], title=u'Initial value of indicator period', text=u'Initial value of indicator period, added by system while ' u'calculating the actual value of this indicator period.', indicator_period=period, period_update=update_value, )
def expulsio_despres_de_posar(instance): professor_recull = instance.professor_recull professor_expulsa = instance.professor Missatge = get_model( 'missatgeria','Missatge') # missatge pel professor que recull la incidència: if professor_recull != professor_expulsa: msg = Missatge( remitent = professor_recull.getUser(), text_missatge = u'''ha recollit la següent expulsió: {0}'''.format( unicode( instance ) ) ) msg.envia_a_usuari(instance.professor_recull.getUser(), 'PI') # missatge pel professor que expulsa: msg = Missatge( remitent = professor_recull.getUser(), text_missatge = u'''Cal tramitar expulsió: {0}'''.format( unicode( instance ) ), enllac = '/incidencies/editaExpulsio/{0}/'.format( instance.pk ) ) msg.envia_a_usuari(instance.professor.getUser(), 'VI') # missatge pels professors que tenen aquest alumne a l'aula (exepte el professor que expulsa): msg = Missatge( remitent = professor_recull.getUser(), text_missatge = unicode( instance ) ) Professor = get_model( 'usuaris','Professor') professors_que_tenen_aquest_alumne_a_classe = Professor.objects.filter( horari__impartir__controlassistencia__alumne = instance.alumne ).exclude( pk = instance.professor.pk ).distinct() for professor in professors_que_tenen_aquest_alumne_a_classe: esTutor = True if professor in instance.alumne.tutorsDeLAlumne() else False importancia = 'VI' if esTutor else 'PI' msg.envia_a_usuari( professor.getUser(), importancia )
def location_mapping_reverse(self, g, rdfPred, djField, lang=None): rdf_values = set(g.objects(rdflib.term.URIRef(self.uri), rdfPred)) # Values contient des instances de Location. # Il faut remonter soit a des Located soit a des AreaLink values = map(coop.models.StaticURIModel.toDjango, rdf_values) if djField == 'located': m = models.get_model('coop_geo', 'located') try: values = set(map(lambda x: m.objects.get(object_id=self.id, location=x), values)) except m.DoesNotExist: values = set([]) elif djField == 'framed': m = models.get_model('coop_geo', 'arealink') try: values = set(map(lambda x: m.objects.get(object_id=self.id, location=x), values)) except m.DoesNotExist: values = set([]) manager = getattr(self, djField) old_values = set(manager.all()) remove = old_values.difference(values) add = values.difference(old_values) for v in remove: manager.remove(v) for v in add: manager.add(v)
def save_value(self, product, value): try: value_obj = product.attribute_values.get(attribute=self) except get_model('catalogue', 'ProductAttributeValue').DoesNotExist: # FileField uses False for anouncing deletion of the file # not creating a new value delete_file = self.is_file and value is False if value is None or value == '' or delete_file: return model = get_model('catalogue', 'ProductAttributeValue') value_obj = model.objects.create(product=product, attribute=self) if self.is_file: # File fields in Django are treated differently, see # django.db.models.fields.FileField and method save_form_data if value is None: # No change return elif value is False: # Delete file value_obj.delete() else: # New uploaded file value_obj.value = value value_obj.save() else: if value is None or value == '': value_obj.delete() return if value != value_obj.value: value_obj.value = value value_obj.save()
def object_delete(request, survey_slug, object_id=None, group_slug=None, group_slug_field=None, group_qs=None, template_name=None, extra_context=None, object_type=None, *args, **kw): """ Refactored from all the whatever_delete() functions there were. """ # TRICK: The following line does not have any logical explination # except than working around a bug in FF. It has been suggested there # http://groups.google.com/group/django-users/browse_thread/thread/e6c96ab0538a544e/0e01cdda3668dfce#0e01cdda3668dfce request_post = request.POST.copy() if not object_type: raise Http404 if not object_id and object_type == 'survey': return delete_object(request, slug=survey_slug, **{"model":models.get_model("survey", object_type), "post_delete_redirect": reverse("survey-editable", kwargs={}), "template_object_name": object_type, "login_required": True, 'extra_context': {'title': _('Delete %s' % object_type )} }) return delete_object(request, object_id=object_id, **{"model":models.get_model("survey", object_type), "post_delete_redirect": reverse("survey-edit", None, (), {"survey_slug": survey_slug }), "template_object_name": object_type, "login_required": True, 'extra_context': {'title': _('Delete %s' % object_type )} })
def get_queryset(self): if self.request.user.is_authenticated(): q1 = Q(author__exact=self.request.user) q2 = Q(is_promoted__exact=True, is_published__exact=True) return get_model('epapyrus', 'Article').objects.filter(q1|q2) else: return get_model('epapyrus', 'Article').objects.filter(is_promoted__exact=True, is_published__exact=True);
def get_child_class(self): """Returns child class""" # for Russia can be added okrug level # for USSR also republic if self.child_class: return models.get_model(*self.child_class.rsplit('.', 1)) return models.get_model('geo', 'region')
GOOGLE_MAPS_API_KEY from xml.dom import minidom import copy import os import urllib try: from PIL import Image except ImportError: import Image if not settings.AUTH_PROFILE_MODULE: raise SiteProfileNotAvailable try: app_label, model_name = settings.AUTH_PROFILE_MODULE.split('.') Profile = models.get_model(app_label, model_name) except (ImportError, ImproperlyConfigured): raise SiteProfileNotAvailable if not Profile: raise SiteProfileNotAvailable if AVATAR_WEBSEARCH: try: import gdata.service import gdata.photos.service except: raise GoogleDataAPINotFound def get_profiles():
def inner_method(models, schema_editor): Pony = models.get_model(app_label, "Pony") Pony.objects.create(pink=1, weight=3.55) Pony.objects.create(weight=5)
def _get_model(self): # Gets the model class from the string name # We assume all of the models are in the Raw app res = get_model('raw', self.ref_model) return res
def get_num_user_applications(self, user): OrderDiscount = models.get_model('order', 'OrderDiscount') aggregates = OrderDiscount.objects.filter( offer_id=self.id, order__user=user).aggregate(total=models.Sum('frequency')) return aggregates['total'] if aggregates['total'] is not None else 0
def order_items(self): OrderItem = models.get_model('bcpp_lab', 'orderitem') return OrderItem.objects.filter(order__pk=self.pk)
def send_updated_admin_log(request): if request.method == 'POST': apikey = request.POST['ApiKey'] timestamp = request.POST['timestamp'] if timestamp: try: apikey_object = ApiKey.objects.get(key=apikey) user = apikey_object.user except Exception: return HttpResponse("-1", status=401) AdminUser = get_model('loop', 'AdminUser') try: requesting_admin_user = AdminUser.objects.get(user_id=user.id) preferred_language = requesting_admin_user.preferred_language.notation user_list = AdminUser.objects.filter( id=requesting_admin_user.id).values_list('user__id', flat=True) except Exception: raise UserDoesNotExist('User with id: ' + str(user.id) + 'does not exist') districts = requesting_admin_user.get_districts() loopusers = requesting_admin_user.get_loopusers() Log = get_model('loop', 'AdminLog') Mandi = get_model('loop', 'Mandi') Gaddidar = get_model('loop', 'Gaddidar') Village = get_model('loop', 'Village') GaddidarCommission = get_model('loop', 'GaddidarCommission') AdminAssignedDistrict = get_model('loop', 'AdminAssignedDistrict') LoopUser = get_model('loop', 'LoopUser') Farmer = get_model('loop', 'Farmer') CropLanguage = get_model('loop', 'CropLanguage') VehicleLanguage = get_model('loop', 'VehicleLanguage') LoopUserAssignedVillage = get_model('loop', 'loopuserassignedvillage') LoopUserAssignedMandi = get_model('loop', 'loopuserassignedmandi') District = get_model('loop', 'District') Block = get_model('loop', 'Block') list_rows = [] #AdminUser Log district_queryset = Log.objects.filter(timestamp__gt=timestamp, entry_table="District", admin_user=None) for row in district_queryset: if District.objects.get(id=row.model_id) in districts: list_rows.append(row) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, entry_table="District", admin_user=requesting_admin_user)) block_queryset = Log.objects.filter(timestamp__gt=timestamp, entry_table="Block", admin_user=None) for row in block_queryset: if Block.objects.get(id=row.model_id).district in districts: list_rows.append(row) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, entry_table="Block", admin_user=requesting_admin_user)) village_list_queryset = Log.objects.filter( timestamp__gt=timestamp, district__in=districts, entry_table__in=['Village'], admin_user=None) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, entry_table__in=['Village'], admin_user=requesting_admin_user)) for vrow in village_list_queryset: if AdminAssignedDistrict.objects.get( admin_user=requesting_admin_user, district=vrow.district).aggregation_switch == True: list_rows.append(vrow) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, model_id=requesting_admin_user.id, entry_table__in=['AdminUser'])) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, entry_table__in=['Crop', 'Vehicle'])) loopuser_querset = Log.objects.filter(timestamp__gt=timestamp, entry_table__in=['LoopUser'], admin_user=None) for row in loopuser_querset: try: if LoopUser.objects.get(id=row.model_id) in loopusers: list_rows.append(row) except: pass list_rows.append( Log.objects.filter(timestamp__gt=timestamp, entry_table__in=['LoopUser'], admin_user=requesting_admin_user)) #Mandi Log list_rows.append( Log.objects.filter(timestamp__gt=timestamp, district__in=districts, entry_table__in=['Mandi'], admin_user=None)) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, entry_table__in=['Mandi'], admin_user=requesting_admin_user)) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, district__in=districts, entry_table__in=['Gaddidar'], admin_user=None)) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, entry_table__in=['Gaddidar'], admin_user=requesting_admin_user)) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, district__in=districts, entry_table__in=['GaddidarCommission'], admin_user=None)) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, entry_table__in=['GaddidarCommission'], admin_user=requesting_admin_user)) loopuserassignedvillage_queryset = Log.objects.filter( timestamp__gt=timestamp, entry_table__in=['LoopUserAssignedVillage'], admin_user=None) loopuserassignedmandi_queryset = Log.objects.filter( timestamp__gt=timestamp, entry_table__in=['LoopUserAssignedMandi'], admin_user=None) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, entry_table__in=[ 'LoopUserAssignedMandi', 'LoopUserAssignedVillage' ], admin_user=requesting_admin_user)) list_rows.append( Log.objects.filter(timestamp__gt=timestamp, entry_table__in=['Crop', 'Vehicle'])) croplanguage_query = Log.objects.filter( timestamp__gt=timestamp, entry_table__in=['CropLanguage']) for row in croplanguage_query: if CropLanguage.objects.get( id=row.model_id).language == preferred_language: list_rows.append(row) vehiclelanguage_query = Log.objects.filter( timestamp__gt=timestamp, entry_table__in=['VehicleLanguage']) for row in vehiclelanguage_query: if VehicleLanguage.objects.get( id=row.model_id).language == preferred_language: list_rows.append(row) for row in loopuserassignedvillage_queryset: try: if LoopUserAssignedVillage.objects.get( id=row.model_id).loop_user in loopusers: list_rows.append(row) except: pass for row in loopuserassignedmandi_queryset: try: if LoopUserAssignedMandi.objects.get( id=row.model_id).loop_user in loopusers: list_rows.append(row) except: pass data_list = [] for row in list_rows: if row: try: for i in row: objectData = get_admin_log_object( i, preferred_language) if objectData is not None: data_list.append(objectData) except TypeError: data_list.append( get_admin_log_object(row, preferred_language)) if list_rows: data = json.dumps(data_list, cls=DatetimeEncoder) return HttpResponse(data, content_type="application/json") return HttpResponse("0")
def get_profile(user): app_label, model_name = settings.AUTH_PROFILE_MODULE.split('.') model = models.get_model(app_label, model_name) return model.objects.get(user=user)
def _get_model_class(model_name): model = models.get_model(*model_name.split(".")) if model == None: raise Exception("%s is not a registered model, cannot use this task" % model_name) return model
from dateutil.parser import parse as du_parse from django.test import TestCase from django.db.models import get_model from oscar.test.factories import create_order from oscar.apps.partner.models import StockRecord from oscar_mws import mixins as mws_mixins from oscar_mws.test import mixins, factories from oscar_mws.fulfillment.creator import FulfillmentOrderCreator from oscar_mws.fulfillment.gateway import (update_fulfillment_order, update_inventory) ShippingEvent = get_model('order', 'ShippingEvent') ShippingEventType = get_model('order', 'ShippingEventType') ShipmentPackage = get_model('oscar_mws', 'ShipmentPackage') FulfillmentOrder = get_model('oscar_mws', 'FulfillmentOrder') FulfillmentShipment = get_model('oscar_mws', 'FulfillmentShipment') FulfillmentOrderLine = get_model('oscar_mws', 'FulfillmentOrderLine') class TestCreateFulfillmentOrder(mixins.DataLoaderMixin, TestCase): @httpretty.activate def test_creates_shipments_for_single_address(self): httpretty.register_uri( httpretty.POST, 'https://mws.amazonservices.com/FulfillmentOutboundShipment/2010-10-01', body=self.load_data('create_fulfillment_order_response.xml'),
def _get_model(model): m = get_model(*model.split('.')) if m is None: raise TemplateSyntaxError("Generic content tag got invalid model: %s" % model) return m
from django import template from django.db.models import get_model from oscar.apps.basket.forms import AddToBasketForm register = template.Library() product_model = get_model('catalogue', 'product') @register.tag(name="basket_form") def do_basket_form(parse, token): tokens = token.split_contents() if len(tokens) < 3 or tokens[2] != 'as': raise template.TemplateSyntaxError( "%r tag uses the following syntax: {% basket_form product_var as form_var %}" % tokens[0]) product_var = tokens[1] form_var = tokens[3] return BasketFormNode(product_var, form_var) class BasketFormNode(template.Node): def __init__(self, product_var, form_var): self.product_var = template.Variable(product_var) self.form_var = form_var def render(self, context): try: product = self.product_var.resolve(context)
from django.contrib import admin from django.db.models import get_model Voucher = get_model('voucher', 'Voucher') VoucherApplication = get_model('voucher', 'VoucherApplication') class VoucherAdmin(admin.ModelAdmin): list_display = ('name', 'code', 'usage', 'num_basket_additions', 'num_orders', 'total_discount') readonly_fields = ('num_basket_additions', 'num_orders', 'total_discount') fieldsets = ( (None, { 'fields': ('name', 'code', 'usage', 'start_date', 'end_date') }), ('Benefit', { 'fields': ('offers', ) }), ('Usage', { 'fields': ('num_basket_additions', 'num_orders', 'total_discount') }), ) class VoucherApplicationAdmin(admin.ModelAdmin): list_display = ('voucher', 'user', 'order', 'date_created') readonly_fields = ('voucher', 'user', 'order') admin.site.register(Voucher, VoucherAdmin) admin.site.register(VoucherApplication, VoucherApplicationAdmin)
from django.db import models from django.contrib.auth import authenticate from django.contrib.auth.backends import ModelBackend from django.utils import simplejson from django.utils.importlib import import_module from social_auth.utils import setting, log, model_to_ctype, ctype_to_model, \ clean_partial_pipeline from social_auth.store import DjangoOpenIDStore from social_auth.backends.exceptions import StopPipeline, AuthException, \ AuthFailed, AuthCanceled, \ AuthUnknownError, AuthTokenError, \ AuthMissingParameter if setting('SOCIAL_AUTH_USER_MODEL'): User = models.get_model(*setting('SOCIAL_AUTH_USER_MODEL').rsplit('.', 1)) else: from django.contrib.auth.models import User # OpenID configuration OLD_AX_ATTRS = [('http://schema.openid.net/contact/email', 'old_email'), ('http://schema.openid.net/namePerson', 'old_fullname'), ('http://schema.openid.net/namePerson/friendly', 'old_nickname')] AX_SCHEMA_ATTRS = [ # Request both the full name and first/last components since some # providers offer one but not the other. ('http://axschema.org/contact/email', 'email'), ('http://axschema.org/namePerson', 'fullname'), ('http://axschema.org/namePerson/first', 'first_name'), ('http://axschema.org/namePerson/last', 'last_name'),
def _get_model(self): if self._model is None: self._model = models.get_model(self.app_label, self.model_name) return self._model
# -*- coding: utf-8 -*- import datetime from django.db.models import get_model from django.core.urlresolvers import reverse from transifex.txcommon.tests import base Project = get_model('projects', 'Project') Resource = get_model('resources', 'Resource') Release = get_model('releases', 'Release') class ReleasesViewsTests(base.BaseTestCase): # Note: The Resource lookup field is tested in the resources app. def test_release_list(self): self.assertTrue(self.project.releases.all()) # Anonymous and maintainer should see it resp = self.client['anonymous'].get(self.urls['project']) self.assertContains(resp, self.release.name) resp = self.client['maintainer'].get(self.urls['project']) self.assertContains(resp, self.release.name) def test_release_list_noreleases(self): self.project.releases.all().delete() # Maintainer should see things resp = self.client['maintainer'].get(self.urls['project']) self.assertContains(resp, "No releases are registered")
from django.conf import settings from django import template from django.contrib.sites.models import Site from django.template import loader, Context try: # django >= 1.7 from django.apps import apps AnalyticsCode = apps.get_model('googletools', 'analyticscode') SiteVerificationCode = apps.get_model('googletools', 'siteverificationcode') except ImportError: # django < 1.7 from django.db.models import get_model AnalyticsCode = get_model('googletools', 'analyticscode') SiteVerificationCode = get_model('googletools', 'siteverificationcode') register = template.Library() class AnalyticsCodeNode(template.Node): def __init__(self, site): self.site = site self.template = 'googletools/analytics_code.html' self.enabled = getattr(settings, 'GOOGLETOOLS_ENABLED', not settings.DEBUG) try: self.code = AnalyticsCode.objects.get(site=self.site) except AnalyticsCode.DoesNotExist: self.code = None
def to_python(self, value): if isinstance(value, ModelBase): return value app_label, model_name = value.lower().split('.') return models.get_model(app_label, model_name)
from django.contrib.sites.models import Site from django.conf import settings from django.db.models import get_model from django.utils.translation import ugettext_lazy as _ from oscar.apps.shipping.methods import Free from oscar.core.loading import get_class from . import exceptions from decimal import Decimal as D ShippingAddress = get_model('order', 'ShippingAddress') Order = get_model('order', 'Order') Line = get_model('order', 'Line') LinePrice = get_model('order', 'LinePrice') LineAttribute = get_model('order', 'LineAttribute') OrderDiscount = get_model('order', 'OrderDiscount') order_placed = get_class('order.signals', 'order_placed') class OrderNumberGenerator(object): """ Simple object for generating order numbers. We need this as the order number is often required for payment which takes place before the order model has been created. """ def order_number(self, basket): """ Return an order number for a given basket
def voucher(self): Voucher = models.get_model('voucher', 'Voucher') try: return Voucher.objects.get(id=self.voucher_id) except Voucher.DoesNotExist: return None
def get_model(self, model_or_label): if isinstance(model_or_label, ModelBase): return model_or_label else: return models.get_model(*model_or_label.lower().split('.'))
from django import template from django.db import models from templatetag_sugar.register import tag from templatetag_sugar.parser import Constant, Variable, Name, Optional register = template.Library() Chunk = models.get_model('chunks', 'chunk') @tag(register, [Variable(), Optional([Constant("as"), Name()])]) def chunk(context, key, asvar=None): try: c = Chunk.objects.get(key=key) content = c.content except Chunk.DoesNotExist: content = '' if asvar: context[asvar] = content return "" return content
def user_model(cls): user_model = cls._meta.get_field('user').rel.to if isinstance(user_model, six.string_types): app_label, model_name = user_model.split('.') return models.get_model(app_label, model_name) return user_model
from decimal import Decimal as D from django import forms from django.utils.translation import ugettext_lazy as _ from django.db.models import get_model from oscar.templatetags.currency_filters import currency Account = get_model('accounts', 'Account') class ValidAccountForm(forms.Form): code = forms.CharField(label=_("Account code")) def __init__(self, user, *args, **kwargs): self.user = user super(ValidAccountForm, self).__init__(*args, **kwargs) def clean_code(self): code = self.cleaned_data['code'].strip().upper() code = code.replace('-', '') try: self.account = Account.objects.get(code=code) except Account.DoesNotExist: raise forms.ValidationError(_("No account found with this code")) if not self.account.is_active(): raise forms.ValidationError(_("This account is no longer active")) if not self.account.is_open(): raise forms.ValidationError(_("This account is no longer open")) if self.account.balance == D('0.00'): raise forms.ValidationError(_("This account is empty")) if not self.account.can_be_authorised_by(self.user):
def offer(self): Offer = models.get_model('offer', 'ConditionalOffer') try: return Offer.objects.get(id=self.offer_id) except Offer.DoesNotExist: return None
def get_queryset(self, content_group='default', exclude_ids=None, use_local_cache=True): cached = self.local_cache.get('get_queryset') if use_local_cache and cached: return cached exclude_ids = exclude_ids or [] _app, _model = self.model.split('.') model = models.get_model(_app, _model) queryset = model.objects.filter( published=True, date_available__lte=timezone.now(), site=self.site ) try: if model._meta.get_field_by_name('show_on_root_channel'): queryset = queryset.filter(show_on_root_channel=True) except: pass # silently pass when FieldDoesNotExists try: if self.channel and not self.channel.homepage: if self.recursive: channel_long_slug = [self.channel.long_slug] channel_descendants = self.channel.get_descendants( include_self=False) for children in channel_descendants: channel_long_slug.append(children.long_slug) queryset = queryset.filter( channel_long_slug__in=channel_long_slug) else: queryset = queryset.filter( channel_long_slug=self.channel.long_slug) except: pass if self.filters: filters = json.loads(self.filters) for key, value in filters.iteritems(): if value == "datetime.now()": filters[key] = datetime.now() queryset = queryset.filter(**filters) if self.excludes: excludes = json.loads(self.excludes) for key, value in excludes.iteritems(): if value == "datetime.now()": excludes[key] = datetime.now() queryset = queryset.exclude(**excludes) # importing here to avoid circular imports from opps.containers.models import Container if issubclass(model, Container): queryset = queryset.exclude( id__in=exclude_ids ) order_term = self.order_field or 'id' if self.order == '-': order_term = "-{0}".format(self.order_field or 'id') queryset = queryset.order_by(order_term) result = queryset[self.offset:self.limit] if use_local_cache: self.local_cache['get_queryset'] = result return result
def get_model_from_string(model_path): try: app_label, model_name = model_path.rsplit('.models.') return models.get_model(app_label, model_name) except: return None
class Meta: VipRequestPortPool = get_model('api_vip_request', 'VipRequestPortPool') model = VipRequestPortPool fields = ('id', 'server_pool', 'l7_rule', 'l7_value', 'order')
# -*- coding: utf-8- -*- from __future__ import unicode_literals import factory from django.db.models import get_model from django.contrib.auth import get_user_model from django.contrib.auth.hashers import make_password Room = get_model('filerooms', 'Room') Download = get_model('filerooms', 'Download') User = get_user_model() class NormalUserFactory(factory.DjangoModelFactory): is_superuser = False is_staff = False is_active = True first_name = factory.Sequence(lambda n: 'first-{0}'.format(n)) last_name = factory.Sequence(lambda n: 'last-{0}'.format(n)) username = factory.Sequence(lambda n: 'user-{0}'.format(n)) email = factory.Sequence(lambda n: 'user-{0}@snowballone.com.au'.format(n)) password = make_password('test') class Meta: model = User class StaffUserFactory(NormalUserFactory): is_staff = True
def get_profile_class(): profile_string = settings.AUTH_PROFILE_MODULE app_label, model = profile_string.split('.') return models.get_model(app_label, model)
class Meta: VipRequestGroupPermission = get_model('api_vip_request', 'VipRequestGroupPermission') model = VipRequestGroupPermission fields = ('group', 'read', 'write', 'change_config', 'delete')