class PlatformFilter(FilterSet):
Field.register_lookup(NotEqual)
#Field.register_lookup(NotIn)
status = filters.TypedChoiceFilter(choices=BOOLEAN_CHOICES, coerce=strtobool)
class Meta:
model = Platform
fields = {
#filters:'exact','ne', 'lt', 'gt', 'lte', 'gte', 'in', icontains
'id': ['exact', 'ne', 'in'], #notin
'pid': ['exact', 'ne','in'], #notin
'tspr': ['exact', 'ne'],
'type': ['exact', 'ne', 'in'], #notin
'inst': ['exact'], #einai kai kleidi gia institutions opote ftiaxnei drop down me ta institutions
'inst__id': ['exact', 'in'],
'dts': [ 'lt', 'gt', 'lte', 'gte', 'icontains'],
'dte': [ 'lt', 'gt', 'lte', 'gte', 'icontains'],
'lat': ['lt', 'gt', 'lte', 'gte'],
'lon': ['lt', 'gt', 'lte', 'gte'],
'status': [],
'params' : ['icontains'],
'platform_code': [],
'wmo': ['exact', 'ne', 'icontains'],
'pi_name' : ['icontains'],
'author' : [],
'contact' : [],
'island': [],
'pl_name' : [],
'inst_ref' : [],
'assembly_center' : ['exact', 'ne', 'in'],
'site_code' : [],
'source' : [],
'cdf_inst': ['exact']
}
class Poseidon_db_List(generics.ListAPIView):
swagger_schema = None
# Only staff users allowed
#permission_classes = (UserPermission, )
def get_queryset(self):
platform = self.kwargs['platform']
t = getModel_no_dvalqc()
t._meta.db_table = 'public\".\"' + platform
queryset = t.objects.all()
return queryset
def get_serializer_class(self):
platform = self.kwargs['platform']
t = getModel_no_dvalqc()
t._meta.db_table = 'public\".\"' + platform
serializer_class = NoDvalqcDataSerializer
serializer_class.Meta.model = t
return serializer_class
filter_backends = (DjangoFilterBackend, )
Field.register_lookup(NotEqual)
filter_fields = {
'dt': ['lt', 'gt', 'lte', 'gte', 'icontains'],
'pres': ['lt', 'gt', 'lte', 'gte', 'in'],
'param__id': ['exact', 'ne', 'in'],
}
def test_custom_lookup_in_search_fields(self):
band = Group.objects.create(name='The Hype')
concert = Concert.objects.create(name='Woodstock', group=band)
m = ConcertAdmin(Concert, custom_site)
m.search_fields = ['group__name__cc']
Field.register_lookup(Contains, 'cc')
try:
request = self.factory.get('/', data={SEARCH_VAR: 'Hype'})
cl = m.get_changelist_instance(request)
self.assertCountEqual(cl.queryset, [concert])
request = self.factory.get('/', data={SEARCH_VAR: 'Woodstock'})
cl = m.get_changelist_instance(request)
self.assertCountEqual(cl.queryset, [])
finally:
Field._unregister_lookup(Contains, 'cc')
def test_custom_lookup_in_search_fields(self):
band = Group.objects.create(name='The Hype')
concert = Concert.objects.create(name='Woodstock', group=band)
m = ConcertAdmin(Concert, custom_site)
m.search_fields = ['group__name__cc']
Field.register_lookup(Contains, 'cc')
try:
request = self.factory.get('/', data={SEARCH_VAR: 'Hype'})
cl = m.get_changelist_instance(request)
self.assertCountEqual(cl.queryset, [concert])
request = self.factory.get('/', data={SEARCH_VAR: 'Woodstock'})
cl = m.get_changelist_instance(request)
self.assertCountEqual(cl.queryset, [])
finally:
Field._unregister_lookup(Contains, 'cc')
class Cdf_InstitutionFilter(FilterSet):
Field.register_lookup(NotEqual)
#Field.register_lookup(NotIn)
class Meta:
model = Cdf_Institution
fields = {
#filters:'exact','ne', 'lt', 'gt', 'lte', 'gte', 'in', icontains
'id': ['exact', 'ne', 'in'], #notin
'name' : ['exact', 'ne', 'icontains'],
'inst_id' : ['exact', 'in']
}
class InstitutionFilter(FilterSet):
Field.register_lookup(NotEqual)
#Field.register_lookup(NotIn)
class Meta:
model = Institution
fields = {
#filters:'exact','ne', 'lt', 'gt', 'lte', 'gte', 'in', icontains
'id': ['exact', 'ne', 'in'], #notin
'name_native' : ['exact', 'ne', 'icontains'],
'abrv' : ['exact', 'ne', 'in', 'icontains'], #notin
'country' : ['exact', 'ne', 'in', 'icontains'], #notin
'cdf_name' : []
}
class DeepObservDataList(generics.ListAPIView):
"""
View to list Deep Observer's data.
* Requires token authentication.
get:
Return a list of all the deep observer's data.
"""
swagger_schema = None
authentication_classes = [OAuth2Authentication]
permission_classes = [TokenHasScope]
required_scopes = ['user']
def get_queryset(self):
platform = self.kwargs['platform']
t = DeepObservgetModel()
t._meta.db_table = 'data\".\"' + platform
queryset = t.objects.all()
return queryset
def get_serializer_class(self):
platform = self.kwargs['platform']
t = DeepObservgetModel()
t._meta.db_table = 'data\".\"' + platform
serializer_class = DeepObservDataSerializer
serializer_class.Meta.model = t
return serializer_class
filter_backends = (
DjangoFilterBackend,
OrderingFilter,
)
Field.register_lookup(NotEqual)
filter_fields = {
# available filters:'exact','ne', 'lt', 'gt', 'lte', 'gte', 'in', icontains
'id': ['exact', 'ne', 'in'], # notin
'dt': ['lt', 'gt', 'lte', 'gte', 'icontains'],
'lat': ['lt', 'gt', 'lte', 'gte'],
'lon': ['lt', 'gt', 'lte', 'gte'],
'posqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'], # notin
'pres': ['lt', 'gt', 'lte', 'gte'],
'presqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'], # notin
'param': ['exact'],
'param__id': ['exact', 'ne', 'in'], # notin
'val': ['lt', 'gt', 'lte', 'gte'],
'valqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'] # notin
}
ordering_fields = ['id']
class ParameterFilter(FilterSet):
Field.register_lookup(NotEqual)
#Field.register_lookup(NotIn)
class Meta:
model = Parameter
fields = {
#filters:'exact','ne', 'lt', 'gt', 'lte', 'gte', 'in', icontains
'id': ['exact', 'ne', 'in'], #notin
'pname': ['exact', 'ne', 'in', 'icontains'], #notin
'unit': ['exact', 'ne', 'in', 'icontains'], #notin
'long_name': ['icontains'],
'stand_name': ['exact', 'ne', 'in', 'icontains'], #notin
'fval_qc': [],
'fval': [],
'category_long': ['exact', 'ne', 'in', 'icontains'], #notin
'category_short': ['exact', 'ne', 'in', 'icontains'], #notin
}
class FerryboxFilter(FilterSet):
Field.register_lookup(NotEqual)
#Field.register_lookup(NotIn)
class Meta:
model = Ferrybox
fields = {
#filters:'exact','ne', 'lt', 'gt', 'lte', 'gte', 'in', icontains
'id': ['exact', 'ne', 'in'], #notin
'dt': ['lt', 'gt', 'lte', 'gte', 'icontains'],
'lat': ['lt', 'gt', 'lte', 'gte'],
'lon': ['lt', 'gt', 'lte', 'gte'],
'posqc': ['exact', 'ne', 'in','lt', 'gt', 'lte', 'gte'], #notin
'pres': ['lt', 'gt', 'lte', 'gte'],
'presqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'], #notin
'param': ['exact'],
'param__id' : ['exact','ne', 'in'], #notin
'val': ['lt', 'gt', 'lte', 'gte'],
'valqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'], #notin
'route_id': ['exact'],
}
""" Utilizamos el model para definir los custom lookup al ser esta aplicacion una libreria general """ from django.db.models import Lookup from django.db.models.fields import Field class NotEqual(Lookup): lookup_name = 'ne' def as_sql(self, qn, connection): lhs, lhs_params = self.process_lhs(qn, connection) rhs, rhs_params = self.process_rhs(qn, connection) params = lhs_params + rhs_params return '%s <> %s' % (lhs, rhs), params Field.register_lookup(NotEqual)
class NotIEndsWith(NotEndsWith):
lookup_name = 'niendswith'
def get_sql_opp(self):
return "NOT ILIKE"
class NotIn(Lookup):
lookup_name = 'nin'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
params[0] = params[0][1:-1]
# Era necesario el ["notinnotinnotin"]
return '%s NOT IN (%s, {})'.format(",".join(params)) % (lhs, rhs), [
"notinnotinnotin"
]
Field.register_lookup(NotEqual)
Field.register_lookup(NotStartsWith)
Field.register_lookup(NotIStartsWith)
Field.register_lookup(NotEndsWith)
Field.register_lookup(NotIEndsWith)
Field.register_lookup(NotContains)
Field.register_lookup(NotIContains)
Field.register_lookup(NotIn)
lookup_name = 'contains'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return '%s @> %s' % (lhs, rhs), params
class ContainedByLookup(Lookup):
lookup_name = "contained_by"
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return '%s <@ %s' % (lhs, rhs), params
class OverlapLookip(Lookup):
lookup_name = "overlap"
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return '%s && %s' % (lhs, rhs), params
from django.db.models.fields import Field
Field.register_lookup(ContainedByLookup)
Field.register_lookup(ContainsLookup)
Field.register_lookup(OverlapLookip)
class Lower(Lookup):
"""
Custom lookup for postgres "lower" function implementation
"""
lookup_name = 'lower'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return 'lower({}) = {}'.format(lhs, rhs), params
Field.register_lookup(Lower)
class Command(BaseCommand):
"""
DONE 1.- llegir fulles
DONE 2.- llegir cada registre
DONE 3.- actualitzar el model
DONE 4.- mirar si hi ha tasca de traducció per aquell registre, si existeix actualitzar-la i posar-la com a done
"""
help = "Command for the import translations duty"
option_list = BaseCommand.option_list + (make_option(
"-a",
"--app",
lookup_name = 'contains'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return '%s @> %s' % (lhs, rhs), params
class ContainedByLookup(Lookup):
lookup_name = "contained_by"
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return '%s <@ %s' % (lhs, rhs), params
class OverlapLookip(Lookup):
lookup_name = "overlap"
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return '%s && %s' % (lhs, rhs), params
from django.db.models.fields import Field
Field.register_lookup(ContainedByLookup)
Field.register_lookup(ContainsLookup)
Field.register_lookup(OverlapLookip)
def validate_form_data(self, unused_request, unused_form, unused_obj):
"""Override this method to validate the form submission."""
pass
def configure(self, unused_request, unused_modeladmin, unused_obj):
"""Override this method to configure the form."""
pass
# see: https://docs.djangoproject.com/en/1.9/howto/custom-lookups/
class CustomIContains(IContains):
"""Provides case-insensitive __icontains queries with utf8_bin collation."""
def as_sql(self, compiler, connection):
lhs, lhs_params = self.process_lhs(compiler, connection)
rhs, rhs_params = self.process_rhs(compiler, connection)
params = lhs_params + rhs_params
return 'UPPER(%s) LIKE UPPER(%s)' % (lhs, rhs), params
class CustomIExact(IExact):
"""Provides case-insensitive __iexact queries with utf8_bin collation."""
def as_sql(self, compiler, connection):
lhs, lhs_params = self.process_lhs(compiler, connection)
rhs, rhs_params = self.process_rhs(compiler, connection)
params = lhs_params + rhs_params
return 'UPPER(%s) = UPPER(%s)' % (lhs, rhs), params
Field.register_lookup(CustomIContains)
Field.register_lookup(CustomIExact)
return lhs_sql, list(params)
def as_sql(self, compiler, connection):
lhs_sql, params = self.process_lhs(compiler, connection)
rhs_sql, rhs_params = self.process_rhs(compiler, connection)
params.extend(rhs_params)
rhs_sql = self.get_rhs_op(connection, rhs_sql)
return '%s %s' % (lhs_sql, rhs_sql), params
def get_rhs_op(self, connection, rhs):
return connection.operators[self.lookup_name] % rhs
class Exact(BuiltinLookup):
lookup_name = 'exact'
Field.register_lookup(Exact)
class IExact(BuiltinLookup):
lookup_name = 'iexact'
def process_rhs(self, qn, connection):
rhs, params = super(IExact, self).process_rhs(qn, connection)
if params:
params[0] = connection.ops.prep_for_iexact_query(params[0])
return rhs, params
Field.register_lookup(IExact)
def ready(self):
# register field lookups
Field.register_lookup(NotEqual)
from django.db.models.lookups import Range
from django.db.models.fields import Field
from django.db.models import Lookup
from django.db.models.expressions import Col
class InfluxDB(Range):
#def as_sql(self,compiler, connection):
# return None
def as_influxdata(self, compiler, connection):
lhs, lhs_params = self.process_lhs(compiler, connection)
rhs, rhs_params = self.process_rhs(compiler, connection)
params = rhs_params
return '%s >= %s AND %s <= %s' % (lhs, rhs[0],lhs,rhs[1]), params
class NotEqual(Lookup):
lookup_name = 'ne'
def as_influxdata(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return '%s != %s' % (lhs, rhs), params
Field.register_lookup(InfluxDB)
Field.register_lookup(NotEqual)
def col_as_influxdb(self, compiler, connection):
qn = compiler.quote_name_unless_alias
return "%s" % (qn(self.target.column)), []
Col.as_influxdata = col_as_influxdb
backend_allowed = reduce(
lambda x, y: x in backend.__name__ or y, db_backends_allowed)
if backend_allowed and 'Lookup' in locals():
# Use Django 1.7 API for registering a new lookup
class Similar(Lookup):
lookup_name = 'similar'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return '%s %%%% %s' % (lhs, rhs), params
Field.register_lookup(Similar)
elif backend_allowed:
# Old pre-Django 1.7 manual injection of lookup
if isinstance(QUERY_TERMS, set):
QUERY_TERMS.add('similar')
else:
QUERY_TERMS['similar'] = None
if backend_allowed == 'postgis':
if isinstance(ALL_TERMS, set):
ALL_TERMS.add('similar')
else:
ALL_TERMS['similar'] = None
connection.operators['similar'] = "%%%% %s"
lookup_name = 'modEqual'
def as_sql(self, compiler, connection):
lhs, lhs_params = self.process_lhs(compiler, connection)
rhs, rhs_params = self.process_rhs(compiler, connection)
params = lhs_params + rhs_params
print(lhs, lhs_params)
print(rhs, rhs_params)
return '%s mod %s = 0' % (lhs, rhs), params
def main():
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mainproject.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)
if __name__ == '__main__':
Field.register_lookup(modEqual)
print('registed')
main()
# Codigo da implementacao de um custom lookup exatamente como esta documentado para maior didatica
class Funcao(Lookup):
lookup_name = 'func'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
print params
return '%s <> %s' % (lhs, rhs), params
# Avisando o Django sobre a implementacao do custom lookup
Field.register_lookup(Funcao)
# Codigo da implementacao de uma transformacao
# foram feitas algumas alteracoes da documentacao
# para se adequar ao template
class IdadeMenor(Transform):
lookup_name = 'idmenor'
def as_sql(self, qn, connection):
lhs, params = qn.compile(self.lhs)
return "ABS(%s)" % lhs, params
# Avisando o Django sobre a implementacao da transformacao
class QueryOperations:
"""
Built-in filter operatations of the Sensor Things API.
"""
class NotEqual(Lookup):
"""
Defines a "Not Equals" comparison operator.
"""
lookup_name = 'ne'
def as_postgresql(self, compiler, connection):
lhs, lhs_params = self.process_lhs(compiler, connection)
rhs, rhs_params = self.process_rhs(compiler, connection)
params = lhs_params + rhs_params
return '%s <> %s' % (lhs, rhs), params
Field.register_lookup(NotEqual)
comparison_operators = {
"eq": '__exact',
"ne": '__ne',
"gt": '__gt',
"ge": '__gte',
"lt": '__lt',
"le": '__lte'
}
def odata_add(parameterstring, **kwargs):
if kwargs['numbers']:
arguments = parameterstring.split(',')
value = operator.add(float(arguments[0]), float(arguments[1]))
return value
else:
d = dict()
arguments = parameterstring.split(',')
try:
num = float(arguments[0])
field = arguments[1]
except ValueError:
num = float(arguments[1])
field = arguments[0]
if field == 'result':
field = 'result__result'
value = operator.add(CustomFunctions.NullIf(field), num)
else:
value = operator.add(F(field), num)
temporary_field = "temp" + str(kwargs['index'])
d['query_field'] = temporary_field
d['annotation'] = {temporary_field: value}
return d
def odata_sub(parameterstring, **kwargs):
if kwargs['numbers']:
arguments = parameterstring.split(',')
value = operator.sub(float(arguments[0]), float(arguments[1]))
return value
else:
d = dict()
arguments = parameterstring.split(',')
try:
num = float(arguments[0])
field = arguments[1]
except ValueError:
num = float(arguments[1])
field = arguments[0]
if field == 'result':
field = 'result__result'
value = operator.sub(CustomFunctions.NullIf(field), num)
else:
value = operator.sub(F(field), num)
temporary_field = "temp" + str(kwargs['index'])
d['query_field'] = temporary_field
d['annotation'] = {temporary_field: value}
return d
def odata_mul(parameterstring, **kwargs):
if kwargs['numbers']:
arguments = parameterstring.split(',')
value = operator.mul(float(arguments[0]), float(arguments[1]))
return value
else:
d = dict()
arguments = parameterstring.split(',')
try:
num = float(arguments[0])
field = arguments[1]
except ValueError:
num = float(arguments[1])
field = arguments[0]
if field == 'result':
field = 'result__result'
value = operator.mul(CustomFunctions.NullIf(field), num)
else:
value = operator.mul(F(field), num)
temporary_field = "temp" + str(kwargs['index'])
d['query_field'] = temporary_field
d['annotation'] = {temporary_field: value}
return d
def odata_div(parameterstring, **kwargs):
if kwargs['numbers']:
arguments = parameterstring.split(',')
value = operator.truediv(float(arguments[0]), float(arguments[1]))
return value
else:
d = dict()
arguments = parameterstring.split(',')
try:
num = float(arguments[0])
field = arguments[1]
except ValueError:
num = float(arguments[1])
field = arguments[0]
if field == 'result':
field = 'result__result'
value = operator.truediv(CustomFunctions.NullIf(field), num)
else:
value = operator.truediv(F(field), num)
temporary_field = "temp" + str(kwargs['index'])
d['query_field'] = temporary_field
d['annotation'] = {temporary_field: value}
return d
def odata_mod(parameterstring, **kwargs):
if kwargs['numbers']:
arguments = parameterstring.split(',')
value = operator.mul(float(arguments[0]), float(arguments[1]))
return value
else:
d = dict()
arguments = parameterstring.split(',')
try:
num = float(arguments[0])
field = arguments[1]
except ValueError:
num = float(arguments[1])
field = arguments[0]
if field == 'result':
field = 'result__result'
value = operator.mod(CustomFunctions.NullIf(field), num)
else:
value = operator.mul(F(field), num)
temporary_field = "temp" + str(kwargs['index'])
d['query_field'] = temporary_field
d['annotation'] = {temporary_field: value}
return d
arithmetic_operators = {
"add": odata_add,
"sub": odata_sub,
"mul": odata_mul,
"div": odata_div,
"mod": odata_mod
}
# Codigo da implementacao de um custom lookup exatamente como esta documentado para maior didatica
class Funcao(Lookup):
lookup_name = 'func'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
print params
return '%s <> %s' % (lhs, rhs), params
# Avisando o Django sobre a implementacao do custom lookup
Field.register_lookup(Funcao)
# Codigo da implementacao de uma transformacao
# foram feitas algumas alteracoes da documentacao
# para se adequar ao template
class IdadeMenor(Transform):
lookup_name = 'idmenor'
def as_sql(self, qn, connection):
lhs, params = qn.compile(self.lhs)
return "ABS(%s)" % lhs, params
# Avisando o Django sobre a implementacao da transformacao
IntegerField.register_lookup(IdadeMenor)
ext = os.path.splitext(filename)[1]
path = os.path.join("artist_images/", slugify(instance.full_name()) + ext)
return path
class InsensitiveUnaccentExact(Lookup):
lookup_name = 'iuexact'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return 'UPPER(unaccent(%s)) = UPPER(unaccent(%s))' % (lhs, rhs), params
Field.register_lookup(InsensitiveUnaccentExact)
class InsensitiveUnaccentStartsWith(Lookup):
lookup_name = 'iustartswith'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return "UPPER(unaccent(%s)) LIKE UPPER(unaccent(%s || '%%%%'))" % (
lhs, rhs), params
Field.register_lookup(InsensitiveUnaccentStartsWith)
from copy import copy
from django.conf import settings
from django.db.models.expressions import Func, Value
from django.db.models.fields import (
DateField, DateTimeField, Field, IntegerField, TimeField,
)
from django.db.models.query_utils import RegisterLookupMixin
from django.utils import timezone
from django.utils.functional import cached_property
from django.utils.six.moves import range
class Lookup(object):
lookup_name = None
def __init__(self, lhs, rhs):
self.lhs, self.rhs = lhs, rhs
self.rhs = self.get_prep_lookup()
if hasattr(self.lhs, 'get_bilateral_transforms'):
bilateral_transforms = self.lhs.get_bilateral_transforms()
else:
bilateral_transforms = []
if bilateral_transforms:
# We should warn the user as soon as possible if he is trying to apply
# a bilateral transformation on a nested QuerySet: that won't work.
# We need to import QuerySet here so as to avoid circular
from django.db.models.query import QuerySet
if isinstance(rhs, QuerySet):
raise NotImplementedError("Bilateral transformations on nested querysets are not supported.")
self.bilateral_transforms = bilateral_transforms
def apply_bilateral_transforms(self, value):
for transform in self.bilateral_transforms:
class DataList(viewsets.ModelViewSet):
"""
View to list all platform's data in the system.
* Requires token authentication.
get:
Return a list of all the platform's data.
post:
Create new platform's data instance.
* Only admin users are able to access.
"""
authentication_classes = [OAuth2Authentication]
permission_classes = [TokenMatchesOASRequirements]
required_alternate_scopes = {
"GET": [["user"]],
"POST": [["user", "staff", "admin"]],
}
def get_queryset(self):
platform = self.kwargs['platform']
t = getModel()
t._meta.db_table = 'data\".\"' + platform
queryset = t.objects.all()
return queryset
serializer_class = DataSerializer
filter_backends = (
DjangoFilterBackend,
OrderingFilter,
)
Field.register_lookup(NotEqual)
filter_fields = {
# available filters:'exact','ne', 'lt', 'gt', 'lte', 'gte', 'in', icontains
'id': ['exact', 'ne', 'in', 'lte'], # notin
'dt': ['lt', 'gt', 'lte', 'gte', 'icontains'],
'lat': ['lt', 'gt', 'lte', 'gte'],
'lon': ['lt', 'gt', 'lte', 'gte'],
'posqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'], # notin
'pres': ['lt', 'gt', 'lte', 'gte'],
'presqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'], # notin
#'param': ['exact', 'in'],
'param__pname': ['exact', 'in'],
'param__id': ['exact', 'ne', 'in'], # notin
'val': ['lt', 'gt', 'lte', 'gte'],
'valqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'] # notin
}
ordering_fields = ['id', 'pres', 'dt']
@swagger_auto_schema(method='post', auto_schema=None)
@api_view(['POST'])
def post(self, request, *args, **kwargs):
# Create or update fields in data."<platform>" tables and create parameter in metadata."parameters" if not exists
platform = self.kwargs['platform']
t = getModel()
t._meta.db_table = 'data\".\"' + platform
body_unicode = request.body.decode('utf-8')
prejson = json.loads(body_unicode)
datalist = prejson['data']
try:
with transaction.atomic():
for i in range(len(datalist)):
par = Parameter.objects.get(pname=datalist[i]['param'])
obj, created = t.objects.update_or_create(
dt=datalist[i]['dt'],
lat=datalist[i]['lat'],
lon=datalist[i]['lon'],
param=par,
pres=datalist[i]['pres'],
defaults={
'dt': datalist[i]['dt'],
'lat': datalist[i]['lat'],
'lon': datalist[i]['lon'],
'posqc': datalist[i]['posqc'],
'pres': datalist[i]['pres'],
'presqc': datalist[i]['presqc'],
'param': par,
'val': datalist[i]['val'],
'valqc': datalist[i]['valqc'],
'dvalqc': datalist[i]['dvalqc']
},
)
except Exception:
return Response({'success': False})
return Response({'success': True})
from django.db.models.fields import Field
from django.db.models.lookups import Transform
class Floor(Transform):
"""
Floor is included in 3 -
required to annotate mptt descendent count for comments
"""
function = "FLOOR"
lookup_name = "floor"
Field.register_lookup(Floor)
class DeepObservAllDataList(generics.ListCreateAPIView):
swagger_schema = None
"""
View to list Deep Observer's data (with rval & rvalqc).
* Requires token authentication.
get:
Return a list of all the deep observer's data.
post:
Create new deep observer's data instance.
* Only admin users are able to access.
"""
authentication_classes = [OAuth2Authentication]
permission_classes = [TokenMatchesOASRequirements]
required_alternate_scopes = {
"GET": [["user"]],
"POST": [["user", "staff", "admin"]],
}
def get_queryset(self):
platform = self.kwargs['platform']
t = DeepObservgetModel()
t._meta.db_table = 'data\".\"' + platform
queryset = t.objects.all()
return queryset
def get_serializer_class(self):
platform = self.kwargs['platform']
t = DeepObservgetModel()
t._meta.db_table = 'data\".\"' + platform
serializer_class = DeepObservAllDataSerializer
serializer_class.Meta.model = t
return serializer_class
filter_backends = (
DjangoFilterBackend,
OrderingFilter,
)
Field.register_lookup(NotEqual)
filter_fields = {
# available filters:'exact','ne', 'lt', 'gt', 'lte', 'gte', 'in', icontains
'id': ['exact', 'ne', 'in'], # notin
'dt': ['lt', 'gt', 'lte', 'gte', 'icontains'],
'lat': ['lt', 'gt', 'lte', 'gte'],
'lon': ['lt', 'gt', 'lte', 'gte'],
'posqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'], # notin
'pres': ['lt', 'gt', 'lte', 'gte'],
'presqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'], # notin
'param': ['exact'],
'param__id': ['exact', 'ne', 'in'], # notin
'val': ['lt', 'gt', 'lte', 'gte'],
'valqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'], # notin
'rval': ['lt', 'gt', 'lte', 'gte'],
'rvalqc': ['exact', 'ne', 'in', 'lt', 'gt', 'lte', 'gte'] # notin
}
ordering_fields = ['id']
def post(self, request, *args, **kwargs):
platform = self.kwargs['platform']
t = DeepObservgetModel()
t._meta.db_table = 'data\".\"' + platform
prejson = json.loads(request.body)
try:
datalist = prejson['data']
with transaction.atomic():
for i in range(len(datalist)):
par = Parameter.objects.get(pname=datalist[i]['param'])
obj, created = t.objects.update_or_create(
dt=datalist[i]['dt'],
lat=datalist[i]['lat'],
lon=datalist[i]['lon'],
param=par,
pres=datalist[i]['pres'],
defaults={
'dt': datalist[i]['dt'],
'lat': datalist[i]['lat'],
'lon': datalist[i]['lon'],
'posqc': datalist[i]['posqc'],
'pres': datalist[i]['pres'],
'presqc': datalist[i]['presqc'],
'param': par,
'val': datalist[i]['val'],
'valqc': datalist[i]['valqc'],
'dvalqc': datalist[i]['dvalqc'],
'rval': datalist[i]['rval'],
'rvalqc': datalist[i]['rvalqc']
},
)
except Exception:
return Response({'success': False})
return Response({'success': True})
from django.dispatch import receiver
from django.db.models.fields import Field
from django.db.models import Lookup
class NotEqual(Lookup):
lookup_name = 'ne'
def as_sql(self, compiler, connection):
lhs, lhs_params = self.process_lhs(compiler, connection)
rhs, rhs_params = self.process_rhs(compiler, connection)
params = lhs_params + rhs_params
return '%s <> %s' % (lhs, rhs), params
Field.register_lookup(NotEqual)
class Message(models.Model):
timestamp = models.DateTimeField(auto_now_add=True, null=False)
text = models.TextField(null=False)
sender = models.ForeignKey(User, on_delete=models.CASCADE, null=False)
def is_recent(self):
return self.timestamp >= timezone.now() - datetime.timedelta(days=1)
def __str__(self):
return self.text
class UserPresence(models.Model):
# The params list may contain expressions which compile to a
# sql/param pair. Zip them to get sql and param pairs that refer to the
# same argument and attempt to replace them with the result of
# compiling the param step.
sql, params = zip(*(
self.resolve_expression_parameter(compiler, connection, sql, param)
for sql, param in zip(*pre_processed)))
params = itertools.chain.from_iterable(params)
return sql, tuple(params)
class Exact(FieldGetDbPrepValueMixin, BuiltinLookup):
lookup_name = 'exact'
Field.register_lookup(Exact)
class IExact(BuiltinLookup):
lookup_name = 'iexact'
prepare_rhs = False
def process_rhs(self, qn, connection):
rhs, params = super(IExact, self).process_rhs(qn, connection)
if params:
params[0] = connection.ops.prep_for_iexact_query(params[0])
return rhs, params
Field.register_lookup(IExact)
class Lower(Lookup):
"""
Custom lookup for postgres "lower" function implementation
"""
lookup_name = 'lower'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
return 'lower({}) = {}'.format(lhs, rhs), params
Field.register_lookup(Lower)
class Command(BaseCommand):
"""
DONE 1.- llegir fulles
DONE 2.- llegir cada registre
DONE 3.- actualitzar el model
DONE 4.- mirar si hi ha tasca de traducció per aquell registre, si existeix actualitzar-la i posar-la com a done
"""
help = "Command for the import translations duty"
option_list = BaseCommand.option_list + (
make_option(
def register(cls):
Field.register_lookup(NotEqualLookup)
ForeignKey.register_lookup(NotEqualLookup)
ReverseStartsWith will flip the right and left hand side of the expression,
effectively making this the same query as::
"koe".startswith(henk)
"""
def process_rhs(self, compiler, connection):
return super().process_lhs(compiler, connection)
def process_lhs(self, compiler, connection, lhs=None):
if lhs is not None:
raise Exception("Flipped process_lhs does not accept lhs argument")
return super().process_rhs(compiler, connection)
Field.register_lookup(ReverseStartsWith, "rstartswith")
class AbstractProductClass(models.Model):
"""
Used for defining options and attributes for a subset of products.
E.g. Books, DVDs and Toys. A product can only belong to one product class.
At least one product class must be created when setting up a new
Oscar deployment.
Not necessarily equivalent to top-level categories but usually will be.
"""
name = models.CharField(_('Name'), max_length=128)
slug = AutoSlugField(_('Slug'),
max_length=128,
def ready(self):
# We have to import signals only when the app is ready.
from authentication_service import signals
Field.register_lookup(lookups.Ilike)
from authentication_service import integration, metrics
metrics.add_prometheus_metrics_for_class(integration.Implementation)
