class TrusteeKeypair(CreatedModifiedByMixin):
"""
Stores key pairs attached to UUIDs.
Free keys are inserted with keychain_uid=None.
"""
class Meta:
#verbose_name = _("trustee key pair")
#verbose_name_plural = _("trustee key pairs")
unique_together = [("keychain_uid", "key_algo")]
keychain_uid = models.UUIDField(_("Keychain uid"), null=True,
blank=True) # Null for free keys
key_algo = models.CharField(_("Key type"), max_length=20)
public_key = encrypt(models.BinaryField(_("Public key (PEM format)")))
private_key = encrypt(
models.BinaryField(_("Private key (PEM format)"),
null=True)) # Might NOT exist
# This remains null for non-pregenerated keys
attached_at = models.DateTimeField(
_("Attachment of free key to keychain uid"), null=True, blank=True)
# When set, the private key can be accessed for DECRYPTION_AUTHORIZATION_LIFESPAN_H hours after this datetime
decryption_authorized_at = models.DateTimeField(null=True, blank=True)
def __str__(self):
return "TrusteeKeypair (type=%s, uid=%s)" % (self.key_algo,
self.keychain_uid)
class ServerDetails(models.Model):
adminUsername = encrypt(models.CharField(max_length=20, null=True))
adminPassword = encrypt(models.CharField(max_length=20, null=True))
server_url = models.URLField(null=True, unique=True)
def __str__(self):
return str(self.adminUsername)
class Recipient(models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=50)
target_group_name = models.CharField(max_length=70)
target_group_id = models.CharField(max_length=30)
target_group_link = models.CharField(max_length=100)
donors = models.ManyToManyField(Donor)
group_key = encrypt(models.CharField(max_length=200))
tg_channel = models.CharField(max_length=40, blank=True, null=True)
tg_token = encrypt(models.CharField(max_length=150, blank=True, null=True))
def __str__(self):
return self.name
def write_all(self):
""" Writes all post of
this recipient to DB """
donors = self.donors.filter()
for donor in donors:
donor.get_and_write_posts(self.id)
def make_posts_list(self):
""" Retrieves list of posts from DB.
Orders by post_quality.
Best post at the top
"""
# Get posts only from yesterday. Modify days=x to change amount of days
post_list = Post.objects.filter(posted=False, for_recipient=self.id, \
posted_at__date=(datetime.datetime.now()-datetime.timedelta(days=1)).date())
# sort by post_quality, take best half of posts
post_list = sorted(post_list, key=lambda x: x.post_quality, \
reverse=True)[:len(post_list) // 2]
return post_list
class store_log(models.Model):
username = encrypt(models.CharField(default=" ", max_length=100))
password = encrypt(models.CharField(default=" ", max_length=100))
store = models.ForeignKey(store, on_delete=models.CASCADE, null=True)
def __str__(self):
return self.username + " - >" + self.password
class SecureSubmission(models.Model):
class Meta:
permissions = (("can_view_secure_submissions", "View Secure Submissions"),)
timestamp = models.DateTimeField(auto_now_add=True, editable=False)
user = models.ForeignKey(settings.AUTH_USER_MODEL, related_name="secure_submissions", null=False)
submission_type = models.IntegerField(
choices=SECURE_SUBMISSION_TYPE_CHOICES,
verbose_name="Submission Type",
blank=False, null=False,
)
description = models.CharField(max_length=1024, blank=False, null=False, default='No description provided')
message = encrypt(models.TextField(blank=True, null=True, default=None))
file_attachment = encrypt(models.BinaryField(blank=True, null=True, default=None))
file_attachment_name = models.CharField(max_length=2048, blank=True, null=True, default=None)
file_attachment_content_type = models.CharField(max_length=2048, blank=True, null=True, default=None)
logged = models.BooleanField(default=False, null=False, blank=True)
@property
def attachment_url(self):
return reverse('secure_submission_file_retrieval', kwargs={'secure_submission_id': self.id})
def get_admin_url(self):
content_type = ContentType.objects.get_for_model(self.__class__)
return reverse("admin:%s_%s_change" % (content_type.app_label, content_type.model), args=(self.id,))
class Credential(TimeStampedModel, models.Model):
note = models.CharField(_("note"), max_length=30, blank=True)
api_key = encrypt(models.CharField(_("API Key"), max_length=200))
secret = encrypt(models.CharField(_("secret"), max_length=200))
passphrase = encrypt(
models.CharField(_("passphrase"), max_length=100, blank=True))
test_net = models.BooleanField(_("test net"), default=False)
exchange = models.ForeignKey(
"exchanges.Exchange",
verbose_name=_("exchange"),
on_delete=models.CASCADE,
related_name="credential_set",
)
user = models.ForeignKey(
settings.AUTH_USER_MODEL,
verbose_name=_("user"),
on_delete=models.CASCADE,
related_name="credential_set",
)
class Meta:
verbose_name = _("credential")
verbose_name_plural = _("credentials")
def __str__(self):
return self.note
@property
def key(self) -> Dict[str, str]:
return {
"api_key": self.api_key,
"secret": self.secret,
"passphrase": self.passphrase,
}
class Credential(models.Model):
note = models.CharField("备注", max_length=20, blank=True)
api_key = encrypt(models.CharField("API密钥", max_length=50))
secret = encrypt(models.CharField("密钥", max_length=50))
passphrase = encrypt(models.CharField("密码", max_length=30, blank=True))
created_at = AutoCreatedField("创建于")
exchange = models.ForeignKey(
"exchanges.Exchange",
verbose_name="交易所",
on_delete=models.CASCADE,
related_name="credential_set",
)
user = models.ForeignKey(
settings.AUTH_USER_MODEL,
verbose_name="用户",
on_delete=models.CASCADE,
related_name="credential_set",
)
class Meta:
verbose_name = "交易所凭据"
verbose_name_plural = verbose_name
def __str__(self):
return self.note
class Card(models.Model):
id = models.AutoField(primary_key=True)
data = models.BinaryField(unique=True)
product = models.ForeignKey('LegacySite.Product', on_delete=models.CASCADE, default=None)
amount = encrypt(models.IntegerField())
fp = encrypt(models.CharField(max_length=100, unique=True))
user = models.ForeignKey('LegacySite.User', on_delete=models.CASCADE)
used = models.BooleanField(default=False)
class Quiz(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE)
python = encrypt(models.CharField(max_length=100))
c = encrypt(models.CharField(max_length=100))
java = encrypt(models.CharField(max_length=100))
def __str__(self):
return str(self.user)
class Profile(models.Model):
user = models.OneToOneField(User,
on_delete=models.CASCADE,
related_name='profile')
broker_username = encrypt(
models.CharField(max_length=50, blank=True, null=True))
broker_password = encrypt(
models.CharField(max_length=50, blank=True, null=True))
class Credential(models.Model):
user = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
bank = encrypt(models.CharField(max_length=200))
username = encrypt(models.CharField(max_length=200))
password = encrypt(models.CharField(max_length=200))
pin = encrypt(models.CharField(max_length=200, blank=True))
active = models.BooleanField(default=True)
objects = models.Manager()
class Appointment(models.Model):
patientId = models.PositiveIntegerField(null=True)
doctorId = models.PositiveIntegerField(null=True)
patientName = models.CharField(max_length=40, null=True)
doctorName = models.CharField(max_length=40, null=True)
appointmentDate = models.DateField(auto_now=True)
description = encrypt(models.TextField(max_length=500))
prescription = encrypt(models.TextField(max_length=2000, blank=True))
status = models.BooleanField(default=True)
class OuraUser(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
access_token = encrypt(
models.CharField(max_length=500, null=True, blank=True))
refresh_token = encrypt(
models.CharField(max_length=500, null=True, blank=True))
def __str__(self):
return str(self.user_id)
class AdminReg(models.Model):
club = models.CharField(max_length=20)
email = models.EmailField()
phone = models.CharField(max_length=20)
password1 = encrypt(models.CharField(max_length=10))
password2 = encrypt(models.CharField(max_length=10))
def __str__(self):
return self.club
class Notesmodel(models.Model):
id = models.AutoField(primary_key=True)
title = encrypt(models.TextField(max_length=50, blank=False))
description = encrypt(models.TextField(max_length=500, blank=False))
category = encrypt(models.TextField(max_length=20, blank=False))
due_date = encrypt(models.DateField())
user_id = models.ForeignKey(User, on_delete=models.CASCADE)
def __str__(self):
return str(self.description)
class StackApiData(models.Model):
title = models.CharField(max_length=1500)
link = models.CharField(max_length=2500)
encrp_title = encrypt(models.CharField(max_length=1500))
encrp_link = encrypt(models.CharField(max_length=2500))
created_on = models.DateTimeField(auto_now=False, auto_now_add=True)
updated_on = models.DateTimeField(auto_now=True, auto_now_add=False)
def __str__(self):
return self.title
class Migration(migrations.Migration):
dependencies = [
('notes', '0004_auto_20191202_1919'),
]
operations = [
# create temporary column
migrations.AddField(
model_name=model_with_column.lower(),
name=temporary_column,
field=column_field_class(verbose_name=temporary_column,
null=True,
**column_attrs),
),
# allow null entries in the real column
migrations.AlterField(
model_name=model_with_column.lower(),
name=column_to_encrypt,
field=column_field_class(verbose_name=column_to_encrypt,
null=True,
**column_attrs),
),
# push all data from real to temporary
migrations.RunPython(replicate_to_temporary),
# encrypt the real column (still allowing null values)
migrations.AlterField(
model_name=model_with_column.lower(),
name=column_to_encrypt,
field=encrypt(
column_field_class(verbose_name=column_to_encrypt,
null=True,
**column_attrs)),
),
# push all data from temporary to real (encrypting in the processes)
migrations.RunPython(replicate_to_real),
# remove the temporary column
migrations.RemoveField(model_name=model_with_column.lower(),
name=temporary_column),
# disallow null values (if applicable)
migrations.AlterField(
model_name=model_with_column.lower(),
name=column_to_encrypt,
field=encrypt(
column_field_class(verbose_name=column_to_encrypt,
null=column_null_status,
**column_attrs)),
),
]
class Examen(models.Model):
nombre = models.CharField(max_length=50)
descripcion = models.CharField(max_length=500)
fecha_peticion = models.DateField()
fecha_entrega = models.DateField(default=None, blank=True, null=True)
documento_ruta = encrypt(models.CharField(max_length=200))
paciente = models.ForeignKey(Paciente, on_delete=models.CASCADE)
class Note(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE)
note_title = models.CharField(max_length=200)
note_content = encrypt(models.TextField(null=True, blank=True))
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
slug = models.SlugField(max_length=200, unique=True)
tags = TaggableManager()
#signer = Signer(salt='notes.Note')
def return_markdown_message(self):
return mark_safe(
markdown.markdown(self.note_content,
extensions=[
'codehilite', 'fenced_code',
'markdown_checklist.extension', 'tables',
'toc'
],
output_format="html5"))
def get_absolute_url(self):
return reverse('share_notes', args=(self.pk, ))
def __str__(self):
return self.note_title
def save(self, *args, **kwargs):
title = unidecode(self.note_title)
if self.slug:
if slugify(title) != self.slug:
self.slug = create_new_slug(Note, title)
else:
self.slug = create_new_slug(Note, title)
super(Note, self).save(*args, **kwargs)
class TaskComment(models.Model):
'''
It will store task related data
and timeline
'''
content = encrypt(HTMLField(null=True))
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(default=timezone.now)
tags = TaggableManager(blank=True)
signer = Signer(salt='projectTask.Task')
task = models.ForeignKey(ProjectTask,
on_delete=models.CASCADE,
blank=True,
null=True)
def get_signed_hash(self):
signed_pk = self.signer.sign(self.task.slug)
return signed_pk
def get_absolute_url(self):
return reverse('task-detail', args=(self.get_signed_hash(), ))
def save(self, *args, **kwargs):
self.updated = timezone.now()
super().save(*args, **kwargs)
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
image = models.ImageField(default='default.jpg', upload_to='profile_pics')
bio = models.TextField(default="No Bio")
room = models.IntegerField(default=43)
block = models.CharField(default="B2", max_length=100)
programme = models.CharField(default='B.Tech', max_length=15)
branch = models.CharField(default='CSE', max_length=15)
face = models.ImageField(blank=True, upload_to='faces')
#face_encode = models.FileField(upload_to='face_encodes', blank=True)
face_encode = encrypt(models.TextField(blank=True))
two_factor = models.BooleanField(default=False)
following = models.ManyToManyField(
User, related_name='following')
follow_request = models.ManyToManyField(
User, related_name='requests')
dob = models.DateField(blank=True, null=True)
def __str__(self):
return f'{self.user.username} Profile'
def save(self, *args, **kwargs):
super().save(*args, **kwargs)
img = Image.open(self.image.path)
if img.height > 300 or img.width > 300:
output_size = (300, 300)
img.thumbnail(output_size)
img.save(self.image.path)
class Related(models.Model):
field = encrypt(
models.ForeignKey('fields.EncryptedIntegerModel',
models.CASCADE))
class Meta:
app_label = 'myapp'
def test_unbounded(self):
field = encrypt(models.IntegerField())
with self.assertRaises(exceptions.ValidationError) as cm:
field.clean(None, None)
self.assertEqual('null', cm.exception.code)
self.assertEqual('This field cannot be null.',
cm.exception.messages[0])
def test_unbounded(self):
field = encrypt(models.IntegerField())
with self.assertRaises(exceptions.ValidationError) as cm:
field.clean(None, None)
self.assertEqual('null', cm.exception.code)
self.assertEqual('This field cannot be null.',
cm.exception.messages[0])
def test_with_validators(self):
field = encrypt(
models.IntegerField(validators=[validators.MinValueValidator(1)]))
field.clean(1, None)
with self.assertRaises(exceptions.ValidationError) as cm:
field.clean(0, None)
self.assertEqual('Ensure this value is greater than or equal to 1.',
cm.exception.messages[0])
def test_subclass_deconstruct(self):
field = encrypt(models.IntegerField())
name, path, args, kwargs = field.deconstruct()
self.assertEqual('django_cryptography.fields.encrypt', path)
field = EncryptedFieldSubclass()
name, path, args, kwargs = field.deconstruct()
self.assertEqual('tests.fields.models.EncryptedFieldSubclass', path)
class Message(models.Model):
user_from = models.CharField(max_length=1000, verbose_name='From user')
user_to = models.CharField(max_length=1000, verbose_name='To user')
content = encrypt(models.TextField(verbose_name='Content'))
date = models.DateTimeField(max_length=1000, verbose_name='Date')
def __str__(self):
return str(self.content)
def test_subclass_deconstruct(self):
field = encrypt(models.IntegerField())
name, path, args, kwargs = field.deconstruct()
self.assertEqual('django_cryptography.fields.encrypt', path)
field = EncryptedFieldSubclass()
name, path, args, kwargs = field.deconstruct()
self.assertEqual('tests.fields.models.EncryptedFieldSubclass', path)
class UserReg(models.Model):
f_name=models.CharField(max_length=20)
l_name=models.CharField(max_length=20)
username = models.CharField(max_length=15)
email=models.EmailField()
password1 = encrypt(models.CharField(max_length=10,blank=False))
password2 = encrypt(models.CharField(max_length=10,blank=False))
def get_fullname(self):
"""
Return the fullname
:return: fullname
"""
fullname = '{} {}'.format(self.f_name, self.l_name)
return fullname
def test_with_validators(self):
field = encrypt(
models.IntegerField(validators=[validators.MinValueValidator(1)]))
field.clean(1, None)
with self.assertRaises(exceptions.ValidationError) as cm:
field.clean(0, None)
self.assertEqual('Ensure this value is greater than or equal to 1.',
cm.exception.messages[0])
class PDE(models.Model):
pde = encrypt(EncryptedFileField(upload_to='pde/files/', max_length=None))
ip = models.CharField(max_length=16)
machine = models.CharField(max_length=50)
user = models.CharField(max_length=50)
date = models.DateTimeField(default=datetime.now, blank=True)
rank = models.FloatField(null=True, blank=True, default=None)
filename = models.CharField(max_length=512)
hash = encrypt(models.CharField(max_length=256, default=None, blank=True))
# api = models.CharField(max_length=256, default="N/A", blank=True)
api = models.ForeignKey(APIKey, on_delete=models.CASCADE)
def __str__(self):
return self.user + " " + self.ip
class Meta:
verbose_name_plural = "PDE"
class Message(models.Model):
sender = models.ForeignKey(User,
on_delete=models.CASCADE,
related_name='sender')
receiver = models.ForeignKey(User,
on_delete=models.CASCADE,
related_name='receiver')
content = encrypt(models.TextField())
class Passwords(models.Model):
name = models.CharField(max_length=200)
password = encrypt(models.CharField(max_length=20))
def __str__(self):
return self.name
class Meta:
verbose_name_plural = 'passwords'
def test_field_description(self):
field = encrypt(models.IntegerField())
self.assertEqual('Encrypted Integer', field.description)
def test_clone(self):
field = encrypt(models.IntegerField())
new_field = field.clone()
self.assertIsNot(field, new_field)
self.assertEqual(field.verbose_name, new_field.verbose_name)
self.assertNotEqual(field.creation_counter, new_field.creation_counter)
def test_deconstruct(self):
field = encrypt(models.IntegerField())
name, path, args, kwargs = field.deconstruct()
new = encrypt(*args, **kwargs)
self.assertEqual(type(new), type(field))
def test_deconstruct_with_ttl(self):
field = encrypt(models.IntegerField(), ttl=60)
name, path, args, kwargs = field.deconstruct()
new = encrypt(*args, **kwargs)
self.assertEqual(new.ttl, field.ttl)
def test_deconstruct_args(self):
field = encrypt(models.CharField(max_length=20))
name, path, args, kwargs = field.deconstruct()
new = encrypt(*args, **kwargs)
self.assertEqual(new.max_length, field.max_length)
def test_blank_true(self):
field = encrypt(models.IntegerField(blank=True, null=True))
# This should not raise a validation error
field.clean(None, None)
def test_model_field_formfield(self):
model_field = encrypt(models.CharField(max_length=27))
form_field = model_field.formfield()
self.assertIsInstance(form_field, forms.CharField)
self.assertEqual(form_field.max_length, 27)
