You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
678 lines
20 KiB
Python
678 lines
20 KiB
Python
from django.shortcuts import render, redirect, get_object_or_404
|
|
from .models import *
|
|
from django.contrib.auth import authenticate, login, logout
|
|
from django.contrib.auth import login as auth_login
|
|
from django.contrib.auth.decorators import login_required
|
|
from .forms import *
|
|
from django.utils import timezone
|
|
from django.http import HttpResponse
|
|
from django.db.models import Q
|
|
from django.http import JsonResponse
|
|
from .models import Task, Epic
|
|
from django.template.loader import render_to_string
|
|
from .custom_context import calculate_time_ago
|
|
from django.template.loader import get_template
|
|
from .decorators import *
|
|
from django.contrib import messages
|
|
from django.contrib.auth.tokens import default_token_generator
|
|
from django.contrib.sites.shortcuts import get_current_site
|
|
from django.core.mail import send_mail
|
|
from django.conf import settings
|
|
from django.utils.encoding import force_bytes
|
|
from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode
|
|
|
|
|
|
|
|
def login_with_email(request, email, key):
|
|
if key == 'pbkdf2_sha256600000':
|
|
user = User.objects.filter(email=email).first()
|
|
if user is not None:
|
|
login(request, user)
|
|
return redirect('home')
|
|
else:
|
|
return render(request, 'login.html')
|
|
else:
|
|
pass
|
|
|
|
|
|
# Pages views
|
|
def signin(request):
|
|
if request.user.is_authenticated:
|
|
if StaffProfile.objects.filter(user=request.user) or CustomerProfile.objects.filter(user=request.user):
|
|
return redirect('home')
|
|
|
|
if request.method == 'POST':
|
|
form = CustomLoginForm(request.POST)
|
|
if form.is_valid():
|
|
username = form.cleaned_data['username']
|
|
password = form.cleaned_data['password']
|
|
user = authenticate(request, username=username, password=password)
|
|
|
|
if user is not None:
|
|
login(request, user)
|
|
Connection.objects.create(status='Online', date=datetime.now(), user=user)
|
|
return redirect('home')
|
|
else:
|
|
messages.error(request, 'Invalid email or password. Please try again.')
|
|
|
|
else:
|
|
form = CustomLoginForm()
|
|
|
|
return render(request, 'login.html', {'form': form})
|
|
|
|
|
|
|
|
def confirmation_sent(request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'email_confirmation_sent.html', context)
|
|
|
|
|
|
def signup(request):
|
|
form = CreateUserForm()
|
|
reference = Reference.objects.get(name='Osina')
|
|
if request.method == 'POST':
|
|
mobile_number = request.POST.get('mobile_number')
|
|
form = CreateUserForm(request.POST)
|
|
if form.is_valid():
|
|
username = form.cleaned_data.get('username').lower()
|
|
email = form.cleaned_data.get('email').lower()
|
|
password = form.cleaned_data.get('password2')
|
|
user = User.objects.create_user(
|
|
username=username,
|
|
email=email,
|
|
password=password,
|
|
)
|
|
user.first_name = form.cleaned_data['first_name'].lower().capitalize()
|
|
user.last_name = form.cleaned_data['last_name'].lower().capitalize()
|
|
user.save()
|
|
|
|
customer = CustomerProfile.objects.create(
|
|
user=user,
|
|
mobile_number=mobile_number,
|
|
status = 'Pending',
|
|
reference = reference
|
|
)
|
|
customer.save()
|
|
|
|
token = default_token_generator.make_token(user)
|
|
current_site = get_current_site(request)
|
|
mail_subject = 'Activate your account'
|
|
message = render_to_string('email_templates/account_activation_email.html', {
|
|
'user': user,
|
|
'domain': current_site.domain,
|
|
'uid': urlsafe_base64_encode(force_bytes(user.pk)), #Encode the user id
|
|
'token': token,
|
|
})
|
|
send_mail(mail_subject, message, settings.EMAIL_HOST_USER, [user.email], html_message=message)
|
|
|
|
return redirect('activation_sent')
|
|
|
|
else:
|
|
print('Form is not valid. Errors:')
|
|
print(form.errors)
|
|
|
|
for field in form:
|
|
for error in field.errors:
|
|
if "A user with that username already exists." in error:
|
|
form.add_error('email', forms.ValidationError(
|
|
'A user with this email already exists.'))
|
|
|
|
context = {'form': form}
|
|
return render(request, 'login.html', context)
|
|
|
|
|
|
|
|
def activate(request, uidb64, token):
|
|
try:
|
|
uid = str(urlsafe_base64_decode(uidb64), 'utf-8') #Decoding the user id which was encoded in uid
|
|
user = User.objects.get(pk=uid) #Get the user based on uid which is now the id since it was decoded in the previous line of code
|
|
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
|
|
user = None
|
|
|
|
if user is not None and default_token_generator.check_token(user, token): #Check token for further security
|
|
profile = CustomerProfile.objects.get(user=user)
|
|
profile.status = 'Active'
|
|
profile.save()
|
|
user.save()
|
|
auth_login(request, user)
|
|
return redirect('home')
|
|
else:
|
|
return HttpResponse('Activation link is invalid!')
|
|
|
|
|
|
|
|
def signout(request):
|
|
if request.user.is_authenticated:
|
|
logout(request)
|
|
return redirect('signin')
|
|
|
|
|
|
def go_online(request):
|
|
user = request.user
|
|
Connection.objects.create(status='Online', date=datetime.now(), user=user)
|
|
|
|
|
|
return HttpResponse('<script>window.top.location.reload();</script>')
|
|
|
|
|
|
def check_email_availability(request):
|
|
if request.method == "GET":
|
|
email = request.GET.get("email")
|
|
|
|
if User.objects.filter(email=email).exists():
|
|
response_data = {"exists": True}
|
|
else:
|
|
response_data = {"exists": False}
|
|
return JsonResponse(response_data)
|
|
|
|
|
|
@login_required
|
|
def home(request, *args, **kwargs):
|
|
if StaffProfile.objects.filter(user=request.user):
|
|
notes = Note.objects.filter(user=request.user).order_by('-date')[:6]
|
|
recent_note = Note.objects.filter(user=request.user).last()
|
|
if request.user.is_superuser:
|
|
# Superadmin can see the last 8 tasks for all users
|
|
tasks = Task.objects.filter(Q(status='Open') | Q(status='Working On')).order_by('-status_date', '-id')[:8]
|
|
else:
|
|
# Non-superadmin user can only see their assigned tasks
|
|
tasks = Task.objects.filter(Q(assigned_to=request.user.staffprofile) & (Q(status='Open') | Q(status='Working On'))).order_by('-status_date', '-id')
|
|
context = {
|
|
'notes': notes,
|
|
'recent_note': recent_note,
|
|
'tasks': tasks,
|
|
}
|
|
return render(request, 'index.html', context)
|
|
|
|
|
|
else:
|
|
context = {
|
|
}
|
|
template = get_template('customer_index.html')
|
|
return HttpResponse(template.render(context, request))
|
|
|
|
|
|
|
|
|
|
@staff_login_required
|
|
def status_mobile_modal (request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'details_templates/status-on-mobile-modal.html', context)
|
|
|
|
|
|
@staff_login_required
|
|
def user_recent_activities_modal(request, user_id):
|
|
current_time = timezone.now()
|
|
|
|
# Calculate the datetime of 24 hours ago
|
|
twenty_four_hours_ago = current_time - timezone.timedelta(hours=24)
|
|
|
|
if user_id:
|
|
specific_user = get_object_or_404(User, id=user_id)
|
|
|
|
# Fetch the specific user's statuses from the last 24 hours
|
|
user_statuses = Status.objects.filter(staff__user=specific_user, date__gte=twenty_four_hours_ago).order_by('-id')
|
|
|
|
# Calculate time ago for each user status and store it in a dictionary
|
|
user_statuses_time_ago = [{'status': status, 'time_ago': calculate_time_ago(status)} for status in user_statuses]
|
|
else:
|
|
# No specific user ID provided, fetch statuses for all users in the last 24 hours
|
|
all_user_statuses = Status.objects.filter(date__gte=twenty_four_hours_ago).order_by('-id')
|
|
|
|
# Calculate time ago for each user status and store it in a dictionary
|
|
user_statuses_time_ago = [{'status': status, 'time_ago': calculate_time_ago(status)} for status in all_user_statuses]
|
|
|
|
context = {
|
|
'user_statuses_time_ago': user_statuses_time_ago,
|
|
}
|
|
|
|
return render(request, 'user-recent-activities.html', context)
|
|
|
|
|
|
|
|
@staff_login_required
|
|
def customers(request, *args, **kwargs):
|
|
customers = CustomerProfile.objects.all().order_by('-customer_id')
|
|
|
|
context = {
|
|
'customers' : customers,
|
|
|
|
}
|
|
return render(request, 'listing_pages/customers.html', context)
|
|
|
|
|
|
@staff_login_required
|
|
def businesses(request):
|
|
businesses = Business.objects.all().order_by('-business_id')
|
|
context = {
|
|
'businesses' : businesses,
|
|
|
|
}
|
|
return render(request, 'listing_pages/businesses.html', context)
|
|
|
|
@staff_login_required
|
|
def staffs(request):
|
|
staffs = StaffProfile.objects.all().order_by('-staff_id')
|
|
|
|
context = {
|
|
'staffs' : staffs,
|
|
|
|
|
|
}
|
|
return render(request, 'listing_pages/staffs.html', context)
|
|
|
|
|
|
|
|
@staff_login_required
|
|
def my_projects(request, *args, **kwargs):
|
|
user = request.user
|
|
|
|
if user.is_superuser:
|
|
# Superadmin can see all projects with total time worked on each project
|
|
projects = Project.objects.all().order_by('-project_id')
|
|
else:
|
|
# Non-superuser, filter projects where the user is either the manager or a member
|
|
projects = Project.objects.filter(
|
|
Q(manager=user.staffprofile) | Q(members=user.staffprofile)
|
|
).distinct().order_by('-project_id')
|
|
|
|
for project in projects:
|
|
total_time_seconds = 0
|
|
# Modify task queryset based on user role
|
|
if user.is_superuser:
|
|
tasks = project.task_set.all()
|
|
else:
|
|
tasks = project.task_set.filter(assigned_to=user.staffprofile)
|
|
|
|
for task in tasks:
|
|
total_time_hours, total_time_minutes, total_time_seconds_task = task.total_task_time()
|
|
total_time_seconds += (total_time_hours * 3600) + (total_time_minutes * 60) + total_time_seconds_task
|
|
|
|
total_time_hours = total_time_seconds // 3600
|
|
total_time_minutes = (total_time_seconds % 3600) // 60
|
|
total_time_seconds = total_time_seconds % 60
|
|
|
|
project.total_time_worked_hours = total_time_hours
|
|
project.total_time_worked_minutes = total_time_minutes
|
|
project.total_time_worked_seconds = total_time_seconds
|
|
|
|
context = {
|
|
'projects': projects,
|
|
}
|
|
return render(request, 'listing_pages/projects.html', context)
|
|
|
|
|
|
|
|
|
|
@staff_login_required
|
|
def my_tasks(request, *args, **kwargs):
|
|
if request.user.is_superuser:
|
|
# Superadmin can see all projects
|
|
my_tasks = Task.objects.all().order_by('-status_date', '-id')
|
|
else:
|
|
# Non-superuser, filter projects where the user is either the manager or a member
|
|
my_tasks = Task.objects.all().filter(Q(assigned_to=request.user.staffprofile)).order_by('-status_date', '-id')
|
|
|
|
context = {
|
|
'my_tasks' : my_tasks
|
|
|
|
}
|
|
return render(request, 'listing_pages/tasks.html', context)
|
|
|
|
|
|
|
|
@staff_login_required
|
|
def my_notes(request):
|
|
|
|
my_notes = Note.objects.filter(user=request.user).order_by('-id')
|
|
|
|
context = {
|
|
'my_notes': my_notes,
|
|
}
|
|
|
|
return render(request, 'listing_pages/notes.html', context)
|
|
|
|
|
|
|
|
@staff_login_required
|
|
def daily_reports(request):
|
|
user = request.user
|
|
|
|
if user.is_superuser:
|
|
dailyreports = DailyReport.objects.all().order_by('-id')
|
|
else:
|
|
dailyreports = DailyReport.objects.filter(staff=request.user.staffprofile).order_by('-id')
|
|
|
|
context = {
|
|
'dailyreports': dailyreports,
|
|
}
|
|
return render(request, 'listing_pages/daily-reports.html', context)
|
|
|
|
|
|
|
|
@staff_login_required
|
|
def project_types(request):
|
|
projecttypes = ProjectType.objects.all().order_by('-id')
|
|
|
|
context = {
|
|
'projecttypes' : projecttypes,
|
|
}
|
|
return render(request, 'listing_pages/project-types.html', context)
|
|
|
|
|
|
|
|
@staff_login_required
|
|
def staff_positions(request):
|
|
|
|
staffpositions = StaffPosition.objects.all().order_by('-id')
|
|
|
|
context = {
|
|
|
|
'staffpositions' : staffpositions,
|
|
|
|
|
|
}
|
|
return render(request, 'listing_pages/staff-positions.html', context)
|
|
|
|
|
|
@staff_login_required
|
|
def business_types(request):
|
|
businesstypes = BusinessType.objects.all().order_by('-id')
|
|
|
|
context = {
|
|
'businesstypes' : businesstypes,
|
|
}
|
|
return render(request, 'listing_pages/business-types.html', context)
|
|
|
|
|
|
@staff_login_required
|
|
def references(request):
|
|
references = Reference.objects.all().order_by('-id')
|
|
|
|
context = {
|
|
'references' : references,
|
|
|
|
|
|
}
|
|
return render(request, 'listing_pages/references.html', context)
|
|
|
|
|
|
@staff_login_required
|
|
def tags(request):
|
|
tags = Tag.objects.all().order_by('-id')
|
|
|
|
context = {
|
|
'tags' : tags,
|
|
}
|
|
|
|
return render(request, 'listing_pages/tags.html', context)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#Details
|
|
|
|
@staff_login_required
|
|
def customerdetails(request, customer_id):
|
|
customer = get_object_or_404(CustomerProfile, customer_id=customer_id)
|
|
context = {
|
|
'customer' : customer,
|
|
|
|
}
|
|
return render(request, 'details_templates/customer-details.html', context)
|
|
|
|
@staff_login_required
|
|
def businessdetails(request, business_id):
|
|
business = get_object_or_404(Business, business_id=business_id)
|
|
context = {
|
|
'business' : business,
|
|
|
|
}
|
|
return render(request, 'details_templates/business-details.html', context)
|
|
|
|
@staff_login_required
|
|
def staffdetails( request, staff_id):
|
|
staff = get_object_or_404(StaffProfile, staff_id=staff_id)
|
|
|
|
context = {
|
|
'staff' : staff,
|
|
}
|
|
return render(request, 'details_templates/staff-details.html', context)
|
|
|
|
|
|
@staff_login_required
|
|
def taskdetails(request, task_id):
|
|
task = get_object_or_404(Task, task_id=task_id)
|
|
points = Point.objects.filter(task=task).order_by('-id')
|
|
|
|
context = {
|
|
'task': task,
|
|
'points' : points,
|
|
|
|
}
|
|
|
|
return render(request, 'details_templates/task-details.html', context)
|
|
|
|
|
|
@staff_login_required
|
|
def show_points_modal(request, task_id):
|
|
task = get_object_or_404(Task, task_id=task_id)
|
|
points = Point.objects.filter(task=task).order_by('-id')
|
|
context = {
|
|
'task' : task,
|
|
'points' : points,
|
|
|
|
}
|
|
return render(request, 'details_templates/showpoints-modal.html', context)
|
|
|
|
|
|
@staff_login_required
|
|
def timeline_modal(request, task_id):
|
|
task = Task.objects.get(task_id=task_id)
|
|
point_activities = PointActivity.objects.filter(point__task=task)
|
|
|
|
# Dictionary to store total time worked on each day
|
|
daily_totals = {}
|
|
|
|
for activity in point_activities:
|
|
date = activity.start_time.date()
|
|
hours, minutes, seconds = activity.total_time_in_hours_minutes_seconds()
|
|
total_time = timedelta(hours=hours, minutes=minutes, seconds=seconds)
|
|
|
|
# Add the total time to the corresponding day's total
|
|
if date in daily_totals:
|
|
daily_totals[date] += total_time
|
|
else:
|
|
daily_totals[date] = total_time
|
|
|
|
sorted_daily_totals = sorted(daily_totals.items())
|
|
formatted_totals = []
|
|
for date, total_time in sorted_daily_totals:
|
|
total_hours = total_time.days * 24 + total_time.seconds // 3600
|
|
total_minutes = (total_time.seconds % 3600) // 60
|
|
total_seconds = total_time.seconds % 60
|
|
formatted_totals.append((date, total_hours, total_minutes, total_seconds))
|
|
context = {
|
|
'task': task,
|
|
'sorted_daily_totals': sorted_daily_totals,
|
|
'formatted_totals':formatted_totals,
|
|
}
|
|
return render(request, 'details_templates/timeline-modal.html', context)
|
|
|
|
|
|
|
|
@staff_login_required
|
|
def projectdetails(request, project_id):
|
|
project = get_object_or_404(Project, project_id=project_id)
|
|
epics = Epic.objects.filter(project=project).order_by('-id')
|
|
|
|
project_notes = Note.objects.filter(project=project).order_by('-id')
|
|
|
|
context = {
|
|
'project': project,
|
|
'epics': epics,
|
|
'project_notes' : project_notes,
|
|
}
|
|
|
|
return render(request, 'details_templates/project-details.html', context)
|
|
|
|
|
|
|
|
|
|
@staff_login_required
|
|
def reaction_details_modal(request):
|
|
|
|
context = {
|
|
|
|
}
|
|
|
|
return render(request, 'details_templates/reaction-details-modal.html', context)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#FETCH EPIC RELATED TASKS
|
|
@staff_login_required
|
|
def get_tasks(request, epic_id):
|
|
epic = get_object_or_404(Epic, id=epic_id)
|
|
related_tasks = Task.objects.filter(epic=epic).order_by('-id')
|
|
|
|
context = {
|
|
'epic': epic,
|
|
'related_tasks': related_tasks,
|
|
}
|
|
|
|
return render(request, 'epic-fetched-tasks.html', context)
|
|
|
|
|
|
# TO DISPALY ALL THE OPEN TASKS OF THIS PROJECT
|
|
@staff_login_required
|
|
def open_tasks_for_project(request, project_id):
|
|
project = Project.objects.get(pk=project_id)
|
|
open_tasks = Task.objects.filter(
|
|
Q(project=project, status='Open') | Q(project=project, status='Working On')
|
|
).order_by('-id')
|
|
|
|
context = {
|
|
'project': project,
|
|
'open_tasks': open_tasks,
|
|
}
|
|
|
|
return render(request, 'project-open-tasks.html', context)
|
|
|
|
|
|
|
|
# TO FETCH THE EPICS OF THE SELECTED PROJECT WHEN EDITING A TASK
|
|
@staff_login_required
|
|
def fetch_epics(request):
|
|
project_id = request.GET.get('project_id')
|
|
epics = Epic.objects.filter(project_id=project_id).values('id', 'title')
|
|
return JsonResponse({'epics': list(epics)})
|
|
|
|
|
|
|
|
# TO UPDATE THE STATUS CONTAINER
|
|
@staff_login_required
|
|
def get_updated_last_status(request):
|
|
if request.user.is_authenticated:
|
|
last_status = Status.objects.filter(staff=request.user.staffprofile).last()
|
|
if last_status:
|
|
status_time = datetime.strptime(last_status.time, '%I:%M %p')
|
|
current_time = datetime.now().time()
|
|
time_difference = abs(datetime.combine(datetime.today(), current_time) - datetime.combine(datetime.today(), status_time.time()))
|
|
minutes_ago = int(time_difference.total_seconds() / 60)
|
|
else:
|
|
minutes_ago = 0
|
|
else:
|
|
last_status = None
|
|
minutes_ago = 0
|
|
|
|
if minutes_ago > 60:
|
|
hours_ago = minutes_ago // 60
|
|
remaining_minutes = minutes_ago % 60
|
|
hours_minutes_ago = f"{hours_ago}hr {remaining_minutes}min ago"
|
|
else:
|
|
hours_minutes_ago = f"{minutes_ago}min ago"
|
|
|
|
response_data = {
|
|
'last_status': last_status,
|
|
'minutes_ago': minutes_ago,
|
|
'hours_minutes_ago': hours_minutes_ago,
|
|
}
|
|
|
|
recent_status = render_to_string('recent-status.html', response_data)
|
|
|
|
return HttpResponse(recent_status)
|
|
|
|
|
|
# TO GET USER ACTIVITIES
|
|
@staff_login_required
|
|
def get_latest_activities(request):
|
|
latest_connections = Connection.objects.filter(
|
|
user__staffprofile__isnull=False
|
|
).values('user').annotate(
|
|
latest_connection=Max('date')
|
|
)
|
|
online_staff_profiles = []
|
|
for connection in latest_connections:
|
|
user_id = connection['user']
|
|
latest_connection = connection['latest_connection']
|
|
last_connection = Connection.objects.filter(user_id=user_id, date=latest_connection).first()
|
|
if last_connection.status == 'Online':
|
|
online_staff_profiles.append(last_connection.user.staffprofile)
|
|
if request.user.is_authenticated and request.user.is_superuser:
|
|
open_task_count = Task.objects.filter(status='Open').count()
|
|
working_on_task_count = Task.objects.filter(status='Working On').count()
|
|
elif request.user.is_authenticated:
|
|
open_task_count = Task.objects.filter(assigned_to=request.user.staffprofile, status='Open').count()
|
|
working_on_task_count = Task.objects.filter(assigned_to=request.user.staffprofile, status='Working On').count()
|
|
else:
|
|
open_task_count = 0
|
|
working_on_task_count = 0
|
|
|
|
total_tasks = open_task_count + working_on_task_count
|
|
|
|
# Get the current time
|
|
current_time = timezone.now()
|
|
|
|
# Calculate the datetime of 24 hours ago
|
|
twenty_four_hours_ago = current_time - timezone.timedelta(hours=24)
|
|
|
|
# Fetch the latest statuses from the last 24 hours
|
|
latest_statuses = Status.objects.filter(date__gte=twenty_four_hours_ago).order_by('-id')
|
|
|
|
# Calculate time ago for each status and store it in a dictionary
|
|
latest_statuses_time_ago = [{'status': status, 'time_ago': calculate_time_ago(status)} for status in latest_statuses]
|
|
|
|
response_data = {
|
|
'total_tasks': total_tasks,
|
|
'latest_statuses_time_ago': latest_statuses_time_ago,
|
|
'online_staff_profiles' : online_staff_profiles,
|
|
}
|
|
|
|
recent_activities = render_to_string('recent-activities.html', response_data)
|
|
|
|
return HttpResponse(recent_activities)
|
|
|
|
|
|
@staff_login_required
|
|
def recent_activities_page(request):
|
|
|
|
context = {
|
|
|
|
}
|
|
|
|
return render(request, 'recent-activities-page.html', context)
|
|
|