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