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)