def _post_root(self, model, related=False):
m = model()
for key, value in self.args.iteritems():
if key == 'id':
continue
if hasattr(m, key):
try:
if m._meta.get_field(key).get_internal_type() == 'DateTimeField':
value = utils.datetime_from_string(value)
elif m._meta.get_field(key).get_internal_type() == 'TimeField':
value = utils.time_from_string(value)
except FieldDoesNotExist:
pass
setattr(m, key, value)
if related:
setattr(m, utils.camel_to_underscore(self.__class__.__name__), self.model)
if hasattr(self, 'post_pre_save_action'):
getattr(self, 'post_pre_save_action')(m)
m.save()
if hasattr(self, 'post_post_save_action'):
getattr(self, 'post_post_save_action')(m)
include = []
if hasattr(self, 'get_serializer_fields'):
include = getattr(self, 'get_serializer_fields')(m)
out = self.serializer(m, include).pack()
if hasattr(self, 'get_pre_return_action'):
getattr(self, 'get_pre_return_action')(m, out)
return self.format_singular(self.get_name(model(), related), out)
def get_related(self):
if self.related_id:
return self.format_success(self._get_id(self.related_model, True))
else:
return self.format_success(self._get_root(self.original_related_model,
True,
filter={utils.camel_to_underscore(self.__class__.__name__):
self.model}))
def exec_related(self):
self.controller.open_model(self.id)
self.related_controller.open_model()
filter = {
utils.camel_to_underscore(self.controller.__class__.__name__): self.controller.model
}
self.related_controller.model.filter(**filter)
return self.return_success(self.related_controller.exec_root())
def get_name(self, model, related=False):
if related:
return self.related_name
else:
if isinstance(model, models.Model):
split = model.__class__.__name__
else:
split = model
return utils.camel_to_underscore(split)
def pack(self):
if len(self.include) > 0:
fields = serializers.serialize('python', (self.model, ), fields=self.include)[0]['fields']
else:
fields = serializers.serialize('python', (self.model, ))[0]['fields']
for name, value in fields.iteritems():
if self.model._meta.get_field(name).get_internal_type() == 'DateTimeField':
fields[name] = utils.string_from_datetime(value)
elif self.model._meta.get_field(name).get_internal_type() == 'TimeField':
fields[name] = utils.string_from_time(value)
fields['id'] = self.model.id
fields['model'] = utils.camel_to_underscore(self.model.__class__.__name__)
return fields
def _get_root(self, model, related=False, filter={}):
models = model.objects.all().filter(**filter)
if related:
name = self.__class__.__name__
kwargs = {
utils.camel_to_underscore(name): self.model
}
models.filter(**kwargs)
ret = None
if hasattr(self, 'get_filter'):
ret = getattr(self, 'get_filter')(models)
if ret is not None:
models = ret
out = []
for m in models:
include = []
if hasattr(self, 'get_serializer_fields'):
include = getattr(self, 'get_serializer_fields')(m)
me = self.serializer(m, include).pack()
if hasattr(self, 'get_pre_return_action'):
getattr(self, 'get_pre_return_action')(m, me)
out.append(me)
return self.format_plural(self.get_name(model(), related), out)
def _format_singular(self, out, name=None):
if not name:
name = utils.camel_to_underscore(self._get_name())
if name[-1:] == "s":
name = name[:-1]
return {name: out}
def _format_plural(self, out, name=None):
if not name:
name = utils.camel_to_underscore(self._get_name())
if name[-1:] != "s":
name = "%ss" % name
return {name: out}
