def refresh(cls, skelValues): # ViUR2 Compatibility
super().refresh(skelValues)
if not skelValues["parententry"] and skelValues.dbEntity.get(
"parentdir"): # parentdir for viur2 compatibility
skelValues["parententry"] = utils.normalizeKey(
db.KeyClass.from_legacy_urlsafe(
skelValues.dbEntity["parentdir"]))
def unserialize(self, skeletonValues: 'viur.core.skeleton.SkeletonValues',
name: str) -> bool:
"""
Inverse of serialize. Evaluates whats
read from the datastore and populates
this bone accordingly.
:param name: The property-name this bone has in its Skeleton (not the description!)
:type name: str
:param expando: An instance of the dictionary-like db.Entity class
:type expando: db.Entity
:returns: bool
"""
assert name == "key", "Keybones must be named key!"
if isinstance(
skeletonValues.entity, Entity
) and skeletonValues.entity.key and not skeletonValues.entity.key.is_partial:
skeletonValues.accessedValues[name] = skeletonValues.entity.key
return True
elif "key" in skeletonValues.entity:
val = skeletonValues.entity["key"]
if isinstance(val, str):
try:
val = normalizeKey(KeyClass.from_legacy_urlsafe(val))
except:
val = None
elif not isinstance(val, KeyClass):
val = None
skeletonValues.accessedValues["key"] = val
return True
return False
def keyHelper(
inKey: Union[KeyClass, str, int],
targetKind: str,
additionalAllowdKinds: Union[None, List[str]] = None) -> KeyClass:
if isinstance(inKey, str):
try:
decodedKey = utils.normalizeKey(
KeyClass.from_legacy_urlsafe(inKey))
except:
decodedKey = None
if decodedKey: # If it did decode, don't try any further
if decodedKey.kind != targetKind and (
not additionalAllowdKinds
or inKey.kind not in additionalAllowdKinds):
raise ValueError("Kin1d mismatch: %s != %s" %
(decodedKey.kind, targetKind))
return decodedKey
if inKey.isdigit():
inKey = int(inKey)
return Key(targetKind, inKey)
elif isinstance(inKey, int):
return Key(targetKind, inKey)
elif isinstance(inKey, KeyClass):
if inKey.kind != targetKind and (not additionalAllowdKinds
or inKey.kind
not in additionalAllowdKinds):
raise ValueError("Kin1d mismatch: %s != %s (%s)" %
(inKey.kind, targetKind, additionalAllowdKinds))
return inKey
else:
raise ValueError("Unknown key type %r" % type(inKey))
def storeEntry2(self, e, key):
if not self._checkKey(key, export=False):
raise errors.Forbidden()
entry = pickle.loads(e.decode("HEX"))
if not "key" in entry and "id" in entry:
entry["key"] = entry["id"]
for k in list(entry.keys())[:]:
if isinstance(entry[k], str):
entry[k] = entry[k].decode("UTF-8")
key = db.Key(encoded=utils.normalizeKey(entry["key"]))
dbEntry = db.Entity(kind=key.kind(),
parent=key.parent(),
id=key.id(),
name=key.name()) # maybe some more fixes here ?
for k in entry.keys():
if k != "key":
val = entry[k]
dbEntry[k] = val
db.Put(dbEntry)
if dbEntry.key().id():
# Ensure the Datastore knows that it's id is in use
datastore._GetConnection()._reserve_keys([dbEntry.key()])
try:
skel = skeletonByKind(key.kind())()
except:
logging.error("Unknown Skeleton - skipping")
skel.fromDB(str(dbEntry.key()))
skel.refresh()
skel.toDB(clearUpdateTag=True)
def fixVals(val):
if isinstance(val, str):
try:
val = normalizeKey(KeyClass.from_legacy_urlsafe(val))
except:
val = None
elif not isinstance(val, KeyClass):
val = None
return val
def add(self, *args, **kwargs):
"""
Allows guests to register a new account if self.registrationEnabled is set to true
.. seealso:: :func:`addSkel`, :func:`onAdded`, :func:`canAdd`
:returns: The rendered, added object of the entry, eventually with error hints.
:raises: :exc:`server.errors.Unauthorized`, if the current user does not have the required permissions.
:raises: :exc:`server.errors.PreconditionFailed`, if the *skey* could not be verified.
"""
if "skey" in kwargs:
skey = kwargs["skey"]
else:
skey = ""
if not self.canAdd():
raise errors.Unauthorized()
skel = self.addSkel()
if (len(kwargs) == 0 # no data supplied
or skey == "" # no skey supplied
or not currentRequest.get().
isPostRequest # bail out if not using POST-method
or not skel.fromClient(
kwargs) # failure on reading into the bones
or ("bounce" in kwargs
and kwargs["bounce"] == "1")): # review before adding
# render the skeleton in the version it could as far as it could be read.
return self.userModule.render.add(skel)
if not securitykey.validate(skey, useSessionKey=True):
raise errors.PreconditionFailed()
skel.toDB()
if self.registrationEmailVerificationRequired and str(
skel["status"]) == "1":
# The user will have to verify his email-address. Create an skey and send it to his address
skey = securitykey.create(duration=60 * 60 * 24 * 7,
userKey=utils.normalizeKey(skel["key"]),
name=skel["name"])
skel.skey = baseBone(descr="Skey")
skel["skey"] = skey
email.sendEMail(dests=[skel["name"]],
tpl=self.userModule.verifyEmailAddressMail,
skel=skel)
self.userModule.onAdded(skel) # Call onAdded on our parent user module
return self.userModule.render.addSuccess(skel)
:raises: :exc:`viur.core.errors.NotFound`, when no entry with the given *key* was found.
:raises: :exc:`viur.core.errors.Unauthorized`, if the current user does not have the required permissions.
:raises: :exc:`viur.core.errors.PreconditionFailed`, if the *skey* could not be verified.
"""
if not (skelType := self._checkSkelType(skelType)):
raise errors.NotAcceptable(f"Invalid skelType provided.")
skel = self.editSkel(skelType) # srcSkel - the skeleton to be moved
parentNodeSkel = self.baseSkel(
"node") # destSkel - the node it should be moved into
if not skel.fromDB(key):
raise errors.NotFound("Cannot find key entity")
if not parentNodeSkel.fromDB(parentNode):
parentNode = utils.normalizeKey(
db.Key.from_legacy_urlsafe(parentNode))
if parentNode.kind != parentNodeSkel.kindName:
raise errors.NotFound(
f"You provided a key of kind {parentNode.kind}, but require a {parentNodeSkel.kindName}."
)
raise errors.NotFound("Cannot find parentNode entity")
if not self.canMove(skelType, skel, parentNodeSkel):
raise errors.Unauthorized()
if skel["key"] == parentNodeSkel["key"]:
raise errors.NotAcceptable("Cannot move a node into itself")
## Test for recursion
def iterImport(module, target, exportKey, cursor=None, amount=0):
"""
Processes 100 Entries and calls the next batch
"""
urlfetch.set_default_fetch_deadline(20)
payload = {"module": module, "key": exportKey}
if cursor:
payload.update({"cursor": cursor})
result = urlfetch.fetch(
url=target,
payload=urllib.urlencode(payload),
method=urlfetch.POST,
headers={'Content-Type': 'application/x-www-form-urlencoded'})
if result.status_code == 200:
res = pickle.loads(result.content.decode("HEX"))
skel = skeletonByKind(module)()
logging.info("%s: %d new entries fetched, total %d entries fetched" %
(module, len(res["values"]), amount))
if len(res["values"]) == 0:
try:
utils.sendEMailToAdmins(
"Import of kind %s finished with %d entities" %
(module, amount), "ViUR finished to import %d entities of "
"kind %s from %s.\n" % (amount, module, target))
except: # OverQuota, whatever
logging.error("Unable to send Email")
return
for entry in res["values"]:
for k in list(entry.keys())[:]:
if isinstance(entry[k], str):
entry[k] = entry[k].decode("UTF-8")
if not "key" in entry:
entry["key"] = entry["id"]
key = db.Key(encoded=utils.normalizeKey(entry["key"]))
# Special case: Convert old module root nodes!!!
if module.endswith(
"_rootNode") and key.name() and "_modul_" in key.name():
name = key.name().replace("_modul_", "_module_")
else:
name = key.name()
dbEntry = db.Entity(kind=key.kind(),
parent=key.parent(),
id=key.id(),
name=name)
for k in entry.keys():
if k == "key":
continue
dbEntry[k] = entry[k]
# Special case: Convert old module root nodes!!!
if (isinstance(skel, (HierarchySkel, TreeLeafSkel))
and k in ["parentdir", "parententry", "parentrepo"]
and entry[k]):
key = db.Key(encoded=str(entry[k]))
if key.parent():
parent = db.Key(
encoded=utils.normalizeKey(key.parent()))
else:
parent = None
if key.id_or_name() and "_modul_" in str(key.id_or_name()):
name = key.id_or_name().replace("_modul_", "_module_")
else:
name = key.id_or_name()
dbEntry[k] = str(
db.Key.from_path(key.kind(), name, parent=parent))
db.Put(dbEntry)
skel.fromDB(str(dbEntry.key()))
skel.refresh()
skel.toDB(clearUpdateTag=True)
amount += 1
iterImport(module, target, exportKey, res["cursor"], amount)
