def presave(self, username, password, email, confirm):
self.clean_memcache()
# Check username
# Rewrite username
username = username.lower()
# if exist self.user no modify username
if not self.user and not username:
raise ValidationError(
"This person doesn't have a user assigned, can not change password or email without an user"
)
# Check passwords
if password and confirm and password != confirm:
raise ValidationError("Passwords do not match")
if password and (len(password) < settings.PASSWORD_MIN_SIZE):
raise ValidationError(
"Password can not be smaller than {0} characters".format(
settings.PASSWORD_MIN_SIZE))
# Check email
if email:
validate_email(email)
else:
raise ValidationError(
"Missing email when saving a new person without a preassigned user"
)
# Create user and save it to the database
if self.user:
# Check if the user requested to change the username
if username != self.user.username:
# Check if the username already exists in the database and it is not me
already = User.objects.filter(username=username).exclude(
pk=self.user.pk).first()
if already:
# Username already in use
raise ValidationError(
"Username already exists in the database")
else:
# Set new username
self.user.username = username
# Update password if any
if password:
self.user.set_password(password)
# Update email address
self.user.email = email
else:
# Create new user
self.user = User.objects.create_user(username=username,
email=email,
password=password)
# user creator of the user
self.creator = get_current_user()
# Save changes
self.user.save()
def save(self, *args, **kwards):
# If we are creating
if not self.pk:
# Set a new CID dynamically
self.cid = str(random.randint(0, 999999999))
# Try to get the user
user = get_current_user()
# Set the owner to the current user
if user:
self.owner = user
# Get rate on realtime (to avoid user decision delay)
self.rate = self.sell_currency.rate(self.buy_currency)
# Recalculate amount
self.buy_amount = self.rate * self.sell_amount
# Keep going like usually
return super(Exchange, self).save(*args, **kwards)
def codenerixmodel_delete_post(sender, instance, **kwargs):
if not hasattr(instance, "name_models_list") and issubclass(sender, GenLog):
user = get_current_user()
if user:
user_id = user.pk
else:
user_id = None
action = DELETION
attrs = {}
attrs_txt = {}
# ._meta.get_fields() return all fields include related name
# ._meta.fields return all fields of models
# list_fields = [x.name for x in instance._meta.get_fields()]
for ffield in instance._meta.get_fields():
key = ffield.name
# exclude manytomany
if instance._meta.model._meta.local_many_to_many and key in [x.name for x in instance._meta.model._meta.local_many_to_many]:
field = None
# elif self._meta.get_all_related_many_to_many_objects() and key in [x.name for x in self._meta.get_all_related_many_to_many_objects()]:
elif instance._meta.get_fields(include_hidden=True) and key in [x.name for x in instance._meta.get_fields(include_hidden=True) if x.many_to_many and x.auto_created]:
field = None
else:
field = getattr(instance, key, None)
value = getattr(instance, ffield.name)
if isinstance(value, CodenerixModel):
attrs[ffield.name] = value.pk
else:
try:
json.dump(value, default=json_util.default)
attrs[ffield.name] = value
except TypeError:
# If related, we don't do anything
if getattr(value, 'all', None) is None:
# value = str(value)
value = smart_text(value)
attrs[ffield.name] = value
if hasattr(ffield, "verbose_name"):
try:
string_checks = [unicode, str]
except NameError:
string_checks = [str]
if type(ffield.verbose_name) in string_checks:
ffield_verbose_name = ffield.verbose_name
else:
ffield_verbose_name = str(ffield.verbose_name)
attrs_txt[ffield_verbose_name] = force_text(field, errors='replace')
log = Log()
log.user_id = user_id
log.content_type_id = ContentType.objects.get_for_model(instance).pk
log.object_id = instance.pk
log.object_repr = force_text(instance)
log.change_json = json.dumps(attrs, default=json_util.default)
log.change_txt = json.dumps(attrs_txt, default=json_util.default)
log.action_flag = action
log.save()
def save(self, **kwargs):
user = get_current_user()
if user:
user_id = user.pk
else:
user_id = None
model = apps.get_model(self._meta.app_label, self.__class__.__name__)
isnew = True
if self.pk is not None:
list_obj = model.objects.filter(pk=self.pk)
isnew = list_obj.count() == 0
# raise IOError,self.__dict__
# only attributes changes
attrs = {}
attrs_txt = {}
# attributes from database
attrs_bd = {}
if isnew:
action = ADDITION
pk = None
else:
action = CHANGE
pk = self.pk
# Instance object
# obj = model.objects.get(pk=self.pk)
obj = list_obj.get()
for key in obj._meta.get_fields():
key = key.name
# exclude manytomany
if obj._meta.model._meta.local_many_to_many and key in [x.name for x in obj._meta.model._meta.local_many_to_many]:
value = None
elif obj._meta.get_fields(include_hidden=True) and key in [x.name for x in obj._meta.get_fields(include_hidden=True) if x.many_to_many and x.auto_created]:
value = None
else:
value = getattr(obj, key, None)
attrs_bd[key] = value
# comparison attributes
# for key in self._meta.get_fields():
aux = None
list_fields = [x.name for x in self._meta.get_fields()]
for ffield in self._meta.get_fields():
key = ffield.name
# exclude manytomany
if self._meta.model._meta.local_many_to_many and key in [x.name for x in self._meta.model._meta.local_many_to_many]:
field = None
# elif self._meta.get_all_related_many_to_many_objects() and key in [x.name for x in self._meta.get_all_related_many_to_many_objects()]:
elif self._meta.get_fields(include_hidden=True) and key in [x.name for x in self._meta.get_fields(include_hidden=True) if x.many_to_many and x.auto_created]:
field = None
else:
field = getattr(self, key, None)
if key in list_fields and field:
# if (not attrs_bd.has_key(key)) or (field != attrs_bd[key]):
if (key not in attrs_bd) or (field != attrs_bd[key]):
if field is not None:
aux = ffield
field_txt = field
if isinstance(field, CodenerixModel):
field = field.pk
try:
json.dumps(field, default=json_util.default)
if key not in attrs_bd or not self.CodenerixMeta.log_full:
attrs[key] = field
else:
if isinstance(attrs_bd[key], CodenerixModel):
attrs[key] = (attrs_bd[key].pk, field, )
else:
attrs[key] = (attrs_bd[key], field, )
except:
# If related, we don't do anything
if getattr(field, 'all', None) is None:
field = str(field)
if key not in attrs_bd or not self.CodenerixMeta.log_full:
attrs[key] = field
else:
attrs[key] = (attrs_bd[key], field, )
if hasattr(ffield, "verbose_name"):
try:
string_checks = [unicode, str]
except NameError:
string_checks = [str]
if type(ffield.verbose_name) in string_checks:
ffield_verbose_name = ffield.verbose_name
else:
ffield_verbose_name = str(ffield.verbose_name)
if key not in attrs_bd or not self.CodenerixMeta.log_full:
attrs_txt[ffield_verbose_name] = force_text(field_txt, errors='replace')
else:
attrs_txt[key] = (
ffield_verbose_name,
u"{}{}{}".format(
force_text(attrs_bd[key], errors='replace'),
SEPARATOR,
force_text(field_txt, errors='replace')
)
)
log = Log()
log.user_id = user_id
log.content_type_id = ContentType.objects.get_for_model(self).pk
log.object_id = pk
log.object_repr = force_text(self, errors="replace")
try:
log.change_json = json.dumps(attrs, default=json_util.default)
except UnicodeDecodeError:
log.change_json = json.dumps({'error': '*JSON_ENCODE_ERROR*'}, default=json_util.default)
try:
log.change_txt = json.dumps(attrs_txt, default=json_util.default)
except UnicodeDecodeError:
log.change_txt = json.dumps({'error': '*JSON_ENCODE_ERROR*'}, default=json_util.default)
log.action_flag = action
aux = super(GenLog, self).save(**kwargs)
if pk is None:
# if new element, get pk
log.object_id = self.pk
log.save()
return aux
def form_valid(self, form):
user = get_current_user()
form.instance.user = user
self.request.user = user
return super(CashMovementCreate, self).form_valid(form)
