def func(self, args, request):
if not args:
raise MudderyError(ERR.missing_args, 'Missing arguments.')
if 'typeclass' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "typeclass".')
if 'location' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "location".')
if 'destination' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "destination".')
typeclass = args["typeclass"]
location = args["location"]
destination = args["destination"]
forms = data_edit.query_object_form(typeclass, typeclass, None)
new_exit = []
for form in forms:
values = {field["name"]: field["value"] for field in form["fields"] if "value" in field}
values["location"] = location
values["destination"] = destination
new_exit.append({
"table": form["table"],
"values": values
})
obj_key = data_edit.save_object_form(new_exit, typeclass, "")
data = {"key": obj_key}
return success_response(data)
def take_off_position(self, position):
"""
Take off an object from position.
"""
if not position in self.db.equipments:
raise MudderyError(_("Can not find this equipment."))
if not self.db.equipments[position]:
raise MudderyError(_("Can not find this equipment."))
# Set object's attribute 'equipped' to False
dbref = self.db.equipments[position]
for obj in self.contents:
if obj.dbref == dbref:
obj.equipped = False
find = True
self.db.equipments[position] = None
# reset character's attributes
self.refresh_properties(True)
message = {
"status": self.return_status(),
"equipments": self.return_equipments(),
"inventory": self.return_inventory()
}
self.msg(message)
def func(self, args, request):
if not args:
raise MudderyError(ERR.missing_args, 'Missing arguments.')
if 'action' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "action".')
if 'event' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "event".')
if 'values' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "values".')
action_type = args["action"]
event_key = args["event"]
values = args["values"]
# Get action's data.
action = EVENT_ACTION_SET.get(action_type)
if not action:
raise MudderyError(ERR.no_table, "Can not find action: %s" % action_type)
table_name = action.model_name
# Remove old records.
data_edit.delete_records(table_name, event_key=event_key)
# Add new data.
for value in values:
data_edit.save_form(value, table_name)
return success_response("success")
def export_file(filename, table_name, file_type=None):
"""
Export a table to a csv file.
"""
if not file_type:
# Get file's extension name.
file_type = os.path.splitext(filename)[1].lower()
if len(file_type) > 0:
file_type = file_type[1:]
writer_class = writers.get_writer(file_type)
if not writer_class:
raise (MudderyError(ERR.export_data_error,
"Unsupport file type %s" % file_type))
writer = writer_class(filename)
if not writer:
raise (MudderyError(ERR.export_data_error,
"Can not export table %s" % table_name))
fields = general_query_mapper.get_all_fields(table_name)
header = [field.name for field in fields]
writer.writeln(header)
records = general_query_mapper.get_all_records(table_name)
for record in records:
line = [
str(record.serializable_value(field.get_attname()))
for field in fields
]
writer.writeln(line)
writer.save()
def func(self, args, request):
if not args:
raise MudderyError(ERR.missing_args, 'Missing arguments.')
if 'tables' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "tables".')
if 'base_typeclass' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "base_typeclass".')
if 'obj_typeclass' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "obj_typeclass".')
if 'obj_key' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "obj_key".')
tables = args["tables"]
base_typeclass = args["base_typeclass"]
obj_typeclass = args["obj_typeclass"]
obj_key = args["obj_key"]
new_key = data_edit.save_object_form(tables, obj_typeclass, obj_key)
if obj_key != new_key:
data_edit.update_object_key(obj_typeclass, obj_key, new_key)
return success_response(new_key)
def save_form(values, table_name, record_id=None):
"""
Save data to a record.
Args:
values: (dict) values to save.
table_name: (string) data table's name.
record_id: (string, optional) record's id. If it is empty, add a new record.
"""
form_class = FORM_SET.get(table_name)
if not form_class:
raise MudderyError(ERR.no_table, "Can not find table: %s" % table_name)
form = None
if record_id:
try:
# Query record's data.
record = general_query_mapper.get_record_by_id(
table_name, record_id)
form = form_class(values, instance=record)
except Exception as e:
form = None
if not form:
# Get empty data.
form = form_class(values)
# Save data
if form.is_valid():
instance = form.save()
return instance.pk
else:
raise MudderyError(ERR.invalid_form, "Invalid form.", data=form.errors)
def func(self, args, request):
if not args:
raise MudderyError(ERR.missing_args, 'Missing arguments.')
if 'typeclass' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "typeclass".')
typeclass = args["typeclass"]
width = args.get("width", 0)
height = args.get("height", 0)
forms = data_edit.query_object_form(typeclass, typeclass, None)
new_area = []
for form in forms:
values = {field["name"]: field["value"] for field in form["fields"] if "value" in field}
values["width"] = width
values["height"] = height
new_area.append({
"table": form["table"],
"values": values
})
obj_key = data_edit.save_object_form(new_area, typeclass, "")
data = {"key": obj_key,
"width": width,
"height": height}
return success_response(data)
def func(self, args, request):
if ('table' not in args):
raise MudderyError(ERR.missing_args, 'Missing the table name.')
table_name = args['table']
file_type = args.get("type", "csv")
writer_class = writers.get_writer(file_type)
if not writer_class:
raise MudderyError(ERR.download_error,
"Unknown file type: %s" % file_type)
# Get tempfile's name.
temp_name = tempfile.mktemp()
exporter.export_file(temp_name, table_name, file_type)
fp = open(temp_name, "rb")
try:
filename = table_name + "." + writer_class.file_ext
return file_response(fp, filename)
except Exception as e:
if fp:
fp.close()
logger.log_tracemsg("Download error: %s" % e)
raise MudderyError(ERR.download_error,
"Download file error: %s" % e)
def query_object_form(base_typeclass, obj_typeclass, obj_key):
"""
Query all data of an object.
Args:
base_typeclass: (string) candidate typeclass group.
obj_typeclass: (string, optional) object's typeclass. If it is empty, use the typeclass of the object
or use base typeclass as object's typeclass.
obj_key: (string) object's key. If it is empty, query an empty form.
"""
candidate_typeclasses = TYPECLASS_SET.get_group(base_typeclass)
if not candidate_typeclasses:
raise MudderyError(ERR.no_table,
"Can not find typeclass: %s" % base_typeclass)
if not obj_typeclass:
if obj_key:
# Get typeclass from the object's record
table_name = TYPECLASS("OBJECT").model_name
record = general_query_mapper.get_record_by_key(
table_name, obj_key)
obj_typeclass = record.typeclass
else:
# Or use the base typeclass
obj_typeclass = base_typeclass
typeclass = TYPECLASS_SET.get(obj_typeclass)
if not typeclass:
raise MudderyError(ERR.no_table,
"Can not find typeclass: %s" % obj_typeclass)
table_names = typeclass.get_models()
forms = []
for table_name in table_names:
if obj_key:
object_form = query_form(table_name, key=obj_key)
else:
object_form = query_form(table_name)
forms.append({"table": table_name, "fields": object_form})
# add typeclasses
if len(forms) > 0:
for field in forms[0]["fields"]:
if field["name"] == "typeclass":
# set typeclass to the new value
field["value"] = obj_typeclass
field["type"] = "Select"
field["choices"] = [
(key, cls.typeclass_name + " (" + key + ")")
for key, cls in candidate_typeclasses.items()
]
break
return forms
def func(self, args, request):
if not args:
raise MudderyError(ERR.missing_args, 'Missing arguments.')
if 'area' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "area".')
area_key = args["area"]
data = data_query.query_map(area_key)
return success_response(data)
def func(self, args, request):
if 'obj_key' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "obj_key".')
if 'level' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "level".')
obj_key = args["obj_key"]
level = args["level"]
data = data_query.query_object_level_properties(obj_key, level)
return success_response(data)
def func(self, args, request):
if 'typeclass' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "typeclass".')
if 'obj_key' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "obj_key".')
typeclass_key = args["typeclass"]
obj_key = args["obj_key"]
data = data_query.query_object_properties(typeclass_key, obj_key)
return success_response(data)
def func(self, args, request):
if 'obj_key' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "obj_key".')
if 'base_typeclass' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "base_typeclass".')
obj_key = args["obj_key"]
base_typeclass = args.get("base_typeclass", None)
data_edit.delete_object(obj_key, base_typeclass)
data = {"obj_key": obj_key}
return success_response(data)
def func(self, args, request):
if 'table' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "table".')
if 'record' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "record".')
table_name = args["table"]
record_id = args["record"]
data_edit.delete_record(table_name, record_id)
data = {"record": record_id}
return success_response(data)
def func(self, args, request):
if not args:
raise MudderyError(ERR.missing_args, 'Missing arguments.')
if "objects" not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "objects".')
objects = args["objects"]
for object_key in objects:
data_edit.delete_object(object_key)
return success_response("success")
def func(self, args, request):
if not args:
raise MudderyError(ERR.missing_args, 'Missing arguments.')
if 'base_typeclass' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "base_typeclass".')
base_typeclass = args["base_typeclass"]
obj_typeclass = args.get('obj_typeclass', None)
obj_key = args.get('obj_key', None)
data = data_edit.query_object_form(base_typeclass, obj_typeclass, obj_key)
return success_response(data)
def import_data(model_obj, data_iterator):
"""
Import data to a table.
Args:
model_obj: (model) model object.
data_iterator: (list) data list.
Returns:
None
"""
line = 1
try:
# read title
titles = next(data_iterator)
field_types = get_field_types(model_obj, titles)
line += 1
# import values
for values in data_iterator:
# skip blank lines
blank_line = True
for value in values:
if value:
blank_line = False
break
if blank_line:
line += 1
continue
record = parse_record(titles, field_types, values)
data = model_obj(**record)
try:
data.full_clean()
data.save()
except ValidationError as e:
if except_errors:
print(parse_error(e, model_obj.__name__, line))
else:
raise
line += 1
except StopIteration:
# reach the end of file, pass this exception
pass
except ValidationError as e:
traceback.print_exc()
raise MudderyError(ERR.import_data_error, parse_error(e, model_obj.__name__, line))
except Exception as e:
traceback.print_exc()
raise MudderyError(ERR.import_data_error, "%s (model: %s, line: %s)" % (e, model_obj.__name__, line))
def func(self, args, request):
if not args:
raise MudderyError(ERR.missing_args, 'Missing arguments.')
if 'area' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "area".')
if 'rooms' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "rooms".')
area = args["area"]
rooms = args["rooms"]
data = data_edit.save_map_positions(area, rooms)
return success_response(data)
def func(self, args, request):
if 'obj_key' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "obj_key".')
if 'level' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "level".')
if 'values' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "values".')
obj_key = args["obj_key"]
level = args["level"]
values = args["values"]
data_edit.save_object_level_properties(obj_key, level, values)
return success_response("success")
def get_tables_data(cls, tables, key):
"""
Get a record from tables whose key field is the value.
Only can get one record.
Args:
tables: (list) tables' name
key: (string) object's key
Return:
(dict) values
"""
data = {}
for table_name in tables:
if table_name not in cls.tables:
cls.load_table(table_name)
fields = cls.tables[table_name].get_fields()
records = cls.tables[table_name].filter_data(key=key)
if not records:
continue
if len(records) > 1:
raise MudderyError(
"Can not solve more than one records from table: %s" %
table_name)
record = records[0]
for field_name in fields:
data[field_name] = getattr(record, field_name)
return data
def query_form(table_name, **kwargs):
"""
Query table's data.
Args:
table_name: (string) data table's name.
kwargs: (dict) conditions.
"""
form_class = FORM_SET.get(table_name)
if not form_class:
raise MudderyError(ERR.no_table, "Can not find table: %s" % table_name)
form = None
record = None
if kwargs:
try:
# Query record's data.
record = general_query_mapper.get_record(table_name, **kwargs)
form = form_class(instance=record)
except Exception as e:
form = None
if not form:
# Get empty data.
form = form_class()
fields = []
fields.append({
"name": "id",
"label": "",
"disabled": True,
"help_text": "",
"type": "Hidden",
"value": record.id if record else "",
})
for key, field in form.fields.items():
info = {
"name": key,
"label": field.label,
"disabled": field.disabled,
"help_text": field.help_text,
"type": field.widget.__class__.__name__,
}
if record:
info["value"] = str(record.serializable_value(key))
if info["type"] == "Select":
info["choices"] = field.choices
if isinstance(field, LocationField):
info["type"] = "Location"
elif isinstance(field, ImageField):
info["type"] = "Image"
info["image_type"] = field.get_type()
fields.append(info)
return fields
def query_event_action_forms(action_type, event_key):
"""
Query forms of the event action.
Args:
action_type: (string) action's type
event_key: (string) event's key
"""
# Get action's data.
action = EVENT_ACTION_SET.get(action_type)
if not action:
raise MudderyError(ERR.no_table,
"Can not find action: %s" % action_type)
# Get all forms.
forms = []
table_name = action.model_name
records = general_query_mapper.filter_records(table_name,
event_key=event_key)
if records:
for record in records:
forms.append(query_form(table_name, id=record.id))
else:
forms.append(query_form(table_name))
return {"forms": forms, "repeatedly": action.repeatedly}
def func(self, args, request):
file_obj = request.FILES.get("file", None)
if not file_obj:
raise MudderyError(ERR.missing_args, 'Missing zip files.')
with tempfile.TemporaryFile() as fp:
try:
for chunk in file_obj.chunks():
fp.write(chunk)
importer.unzip_resources_all(fp)
except Exception as e:
logger.log_tracemsg("Upload error: %s" % e)
raise MudderyError(ERR.upload_error, str(e))
return success_response("success")
def func(self, args, request):
if not args or ('username' not in args) or ('password' not in args):
raise MudderyError(ERR.missing_args, 'Missing arguments.')
username = args['username']
password = args['password']
user = auth.authenticate(username=username, password=password)
if not user:
raise MudderyError(ERR.no_authentication, "Authentication fialed.")
if not user.is_staff:
raise MudderyError(ERR.no_permission, "No permission.")
auth.login(request, user)
return success_response("success")
def filter_data(self, **kwargs):
"""
Filter data by record's value. Fields must have index. If filter multi fields, put them in a tuple.
Args:
kwargs: (dict) query conditions
"""
if len(kwargs) == 0:
return self.all_data()
if len(kwargs) == 1:
keys = list(kwargs.keys())
index_name = keys[0]
values = kwargs[index_name]
else:
unique_fields = set(kwargs.keys())
index_name = ".".join(unique_fields)
values = tuple(kwargs[field_name] for field_name in unique_fields)
if index_name not in self.index:
raise MudderyError("Only indexed fields can be searched.")
index = self.index[index_name]
if values in index:
return [self.data[i] for i in index[values]]
else:
return []
def func(self, args, request):
if not args:
raise MudderyError(ERR.missing_args, 'Missing arguments.')
if 'values' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "values".')
if 'table' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "table".')
values = args["values"]
table_name = args["table"]
record_id = args.get('record', None)
record_id = data_edit.save_form(values, table_name, record_id)
data = data_edit.query_form(table_name, id=record_id)
return success_response(data)
def func(self, args, request):
if 'typeclass' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "typeclass".')
typeclass = args["typeclass"]
data = data_query.query_object_event_triggers(typeclass)
return success_response(data)
def func(self, args, request):
if 'object' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "object".')
object_key = args["object"]
data = data_query.query_object_events(object_key)
return success_response(data)
def func(self, args, request):
if 'table' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "table".')
table_name = args["table"]
try:
record = general_query_mapper.get_the_first_record(table_name)
if record:
record_id = record.id
else:
record_id = None
except Exception as e:
raise MudderyError(ERR.invalid_form, "Wrong table: %s." % table_name)
data = data_edit.query_form(table_name, id=record_id)
return success_response(data)
def func(self, args, request):
if 'table' not in args:
raise MudderyError(ERR.missing_args, 'Missing the argument: "table".')
table_name = args["table"]
data = general_query.query_table(table_name)
return success_response(data)
