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)