def post(self): kind = self.request.get('kind') entity_key = self.request.get('key') if entity_key: if self.request.get('action') == 'Delete': datastore.Delete(datastore.Key(entity_key)) self.redirect(self.request.get('next')) return entity = datastore.Get(datastore.Key(entity_key)) else: entity = datastore.Entity(kind) args = self.request.arguments() for arg in args: bar = arg.find('|') if bar > 0: data_type_name = arg[:bar] field_name = arg[bar + 1:] form_value = self.request.get(arg) data_type = DataType.get_by_name(data_type_name) if entity and entity.has_key(field_name): old_formatted_value = data_type.format(entity[field_name]) if old_formatted_value == ustr(form_value): continue if len(form_value) > 0: value = data_type.parse(form_value) entity[field_name] = value elif entity.has_key(field_name): del entity[field_name] datastore.Put(entity) self.redirect(self.request.get('next'))
def post(self, project_id, entity_key_string=None): """ Handles mutations to a given entity. Args: project_id: A string specifying the project ID. entity_key_string: A string specifying the entity key. """ self.ensure_user_has_admin(project_id) ds_access = DatastoreDistributed(project_id, DATASTORE_LOCATION, trusted=True) if self.request.get('action:delete'): if entity_key_string: _delete_entities(ds_access, [datastore.Key(entity_key_string)]) redirect_url = self.request.get( 'next', '/datastore_viewer/{}'.format(project_id)) self.redirect(str(redirect_url)) else: self.response.set_status(400) return if entity_key_string: entity = _get_entity_by_key(ds_access, datastore.Key(entity_key_string)) else: kind = self.request.get('kind') namespace = self.request.get('namespace', None) entity = datastore.Entity(kind, _namespace=namespace, _app=project_id) for arg_name in self.request.arguments(): # Arguments are in <property_type>|<property_name>=<value> format. if '|' not in arg_name: continue data_type_name, property_name = arg_name.split('|') form_value = self.request.get(arg_name) data_type = DataType.get_by_name(data_type_name) if (entity and property_name in entity and data_type.format(entity[property_name]) == form_value): # If the property is unchanged then don't update it. This will prevent # empty form values from causing the property to be deleted if the # property was already empty. continue # TODO: Handle parse exceptions. entity[property_name] = data_type.parse(form_value) _put_entity(ds_access, entity) redirect_url = self.request.get( 'next', '/datastore_viewer/{}'.format(project_id)) self.redirect(str(redirect_url))
def get(self, entity_key_string=None): if entity_key_string: entity_key = datastore.Key(entity_key_string) entity_key_name = entity_key.name() entity_key_id = entity_key.id() namespace = entity_key.namespace() kind = entity_key.kind() entities = [datastore.Get(entity_key)] parent_key = entity_key.parent() if parent_key: parent_key_string = _format_datastore_key(parent_key) else: parent_key_string = None else: entity_key = None entity_key_string = None entity_key_name = None entity_key_id = None namespace = self.request.get('namespace') kind = self.request.get('kind') entities, _ = _get_entities(kind, namespace, order=None, start=0, count=20) parent_key = None parent_key_string = None if not entities: self.redirect('/datastore?%s' % (urllib.parse.urlencode([ ('kind', kind), ('message', 'Cannot create the kind "%s" in the "%s" namespace because ' 'no template entity exists.' % (kind, namespace)), ('namespace', namespace) ]))) return property_name_to_values = _property_name_to_values(entities) fields = [] for property_name, values in sorted(property_name_to_values.items()): data_type = DataType.get(values[0]) field = data_type.input_field( '%s|%s' % (data_type.name(), property_name), values[0] if entity_key else None, values, self.request.uri) fields.append((property_name, data_type.name(), field)) self.response.write( self.render( 'datastore_edit.html', { 'fields': fields, 'key': entity_key_string, 'key_id': entity_key_id, 'key_name': entity_key_name, 'kind': kind, 'namespace': namespace, 'next': self.request.get('next', '/datastore'), 'parent_key': parent_key, 'parent_key_string': parent_key_string }))
def post(self, project_id): """ Handle modifying actions and redirect to a GET page. Args: project_id: A string specifyng the project ID. """ self.ensure_user_has_admin(project_id) if self.request.get('action:flush_memcache'): if memcache.flush_all(): message = 'Cache flushed, all keys dropped.' else: message = 'Flushing the cache failed. Please try again.' self.redirect(self._construct_url(remove=['action:flush_memcache'], add={'message': message})) elif self.request.get('action:delete_entities'): ds_access = DatastoreDistributed(project_id, DATASTORE_LOCATION, trusted=True) entity_keys = [datastore.Key(key) for key in self.request.params.getall('entity_key')] _delete_entities(ds_access, entity_keys) self.redirect(self._construct_url( remove=['action:delete_entities'], add={'message': '%d entities deleted' % len(entity_keys)})) else: self.error(404)
def validate(self, value): if isinstance(value, datastore.Key): return value if isinstance(value, str): return datastore.Key(value) if value is not None and not value.has_key(): raise BadValueError( '%s instance must have a complete key before it can be stored as a ' 'reference' % self.reference_class.kind()) value = super(db.ReferenceProperty, self).validate(value) if isinstance(self.reference_class, basestring): try: self.reference_class = class_for_kind(self.reference_class) except KindError: raise KindError('Property has undefined class type %s' % (self.reference_class)) if not ((isinstance(self.reference_class, type) and issubclass(self.reference_class, Model)) or self.reference_class is db._SELF_REFERENCE): raise KindError('reference_class must be Model or _SELF_REFERENCE') if value is not None and not isinstance(value, self.reference_class): raise KindError('Property %s must be an instance of %s' % ("", self.reference_class.kind())) return value
def post(self): kind = self.request.get('kind') keys = [] index = 0 num_keys = int(self.request.get('numkeys')) for i in xrange(1, num_keys + 1): key = self.request.get('key%d' % i) if key: keys.append(key) if self.request.get('action') == 'Delete': num_deleted = 0 for key in keys: datastore.Delete(datastore.Key(key)) num_deleted = num_deleted + 1 message = '%d entit%s deleted.' % (num_deleted, ('ies', 'y')[num_deleted == 1]) self.redirect( '%s&msg=%s' % (self.request.get('next'), urllib.quote_plus(message))) return self.error(404)
def history_view(self, request, object_id, extra_context=None): "The 'history' admin view for this model." from .models import LogEntry model = self.model opts = model._meta app_label = opts.app_label parent = datastore.Key(object_id) action_list = LogEntry.all().ancestor(parent).order( '-action_time').fetch(100) # If no history was found, see whether this object even exists. obj = self.get_object(request, object_id) if obj is None: raise Http404 context = { 'title': _('Change history: %s') % obj, 'action_list': action_list, 'module_name': opts.verbose_name_plural, 'object': obj, 'root_path': self.admin_site.root_path, 'app_label': app_label, } context.update(extra_context or {}) context_instance = template.RequestContext( request, current_app=self.admin_site.name) return render_to_response(self.object_history_template or [ "admin/%s/%s/object_history.html" % (app_label, opts.object_name.lower()), "admin/%s/object_history.html" % app_label, "admin/object_history.html" ], context, context_instance=context_instance)
def get(self): kind = self.request.get('kind') sample_entities = self.execute_query()[0] if len(sample_entities) < 1: next_uri = self.request.get('next') kind_param = 'kind=%s' % kind if not kind_param in next_uri: if '?' in next_uri: next_uri += '&' + kind_param else: next_uri += '?' + kind_param self.redirect(next_uri) return entity_key = self.request.get('key') if entity_key: key_instance = datastore.Key(entity_key) entity_key_name = key_instance.name() entity_key_id = key_instance.id() parent_key = key_instance.parent() entity = datastore.Get(key_instance) else: key_instance = None entity_key_name = None entity_key_id = None parent_key = None entity = None if parent_key: parent_kind = parent_key.kind() else: parent_kind = None fields = [] key_values = self.get_key_values(sample_entities) for key, sample_values in key_values.iteritems(): if entity and entity.has_key(key): data_type = DataType.get(entity[key]) else: data_type = DataType.get(sample_values[0]) name = data_type.name() + "|" + key if entity and entity.has_key(key): value = entity[key] else: value = None field = data_type.input_field(name, value, sample_values) fields.append((key, data_type.name(), field)) self.generate( 'datastore_edit.html', { 'kind': kind, 'key': entity_key, 'key_name': entity_key_name, 'key_id': entity_key_id, 'fields': fields, 'focus': self.request.get('focus'), 'next': self.request.get('next'), 'parent_key': parent_key, 'parent_kind': parent_kind, })
def _normalize_key(value): """Return a key from an entity, model instance, key, or key string.""" if getattr(value, "key", None): return value.key() elif isinstance(value, basestring): return datastore.Key(value) else: return value
def _normalize_key(value): """Return a key from an entity, model instance, key, or key string.""" if ndb is not None and isinstance(value, (ndb.Model, ndb.Key)): return None if getattr(value, "key", None): return value.key() elif isinstance(value, six.string_types): return datastore.Key(value) else: return value
def map(instance, *args, **kwargs): """ Figure out what markers the instance should use and verify they're attached to this instance. Log any weirdness and in repair mode - recreate missing markers. """ action_id = kwargs.get("action_pk") repair = kwargs.get("repair") alias = kwargs.get("db", "default") namespace = settings.DATABASES.get(alias, {}).get("NAMESPACE") assert alias == (instance._state.db or "default") entity, _ = django_instance_to_entities(connections[alias], instance._meta.fields, raw=True, instance=instance, check_null=False) identifiers = unique_identifiers_from_entity(type(instance), entity, ignore_pk=True) identifier_keys = [datastore.Key.from_path(UniqueMarker.kind(), i, namespace=namespace) for i in identifiers] markers = datastore.Get(identifier_keys) instance_key = str(entity.key()) markers_to_save = [] for i, m in zip(identifier_keys, markers): marker_key = str(i) if m is None: # Missig marker if repair: new_marker = datastore.Entity(UniqueMarker.kind(), name=i.name(), namespace=namespace) new_marker['instance'] = entity.key() new_marker['created'] = datetime.datetime.now() markers_to_save.append(new_marker) else: log(action_id, "missing_marker", instance_key, marker_key) elif 'instance' not in m or not m['instance']: # Marker with missining instance attribute if repair: m['instance'] = entity.key() markers_to_save.append(m) else: log(action_id, "missing_instance", instance_key, marker_key) elif m['instance'] != entity.key(): if isinstance(m['instance'], basestring): m['instance'] = datastore.Key(m['instance']) if repair: markers_to_save.append(m) else: log(action_id, "old_instance_key", instance_key, marker_key) if m['instance'] != entity.key(): # Marker already assigned to a different instance log(action_id, "already_assigned", instance_key, marker_key) # Also log in repair mode as reparing would break the other instance. if markers_to_save: datastore.Put(markers_to_save)
def post(self, entity_key_string=None): super(DatastoreEditRequestHandler, self).post(entity_key_string) if self.request.get('action:delete'): if entity_key_string: datastore.Delete(datastore.Key(entity_key_string)) self.redirect(str(self.request.get('next', '/datastore'))) else: self.response.set_status(400) return if entity_key_string: entity = datastore.Get(datastore.Key(entity_key_string)) else: kind = self.request.get('kind') namespace = self.request.get('namespace', None) entity = datastore.Entity(kind, _namespace=namespace) for arg_name in self.request.arguments(): # Arguments are in <property_type>|<property_name>=<value> format. if '|' not in arg_name: continue data_type_name, property_name = arg_name.split('|') form_value = self.request.get(arg_name) data_type = DataType.get_by_name(data_type_name) if (entity and property_name in entity and data_type.format(entity[property_name]) == form_value): # If the property is unchanged then don't update it. This will prevent # empty form values from causing the property to be deleted if the # property was already empty. continue if form_value: # TODO: Handle parse exceptions. entity[property_name] = data_type.parse(form_value) elif property_name in entity: # TODO: Treating empty input as deletion is a not a good # interface. del entity[property_name] datastore.Put(entity) self.redirect(str(self.request.get('next', '/datastore')))
def get(self, project_id, entity_key_string=None): """ Displays the fields for a given entity. Args: project_id: A string specifying the project ID. entity_key_string: A string specifying the entity key. """ self.ensure_user_has_admin(project_id) ds_access = DatastoreDistributed(project_id, DATASTORE_LOCATION, trusted=True) if entity_key_string: entity_key = datastore.Key(entity_key_string) entity_key_name = entity_key.name() entity_key_id = entity_key.id() namespace = entity_key.namespace() kind = entity_key.kind() entities = [_get_entity_by_key(ds_access, entity_key)] parent_key = entity_key.parent() if parent_key: parent_key_string = _format_datastore_key(parent_key) else: parent_key_string = None else: entity_key = None entity_key_string = None entity_key_name = None entity_key_id = None namespace = self.request.get('namespace') kind = self.request.get('kind') entities, _ = _get_entities(ds_access, kind, namespace, order=None, start=0, count=20) parent_key = None parent_key_string = None if not entities: params = urllib.urlencode( [('kind', kind), ('message', 'Cannot create the kind "%s" in the "%s" namespace ' 'because no template entity ' 'exists.' % (kind, namespace)), ('namespace', namespace)]) self.redirect('/datastore_viewer/%s?%s' % (project_id, params)) return property_name_to_values = _property_name_to_values(entities) fields = [] for property_name, values in sorted(property_name_to_values.iteritems()): data_type = DataType.get(values[0]) field = data_type.input_field('%s|%s' % (data_type.name(), property_name), values[0] if entity_key else None, values, self.request.uri) fields.append((property_name, data_type.name(), field)) context = { 'page_content': self.TEMPLATE, 'project_id': project_id, 'fields': fields, 'key': entity_key_string, 'key_id': entity_key_id, 'key_name': entity_key_name, 'kind': kind, 'namespace': namespace, 'next': self.request.get('next', '/datastore_viewer/{}'.format(project_id)), 'parent_key': parent_key, 'parent_key_string': parent_key_string, 'request': self.request } self.render_app_page(page='datastore_editor', values=context)
def RemoveLocation(self, key): datastore.Delete(datastore.Key(key.encode('utf-8'))) return True
def get(self): entity_key = self.request.get('key') if entity_key: key_instance = datastore.Key(entity_key) entity_key_name = key_instance.name() entity_key_id = key_instance.id() namespace = key_instance.namespace() parent_key = key_instance.parent() kind = key_instance.kind() entity = datastore.Get(key_instance) sample_entities = [entity] else: kind = self.request.get('kind') sample_entities = self.execute_query()[0] if len(sample_entities) < 1: next_uri = self.request.get('next') next_uri += '&msg=%s' % urllib.quote_plus( "The kind %s doesn't exist in the %s namespace" % (kind, self.request.get('namespace', '<Empty>'))) kind_param = 'kind=%s' % kind if not kind_param in next_uri: if '?' in next_uri: next_uri += '&' + kind_param else: next_uri += '?' + kind_param self.redirect(next_uri) return if not entity_key: key_instance = None entity_key_name = None entity_key_id = None namespace = self.request.get('namespace') parent_key = None entity = None if parent_key: parent_kind = parent_key.kind() parent_key_string = PseudoBreadcrumbs(parent_key) else: parent_kind = None parent_key_string = None fields = [] key_values = self.get_key_values(sample_entities) for key, sample_values in key_values.iteritems(): if entity and entity.has_key(key): data_type = DataType.get(entity[key]) else: data_type = DataType.get(sample_values[0]) name = data_type.name() + "|" + key if entity and entity.has_key(key): value = entity[key] else: value = None field = data_type.input_field(name, value, sample_values) fields.append((key, data_type.name(), field)) self.generate( 'datastore_edit.html', { 'kind': kind, 'key': entity_key, 'key_name': entity_key_name, 'key_id': entity_key_id, 'fields': fields, 'focus': self.request.get('focus'), 'namespace': namespace, 'next': self.request.get('next'), 'parent_key': parent_key, 'parent_kind': parent_kind, 'parent_key_string': parent_key_string, })
def map(instance, *args, **kwargs): """ Figure out what markers the instance should use and verify they're attached to this instance. Log any weirdness and in repair mode - recreate missing markers. """ action_id = kwargs.get("action_pk") repair = kwargs.get("repair") entity = django_instance_to_entity(connection, type(instance), instance._meta.fields, raw=False, instance=instance) identifiers = unique_identifiers_from_entity(type(instance), entity, ignore_pk=True) identifier_keys = [ datastore.Key.from_path(UniqueMarker.kind(), i) for i in identifiers ] markers = datastore.Get(identifier_keys) instance_key = str(entity.key()) markers_to_save = [] for i, m in zip(identifier_keys, markers): marker_key = str(i) if m is None: # Missig marker if repair: new_marker = datastore.Entity(UniqueMarker.kind(), name=i.name()) new_marker['instance'] = entity.key() markers_to_save.append(new_marker) else: log(action_id, "missing_marker", instance_key, marker_key) elif 'instance' not in m or not m['instance']: # Marker with missining instance attribute if repair: m['instance'] = entity.key() markers_to_save.append(m) else: log(action_id, "missing_instance", instance_key, marker_key) elif m['instance'] != entity.key(): if isinstance(m['instance'], basestring): m['instance'] = datastore.Key(m['instance']) if repair: markers_to_save.append(m) else: log(action_id, "old_instance_key", instance_key, marker_key) if m['instance'] != entity.key(): # Marker already assigned to a different instance log(action_id, "already_assigned", instance_key, marker_key) # Also log in repair mode as reparing would break the other instance. if markers_to_save: datastore.Put(markers_to_save) yield ('_', [instance.pk])