def tearDown(self): for t in [ "django_rethink_test", "history", "django_rethink_test_reviewed", "django_rethink_test_history_permissions", "django_rethink_test_history_has_read_permission", ]: r.table(t).delete().run(self.conn) super(APITests, self).tearDown()
def delete(self): if 'request' in self.context: data = self.context['request'].data if 'log' not in data: if hasattr(self.Meta, 'log_required') and self.Meta.log_required: raise serializers.ValidationError( "'log' field is required when deleting an object") log = None else: log = data['log'] elif 'log' in self.context: log = self.context['log'] else: log = None result = r.table(self.Meta.table_name).get( self.instance[self.Meta.pk_field]).delete(return_changes=True).run( self.conn) history = HistorySerializer(None, data={ 'object_type': self.Meta.table_name, 'object': { self.Meta.pk_field: self.instance[self.Meta.pk_field] }, 'username': self.get_username(), 'timestamp': timezone.now(), 'message': log, }) history.is_valid(raise_exception=True) history.save() return result['deleted'] > 0
def create(self, validated_data): if 'log' in validated_data: log = validated_data.pop('log') else: log = None if 'version' not in validated_data: validated_data['version'] = 1 result = r.table(self.Meta.table_name).insert(validated_data, return_changes=True).run( self.conn) history = HistorySerializer(None, data={ 'object_type': self.Meta.table_name, 'object': result['changes'][0]['new_val'].copy(), 'username': self.get_username(), 'timestamp': timezone.now(), 'message': log, }) history.is_valid(raise_exception=True) history.save() return result['changes'][0]['new_val']
def validate(self, data): for group in self.Meta.unique_together: value = [ data.get( field, self.instance.get(field, None) if self.instance is not None else None) for field in group ] for index in self.Meta.indices: if isinstance(index, (tuple, list)) and isinstance( index[1], tuple) and [str(i) for i in index[1] ] == [str(i) for i in group]: query = r.table(self.Meta.table_name).get_all( value, index=index[0]) break else: query = self.filter(dict([(field, value[i]) for i, field in enumerate(group)]), reql=True) if self.instance is not None: query = query.filter(r.row[self.Meta.pk_field] != self.instance[self.Meta.pk_field]) query = query.count() matched = query.run(self.conn) if matched > 0: raise serializers.ValidationError( "combination of %r is not unique" % (group, )) return data
def default_filter_queryset(self, queryset): if '_include_object' in self.request.query_params: return queryset.merge( lambda review: { "orig_object": r.table(review['object_type']).get(review['object_id']) }) else: return queryset
def update(self, instance, validated_data): queryset = r.table(self.Meta.table_name).get(instance['id']) if self.partial: queryset = queryset.update(validated_data, return_changes=True) else: queryset = queryset.replace(validated_data, return_changes=True) result = queryset.run(self.conn) if len(result['changes']) == 0: return validated_data else: return result['changes'][0]['new_val']
def get_queryset(self): if self.queryset is None: if self.table_name: return r.table(self.table_name) else: raise ImproperlyConfigured( "%(cls)s is missing a QuerySet. Define " "%(cls)s.model, %(cls)s.queryset, or override " "%(cls)s.get_queryset()." % {'cls': self.__class__.__name__}) return self.queryset
def rethinkdb_unlock(self, *args, **kwargs): if 'name' in kwargs: name = kwargs['name'] else: name = args[0] args = args[1:] token = kwargs.get('token', self.request.root_id) result = r.table("locks").get_all(_distributed_lock_id(name)). \ filter({"token": token}).delete().run(get_connection()) if result['deleted'] == 1: logger.info("unlocked %s", name) else: logger.warning("unable to unlock %s, token was not %s", name, token) if len(args) > 0: return args[0]
def post(self, *args, **kwargs): conn = self.get_connection() update_data = self.get_update_data() result = self.get_object_qs().update( r.expr(update_data, nesting_depth=40)).run(conn) if max(result.values()) == 0: result = r.table(self.table_name).insert( r.expr(self.get_insert_data(update_data), nesting_depth=40)).run(conn) self.post_update() if self.request.META['CONTENT_TYPE'] == "application/json": return HttpResponse(json.dumps({'success': True}), content_type="application/json") else: return HttpResponseRedirect(self.get_success_url())
def rethinkdb_lock(self, name, token=None, timeout=300): if token is None: token = self.request.root_id result = r.table("locks").insert({ "id": _distributed_lock_id(name), "token": token, "server": socket.gethostname(), "timestamp": r.now(), }).run(get_connection()) if result['inserted'] == 0: self.retry(exc=Exception("failed to acquire lock %s" % name), countdown=1, max_retries=timeout) else: logger.info("locked %s with token %s", name, token) return token
def update(self, instance, validated_data): update = dict(validated_data) if 'log' in update: log = update.pop('log') else: log = None if 'version' in validated_data: old_version = validated_data['version'] else: old_version = instance['version'] update['version'] = old_version + 1 filtered = r.table(self.Meta.table_name) \ .get_all(instance[self.Meta.pk_field]) \ .filter(r.row['version'] == old_version) if self.partial: result = filtered.update(update, return_changes=True).run(self.conn) else: result = filtered.replace(update, return_changes=True).run(self.conn) if result['replaced'] + result['unchanged'] == 0: raise SimultaneousObjectManipulationException( "Simultaneous object manipulation error! %s %d" % (instance[self.Meta.pk_field], instance['version'])) if len(result['changes']) == 0: new_val = instance else: new_val = result['changes'][0]['new_val'] history = HistorySerializer(None, data={ 'object_type': self.Meta.table_name, 'object': new_val.copy(), 'username': self.get_username(), 'timestamp': timezone.now(), 'message': log, }) history.is_valid(raise_exception=True) history.save() return new_val
def filter(cls, *args, **fields): query = r.table(cls.Meta.table_name) try: reql = fields.pop('reql') except KeyError: reql = False if len(args) == 0 and len(fields) == 1 and list(fields.keys( ))[0] in cls.Meta.indices and not cls.Meta.order_by: index, value = list(fields.items())[0] query = query.get_all(value, index=index) else: if args: query = query.filter(*args) if fields: query = query.filter(fields) if cls.Meta.order_by: query = query.order_by(*cls.Meta.order_by) if reql: return query else: rs = query.run(get_connection()) if not isinstance(rs, list): rs.reql_query = query return rs
def delete(self): result = r.table(self.Meta.table_name).get( self.data[self.Meta.pk_field]).delete().run(self.conn) return result['deleted'] > 0
def create(self, validated_data): result = r.table(self.Meta.table_name).insert(validated_data, return_changes=True).run( self.conn) return result['changes'][0]['new_val']