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')
