Convert string to bytes object python
Convert string to bytes object python
1 2 3 | my_simple_string = 'test'
bytes_obj = bytes(my_simple_string, 'utf-8')
print(bytes_obj)
|
Discover code snippets, tutorials, and programming insights
Convert string to bytes object python
1 2 3 | my_simple_string = 'test'
bytes_obj = bytes(my_simple_string, 'utf-8')
print(bytes_obj)
|
Model to store password per project in django
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | import base64
from Crypto.Cipher import AES
from Crypto.Hash import SHA256
from Crypto import Random
from django.db import models
from django.conf import settings
def encrypt(key, source, encode=True):
key = SHA256.new(key).digest()
IV = Random.new().read(AES.block_size)
encryptor = AES.new(key, AES.MODE_CBC, IV)
padding = AES.block_size - len(source) % AES.block_size
source += bytes([padding]) * padding
data = IV + encryptor.encrypt(source)
return base64.b64encode(data).decode("utf-8") if encode else data
def decrypt(key, source, decode=True):
if decode:
source = base64.b64decode(source.encode("utf-8"))
key = SHA256.new(key).digest()
IV = source[:AES.block_size]
decryptor = AES.new(key, AES.MODE_CBC, IV)
data = decryptor.decrypt(source[AES.block_size:])
padding = data[-1]
if data[-padding:] != bytes([padding]) * padding:
raise ValueError("Invalid padding...")
return data[:-padding] # remove the padding
class Timestamped(models.Model):
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
class Meta:
abstract = True
class AccountType(Timestamped):
name = models.CharField(max_length=100)
class Meta:
default_related_name = 'accounttypes'
verbose_name = 'account type'
verbose_name_plural = 'account types'
def __str__(self):
return self.name
class Project(Timestamped):
name = models.CharField(max_length=100)
class Meta:
default_related_name = 'projects'
verbose_name = 'project'
verbose_name_plural = 'projects'
def __str__(self):
return self.name
class Password(Timestamped):
account_type = models.ForeignKey(AccountType, on_delete=models.CASCADE)
project = models.ForeignKey(Project, on_delete=models.CASCADE)
username = models.CharField(max_length=100)
password = models.CharField(max_length=255)
comments = models.TextField(blank=True)
url = models.URLField(blank=True)
class Meta:
default_related_name = 'passwords'
verbose_name = 'password'
verbose_name_plural = 'passwords'
def __str__(self):
return self.username
def save(self, *args, **kwargs):
encrypted = encrypt(bytes(settings.SECRET_KEY, 'utf-8'), bytes(self.password, 'utf-8'))
self.password = encrypted
decrypted = decrypt(bytes(settings.SECRET_KEY, 'utf-8'), encrypted)
print(encrypted)
print(decrypted)
super().save(*args, **kwargs)
|
<p>The code defines several Django views that handle AJAX requests for different actions in a web application. The views are designed to respond with JSON containing HTML content that can …
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 | from django.http import JsonResponse
from django import template
from django.template.loader import render_to_string
from django.template.loader import TemplateDoesNotExist
class AjaxListView:
def get(self, request, *args, **kwargs):
ajax_list_partial = self.ajax_list_partial
self.object_list = super().get_queryset()
context = super().get_context_data(**kwargs)
if not ajax_list_partial:
raise TemplateDoesNotExist("No ajax__list_partial provided {}".format(self))
if request.is_ajax():
html_form = render_to_string(self.ajax_list_partial, context, request)
return JsonResponse({'html_form': html_form})
return super().get(request, *args, **kwargs)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['object_list'] = super().get_queryset()
return context
class AjaxCreateView:
def get(self, request, *args, **kwargs):
self.object = None
ajax_create_partial = self.ajax_create_partial
ajax_list_partial = self.ajax_list_partial
context = super().get_context_data(**kwargs)
if not ajax_create_partial or not ajax_list_partial:
raise TemplateDoesNotExist("No ajax_create_partial or ajax_list_partial provided {}".format(self))
if request.is_ajax():
html_form = render_to_string(self.ajax_create_partial, context, request)
return JsonResponse({'html_form': html_form})
return super().get(request, *args, **kwargs)
def form_valid(self, form):
data = dict()
context = self.get_context_data()
if form.is_valid():
form.save()
data['form_is_valid'] = True
data['list'] = render_to_string(
self.ajax_list_partial, context, self.request)
if self.request.is_ajax():
return JsonResponse(data)
return super().form_valid(form)
def form_invalid(self, form):
data = dict()
context = self.get_context_data()
data['form_is_valid'] = False
data['html_form'] = render_to_string(
self.ajax_create_partial, context, request=self.request)
if self.request.is_ajax():
return JsonResponse(data)
return super().form_invalid(form)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['object_list'] = super().get_queryset()
return context
class AjaxUpdateView:
def get(self, request, *args, **kwargs):
ajax_update_partial = self.ajax_update_partial
ajax_list_partial = self.ajax_list_partial
self.object = super().get_object()
context = super().get_context_data(**kwargs)
if not ajax_update_partial or not ajax_list_partial:
raise TemplateDoesNotExist("No ajax_update_partial or ajax_list_partial provided {}".format(self))
if request.is_ajax():
html_form = render_to_string(self.ajax_update_partial, context, request)
return JsonResponse({'html_form': html_form})
return super().get(request, *args, **kwargs)
def form_valid(self, form):
data = dict()
context = self.get_context_data()
if form.is_valid():
form.save()
data['form_is_valid'] = True
data['list'] = render_to_string(
self.ajax_list_partial, context, self.request)
if self.request.is_ajax():
return JsonResponse(data)
return super().form_valid(form)
def form_invalid(self, form):
data = dict()
context = super().get_context_data()
data['form_is_valid'] = False
data['html_form'] = render_to_string(
self.ajax_update_partial, context, request=self.request)
if self.request.is_ajax():
return JsonResponse(data)
return super().form_invalid(form)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['object_list'] = super().get_queryset()
return context
class AjaxDeleteView:
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = super().get_context_data(**kwargs)
ajax_delete_partial = self.ajax_delete_partial
ajax_list_partial = self.ajax_list_partial
if not ajax_delete_partial or not ajax_list_partial:
raise TemplateDoesNotExist("No ajax_delete_partial or ajax_list_partial provided {}".format(self))
if request.is_ajax():
html_form = render_to_string(
self.ajax_delete_partial, context, request)
return JsonResponse({'html_form': html_form})
return super().get(request, *args, **kwargs)
def post(self, *args, **kwargs):
ajax_delete_partial = self.ajax_delete_partial
ajax_list_partial = self.ajax_list_partial
if self.request.is_ajax():
self.object = super().get_object()
self.object.delete()
data = dict()
data['form_is_valid'] = True
context = super().get_context_data(**kwargs)
context['object_list'] = self.get_queryset()
data['list'] = render_to_string(
self.ajax_list_partial, context, self.request)
return JsonResponse(data)
return self.delete(*args, **kwargs)
|
Pass request get items to a form class in django
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | def initial_form(request, form):
'''
form is an instance of a form
'''
form_init = {}
if request.GET.items():
try:
parameters = request.GET.items()
except KeyError:
parameters = {}
for key, value in parameters:
for field in form.fields:
if key == field:
form_init[key] = value
form.initial = form_init
return form
|
Django pagination function
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
def get_pagination(request, queryset, items):
'''
items: The number for pagination
return tuple (total_pages, paginated queryset)
'''
paginator = Paginator(queryset, items)
page = request.GET.get('page')
try:
items_page = paginator.page(page)
except PageNotAnInteger:
items_page = paginator.page(1)
except EmptyPage:
items_page = paginator.page(paginator.num_pages)
return (paginator.num_pages, items_page)
|