Ejemplo n.º 1
0
    def alter_detail_data_to_serialize(self, request, bundle):
        # Show additional field following the model's rules
        rules = register_model_rules().model(self.get_model()).all()
        # All additional relationships
        for key in rules:
            # Filter rules to keep only Neomatch
            if isinstance(rules[key], Neomatch):
                bundle.data[key] = rules[key].query(bundle.obj.id)

        return bundle
Ejemplo n.º 2
0
def get_model_fields(model):
    fields      = []
    modelsRules = register_model_rules().model(model)
    if hasattr(model, "_meta"):          
        # Create field object
        for fieldRules in modelsRules.fields():
            try:
                f = model._meta.get_field(fieldRules.name)
            except FieldDoesNotExist:
                # This is rule field. Ignore it!
                continue
            # Ignores field terminating by + or begining by _
            if not f.name.endswith("+") and not f.name.endswith("_set") and not f.name.startswith("_"):             
                # Find related model for relation
                if hasattr(f, "target_model"):
                    # We received a model as a string
                    if type(f.target_model) is str:
                        # Extract parts of the module path
                        module_path  = f.target_model.split(".")
                        # Import models as a module
                        module       = __import__( ".".join(module_path[0:-1]), fromlist=["class"])
                        # Import the target_model from the models module
                        target_model = getattr(module, module_path[-1], {__name__: None})
                    else:                        
                        target_model  = f.target_model                     
                    related_model = target_model.__name__
                else:
                    related_model = None     
                
                field = {
                    'name'         : f.name,
                    'type'         : f.get_internal_type(),
                    'help_text'    : getattr(f, "help_text", ""),
                    'verbose_name' : getattr(f, "verbose_name", pretty_name(f.name)),
                    'related_model': related_model,
                    'rules'        : fieldRules.all()
                }
                
                fields.append(field)

    return fields
Ejemplo n.º 3
0
    def dehydrate(self, bundle):
        # Show additional field following the model's rules
        rules = register_model_rules().model( self.get_model() )
        # Get the output transformation for this model
        transform = rules.get("transform")
        # This is just a string
        # For complex formating use http://docs.python.org/2/library/string.html#formatspec
        if type(transform) is str:
            transform = transform.format(**bundle.data)
        # We can also receive a function
        elif callable(transform):
            transform = transform(bundle.data)

        bundle.data["_transform"] = transform or getattr(bundle.data, 'name', None)
        # Control that every relationship fields are list
        # and that we didn't send hidden field
        for field in bundle.data:
            # Find the model's field
            modelField = getattr(bundle.obj, field, False)
            # The current field is a relationship
            if modelField and hasattr(modelField, "_rel"):
                # Wrong type given, relationship field must ouput a list
                if type(bundle.data[field]) is not list:
                    # We remove the field from the ouput
                    bundle.data[field] = []
            # The field is a list of literal values
            elif type(modelField) in (list, tuple):
                # For tuple serialization
                bundle.data[field] = modelField
            # Get the output transformation for this field
            transform = rules.field(field).get("transform")
            # This is just a string
            # For complex formating use http://docs.python.org/2/library/string.html#formatspec
            if type(transform) is str:
                bundle.data[field] = transform.format(**bundle.data)
            # We can also receive a function
            elif callable(transform):
                bundle.data[field] = transform(bundle.data, field)

        return bundle