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 func(self, args, request):
file_obj = request.FILES.get("file", None)
if not file_obj:
raise MudderyError(ERR.missing_args, 'Missing data files.')
fullname = file_obj.name
filename, ext_name = os.path.splitext(fullname)
table_name = args.get("table", None)
if not table_name:
table_name = filename
file_type = ""
if ext_name:
file_type = ext_name[1:].lower()
with tempfile.NamedTemporaryFile() as fp:
try:
for chunk in file_obj.chunks():
fp.write(chunk)
importer.import_data_file(fp, table_name=table_name, file_type=file_type)
except Exception, e:
logger.log_tracemsg("Upload error: %s" % e.message)
raise MudderyError(ERR.upload_error, e.message)
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 func(self, args, request):
file_obj = request.FILES.get("file", None)
if not file_obj:
raise MudderyError(ERR.missing_args, 'Missing icon files.')
file_type = args["type"]
filename = file_obj.name
path = os.path.join(settings.MEDIA_ROOT, settings.IMAGE_PATH, file_type)
filepath = os.path.join(path, filename)
exist = False
if not os.path.exists(filepath):
if not os.path.exists(path):
# If does not exist, create one.
os.makedirs(path)
# save file
fp = None
try:
fp = open(filepath, "wb+")
for chunk in file_obj.chunks():
fp.write(chunk)
fp.flush()
except Exception, e:
if fp:
fp.close()
logger.log_tracemsg("Upload error: %s" % e.message)
raise MudderyError(ERR.upload_error, e.message)
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 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_data()
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 '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 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 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 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 save_object_form(tables, obj_typeclass, obj_key):
"""
Save all data of an object.
Args:
tables: (list) a list of table data.
[{
"table": (string) table's name.
"record": (string, optional) record's id. If it is empty, add a new record.
}]
obj_typeclass: (string) object's typeclass.
obj_key: (string) current object's key. If it is empty or changed, query an empty form.
"""
if not tables:
raise MudderyError(ERR.invalid_form,
"Invalid form.",
data="Empty form.")
try:
typeclass = TYPECLASS(obj_typeclass)
except:
raise MudderyError(ERR.invalid_form,
"Invalid form.",
data="No typeclass: %s" % obj_typeclass)
# Get object's new key from the first form.
new_obj = not (obj_key and obj_key == tables[0]["values"]["key"])
if new_obj:
try:
obj_key = tables[0]["values"]["key"]
except KeyError:
pass
if not obj_key:
# Generate a new key.
try:
# Get object table's last id.
query = general_query_mapper.get_the_last_record(
typeclass.model_name)
if query:
index = int(query.id) + 1
else:
index = 1
except Exception, e:
raise MudderyError(ERR.invalid_form,
"Invalid form.",
data="No typeclass model: %s" %
obj_typeclass)
obj_key = obj_typeclass + "_" + str(index)
for table in tables:
table["values"]["key"] = obj_key
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):
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, e:
logger.log_tracemsg("Upload error: %s" % e.message)
raise MudderyError(ERR.upload_error, e.message)
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 '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 '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 decrease_num(self, number):
"""
Decrease object's number.
"""
if number == 0:
return
if number < 0:
raise MudderyError("%s can not decrease a negative nubmer." % self.get_data_key())
if self.db.number < number:
raise MudderyError("%s's number will below zero." % self.get_data_key())
self.db.number -= number
return
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 '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 load_data_fields(self, key):
"""
Get object's data record from database.
Args:
key: (String) object's data key.
Returns:
None
"""
# Get model and key names.
if not key:
key = self.get_data_key()
if not key:
raise MudderyError("No data key.")
for data_model in self.get_models():
# Get db model
model_obj = apps.get_model(settings.WORLD_DATA_APP, data_model)
if not model_obj:
logger.log_errmsg("%s can not open model %s" %
(key, data_model))
continue
# Get data record.
try:
data = model_obj.objects.get(key=key)
except Exception, e:
logger.log_errmsg("%s can not find key %s" % (key, key))
continue
# Set data.
for field in data._meta.fields:
setattr(self.dfield, field.name,
data.serializable_value(field.name))
def submit_form(self):
"""
Edit a record.
Returns:
HttpResponse
"""
if not self.valid:
raise MudderyError("Invalid form: %s." % self.form_name)
# Query data.
if not self.data:
self.query_submit_data()
# Save data
if self.data.is_valid():
instance = self.data.save()
self.record = instance.pk
try:
oldkey = self.key
self.key = instance.key
# modify relative sentences
sentence_form_class = forms.Manager.get_form(
"dialogue_sentences")
sentence_form_class.Meta.model.objects.filter(
dialogue=oldkey).update(dialogue=self.key)
except Exception, e:
pass
if "_save" in self.request_data:
# Save and quit.
return self.quit_form()
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 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, e:
raise MudderyError(ERR.invalid_form,
"Wrong table: %s." % table_name)
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 submit_form(self):
"""
Edit a record.
Returns:
HttpResponse
"""
if not self.valid:
raise MudderyError("Invalid form: %s." % self.form_name)
# Query data.
if not self.data:
self.query_submit_data()
# Save data
if self.data.is_valid():
instance = self.data.save()
self.record = instance.pk
try:
self.key = instance.key
except Exception, e:
pass
if "_save" in self.request_data:
# Save and quit.
return self.quit_form()
def func(self, args, request):
try:
# reload system data
# import_syetem_data()
# reload localized strings
# LOCALIZED_STRINGS_HANDLER.reload()
# rebuild the world
build_all()
# send client settings
client_settings = GAME_SETTINGS.get_client_settings()
text = json.dumps({"settings": client_settings})
SESSIONS.announce_all(text)
# restart the server
SESSIONS.announce_all("Server restarting ...")
SESSIONS.portal_restart_server()
except Exception as e:
message = "Can not build the world: %s" % e
logger.log_tracemsg(message)
raise MudderyError(ERR.build_world_error, message)
return success_response("success")
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_data_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 get_context(self):
"""
Get render context.
Returns:
context
"""
if not self.valid:
raise MudderyError("Invalid form: %s." % self.form_name)
# Query data.
if not self.data:
self.query_view_data()
verbose_name = self.form_class.Meta.model._meta.verbose_name_plural
context = {
"data": self.data,
"title": verbose_name,
"desc": getattr(self.form_class.Meta, "desc", verbose_name),
"can_delete": (self.record is not None)
}
if self.record:
context["record"] = self.record
if self.page:
context["page"] = self.page
return context
