Add application file

Dockerfile

@@ -0,0 +1,24 @@
+# Use an official Python runtime as the base image
+FROM python:3.10
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file to the working directory
+COPY requirements.txt .
+
+# Install project dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the project code to the working directory
+COPY . .
+
+# Expose the port your Django app will run on
+EXPOSE 8000
+
+# Run the Django development server
+CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

app/PaperLayout.py

@@ -0,0 +1,143 @@
+from PIL import Image
+import math
+import os
+import subprocess
+from .tele import SendToTele
+
+
+class GeneratePhoto:
+    def __init__(self,paper_size,gap,images,img_max_width,img_max_height,raw_export):
+        self.paper_size = paper_size
+        self.gap = gap 
+        self.images = images 
+        self.img_max_width = img_max_width
+        self.img_max_height =img_max_height
+        self.raw_export = raw_export
+
+    def deleteimage(self,file_path):
+        # Check if the file exists before deleting
+        if os.path.exists(file_path):
+            # Delete the file
+            os.remove(file_path)
+            print("File deleted successfully.")
+        else:
+            print("File does not exist.")
+    
+    def export(self):
+        paper_size = self.paper_size
+        gap = self.gap
+
+        images = self.images
+        img_max_width = self.img_max_width
+        img_max_height = self.img_max_height
+
+        #Calculate the images that how much fit inside the paper
+        limited_img_xaxis = int(paper_size[0] / (img_max_width + gap))
+        limited_img_yaxis = int(paper_size[1] / (img_max_height + gap))
+
+        
+        limited_paper_images =  limited_img_xaxis * limited_img_yaxis
+        img_qty = 0;
+
+
+        for (a,b) in images:
+            img_qty += int(b) 
+
+        # print(math.ceil(img_qty/limited_paper_images))
+
+        # print('limited image',limited_paper_images)
+        # print(img_qty)
+
+        paper_qty = math.ceil(img_qty/limited_paper_images)
+
+        sets = []  # Initialize an empty list of sets
+        current_set = []  # Initialize an empty list to hold the images for the current set
+
+        # Iterate over the images
+        for image in images:
+            name, count = image
+            
+            # Add the current image to the current set count times
+            for i in range(int(count)):
+                # If adding the current image would exceed the limit, add the current set to the list of sets and start a new set
+                if len(current_set) == limited_paper_images:
+                    sets.append(current_set)
+                    current_set = []
+                current_set.append(name)
+
+        # Add the last set to the list of sets
+        if current_set:
+            sets.append(current_set)
+            
+        # Count the duplicate image names in each set and print the sets
+        count_set = []
+
+        for i, set in enumerate(sets):
+            name_counts = {}
+            for name in set:
+                if name in name_counts:
+                    name_counts[name] += 1
+                else:
+                    name_counts[name] = 1
+            # print(f"Name counts: {name_counts}")
+            count_set.append(name_counts)
+
+
+        print(count_set)
+
+        pname = 0
+
+        for p in count_set:
+            a4_image = Image.new('RGB', paper_size, color='white')
+        
+            values_list = list(p.values()) 
+            key_list = list(p.keys())
+        
+
+            imgs_sum = sum(values_list)
+            index = 0
+
+            print('Img : ', self.raw_export +os.path.basename(key_list[index]) )
+
+            img = Image.open(self.raw_export + os.path.basename(key_list[index]))
+
+            self.deleteimage(self.raw_export + os.path.basename(key_list[index]))
+            #Change pictures to Thumbnail
+            img = img.resize((int(img_max_width),int(img_max_height)),resample=Image.BICUBIC)  #Resize Image
+            print(img.size,'Image size')
+            img.thumbnail((img_max_width,img_max_height))
+             
+
+
+            for a in range(imgs_sum):            
+                x_pos = a % limited_img_xaxis
+                y_pos = a // limited_img_xaxis
+                print(f"({x_pos}, {y_pos})")
+
+                position = (int(x_pos*img_max_width)+(gap*x_pos)+gap), int((y_pos*img_max_height)+(gap*y_pos)+gap) 
+
+                print(position)
+                a4_image.paste(img,position)
+                
+                if a == sum(values_list[:index+1])-1:
+                       
+                        index += 1
+                        try:
+                            img = Image.open(self.raw_export+os.path.basename(key_list[index]))
+                            img = img.resize((int(img_max_width),int(img_max_height)),resample=Image.BICUBIC)  #Resize Image
+                            print(img.size,'Resize Image')
+                            img.thumbnail((img_max_width,img_max_height))
+                            self.deleteimage(self.raw_export + os.path.basename(key_list[index]))
+                          
+
+                        except IndexError:
+                            print(IndexError)
+                    
+            pname += 1 
+                
+            pathname = 'paper/paper'+str(pname)+'.png'
+            a4_image.save(pathname)
+            SendToTele(document_path=pathname)
+            self.deleteimage(pathname)
+
+

app/RemoveBg.py

@@ -0,0 +1,110 @@
+import cv2
+# import cvzone
+# from cvzone.SelfiSegmentationModule import SelfiSegmentation
+from PIL import Image
+import rembg
+# Load the input image
+import os
+
+import subprocess
+from .tele import SendToTele
+
+
+class RemoveBackground():
+
+   #images will be array
+    def __init__(self,images,aspect_ratio,rgb,output_di,bw=False):
+        self.images = images
+        self.aspect_ratio = aspect_ratio
+        self.rgb = rgb
+        self.output_di = output_di
+        self.bw = bw
+        self.model_name = "silueta"
+        self.session = rembg.new_session(model_name=self.model_name)
+
+    def deleteimage(self,file_path):
+        # Check if the file exists before deleting
+        if os.path.exists(file_path):
+            # Delete the file
+            os.remove(file_path)
+            print("File deleted successfully.")
+        else:
+            print("File does not exist.")
+
+      
+    def remove(self):       
+        aspect_ratio = self.aspect_ratio
+        
+        for i in self.images:
+            print(i)
+           
+            imgread = cv2.imread(i[0])
+            self.deleteimage(i[0])
+            if self.bw:
+                rgb = (128,128,128,0)
+            else:
+                rgb = (255,0,0,0)
+            
+            img = rembg.remove(imgread,bgcolor=rgb, alpha_matting=True, alpha_matting_foreground_threshold=270,alpha_matting_background_threshold=20, alpha_matting_erode_size=11)
+           
+            # Convert the image to grayscale
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+            # Load the face detector
+            face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
+
+            if face_cascade.empty():
+                raise IOError('Unable to load the face cascade classifier xml file')
+
+
+            # Detect faces in the grayscale image
+            faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)
+
+            if len(faces) > 0:
+                # Calculate the center of the bounding box
+                x, y, w, h = faces[0]
+                center_x = x + w // 2
+                center_y = y + h // 2
+                
+                # Calculate the width and height of the cropped image
+                aspect_ratio = self.aspect_ratio
+                if w / h > aspect_ratio:
+                    crop_width = int(aspect_ratio * h)
+                    crop_height = h
+                else:
+                    crop_width = w
+                    crop_height = int(w / aspect_ratio)
+                    
+                # Calculate the coordinates of the top-left corner of the cropped image
+                margin_x = crop_width // 2
+                margin_y = crop_height // 2
+                crop_x = max(0, center_x - crop_width // 2 - margin_x)
+                crop_y = max(0, center_y - crop_height // 2 - margin_y)
+
+                # Crop the image
+                if self.bw:
+                    crop_img = gray[crop_y:crop_y+crop_height+margin_y*2, crop_x:crop_x+crop_width+margin_x*2]
+                else:
+                    crop_img = img[crop_y:crop_y+crop_height+margin_y*2, crop_x:crop_x+crop_width+margin_x*2]
+                                
+            else:
+                print("Face not detect")  
+               
+            basename =os.path.basename(i[0])
+           
+            cv2.imwrite(self.output_di+basename,crop_img)
+            SendToTele(document_path=self.output_di+basename)
+
+# images = {('img.jpg',5)}
+# paper_size = (1200,1800)
+# gap = 40; # gap between images;
+
+# img_max_width = 1.1 * 300
+# img_max_height = 1.3 * 300
+
+
+# aspect_ratio = img_max_width / img_max_height
+# bg_rgb = (255,0,0)
+# output_di = 'img/'
+# a = RemoveBackground(images,aspect_ratio,bg_rgb,output_di,True)
+# a.remove()

app/admin.py

@@ -0,0 +1,7 @@
+from django.contrib import admin
+from . import models
+# Register your models here.
+# admin.site.register(models.User)
+admin.site.register(models.PassportDetail)
+admin.site.register(models.User)
+admin.site.register(models.Images)

app/apiview.py

@@ -0,0 +1,199 @@
+from datetime import timedelta
+import operator
+import functools
+import collections
+from collections import OrderedDict
+from datetime import datetime
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+from rest_framework.generics import CreateAPIView
+from rest_framework import status
+from rest_framework.authtoken.models import Token
+
+from django.core.exceptions import ObjectDoesNotExist
+from django.contrib.auth import get_user_model
+
+from django.utils import timezone
+from . import models, serializers
+from . import RemoveBg, PaperLayout
+
+import json
+from PIL import Image
+import base64
+
+def write_file_from_object_file(object_file, file_path):
+    file_data = base64.b64decode(object_file)
+    with open(file_path, 'wb') as file:
+        file.write(file_data)
+
+
+class CreateUserApiView(CreateAPIView):
+
+    permission_classes = [AllowAny]
+    serializer_class = serializers.CreateUserSerializer
+
+    def post(self, request):
+        print('posteed')
+        print(request.data)
+        serializers = self.get_serializer(data=request.data)
+        serializers.is_valid(raise_exception=True)
+        self.perform_create(serializers)
+        headers = self.get_success_headers(serializers.data)
+
+        # Create a token than will be used for future auth
+        token = Token.objects.create(user=serializers.instance)
+        token_data = {'token': token.key}
+
+        return Response(
+            {**serializers.data, **token_data},
+            status=status.HTTP_201_CREATED,
+            headers=headers)
+
+class SendImage(APIView):
+    def get(self,request):
+
+        return Response(status=status.HTTP_200_OK)
+
+    def post(self,request):
+        print(request.data)
+        image = request.data['image']
+        qty = request.data['qty']
+      
+        size = request.data['img_size'] # img size
+        bw = request.data['bw'] # img is black or white
+        paper = request.data['paper_size'] # paper size to print out
+        bgcolor = request.data['bg_color']
+
+        try:
+            PPD = models.PassportDetail.objects.get(is_done=False)
+        except ObjectDoesNotExist:
+            #the passport detail dnexist create one
+            PPD = models.PassportDetail.objects.create(size=size,paper=paper,bgcolor=bgcolor)
+       
+        if bw == "true":
+            PPD.bw = True 
+            PPD.save()     
+
+        models.Images.objects.create(image=image,img_qty=qty,ppd=PPD)
+        # models.Images.objects.create(image=image,img_qty=qty)
+       
+        return Response(PPD.id)
+
+
+
+class GenerateImage(APIView):
+    def get(self,request):
+        PDDID = request.GET.get('pdid')
+
+        PD = models.PassportDetail.objects.get(id=PDDID)
+        PD.is_done = True 
+        PD.save()
+
+        images_list = models.Images.objects.filter(ppd=PD)
+        images = []
+        for img in images_list:
+            print(img)
+            images.append((img.image.url[1:],img.img_qty))
+    
+        paper_size = tuple(int(x) for x in PD.paper.split(","))
+
+        img_size = tuple(float(x) for x in PD.size.split(","))
+        bg_color = tuple(int(x) for x in PD.bgcolor.split(","))
+
+        gap = 40; # gap between images;
+
+        img_max_width = img_size[0] * 300
+        img_max_height = img_size[1] * 300
+        aspect_ratio = img_max_width / img_max_height
+        output_di = 'img/'
+
+        print("Start Removing",PD.bw)
+        RemoveBg.RemoveBackground(images,aspect_ratio,bg_color,output_di,PD.bw).remove()
+        PaperLayout.GeneratePhoto(paper_size,gap,images,img_max_width,img_max_height,raw_export=output_di).export()
+     
+        print("end Removing")
+       
+
+        return Response(status=status.HTTP_200_OK)
+
+#    const token = '5499662958:AAEAoWy0khLJMf238ZwvvEoBV1FKfaVF6S0';
+#     const chatid = '-618629809';
+# 
+# 'https://api.telegram.org/bot' +
+        #   token +
+        #   '/sendDocument?chat_id=' +
+        #   chatid;
+
+
+# class SalesTwoDigits(APIView):
+#     # permission_classes = [AllowAny]P
+
+#     def get(self, request):
+#         user = get_user_model().objects.get(username=request.user,is_plan=True,
+#                                             is_salesDigits=True)
+      
+#         try:
+#             G = models.TwoDigitsGroup.objects.get(user=user, is_done=False)          
+#             print('Group M Exists')
+#         except ObjectDoesNotExist:
+#             print('Group M Not Exits')
+#             G = models.TwoDigitsGroup.objects.create(user=user)
+#             print('Group M Created')
+
+
+#         data = models.SalesTwoDigits.objects.filter(user=user,group=G)
+#         ser = serializers.SalesTwoDigitSerializer(data,many=True)
+
+#         return Response(ser.data)
+
+#     def post(self, request):
+#         name = request.data['customername']
+#         phoneno = request.data['phoneno']
+#         digits = request.data['digits']
+#         totalamount = request.data['totalamount']
+#         print(request.user)
+#         user = get_user_model().objects.get(username=request.user,is_plan=True,
+#                                             is_salesDigits=True)
+                                
+#         try:
+#             G = models.TwoDigitsGroup.objects.get(user=user, is_done=False)          
+#             print('Group M Exists')
+#         except ObjectDoesNotExist:
+#             print('Group M Not Exits')
+#             G = models.TwoDigitsGroup.objects.create(user=user)
+#             print('Group M Created')
+
+
+#         # print(str(name) +'\n')
+#         # print(str(phoneno) + '\n')
+#         # print(digits)
+#         # print(int(totalamount))
+
+#         Sales = models.SalesTwoDigits.objects.create(customername=name,phoneno=phoneno,totalprice=totalamount,user=user,group=G)
+#         # Sales1 = models.SalesTwoDigits.objects.create(customername=name,phoneno=phoneno,totalprice=totalamount,user=user,group=G1)
+
+#         print('Sales Objects Created')
+
+
+#         ds = json.loads(digits)
+#         # print(p)
+#         for d in ds:
+#             print(d)
+#             d1 = models.TwoDigits.objects.create(number=d['digits'],amount=d['amount'],user=user,sales=Sales)
+#             print('D1 Create')
+           
+
+#         print('Finished All')
+
+#         #     product = models.Product.objects.get(id=b['name'], user=user)
+#         #     product.qty = int(product.qty) - int(b['qty'])
+#         #     product.save()
+
+#         #     a = models.SoldProduct.objects.create(
+#         #         name=product, price=b['price'], qty=b['qty'], sales=S)
+#         #     print(a)
+
+#         # S.save()
+
+#         return Response(status=status.HTTP_201_CREATED)

app/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class AppConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'app'

app/migrations/0001_initial.py

@@ -0,0 +1,69 @@
+# Generated by Django 4.2.1 on 2023-05-09 17:18
+
+import django.contrib.auth.models
+import django.contrib.auth.validators
+from django.db import migrations, models
+import django.db.models.deletion
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('auth', '0012_alter_user_first_name_max_length'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='PassportDetail',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('size', models.CharField(choices=[('0.8, 0.8', '0.8 x 0.8 (မှတ်ပုံတင်ဆိုဒ်)'), ('1, 1', '1 x 1 (ကားလိုင်စင်ဆိုဒ်)'), ('1.1, 1.3', '1.1, 1.3 (ကျောင်းသား/ဝန်ထမ်းကဒ်)'), ('1.2, 1.4', '1.2 x 1.4 (လုပ်ငန်းသုံးလိုင်စင်ဆိုဒ်)'), ('1.25, 1.5', '1.25 x 1.5 (ဖောင်တင်ရန်၊ ဖုန်းလျှောက်ရန်)'), ('1.25, 1.6', '1.25, 1.6 (Visa လျှောက်ရန်)'), ('1.25, 1.65', '0.8 x 0.8 (Passport စာအုပ်ဆိုဒ်)'), ('1.5, 2', '0.8 x 0.8 (ဘွဲ့ဖောင်ဆိုဒ်)'), ('2,3', '2 x 3 (ထီးပေါက်လက်မှတ်ငွေထုတ်)')], max_length=255)),
+                ('bw', models.BooleanField(default=False)),
+                ('paper', models.CharField(choices=[('2480,3508', 'A4'), ('1200,1800', '4 x 6'), ('2550,3300', 'Letter'), ('2550,4200', 'Legal'), ('1748,2480', 'A5'), ('2079,2953', 'B5'), ('2175,3150', 'Executive'), ('2480,3900', 'Folio'), ('3300,5100', 'Ledger'), ('5100,6600', 'Poster')], max_length=255)),
+                ('bgcolor', models.CharField(max_length=255, null=True)),
+                ('is_done', models.BooleanField(default=False)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='Images',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('image', models.ImageField(null=True, upload_to='rawimg/%y/%mm/%dd')),
+                ('img_qty', models.CharField(max_length=4)),
+                ('ppd', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='app.passportdetail')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='User',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('password', models.CharField(max_length=128, verbose_name='password')),
+                ('last_login', models.DateTimeField(blank=True, null=True, verbose_name='last login')),
+                ('is_superuser', models.BooleanField(default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='superuser status')),
+                ('username', models.CharField(error_messages={'unique': 'A user with that username already exists.'}, help_text='Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.', max_length=150, unique=True, validators=[django.contrib.auth.validators.UnicodeUsernameValidator()], verbose_name='username')),
+                ('first_name', models.CharField(blank=True, max_length=150, verbose_name='first name')),
+                ('last_name', models.CharField(blank=True, max_length=150, verbose_name='last name')),
+                ('is_staff', models.BooleanField(default=False, help_text='Designates whether the user can log into this admin site.', verbose_name='staff status')),
+                ('is_active', models.BooleanField(default=True, help_text='Designates whether this user should be treated as active. Unselect this instead of deleting accounts.', verbose_name='active')),
+                ('date_joined', models.DateTimeField(default=django.utils.timezone.now, verbose_name='date joined')),
+                ('name', models.CharField(max_length=255)),
+                ('phoneno', models.CharField(max_length=11, null=True)),
+                ('profileimage', models.ImageField(null=True, upload_to='img/profile/%y/%mm/%dd')),
+                ('email', models.EmailField(max_length=254, null=True, unique=True)),
+                ('address', models.TextField(blank=True, null=True)),
+                ('groups', models.ManyToManyField(blank=True, help_text='The groups this user belongs to. A user will get all permissions granted to each of their groups.', related_name='user_set', related_query_name='user', to='auth.group', verbose_name='groups')),
+                ('user_permissions', models.ManyToManyField(blank=True, help_text='Specific permissions for this user.', related_name='user_set', related_query_name='user', to='auth.permission', verbose_name='user permissions')),
+            ],
+            options={
+                'verbose_name': 'user',
+                'verbose_name_plural': 'users',
+                'abstract': False,
+            },
+            managers=[
+                ('objects', django.contrib.auth.models.UserManager()),
+            ],
+        ),
+    ]

app/models.py

@@ -0,0 +1,65 @@
+from django.db import models
+
+# Create your models here.
+from email.policy import default
+from unittest.util import _MAX_LENGTH
+from django.db import models
+from django.contrib.auth.models import AbstractUser, Group
+
+from django.core.files.base import ContentFile
+# Create your models here.
+
+class User(AbstractUser):
+    name = models.CharField(max_length=255, null=False)
+    phoneno = models.CharField(max_length=11, null=True, blank=False)
+
+    profileimage = models.ImageField(
+        upload_to="img/profile/%y/%mm/%dd", null=True)
+    email = models.EmailField(unique=True,null=True)
+    address = models.TextField(null=True,blank=True)
+
+
+
+class PassportDetail(models.Model):
+   
+
+    size_choose = [
+        ('0.8, 0.8', '0.8 x 0.8 (မှတ်ပုံတင်ဆိုဒ်)'),
+        ('1, 1', '1 x 1 (ကားလိုင်စင်ဆိုဒ်)'),
+        ('1.1, 1.3', '1.1, 1.3 (ကျောင်းသား/ဝန်ထမ်းကဒ်)'),
+        ('1.2, 1.4', '1.2 x 1.4 (လုပ်ငန်းသုံးလိုင်စင်ဆိုဒ်)'),
+        ('1.25, 1.5', '1.25 x 1.5 (ဖောင်တင်ရန်၊ ဖုန်းလျှောက်ရန်)'),
+        ('1.25, 1.6','1.25, 1.6 (Visa လျှောက်ရန်)'),
+        ('1.25, 1.65', '0.8 x 0.8 (Passport စာအုပ်ဆိုဒ်)'),
+        ('1.5, 2', '0.8 x 0.8 (ဘွဲ့ဖောင်ဆိုဒ်)'),
+        ('2,3', '2 x 3 (ထီးပေါက်လက်မှတ်ငွေထုတ်)'),
+    ]
+
+    paper_sizes = [
+        ('2480,3508', 'A4'),
+        ('1200,1800', '4 x 6'),
+        ('2550,3300', 'Letter'),
+        ('2550,4200', 'Legal'),  
+        ('1748,2480', 'A5'),
+        ('2079,2953', 'B5'),
+        ('2175,3150', 'Executive'),
+        ('2480,3900', 'Folio'),
+        ('3300,5100', 'Ledger'),
+        ('5100,6600', 'Poster')
+    ]
+
+   
+    size = models.CharField(max_length=255) # Format "1.1,1.3"
+    bw = models.BooleanField(default=False)
+    paper = models.CharField(max_length=255) # Format "2480,3508"
+    bgcolor = models.CharField(max_length=255,null=True)
+    #    images = models.ForeignKey(Images,on_delete=models.CASCADE,related_name='raw_images')
+    #    user =  models.ForeignKey(User,on_delete=models.CASCADE,related_name='passport_user')
+    is_done = models.BooleanField(default=False)
+
+
+
+class Images(models.Model):
+    image = models.ImageField(upload_to="rawimg/%y/%mm/%dd", null= True)
+    img_qty = models.CharField(max_length=4)
+    ppd = models.ForeignKey(PassportDetail,on_delete=models.CASCADE)

app/serializers.py

@@ -0,0 +1,26 @@
+from rest_framework import serializers
+from django.contrib.auth import get_user_model
+from . import models
+
+from django.core.exceptions import ObjectDoesNotExist
+from django.core.exceptions import ValidationError
+
+from django.utils import timezone
+
+
+class CreateUserSerializer(serializers.ModelSerializer):
+    username = serializers.CharField()
+    password = serializers.CharField(write_only=True,
+                                     style={'input_type': 'password'})
+
+    class Meta:
+        model = get_user_model()
+        fields = ['name', 'username', 'email', 'phoneno', 'password','address']
+        write_only_fields = ('password')
+
+    def create(self, validated_data):
+        user = super(CreateUserSerializer, self).create(validated_data)
+        user.set_password(validated_data['password'])
+        user.save()
+
+        return user

app/tele.py

@@ -0,0 +1,21 @@
+import telegram
+import asyncio
+
+
+bot_token = '5499662958:AAEAoWy0khLJMf238ZwvvEoBV1FKfaVF6S0'
+chat_id = '-618629809'
+
+async def send(chat_id,document_path,bot_token):
+   
+    # Create an instance of the bot
+    bot = telegram.Bot(token=bot_token)
+    a = open(document_path,'rb')
+    await bot.send_document(chat_id=chat_id,document=a)
+
+
+class SendToTele():
+    def __init__(self,document_path,chat_id=chat_id,bot_token=bot_token):      
+        print("Sending to tele")
+        asyncio.run(send(chat_id,document_path,bot_token))
+        print("Sended To Tele")
+

app/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

app/urls.py

@@ -0,0 +1,19 @@
+from django.urls import path, include
+
+# from app.models import SalesTwoDigits
+from . import views
+from . import apiview
+from django.conf.urls.static import static
+from django.conf import settings
+from rest_framework.authtoken.views import obtain_auth_token
+
+urlpatterns = [
+    path('api/auth/register',apiview.CreateUserApiView.as_view(),name='register'),
+ path('api/sendimage/', apiview.SendImage.as_view(), name='category'),   
+    path('api/generateimage/', apiview.GenerateImage.as_view(), name='category'),   
+]
+
+
+if settings.DEBUG:
+    urlpatterns += static(settings.MEDIA_URL,
+                          document_root=settings.MEDIA_ROOT)

app/views.py

@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.

manage.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+import os
+import sys
+
+
+def main():
+    """Run administrative tasks."""
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'passportapi.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == '__main__':
+    main()