def setUserEmailAddress(self, address=""):
if re.match(self.validEmailRegex, address):
self.email = address
return True
else:
msg = "{} account.setUserEmailAddress: Bad email: {}".format(self.client,
address)
logger.error(msg)
return False
def getPermanents(self, idList=[]):
""" Returns a list of objects for the corresponding object IDs """
objList = []
for permId in idList:
oneObj = self.getPermanent(permId)
if oneObj:
objList.append(oneObj)
else:
logger.error("Could not add permanent " + permId + " to list")
return objList
def createObject(self, num=99999, type="Portal", name="portal"):
obj = ObjectFactory(type, num)
if not obj:
logger.error("Could not instanciate object type " + type)
obj._name = name
obj._article = "a"
obj._singledesc = name
obj._pluraldesc = name + "s"
obj._longdesc = "A long " + name
obj._weight = 5
obj._value = 100
return obj
def ObjectFactory(objType, id=0): # noqa: C901
""" Factory method to return the correct object, depending on the type """
obj = None
if objType.lower() == "object":
obj = Portal(id)
elif objType.lower() == "portal":
obj = Portal(id)
elif objType.lower() == "door":
obj = Door(id)
elif objType.lower() == "armor":
obj = Armor(id)
elif objType.lower() == "weapon":
obj = Weapon(id)
elif objType.lower() == "shield":
obj = Shield(id)
elif objType.lower() == "container":
obj = Container(id)
elif objType.lower() == "key":
obj = Key(id)
elif objType.lower() == "scroll":
obj = Scroll(id)
elif objType.lower() == "potion":
obj = Potion(id)
elif objType.lower() == "staff":
obj = Staff(id)
elif objType.lower() == "teleport":
obj = Teleport(id)
elif objType.lower() == "coins":
obj = Coins(id)
elif objType.lower() == "ring":
obj = Ring(id)
elif objType.lower() == "necklace":
obj = Necklace(id)
elif objType.lower() == "treasure":
obj = Treasure(id)
try:
obj.getId()
except AttributeError:
logger.error(
"ObjectFactory: Could not obtain id for newly"
+ "instanciated "
+ objType
+ " object"
)
return obj
def othersInRoomMsg(self, charObj, roomObj, msg, ignore=False):
""" shown to others in room, but not you """
received = False
if ignore: # may get set to True if player is hidden
return False
if not roomObj:
logger.error("ipc.othersInRoomMsg: roomObj not defined. Skipping")
for oneChar in roomObj.getCharacterList():
if charObj:
if oneChar == charObj:
continue # skip yourself
status = self.charMsg(oneChar, msg)
if status:
received = True # sent to at least one recipient
return received
def extract_parameters_from_request(event: dict) -> (str, str, str):
logger.info(event)
if 'queryStringParameters' not in event:
logger.error("No query parameters passed")
return {}
text = event.get('queryStringParameters').get('text', None)
voice_id = event.get('queryStringParameters').get('voiceId', None)
output_format = event.get('queryStringParameters').get(
'outputFormat', None)
if len(text) == 0 or len(
voice_id) == 0 or output_format not in AUDIO_FORMATS:
logger.error("Bad request: wrong parameters")
sys.exit(1)
return text, voice_id, output_format
def RoomFactory(objType="room", id=0):
""" Factory method to return the correct object, depending on the type """
obj = None
if objType.lower() == "room":
obj = Room(id)
elif objType.lower() == "shop":
obj = Shop(id)
elif objType.lower() == "guild":
obj = Guild(id)
if not obj.getId():
logger.error(
"RoomFactory: Could not obtain id for newly"
+ "instanciated "
+ objType
+ " object"
)
return obj
def addAttributesToSelf(self, loadedDict, requestedAttNames=[], logStr=""):
""" Add attributes to current class object """
logPrefix = "addAttributesToSelf: "
if not isinstance(loadedDict, dict):
logger.error(logPrefix + "loadedDict is not a dict." +
" Its of type " + str(type(loadedDict)))
for key, value in zip(loadedDict.keys(), loadedDict.values()):
# If specific attributes are requested, skip all attributes that
# do not match.
if len(requestedAttNames) > 0:
if key not in requestedAttNames:
continue
setattr(self, key, value)
buf = "imported " + logStr + "attribute " + key
if (isinstance(value, str) or isinstance(value, int)
or isinstance(value, list)):
buf += "=" + str(value)
dLog(logPrefix + " " + buf + "\n", self._debugStorage)
def getPermanent(self, permId):
""" Returns an object, given the objectID """
itemObj = None
(objType, objId) = permId.split("/")
if objType.lower() == "creature":
itemObj = Creature(objId)
elif isObjectFactoryType(objType.lower()):
itemObj = ObjectFactory(objType, objId)
else:
logger.error("Can not determine object type.")
return None
if itemObj:
if itemObj.load():
return itemObj
else:
logger.error(
"Could not load object "
+ permId
+ " with type "
+ itemObj.getType()
)
else:
logger.error(
"Could not instanciate object "
+ permId
+ " with type="
+ objType
+ "and id="
+ str(objId)
)
return None
def setDataFilename(self, dfStr=""):
""" sets the data file name.
If no datafilename arg is provided, generate the datafile name
based on the class and ID. We can also override this method
to use a different filename """
id = ""
logPrefix = __class__.__name__ + " setDataFilename: "
if dfStr == "":
# generate the data file name based on class and id
try:
id = self.getId()
except AttributeError:
pass
if not id:
logger.error(logPrefix + "Could not retrieve Id to " +
"generate filename")
return False
if id == "":
logger.error(logPrefix + "ID is empty while generating " +
"datafile name")
return False
if hasattr(self, "_fileextension"):
extension = self._fileextension
else:
extension = ".pickle"
self._datafile = os.path.abspath(DATADIR + "/" +
self.__class__.__name__ + "/" +
str(id) + extension)
else:
# set data file name to name provided
self._datafile = os.path.abspath(str(dfStr))
dLog(logPrefix + "_datafile = " + self._datafile, self._debugStorage)
return True
def load(self, requestedAttNames=[], logStr="", fileType="pickle"):
""" load from persistant storage
- load data into tmp object
- iterate through the attributes assigning all, except the
ones that we specificly exclude, to the current object
- values of excluded objects are not overwritten """
if logStr != "":
logStr += " " # append a space for easy logging
self.setDataFilename()
# We may muck with the object data. Before we do, store
# the datafile info as a local variable so that there is no conflict.
filename = self._datafile
logPrefix = self.__class__.__name__ + " load: "
if filename == "":
logger.error(logPrefix + " Could not determine " +
"filename for loading " + logStr)
return False
dLog(logPrefix + "Loading " + filename + "...", self._debugStorage)
if self.dataFileExists():
# read the persisted content
if re.search("\\.json$", filename):
loadedDict = self.readJsonFile(filename, logStr)
else:
loadedDict = self.readPickleFile(filename, logStr)
if not loadedDict:
logger.error("storage.load - Could not get loaded instance")
# Add attributes to current class object, based on revised list
self.addAttributesToSelf(loadedDict, requestedAttNames, logStr)
dLog(
logPrefix + " loaded " + logStr + str(self.getId()) + " - " +
self.describe(),
self._debugStorage,
)
self.initTmpAttributes()
self.fixAttributes()
self.postLoad()
if self.isValid():
return True
else:
logger.error(logPrefix + logStr + str(self.getId()) +
" is not valid")
else:
logger.warning(logPrefix + " " + logStr +
"datafile doesn't exist at " + self._datafile)
return False
def delete(self, logStr=""):
logPrefix = self.__class__.__name__ + " delete: "
self.setDataFilename()
filename = self._datafile
if filename == "":
logger.error(logPrefix + " Could not determine filename " +
" while deleting " + logStr + str(self.getId()))
return False
if not os.path.isfile(filename):
logger.error(logPrefix + " Could not delete " + filename +
" because it is not a file ")
return False
if self.dataFileExists():
logger.info(logPrefix + " Preparing to delete " + logStr + " " +
filename)
try:
os.remove(filename)
except OSError as e:
logger.error(logPrefix + "Failed with:" + e.strerror)
logger.error(logPrefix + "Error code:" + e.code)
if os.path.isfile(filename):
logger.error(logPrefix + " " + filename + " could not " +
"be deleted")
return False
else:
logger.info(logPrefix + " " + filename + " deleted")
return True
else:
logger.error(logPrefix + " " + filename + " could not " +
"be deleted because it doesn't exist")
return False
return False
def getDataFilename(self):
""" returns the filename - should always be overridden """
logger.error("storage.getDataFilename: method not overwritten")
return self._datafile
def save(self, logStr=""):
""" save to persistant storage """
if logStr != "":
logStr += " " # append a space for easy logging
self.setDataFilename()
# We are about to muck with the object data. Before we do, store
# the datafile info as a local variable so that there is no conflict.
filename = self._datafile
logPrefix = self.__class__.__name__ + " save: "
if filename == "":
logger.error(logPrefix + "Could not determine filename " +
" while saving " + logStr + str(self.getId()))
return False
if not self.isValid(): # if the instance we are saving is not valid
logger.error(logPrefix + "Save aborted - " + logStr +
str(self.getId()) + " is not valid")
return False
# create directory
path = Path(os.path.dirname(self._datafile))
path.mkdir(parents=True, exist_ok=True)
# some attributes should not be, or can not be pickled, so we
# store the values before we save, then we will restore them
# immediately after.
tmpStore = {}
for attName in self.getAttributesThatShouldntBeSaved() + [
"_datafile",
"_instanceDebug",
]:
try:
tmpStore[attName] = getattr(self, attName)
if hasattr(self, attName):
delattr(self, attName)
dLog(
logPrefix + "Ignoring " + attName + " during save",
self._debugStorage,
)
except AttributeError:
dLog(
logPrefix + "Could not ignore " + attName + " during save",
self._debugStorage,
)
# persist content - create data file
if re.search("\\.json$", filename):
self.writeJSonFile(filename)
else:
self.writePickleFile(filename)
# Restore attributes that we temporarily set aside when saving.
for attName in tmpStore.keys():
setattr(self, attName, tmpStore[attName])
dLog(
logPrefix + "saved " + logStr + " - " + str(self.getId()),
self._debugStorage,
)
return True
