354 lines
14 KiB
Python
354 lines
14 KiB
Python
from django.shortcuts import render, HttpResponse, get_object_or_404, Http404, redirect
|
|
from .models import resulation
|
|
from datetime import datetime
|
|
import os, uuid
|
|
import misdghs.settings
|
|
from django.http import FileResponse, StreamingHttpResponse
|
|
from urllib.parse import unquote
|
|
from misdghs import settings
|
|
from django.core.files.storage import default_storage
|
|
from django.shortcuts import render, redirect
|
|
from django.urls import reverse_lazy, reverse
|
|
from django.contrib.auth.views import LoginView
|
|
from django.contrib.auth.models import User
|
|
from django.contrib.messages.views import SuccessMessageMixin
|
|
from django.views.generic.edit import CreateView
|
|
from .models import Verification
|
|
from .forms import SignupForm
|
|
from django.contrib.auth import authenticate, login, logout
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.contrib import messages
|
|
|
|
|
|
class SignupView(SuccessMessageMixin, CreateView):
|
|
form_class = SignupForm
|
|
template_name = 'registration/signup.html'
|
|
success_url = reverse_lazy('login')
|
|
success_message = "Registration successful! Please verify your email."
|
|
|
|
def form_valid(self, form):
|
|
print("=== Checking form validity in SignupView ===")
|
|
|
|
# Check if the username already exists
|
|
existing_username = User.objects.filter(username=form.cleaned_data['username'])
|
|
if existing_username.exists():
|
|
print(f"Username '{form.cleaned_data['username']}' already exists.")
|
|
form.add_error('username', 'Username already taken.')
|
|
return super().form_invalid(form)
|
|
|
|
# Check if the email already exists
|
|
existing_email = User.objects.filter(email=form.cleaned_data['email'])
|
|
if existing_email.exists():
|
|
print(f"Email '{form.cleaned_data['email']}' already registered.")
|
|
form.add_error('email', 'Email already registered.')
|
|
return super().form_invalid(form)
|
|
|
|
# Form is valid, proceed to create user
|
|
print("Form validation passed. Proceeding to create user...")
|
|
response = super().form_valid(form)
|
|
print(f"User created successfully. User object: {self.object}")
|
|
|
|
# Verify that self.object exists and has the correct fields
|
|
if self.object:
|
|
print(f"New user details - Username: {self.object.username}, Email: {self.object.email}")
|
|
print("Proceeding to send verification email.")
|
|
self.send_verification_email()
|
|
else:
|
|
print("Error: User object is not created after form submission.")
|
|
|
|
return response
|
|
|
|
def send_verification_email(self):
|
|
print("\n=== Entering send_verification_email method ===")
|
|
try:
|
|
# Create a new Verification instance
|
|
verification = Verification.objects.create(user=self.object)
|
|
print(f"Verification object created with key: {verification.key}")
|
|
|
|
# Generate the verification key (you can improve this by using a more secure method)
|
|
import uuid
|
|
key = str(uuid.uuid4())
|
|
print(f"Generated verification key: {key}")
|
|
|
|
# Prepare email content
|
|
subject = 'Verify your email'
|
|
body = (
|
|
f'Please verify your account by clicking this link: '
|
|
f'{self.request.build_absolute_uri(reverse("verify", kwargs={"key": key}))}'
|
|
)
|
|
html_body = (
|
|
f'<a href="{self.request.build_absolute_uri(reverse("verify", kwargs={"key": key}))}">'
|
|
'Verify Email</a>'
|
|
)
|
|
|
|
# Send email using Django's send_mail function
|
|
print(f"Attempting to send verification email to: {self.object.email}")
|
|
from django.core.mail import send_mail
|
|
send_mail(
|
|
subject,
|
|
body,
|
|
'dpmehealth@gmail.com',
|
|
[self.object.email],
|
|
fail_silently=False
|
|
)
|
|
print("Verification email sent successfully.")
|
|
|
|
except Exception as e:
|
|
print(f"Error sending verification email: {str(e)}")
|
|
raise # Re-raise the exception to see it in logs or handle appropriately
|
|
|
|
def generate_key(self):
|
|
import uuid
|
|
return str(uuid.uuid4())
|
|
|
|
def Verify(request, key):
|
|
try:
|
|
print(f"\n=== Verification view called with key: {key} ===")
|
|
verification = Verification.objects.get(key=key)
|
|
if not verification.verified:
|
|
print(f"Verification found and unverified. Proceeding to verify.")
|
|
verification.verified = True
|
|
verification.save()
|
|
user = verification.user
|
|
print(f"User associated with this verification: {user.username}")
|
|
user.is_active = True
|
|
user.save()
|
|
messages.success(request, 'Email verified successfully!')
|
|
return redirect('login')
|
|
else:
|
|
print("Verification link already used.")
|
|
messages.error(request, 'Already verified.')
|
|
except Verification.DoesNotExist:
|
|
print(f"Invalid verification key: {key}")
|
|
messages.error(request, 'Invalid verification link.')
|
|
return redirect('home')
|
|
|
|
|
|
def signin(request):
|
|
if request.method == "POST":
|
|
username = request.POST.get("username")
|
|
password = request.POST.get("password")
|
|
user = authenticate(request, username=username, password=password)
|
|
if user is not None:
|
|
login(request, user)
|
|
messages.success(request, "You have successfully logged in!")
|
|
return redirect("home")
|
|
messages.error(request, "Invalid username or password.")
|
|
else:
|
|
return render(request, "registration/signin.html")
|
|
|
|
@login_required
|
|
def signout(request):
|
|
logout(request)
|
|
messages.info(request, "You have successfully logged out.")
|
|
return redirect("home")
|
|
|
|
|
|
|
|
|
|
# Create your views here.
|
|
def Home(request):
|
|
return render(request,'resulation/home.html')
|
|
|
|
|
|
@login_required
|
|
def Savepdf(request):
|
|
if request.method == 'POST':
|
|
try:
|
|
# Get text form fields
|
|
pdftype= request.POST.get('pdftype')
|
|
org_unit = request.POST.get('org_unit')
|
|
topic = request.POST.get('topic')
|
|
tittle = request.POST.get('tittle')
|
|
m_number = request.POST.get('m_number')
|
|
m_date = request.POST.get('m_date')
|
|
m_venue = request.POST.get('m_venue')
|
|
|
|
# Get file uploads
|
|
attendance_file = request.FILES.get('attendance_file')
|
|
res_con_mou_file = request.FILES.get('res_con_mou_file')
|
|
|
|
# Create a new seminar instance with text fields
|
|
if attendance_file:
|
|
new_filename1 = f"attendance_{uuid.uuid4()}.pdf"
|
|
path1 = os.path.join('media', 'attendance_files', new_filename1)
|
|
|
|
with open(path1, 'wb') as destination:
|
|
for chunk in attendance_file.chunks():
|
|
destination.write(chunk)
|
|
|
|
if res_con_mou_file:
|
|
new_filename2 = f"res_con_{uuid.uuid4()}.pdf"
|
|
path2 = os.path.join('media', 'resolution_files', new_filename2)
|
|
|
|
print(path2)
|
|
with open(path2, 'wb') as destination:
|
|
for chunk in res_con_mou_file.chunks():
|
|
destination.write(chunk)
|
|
seminar = resulation(
|
|
pdftype=pdftype,
|
|
org_unit=org_unit,
|
|
topic=topic,
|
|
tittle=tittle,
|
|
m_number=m_number,
|
|
m_date=m_date,
|
|
m_venue=m_venue,
|
|
attendance_file=new_filename1,
|
|
res_con_mou_file=new_filename2,
|
|
)
|
|
seminar.save()
|
|
print(path1)
|
|
message = "Data Inserted successfully"
|
|
# Redirect after a successful save
|
|
return render(request, "resulation/home.html", {'message': message})
|
|
|
|
except Exception as e:
|
|
# Handle any errors (e.g., invalid file types or sizes)
|
|
print(f"Error processing form: {str(e)}")
|
|
return render(request, 'resulation/resulation.html', {'error': str(e)})
|
|
|
|
else:
|
|
# Render the form template
|
|
return render(request, 'resulation/resulation.html')
|
|
|
|
@login_required
|
|
def Viewresulation(request):
|
|
# Get all records from database
|
|
pdf_records = resulation.objects.filter(pdftype='Meeting Minutes').order_by('-m_date') # Latest first
|
|
return render(request, 'resulation/viewresulation.html', {'pdf_records': pdf_records})
|
|
|
|
@login_required
|
|
def file_download(request, type, filename):
|
|
# Construct the full path to the file
|
|
if type== 'attendance':
|
|
file_path = os.path.join(settings.MEDIA_ROOT, 'attendance_files', filename)
|
|
if type=='resolution':
|
|
file_path = os.path.join(settings.MEDIA_ROOT, 'resolution_files', filename)
|
|
|
|
|
|
# Use sendfile to stream the file directly
|
|
return FileResponse(open(file_path, 'rb'), content_type='application/pdf')
|
|
|
|
|
|
@login_required
|
|
def Mou(request):
|
|
if request.method == 'POST':
|
|
try:
|
|
# Get text form fields
|
|
pdftype= request.POST.get('pdftype')
|
|
first_party = request.POST.get('first_party')
|
|
second_party = request.POST.get('second_party')
|
|
contract_mou_date = request.POST.get('contract_mou_date')
|
|
# Get file uploads
|
|
res_con_mou_file = request.FILES.get('res_con_mou_file')
|
|
|
|
if res_con_mou_file:
|
|
new_filename2 = f"res_con_{uuid.uuid4()}.pdf"
|
|
path2 = os.path.join('media', 'resolution_files', new_filename2)
|
|
|
|
print(path2)
|
|
with open(path2, 'wb') as destination:
|
|
for chunk in res_con_mou_file.chunks():
|
|
destination.write(chunk)
|
|
seminar = resulation(
|
|
pdftype=pdftype,
|
|
first_party = first_party,
|
|
second_party = second_party,
|
|
contract_mou_date = contract_mou_date,
|
|
res_con_mou_file=new_filename2,
|
|
)
|
|
seminar.save()
|
|
message = "Data Inserted successfully"
|
|
# Redirect after a successful save
|
|
return render(request, "resulation/home.html", {'message': message})
|
|
|
|
except Exception as e:
|
|
# Handle any errors (e.g., invalid file types or sizes)
|
|
print(f"Error processing form: {str(e)}")
|
|
return render(request, 'resulation/mou.html', {'error': str(e)})
|
|
|
|
else:
|
|
# Render the form template
|
|
return render(request, 'resulation/mou.html')
|
|
|
|
|
|
@login_required
|
|
def Viewmou(request):
|
|
# Get all records from database
|
|
pdf_records = resulation.objects.filter(pdftype='MoU').order_by('-m_date') # Latest first
|
|
print(pdf_records)
|
|
return render(request, 'resulation/viewmou.html', {'pdf_records': pdf_records})
|
|
|
|
|
|
@login_required
|
|
def Contract(request):
|
|
if request.method == 'POST':
|
|
try:
|
|
# Get text form fields
|
|
pdftype= request.POST.get('pdftype')
|
|
contract_name= request.POST.get('topic')
|
|
first_party = request.POST.get('first_party')
|
|
second_party = request.POST.get('second_party')
|
|
contract_mou_date = request.POST.get('contract_mou_date')
|
|
contract_mou_closing_date = request.POST.get('closing_date')
|
|
duration= request.POST.get('duration')
|
|
# Get file uploads
|
|
res_con_mou_file = request.FILES.get('res_con_mou_file')
|
|
|
|
if res_con_mou_file:
|
|
new_filename2 = f"res_con_{uuid.uuid4()}.pdf"
|
|
path2 = os.path.join('media', 'resolution_files', new_filename2)
|
|
|
|
print(path2)
|
|
with open(path2, 'wb') as destination:
|
|
for chunk in res_con_mou_file.chunks():
|
|
destination.write(chunk)
|
|
seminar = resulation(
|
|
pdftype=pdftype,
|
|
topic=contract_name,
|
|
first_party = first_party,
|
|
second_party = second_party,
|
|
contract_mou_date = contract_mou_date,
|
|
closing_date= contract_mou_closing_date,
|
|
duration=duration,
|
|
res_con_mou_file=new_filename2,
|
|
)
|
|
seminar.save()
|
|
message = "Data Inserted successfully"
|
|
# Redirect after a successful save
|
|
return render(request, "resulation/home.html", {'message': message})
|
|
|
|
except Exception as e:
|
|
# Handle any errors (e.g., invalid file types or sizes)
|
|
print(f"Error processing form: {str(e)}")
|
|
return render(request, 'resulation/contract.html', {'error': str(e)})
|
|
|
|
else:
|
|
# Render the form template
|
|
return render(request, 'resulation/contract.html')
|
|
|
|
|
|
@login_required
|
|
def Viewcontract(request):
|
|
# Get all records from database
|
|
pdf_records = resulation.objects.filter(pdftype='Contract').order_by('-m_date') # Latest first
|
|
return render(request, 'resulation/viewcontract.html', {'pdf_records': pdf_records})
|
|
|
|
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
|
|
def contracts_list(request):
|
|
records = resulation.objects.all() # Replace with your model
|
|
paginator = Paginator(records, 10) # Show 10 records per page
|
|
|
|
try:
|
|
page = int(request.GET.get('page', '1'))
|
|
except ValueError:
|
|
page = 1
|
|
|
|
try:
|
|
pdf_records = paginator.page(page)
|
|
except PageNotAnInteger:
|
|
pdf_records = paginator.page(1)
|
|
except EmptyPage:
|
|
pdf_records = paginator.page(paginator.num_pages)
|
|
|
|
return {'pdf_records': pdf_records, 'paginator': paginator} |