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