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