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.
1929 lines
51 KiB
Python
1929 lines
51 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.decorators import login_required
|
|
from django.contrib import messages
|
|
from .forms import *
|
|
from django.utils import timezone
|
|
from django.urls import reverse
|
|
from django.http import HttpResponse, HttpResponseServerError, Http404
|
|
from django.db.models import Q
|
|
from django.http import JsonResponse
|
|
from .models import Task, Epic
|
|
from datetime import date
|
|
from django.http import HttpResponseRedirect
|
|
from django.template.loader import render_to_string
|
|
from .custom_context import calculate_time_ago
|
|
|
|
|
|
def get_point_total_time(request, point_id):
|
|
point = Point.objects.get(id=point_id)
|
|
total_time = point.total_time()
|
|
return JsonResponse({'hours': total_time[0], 'minutes': total_time[1], 'seconds': total_time[2]})
|
|
|
|
|
|
# Pages views
|
|
def signin(request):
|
|
if request.user.is_authenticated:
|
|
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)
|
|
return redirect('home')
|
|
else:
|
|
form.add_error(None, 'Invalid email or password. Please try again.')
|
|
|
|
else:
|
|
form = CustomLoginForm()
|
|
|
|
return render(request, 'login.html', {'form': form})
|
|
|
|
|
|
def signout(request):
|
|
if request.user.is_authenticated:
|
|
logout(request)
|
|
return redirect('signin')
|
|
|
|
|
|
@login_required
|
|
def home(request, *args, **kwargs):
|
|
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)
|
|
|
|
|
|
|
|
|
|
|
|
from django.db.models import Subquery, OuterRef
|
|
|
|
#Listing Pages
|
|
@login_required
|
|
def my_projects(request, *args, **kwargs):
|
|
user = request.user
|
|
|
|
if user.is_superuser:
|
|
# Superadmin can see all projects
|
|
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')
|
|
|
|
# Annotate each project with its most recent note
|
|
projects = projects.annotate(
|
|
recent_note_text=Subquery(
|
|
Note.objects.filter(project=OuterRef('pk')).order_by('-date').values('text')[:1]
|
|
),
|
|
recent_note_color=Subquery(
|
|
Note.objects.filter(project=OuterRef('pk')).order_by('-date').values('color')[:1]
|
|
),
|
|
recent_note_date=Max('note__date')
|
|
)
|
|
|
|
context = {
|
|
'projects': projects,
|
|
}
|
|
return render(request, 'listing_pages/projects.html', context)
|
|
|
|
|
|
@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)
|
|
|
|
|
|
@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)
|
|
|
|
|
|
@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)
|
|
|
|
@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)
|
|
|
|
|
|
@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)
|
|
|
|
|
|
@login_required
|
|
def references(request):
|
|
references = Reference.objects.all().order_by('-id')
|
|
|
|
context = {
|
|
'references' : references,
|
|
|
|
|
|
}
|
|
return render(request, 'listing_pages/references.html', context)
|
|
|
|
|
|
@login_required
|
|
def tags(request):
|
|
tags = Tag.objects.all().order_by('-id')
|
|
|
|
context = {
|
|
'tags' : tags,
|
|
}
|
|
|
|
return render(request, 'listing_pages/tags.html', context)
|
|
|
|
|
|
|
|
def daily_reports(request):
|
|
|
|
dailyreports = DailyReport.objects.all().order_by('-id')
|
|
|
|
context = {
|
|
'dailyreports' : dailyreports,
|
|
|
|
|
|
}
|
|
return render(request, 'listing_pages/daily-reports.html', context)
|
|
|
|
@login_required
|
|
def businesses(request):
|
|
businesses = Business.objects.all().order_by('-business_id')
|
|
context = {
|
|
'businesses' : businesses,
|
|
|
|
}
|
|
return render(request, 'listing_pages/businesses.html', context)
|
|
|
|
@login_required
|
|
def staffs(request):
|
|
staffs = StaffProfile.objects.all().order_by('-staff_id')
|
|
|
|
context = {
|
|
'staffs' : staffs,
|
|
|
|
|
|
}
|
|
return render(request, 'listing_pages/staffs.html', context)
|
|
|
|
@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)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#Details pages
|
|
@login_required
|
|
def detailed_project(request, project_id):
|
|
project = get_object_or_404(Project, project_id=project_id)
|
|
epics = Epic.objects.filter(project=project)
|
|
latest_epic = Epic.objects.filter(project=project).last()
|
|
|
|
project_notes = Note.objects.filter(project=project).order_by('-id')
|
|
|
|
if latest_epic:
|
|
epics = epics.exclude(pk=latest_epic.pk)
|
|
|
|
selected_epic_id = request.GET.get('epic_id')
|
|
|
|
if selected_epic_id:
|
|
selected_epic = get_object_or_404(Epic, id=selected_epic_id)
|
|
related_tasks = Task.objects.filter(epic=selected_epic)
|
|
else:
|
|
selected_epic = None
|
|
related_tasks = []
|
|
|
|
context = {
|
|
'project': project,
|
|
'epics': epics,
|
|
'selected_epic': selected_epic,
|
|
'related_tasks': related_tasks,
|
|
'latest_epic': latest_epic,
|
|
'project_notes' : project_notes,
|
|
}
|
|
|
|
return render(request, 'details_pages/project-details.html', context)
|
|
|
|
|
|
|
|
@login_required
|
|
def customerdetails(request, customer_id):
|
|
customer = get_object_or_404(CustomerProfile, customer_id=customer_id)
|
|
context = {
|
|
'customer' : customer,
|
|
|
|
}
|
|
return render(request, 'details_pages/customer-details.html', context)
|
|
|
|
@login_required
|
|
def businessdetails(request, business_id):
|
|
business = get_object_or_404(Business, business_id=business_id)
|
|
context = {
|
|
'business' : business,
|
|
|
|
}
|
|
return render(request, 'details_pages/business-details.html', context)
|
|
|
|
@login_required
|
|
def staffdetails( request, staff_id):
|
|
staff = get_object_or_404(StaffProfile, staff_id=staff_id)
|
|
|
|
context = {
|
|
'staff' : staff,
|
|
}
|
|
return render(request, 'details_pages/staff-details.html', context)
|
|
|
|
|
|
@login_required
|
|
def detailed_task(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_pages/task-details.html', context)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#Add Pages
|
|
@login_required
|
|
def createtask_project(request, project_id):
|
|
project = get_object_or_404(Project, project_id=project_id)
|
|
epics_of_my_project = Epic.objects.filter(project=project)
|
|
staffs = StaffProfile.objects.all().order_by('-id')
|
|
context = {
|
|
|
|
'project' : project,
|
|
'epics_of_my_project' : epics_of_my_project,
|
|
'staffs' : staffs,
|
|
|
|
}
|
|
return render(request, 'add_pages/createtask-project.html', context)
|
|
|
|
|
|
@login_required
|
|
def create_user_story_task(request, requirement_id):
|
|
requirement = get_object_or_404(ProjectRequirement, id=requirement_id)
|
|
members_list = list(requirement.project.members.all())
|
|
|
|
context = {
|
|
'requirement' : requirement,
|
|
'members_list' : members_list,
|
|
|
|
|
|
}
|
|
return render(request, 'add_pages/create-user-story-task.html', context)
|
|
|
|
|
|
@login_required
|
|
def create_project(request):
|
|
staffs = StaffProfile.objects.all().order_by('-id')
|
|
project_types = ProjectType.objects.all()
|
|
customers = CustomerProfile.objects.all().order_by('-id')
|
|
context = {
|
|
'staffs' : staffs,
|
|
'project_types' : project_types,
|
|
'customers' : customers,
|
|
|
|
}
|
|
return render(request, 'add_pages/create-project.html', context)
|
|
|
|
@login_required
|
|
def create_epic(request, project_id):
|
|
project = get_object_or_404(Project, project_id=project_id)
|
|
|
|
context = {
|
|
'project' : project,
|
|
|
|
|
|
}
|
|
return render(request, 'add_pages/create-epic.html', context)
|
|
|
|
@login_required
|
|
def create_task(request):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'add_pages/create-task.html', context)
|
|
|
|
|
|
@login_required
|
|
def createtask_epic(request):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'add_pages/createtask-epic.html', context)
|
|
|
|
@login_required
|
|
def add_customer(request):
|
|
businesses = Business.objects.all().order_by('-id')
|
|
references = Reference.objects.all().order_by('-id')
|
|
business_types = BusinessType.objects.all().order_by('-id')
|
|
|
|
context = {
|
|
'businesses' : businesses,
|
|
'references' :references,
|
|
'business_types' : business_types
|
|
|
|
}
|
|
return render(request, 'add_pages/add-customer.html', context)
|
|
|
|
|
|
@login_required
|
|
def addbusiness(request):
|
|
business_types = BusinessType.objects.all().order_by('-id')
|
|
|
|
context = {
|
|
'business_types': business_types,
|
|
}
|
|
|
|
return render(request, 'add_pages/add-business.html', context)
|
|
|
|
|
|
|
|
@login_required
|
|
def addstaff(request):
|
|
|
|
staffpositions = StaffPosition.objects.all().order_by('-id')
|
|
|
|
context = {
|
|
|
|
'staffpositions' : staffpositions,
|
|
|
|
|
|
}
|
|
return render(request, 'add_pages/add-staff.html', context)
|
|
|
|
|
|
|
|
|
|
def add_daily_report(request):
|
|
user = request.user
|
|
today = date.today()
|
|
statuses = Status.objects.filter(staff=user.staffprofile, date=today)
|
|
|
|
context = {
|
|
'statuses': statuses,
|
|
|
|
|
|
}
|
|
return render(request, 'add_pages/add-daily-report.html', context)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Modals views
|
|
def add_note_modal(request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'popup_modals/addnote-modal.html', context)
|
|
|
|
|
|
def add_project_note_modal(request, project_id):
|
|
project = get_object_or_404(Project, project_id=project_id)
|
|
|
|
context = {
|
|
'project' : project
|
|
}
|
|
|
|
return render(request, 'popup_modals/add-project-note-modal.html', context)
|
|
|
|
|
|
def add_status_modal(request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'popup_modals/addstatus-modal.html', context)
|
|
|
|
def add_file_modal(request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'popup_modals/addfile-modal.html', context)
|
|
|
|
def add_credentials_modal(request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'popup_modals/addcredentials-modal.html', context)
|
|
|
|
|
|
def add_point_modal(request, task_id):
|
|
task = get_object_or_404(Task, task_id=task_id)
|
|
context = {
|
|
'task' : task,
|
|
|
|
}
|
|
return render(request, 'popup_modals/addpoint-modal.html', context)
|
|
|
|
def add_time_modal(request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'popup_modals/addtime-modal.html', context)
|
|
|
|
|
|
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, 'popup_modals/showpoints-modal.html', context)
|
|
|
|
def timeline_modal(request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'popup_modals/timeline-modal.html', context)
|
|
|
|
|
|
def update_status_modal(request, *, task_id):
|
|
task = get_object_or_404(Task, task_id=task_id)
|
|
|
|
if request.method == 'POST':
|
|
status = request.POST.get('status')
|
|
task.status = status
|
|
task.save()
|
|
|
|
# Reload the parent page using JavaScript
|
|
response = HttpResponse('<script>window.top.location.reload();</script>')
|
|
return response
|
|
|
|
context = {
|
|
'task' : task,
|
|
}
|
|
|
|
return render(request, 'popup_modals/update-status-modal.html', context)
|
|
|
|
|
|
def add_projecttype_modal(request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'popup_modals/addprojecttype-modal.html', context)
|
|
|
|
|
|
def add_businesstype_modal(request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'popup_modals/addbusinesstype-modal.html', context)
|
|
|
|
|
|
|
|
def add_reference_modal(request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'popup_modals/addreference-modal.html', context)
|
|
|
|
|
|
|
|
def add_tag_modal(request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'popup_modals/addtag-modal.html', context)
|
|
|
|
|
|
|
|
def add_business_modal(request, *args, **kwargs):
|
|
|
|
context = {
|
|
|
|
}
|
|
|
|
return render(request, 'popup_modals/addbusiness-modal.html', context)
|
|
|
|
|
|
|
|
def add_user_story_modal(request, project_id):
|
|
project = get_object_or_404(Project, project_id=project_id)
|
|
if request.method == 'POST':
|
|
content = request.POST.get('content')
|
|
|
|
story = ProjectRequirement(
|
|
content = content,
|
|
project = project,
|
|
added_by = request.user,
|
|
)
|
|
story.save()
|
|
# Reload the parent page using JavaScript
|
|
response = HttpResponse('<script>window.top.location.reload();</script>')
|
|
return response
|
|
|
|
|
|
context = {
|
|
|
|
'project' : project,
|
|
|
|
}
|
|
|
|
return render(request, 'popup_modals/add-userstory-modal.html', context)
|
|
|
|
|
|
|
|
def staff_position_modal(request):
|
|
|
|
context = {
|
|
|
|
|
|
}
|
|
return render(request, 'popup_modals/add-staffposition-modal.html', context)
|
|
|
|
|
|
def status_mobile_modal (request, *args, **kwargs):
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'popup_modals/status-on-mobile-modal.html', context)
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#FETCH EPIC RELATED TASKS
|
|
def get_tasks (request, epic_id):
|
|
epic = get_object_or_404(Epic, id=epic_id)
|
|
related_tasks = Task.objects.filter(epic_id=epic).order_by('-id')
|
|
|
|
context = {
|
|
'epic': epic,
|
|
'related_tasks': related_tasks,
|
|
}
|
|
|
|
return render(request, 'epic-fetched-tasks.html', context)
|
|
|
|
|
|
# TO FETCH THE LATEST EPIC AND ITS TASKS
|
|
def get_latest_epic(request, project_id):
|
|
try:
|
|
project = get_object_or_404(Project, id=project_id)
|
|
latest_epic = Epic.objects.filter(project=project).order_by('-id').first()
|
|
|
|
if latest_epic:
|
|
related_tasks = Task.objects.filter(epic=latest_epic)
|
|
else:
|
|
related_tasks = []
|
|
|
|
context = {
|
|
'latest_epic': latest_epic,
|
|
'related_tasks': related_tasks,
|
|
}
|
|
|
|
return render(request, 'epic-fetched-tasks.html', context)
|
|
except Http404:
|
|
# Handle case where the specified project does not exist
|
|
return HttpResponseServerError("Project not found")
|
|
except Exception as e:
|
|
# Log the error or return a specific error response
|
|
print(f"An error occurred: {str(e)}")
|
|
return HttpResponseServerError("Internal Server Error")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#Save Functions
|
|
@login_required
|
|
def save_note(request):
|
|
if request.method == 'POST':
|
|
text = request.POST.get('note_text')
|
|
color = request.POST.get('note_color')
|
|
user = request.user
|
|
date = timezone.now()
|
|
|
|
note = Note(
|
|
text=text,
|
|
color=color,
|
|
user=user,
|
|
date=date,
|
|
)
|
|
note.save()
|
|
|
|
# Reload the parent page
|
|
return HttpResponse('<script>window.top.location.reload();</script>')
|
|
|
|
return render(request, 'addnote-modal.html')
|
|
|
|
|
|
def save_project_note(request):
|
|
|
|
if request.method == 'POST':
|
|
text = request.POST.get('note_text')
|
|
color = request.POST.get('note_color')
|
|
user = request.user
|
|
date = timezone.now()
|
|
|
|
project_id = request.POST.get('project')
|
|
project = get_object_or_404(Project, id=project_id)
|
|
|
|
note = Note(
|
|
text=text,
|
|
color=color,
|
|
user=user,
|
|
date=date,
|
|
project=project,
|
|
)
|
|
note.save()
|
|
|
|
return HttpResponse('<script>window.top.location.reload();</script>')
|
|
|
|
return render(request, 'add-project-note-modal.html')
|
|
|
|
|
|
|
|
@login_required
|
|
def save_project(request):
|
|
if request.method == 'POST':
|
|
name = request.POST.get('name')
|
|
customer_username = request.POST.get('customer')
|
|
manager_username = request.POST.get('manager')
|
|
project_type = request.POST.getlist('project_type')
|
|
details = request.POST.get('details')
|
|
members_usernames = request.POST.getlist('members')
|
|
status = request.POST.get('status')
|
|
start_date = request.POST.get('start_date')
|
|
end_date = request.POST.get('end_date')
|
|
|
|
try:
|
|
customer_profile = CustomerProfile.objects.get(user__username=customer_username)
|
|
manager_profile = StaffProfile.objects.get(user__username=manager_username)
|
|
members_profiles = StaffProfile.objects.filter(user__username__in=members_usernames)
|
|
except (CustomerProfile.DoesNotExist, StaffProfile.DoesNotExist):
|
|
# Handle the case where customer_profile or manager_profile is not found
|
|
pass
|
|
|
|
# Create and save the project
|
|
project = Project(
|
|
name=name,
|
|
customer=customer_profile,
|
|
manager=manager_profile,
|
|
details=details,
|
|
status=status,
|
|
start_date=start_date,
|
|
end_date=end_date,
|
|
)
|
|
project.save()
|
|
|
|
project.project_type.set(project_type)
|
|
project.members.set(members_profiles)
|
|
|
|
# Save project requirements
|
|
requirements = request.POST.getlist('requirements')
|
|
for requirement_content in requirements:
|
|
if requirement_content:
|
|
requirement = ProjectRequirement(content=requirement_content, project=project, added_by=request.user)
|
|
requirement.save()
|
|
|
|
return redirect('my-projects')
|
|
|
|
|
|
|
|
@login_required
|
|
def save_epic(request):
|
|
if request.method == 'POST':
|
|
title = request.POST.get('title')
|
|
status = request.POST.get('status')
|
|
description = request.POST.get('description')
|
|
|
|
|
|
project_id = request.POST.get('project')
|
|
project = get_object_or_404(Project, id=project_id)
|
|
|
|
|
|
start_date = request.POST.get('start_date')
|
|
end_date = request.POST.get('end_date')
|
|
|
|
|
|
epic = Epic(
|
|
title=title,
|
|
status=status,
|
|
project=project,
|
|
description=description,
|
|
start_date=start_date,
|
|
end_date=end_date
|
|
)
|
|
|
|
|
|
epic.save()
|
|
|
|
# Redirect to the detailed project page
|
|
redirect_url = reverse('detailed-project', args=[project.project_id])
|
|
return redirect(redirect_url)
|
|
|
|
|
|
|
|
@login_required
|
|
def save_task(request):
|
|
if request.method == 'POST':
|
|
name = request.POST.get('name')
|
|
status = request.POST.get('status')
|
|
extra = request.POST.get('extra')
|
|
description = request.POST.get('description')
|
|
start_date = request.POST.get('start_date')
|
|
end_date = request.POST.get('end_date')
|
|
requirement_id = request.POST.get('requirement')
|
|
|
|
if requirement_id:
|
|
requirement = get_object_or_404(ProjectRequirement, id =requirement_id)
|
|
|
|
else:
|
|
requirement = None
|
|
|
|
|
|
project_id = request.POST.get('project')
|
|
project = get_object_or_404(Project, id=project_id)
|
|
|
|
epic_id = request.POST.get('epic')
|
|
epic = get_object_or_404(Epic, id=epic_id)
|
|
|
|
|
|
assigned_to_id = request.POST.get('assigned_to')
|
|
assigned_to = get_object_or_404(StaffProfile, id=assigned_to_id)
|
|
|
|
task = Task(
|
|
name=name,
|
|
status=status,
|
|
project=project,
|
|
epic=epic,
|
|
extra=extra,
|
|
description=description,
|
|
start_date=start_date,
|
|
end_date=end_date,
|
|
assigned_to = assigned_to,
|
|
requirement = requirement,
|
|
|
|
)
|
|
|
|
# Save the Task object to the database
|
|
task.save()
|
|
|
|
|
|
# Redirect to the task detailed page
|
|
task_details_url = reverse('detailed-task', args=[task.task_id])
|
|
if requirement:
|
|
return redirect('detailed-project', project_id=project.project_id)
|
|
else:
|
|
return HttpResponseRedirect(task_details_url)
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
def save_business(request):
|
|
if request.method == 'POST':
|
|
name = request.POST.get('name')
|
|
email= request.POST.get('email')
|
|
financial_number = request.POST.get('financial_number')
|
|
phone_number = request.POST.get('phone_number')
|
|
vat = request.POST.get('vat')
|
|
if vat == 'true':
|
|
vat = True
|
|
else:
|
|
vat = False
|
|
commercial_registration = request.POST.get('commercial_registration')
|
|
website = request.POST.get('website')
|
|
logo = request.FILES.get('logo')
|
|
|
|
business_type_id = request.POST.get('type')
|
|
|
|
business_type = get_object_or_404(BusinessType, id=business_type_id)
|
|
|
|
business = Business(
|
|
name = name,
|
|
email = email,
|
|
financial_number = financial_number,
|
|
vat = vat,
|
|
commercial_registration = commercial_registration,
|
|
website = website,
|
|
type=business_type,
|
|
logo = logo,
|
|
phone_number = phone_number,
|
|
)
|
|
business.save()
|
|
|
|
return redirect(businesses)
|
|
|
|
|
|
@login_required
|
|
def save_business_modal(request):
|
|
if request.method == 'POST':
|
|
name = request.POST.get('name')
|
|
email = request.POST.get('email')
|
|
financial_number = request.POST.get('financial_number')
|
|
phone_number = request.POST.get('phone_number')
|
|
vat = request.POST.get('vat')
|
|
if vat == 'true':
|
|
vat = True
|
|
else:
|
|
vat = False
|
|
commercial_registration = request.POST.get('commercial_registration')
|
|
website = request.POST.get('website')
|
|
logo = request.FILES.get('logo')
|
|
|
|
business_type_id = request.POST.get('type')
|
|
business_type = get_object_or_404(BusinessType, id=business_type_id)
|
|
|
|
business = Business(
|
|
name=name,
|
|
email=email,
|
|
financial_number=financial_number,
|
|
vat=vat,
|
|
commercial_registration=commercial_registration,
|
|
website=website,
|
|
type=business_type,
|
|
logo=logo,
|
|
phone_number=phone_number,
|
|
)
|
|
business.save()
|
|
|
|
|
|
businesses = Business.objects.all()
|
|
|
|
updated_options = [{'id': business.id, 'name': business.name} for business in businesses]
|
|
|
|
|
|
return JsonResponse(updated_options, safe=False)
|
|
|
|
|
|
return render(request, 'addbusiness-modal.html')
|
|
|
|
|
|
def save_customer(request):
|
|
if request.method == 'POST':
|
|
email = request.POST.get('email').lower()
|
|
first_name = request.POST.get('first_name')
|
|
last_name = request.POST.get('last_name')
|
|
business_id = request.POST.get('business')
|
|
business = get_object_or_404(Business, id=business_id)
|
|
username = f"{first_name.lower()}{last_name.lower()}"
|
|
original_username = username
|
|
counter = 1
|
|
|
|
while User.objects.filter(username=username).exists():
|
|
username = f"{original_username.lower()}{counter}"
|
|
counter += 1
|
|
|
|
user = User.objects.create_user(
|
|
username=username,
|
|
email=email,
|
|
password=request.POST.get('password2')
|
|
)
|
|
user.first_name = first_name.lower().capitalize()
|
|
user.last_name = last_name.lower().capitalize()
|
|
user.save()
|
|
|
|
|
|
referenceid = request.POST.get('referenceid')
|
|
reference = get_object_or_404(Reference, id=referenceid)
|
|
|
|
CustomerProfile.objects.create(
|
|
user=user,
|
|
mobile_number = request.POST.get('mobile_number'),
|
|
personal_website = request.POST.get('personal_website'),
|
|
status = request.POST.get('status'),
|
|
reference = reference,
|
|
business = business,
|
|
)
|
|
return redirect('customers')
|
|
|
|
|
|
|
|
def save_staff(request):
|
|
if request.method == 'POST':
|
|
email = request.POST.get('email').lower()
|
|
first_name = request.POST.get('first_name')
|
|
last_name = request.POST.get('last_name')
|
|
username = f"{first_name.lower()}{last_name.lower()}"
|
|
original_username = username
|
|
counter = 1
|
|
|
|
while User.objects.filter(username=username).exists():
|
|
username = f"{original_username.lower()}{counter}"
|
|
counter += 1
|
|
|
|
user = User.objects.create_user(
|
|
username=username,
|
|
email=email,
|
|
password= request.POST.get('password2')
|
|
)
|
|
user.first_name = first_name.lower().capitalize()
|
|
user.last_name = last_name.lower().capitalize()
|
|
user.save()
|
|
|
|
staff_positionid = request.POST.get('staff_position')
|
|
staff_position = get_object_or_404(StaffPosition, id=staff_positionid)
|
|
|
|
StaffProfile.objects.create(
|
|
user=user,
|
|
image = request.FILES.get('image'),
|
|
mobile_number = request.POST.get('mobile_number'),
|
|
active = request.POST.get('active'),
|
|
intern = request.POST.get('intern'),
|
|
staff_position = staff_position,
|
|
)
|
|
return redirect('users')
|
|
|
|
|
|
|
|
@login_required
|
|
def save_status(request):
|
|
if request.method == 'POST':
|
|
text = request.POST.get('text')
|
|
current_datetime = datetime.now()
|
|
date = datetime.now().date()
|
|
time = current_datetime.strftime("%I:%M %p")
|
|
|
|
try:
|
|
staff_profile = StaffProfile.objects.get(user=request.user)
|
|
except StaffProfile.DoesNotExist:
|
|
# Handle the case where a StaffProfile does not exist for the user
|
|
staff_profile = None
|
|
|
|
status = Status(
|
|
text=text,
|
|
staff=staff_profile,
|
|
date=date,
|
|
time = time,
|
|
)
|
|
status.save()
|
|
|
|
# Reload the parent page
|
|
return HttpResponse('<script>window.top.location.reload();</script>')
|
|
|
|
return render(request, 'addstatus-modal.html')
|
|
|
|
|
|
|
|
@login_required
|
|
def save_projecttype(request):
|
|
if request.method == 'POST':
|
|
name = request.POST.get('name')
|
|
|
|
|
|
projecttype = ProjectType(
|
|
name = name,
|
|
|
|
)
|
|
projecttype.save()
|
|
|
|
|
|
# Reload the parent page
|
|
return HttpResponse('<script>window.top.location.reload();</script>')
|
|
|
|
return redirect('projecttypes')
|
|
|
|
|
|
@login_required
|
|
def save_businesstype(request):
|
|
if request.method == 'POST':
|
|
name = request.POST.get('name')
|
|
|
|
|
|
businesstype = BusinessType(
|
|
name = name,
|
|
)
|
|
businesstype.save()
|
|
|
|
|
|
# Reload the parent page
|
|
return HttpResponse('<script>window.top.location.reload();</script>')
|
|
|
|
return redirect('businesstypes')
|
|
|
|
|
|
@login_required
|
|
def save_reference(request):
|
|
if request.method == 'POST':
|
|
name = request.POST.get('name')
|
|
date = request.POST.get('date')
|
|
|
|
|
|
reference = Reference(
|
|
name = name,
|
|
date = date,
|
|
|
|
)
|
|
reference.save()
|
|
|
|
|
|
# Reload the parent page
|
|
return HttpResponse('<script>window.top.location.reload();</script>')
|
|
|
|
return redirect('references')
|
|
|
|
|
|
|
|
@login_required
|
|
def save_tag(request):
|
|
if request.method == 'POST':
|
|
name = request.POST.get('name')
|
|
|
|
|
|
|
|
tag = Tag(
|
|
name = name,
|
|
|
|
|
|
)
|
|
tag.save()
|
|
|
|
# Reload the parent page
|
|
return HttpResponse('<script>window.top.location.reload();</script>')
|
|
|
|
return redirect('tags')
|
|
|
|
|
|
@login_required
|
|
def save_staffposition(request):
|
|
if request.method == 'POST':
|
|
name = request.POST.get('name')
|
|
|
|
|
|
|
|
staffposition = StaffPosition(
|
|
name = name,
|
|
|
|
|
|
)
|
|
staffposition.save()
|
|
|
|
# Reload the parent page
|
|
return HttpResponse('<script>window.top.location.reload();</script>')
|
|
|
|
return redirect('staffpositions')
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
def save_point(request):
|
|
if request.method == 'POST':
|
|
text = request.POST.get('text')
|
|
task = request.POST.get('task')
|
|
|
|
taskobj = get_object_or_404(Task, id=task)
|
|
|
|
|
|
point = Point(
|
|
text = text,
|
|
task = taskobj,
|
|
status='Not Completed'
|
|
)
|
|
point.save()
|
|
|
|
# Redirect back to the same page
|
|
return redirect(request.META.get('HTTP_REFERER', ''))
|
|
|
|
|
|
return render(request, 'addpoint-modal.html')
|
|
|
|
|
|
|
|
@login_required
|
|
def save_dailyreport(request):
|
|
if request.method == 'POST':
|
|
text = request.POST.get('text')
|
|
current_datetime = datetime.now()
|
|
date = datetime.now().date()
|
|
time = current_datetime.strftime("%I:%M %p")
|
|
try:
|
|
staff_profile = StaffProfile.objects.get(user=request.user)
|
|
except StaffProfile.DoesNotExist:
|
|
# Handle the case where a StaffProfile does not exist for the user
|
|
staff_profile = None
|
|
|
|
|
|
dailyreport = DailyReport(
|
|
text = text,
|
|
date = date,
|
|
time = time,
|
|
staff = staff_profile
|
|
)
|
|
dailyreport.save()
|
|
|
|
|
|
return redirect('dailyreports')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# EDIT TEMPLATES
|
|
@login_required
|
|
def edit_project(request, project_id):
|
|
project = get_object_or_404(Project, project_id=project_id)
|
|
|
|
staffs = StaffProfile.objects.all().order_by('-id')
|
|
current_manager = project.manager
|
|
customers = CustomerProfile.objects.all().order_by('-id')
|
|
current_client = project.customer
|
|
types = ProjectType.objects.all().order_by('-id')
|
|
|
|
|
|
if request.method == 'POST':
|
|
|
|
project.name = request.POST.get('name')
|
|
|
|
new_customer_id = request.POST.get('customer')
|
|
customer = get_object_or_404(CustomerProfile, id=new_customer_id)
|
|
project.customer = customer
|
|
|
|
new_manager_id = request.POST.get('manager')
|
|
manager = get_object_or_404(StaffProfile, id=new_manager_id)
|
|
project.manager = manager
|
|
|
|
|
|
members_ids = request.POST.getlist('members')
|
|
members_profiles = StaffProfile.objects.filter(id__in=members_ids)
|
|
project.members.set(members_profiles)
|
|
|
|
|
|
project.status = request.POST.get('status')
|
|
|
|
|
|
type_ids = request.POST.getlist('types')
|
|
types = ProjectType.objects.filter(id__in=type_ids)
|
|
project.project_type.set(type_ids)
|
|
|
|
|
|
project.details = request.POST.get('details')
|
|
project.start_date = request.POST.get('start_date')
|
|
project.end_date = request.POST.get('end_date')
|
|
|
|
|
|
project.save()
|
|
return redirect('detailed-project', project_id=project.project_id)
|
|
|
|
|
|
|
|
context = {
|
|
|
|
'project' : project,
|
|
'staffs' : staffs,
|
|
'current_manager' : current_manager,
|
|
'customers' : customers,
|
|
'current_client' : current_client,
|
|
'types' : types,
|
|
|
|
|
|
}
|
|
return render(request, 'edit_pages/edit-project.html', context)
|
|
|
|
|
|
|
|
@login_required
|
|
def edit_epic(request, *args, **kwargs):
|
|
|
|
context = {
|
|
|
|
}
|
|
return render(request, 'edit_pages/edit-epic.html', context)
|
|
|
|
|
|
@login_required
|
|
def edit_task(request, task_id):
|
|
task = get_object_or_404(Task, task_id=task_id)
|
|
projects = Project.objects.all().order_by('-id')
|
|
staffs = StaffProfile.objects.all().order_by('-id')
|
|
|
|
selected_project_id = request.POST.get('project', task.project.id) if request.method == 'POST' else task.project.id
|
|
epics_of_my_project = Epic.objects.filter(project_id=selected_project_id)
|
|
|
|
if request.method == 'POST':
|
|
task.name = request.POST.get('name')
|
|
|
|
# Convert project ID to a Project instance
|
|
project_id = request.POST.get('project')
|
|
project = get_object_or_404(Project, id=project_id)
|
|
task.project = project
|
|
|
|
# Convert epic ID to an Epic instance
|
|
epic_id = request.POST.get('epic')
|
|
epic = get_object_or_404(Epic, id=epic_id)
|
|
task.epic = epic
|
|
|
|
task.requirement = request.POST.get('requirement')
|
|
task.status = request.POST.get('status')
|
|
|
|
# Convert assigned_to ID to a StaffProfile instance
|
|
assigned_to_id = request.POST.get('assigned_to')
|
|
assigned_to = get_object_or_404(StaffProfile, id=assigned_to_id)
|
|
task.assigned_to = assigned_to
|
|
|
|
task.description = request.POST.get('description')
|
|
task.start_date = request.POST.get('start_date')
|
|
task.end_date = request.POST.get('end_date')
|
|
|
|
task.save()
|
|
return redirect('detailed-task', task_id=task.task_id)
|
|
|
|
context = {
|
|
'task': task,
|
|
'projects': projects,
|
|
'epics_of_my_project': epics_of_my_project,
|
|
'staffs': staffs,
|
|
}
|
|
return render(request, 'edit_pages/edit-task.html', context)
|
|
|
|
|
|
|
|
|
|
# TO FETCH THE EPICS OF THE SELECTED PROJECT WHEN EDITING A TASK
|
|
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)})
|
|
|
|
|
|
@login_required
|
|
def edit_customer(request, customer_id):
|
|
customer = get_object_or_404(CustomerProfile, customer_id=customer_id)
|
|
|
|
#Utilities
|
|
references = Reference.objects.all()
|
|
businesses = Business.objects.all
|
|
customer_status = customer.status
|
|
customer_reference = customer.reference
|
|
customer_business = customer.business
|
|
|
|
|
|
if request.method == 'POST':
|
|
|
|
customer.user.first_name = request.POST.get('first_name')
|
|
customer.user.last_name = request.POST.get('last_name')
|
|
customer.user.email = request.POST.get('email')
|
|
customer.user.save()
|
|
customer.mobile_number = request.POST.get('mobile_number')
|
|
customer.personal_website = request.POST.get('personal_website')
|
|
customer.status = request.POST.get('status')
|
|
|
|
customer_reference = request.POST.get('reference')
|
|
reference = get_object_or_404(Reference, id=customer_reference)
|
|
customer.reference = reference
|
|
|
|
if customer.business:
|
|
customer_business = request.POST.get('business')
|
|
business = get_object_or_404(Business, id=customer_business)
|
|
customer.business = business
|
|
|
|
|
|
|
|
customer.save()
|
|
|
|
|
|
return redirect('customerdetails', customer_id=customer.customer_id)
|
|
|
|
|
|
context = {
|
|
|
|
'customer' : customer,
|
|
'references' : references,
|
|
'businesses' : businesses,
|
|
'customer_status' : customer_status,
|
|
'customer_reference' : customer_reference,
|
|
'customer_business' : customer_business,
|
|
|
|
}
|
|
return render(request, 'edit_pages/edit-customer.html', context)
|
|
|
|
|
|
@login_required
|
|
def edit_business(request, business_id):
|
|
business = get_object_or_404(Business, business_id=business_id)
|
|
business_types = BusinessType.objects.all().order_by('name')
|
|
current_business_type = None
|
|
if business.type:
|
|
current_business_type = business.type
|
|
|
|
|
|
if request.method == 'POST':
|
|
|
|
business.name= request.POST.get('name')
|
|
business.financial_number = request.POST.get('financial_number')
|
|
business.commercial_registration = request.POST.get('commercial_registration')
|
|
business.vat = request.POST.get('vat')
|
|
business.phone_number = request.POST.get('phone_number')
|
|
business.website = request.POST.get('website')
|
|
|
|
|
|
business_type = request.POST.get('business_type')
|
|
type = get_object_or_404(BusinessType, id=business_type)
|
|
business.type = type
|
|
|
|
new_logo = request.FILES.get('logo')
|
|
if new_logo:
|
|
business.logo = new_logo
|
|
|
|
|
|
business.save()
|
|
|
|
|
|
return redirect('businessdetails', business_id=business.business_id)
|
|
|
|
context = {
|
|
'business' : business,
|
|
'business_types' : business_types,
|
|
'current_business_type' : current_business_type,
|
|
|
|
}
|
|
return render(request, 'edit_pages/edit-business.html', context)
|
|
|
|
|
|
@login_required
|
|
def edit_staff(request, staff_id):
|
|
staff = get_object_or_404(StaffProfile, staff_id=staff_id)
|
|
positions = StaffPosition.objects.all().order_by('name')
|
|
current_position = staff.staff_position
|
|
|
|
|
|
if request.method == 'POST':
|
|
|
|
staff.user.first_name= request.POST.get('first_name')
|
|
staff.user.last_name = request.POST.get('last_name')
|
|
staff.user.email = request.POST.get('email')
|
|
staff.user.save()
|
|
|
|
staff.mobile_number = request.POST.get('mobile_number')
|
|
staff.active = request.POST.get('active')
|
|
staff.intern = request.POST.get('intern')
|
|
|
|
new_position_id = request.POST.get('staff_position')
|
|
new_position = get_object_or_404(StaffPosition, id=new_position_id)
|
|
staff.staff_position = new_position
|
|
|
|
|
|
new_image = request.FILES.get('image')
|
|
if new_image:
|
|
staff.image = new_image
|
|
|
|
staff.active = request.POST.get('active') == 'on'
|
|
staff.intern = request.POST.get('intern') == 'on'
|
|
|
|
|
|
staff.save()
|
|
|
|
|
|
return redirect('userdetails', staff_id=staff.staff_id)
|
|
|
|
context = {
|
|
'staff' : staff,
|
|
'positions' : positions,
|
|
'current_position' : current_position,
|
|
|
|
}
|
|
return render(request, 'edit_pages/edit-staff.html', context)
|
|
|
|
|
|
@login_required
|
|
def edit_staff_position(request):
|
|
|
|
context = {
|
|
|
|
|
|
}
|
|
return render(request, 'edit_pages/edit-staff-position.html', context)
|
|
|
|
|
|
@login_required
|
|
def edit_project_type(request, projecttype_id):
|
|
|
|
projecttype = get_object_or_404(ProjectType, id=projecttype_id)
|
|
|
|
if request.method == 'POST':
|
|
projecttype.name = request.POST.get('name')
|
|
projecttype.save()
|
|
|
|
return redirect('projecttypes')
|
|
|
|
return render(request, 'edit_pages/edit-project-type.html', {'projecttype': projecttype})
|
|
|
|
|
|
@login_required
|
|
def edit_business_type(request, businesstype_id):
|
|
|
|
businesstype = get_object_or_404(BusinessType, id=businesstype_id)
|
|
|
|
if request.method == 'POST':
|
|
businesstype.name = request.POST.get('name')
|
|
businesstype.save()
|
|
|
|
return redirect('businesstypes')
|
|
|
|
return render(request, 'edit_pages/edit-business-type.html', {'businesstype': businesstype})
|
|
|
|
|
|
@login_required
|
|
def edit_reference(request, reference_id):
|
|
reference = get_object_or_404(Reference, id=reference_id)
|
|
|
|
if request.method == 'POST':
|
|
reference.name = request.POST.get('name')
|
|
reference.date = request.POST.get('date')
|
|
reference.save()
|
|
|
|
return redirect('references')
|
|
|
|
return render(request, 'edit_pages/edit-reference.html', {'reference': reference})
|
|
|
|
|
|
|
|
@login_required
|
|
def edit_tag(request, tag_id):
|
|
tag = get_object_or_404(Tag, id=tag_id)
|
|
|
|
if request.method == 'POST':
|
|
tag.name = request.POST.get('name')
|
|
tag.save()
|
|
|
|
return redirect('tags')
|
|
|
|
return render(request, 'edit_pages/edit-tag.html', {'tag': tag})
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# TO UPDATE THE STATUS CONTAINER
|
|
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
|
|
def get_latest_activities(request):
|
|
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, # Include latest_statuses_time_ago in the context
|
|
}
|
|
|
|
recent_activities = render_to_string('recent-activities.html', response_data)
|
|
|
|
return HttpResponse(recent_activities)
|
|
|
|
|
|
|
|
|
|
# Delete Popup Modals
|
|
@login_required
|
|
def delete_customer_modal(request, customer_id):
|
|
customer = get_object_or_404(CustomerProfile, id=customer_id)
|
|
|
|
if request.method == 'POST':
|
|
customer.delete()
|
|
return redirect('customers')
|
|
|
|
context = {
|
|
'customer': customer,
|
|
}
|
|
return render(request, "delete_modals/delete-customer-modal.html", context)
|
|
|
|
|
|
@login_required
|
|
def delete_note_modal(request, note_id):
|
|
note = get_object_or_404(Note, id=note_id)
|
|
|
|
if request.method == 'POST':
|
|
note.delete()
|
|
return redirect('my-notes')
|
|
|
|
context = {
|
|
'note': note,
|
|
}
|
|
|
|
return render(request, "delete_modals/delete-note-modal.html", context)
|
|
|
|
|
|
@login_required
|
|
def delete_point_modal(request, point_id, task_id):
|
|
task = get_object_or_404(Task, id=task_id)
|
|
point = get_object_or_404(Point, id=point_id)
|
|
|
|
if request.method == 'POST':
|
|
point.delete()
|
|
|
|
task_id_str = task.task_id
|
|
|
|
showpoints_url = reverse('showpoints', args=[task_id_str])
|
|
return HttpResponseRedirect(showpoints_url)
|
|
|
|
|
|
|
|
@login_required
|
|
def delete_task_point_modal(request, point_id, task_id):
|
|
task = get_object_or_404(Task, id=task_id)
|
|
point = get_object_or_404(Point, id=point_id)
|
|
|
|
if request.method == 'POST':
|
|
point.delete()
|
|
|
|
task_id_str = task.task_id
|
|
|
|
task_details_url = reverse('detailed-task', args=[task_id_str])
|
|
return HttpResponseRedirect(task_details_url)
|
|
|
|
|
|
|
|
@login_required
|
|
def delete_project_note_modal(request, note_id):
|
|
note = get_object_or_404(Note, id=note_id)
|
|
|
|
if request.method == 'POST':
|
|
project_id = note.project_id
|
|
project = get_object_or_404(Project, id=project_id)
|
|
note.delete()
|
|
|
|
return redirect('detailed-project', project_id=project.project_id)
|
|
|
|
context = {
|
|
'note': note,
|
|
}
|
|
|
|
return render(request, "delete_modals/delete-project-note-modal.html", context)
|
|
|
|
|
|
|
|
@login_required
|
|
def delete_business_modal(request, business_id):
|
|
business = get_object_or_404(Business, id=business_id)
|
|
|
|
if request.method == 'POST':
|
|
business.delete()
|
|
return redirect('businesses')
|
|
|
|
context = {
|
|
'business': business,
|
|
}
|
|
return render(request, "delete_modals/delete-business-modal.html", context)
|
|
|
|
|
|
@login_required
|
|
def delete_staff_modal(request, staff_id):
|
|
staff = get_object_or_404(StaffProfile, id=staff_id)
|
|
|
|
if request.method == 'POST':
|
|
staff.delete()
|
|
return redirect('users')
|
|
|
|
context = {
|
|
'staff': staff,
|
|
}
|
|
return render(request, "delete_modals/delete-staff-modal.html", context)
|
|
|
|
|
|
@login_required
|
|
def delete_project_modal(request, project_id):
|
|
project = get_object_or_404(Project, id=project_id)
|
|
|
|
if request.method == 'POST':
|
|
project.delete()
|
|
return redirect('my-projects')
|
|
|
|
context = {
|
|
'project': project,
|
|
}
|
|
return render(request, "delete_modals/delete-project-modal.html", context)
|
|
|
|
|
|
@login_required
|
|
def delete_task_modal(request, task_id):
|
|
task = get_object_or_404(Task, id=task_id)
|
|
|
|
if request.method == 'POST':
|
|
task.delete()
|
|
return redirect('my-tasks')
|
|
|
|
context = {
|
|
'task': task,
|
|
}
|
|
return render(request, "delete_modals/delete-task-modal.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#Mark points
|
|
|
|
@login_required
|
|
def mark_point_working_on(request, point_id, task_id):
|
|
task = get_object_or_404(Task, id=task_id)
|
|
point = get_object_or_404(Point, id=point_id)
|
|
point.status = 'Working On'
|
|
current_datetime = datetime.now()
|
|
|
|
point.save()
|
|
|
|
activity = PointActivity(
|
|
point = point,
|
|
start_time = datetime.now(),
|
|
)
|
|
activity.save()
|
|
|
|
if PointActivity.objects.filter(point=point).count() == 1:
|
|
status_text = f'Started Working On: {point.text}'
|
|
status = Status(text=status_text, date=current_datetime.date(), time=current_datetime.strftime("%I:%M %p"), staff=request.user.staffprofile)
|
|
status.save()
|
|
else:
|
|
status_text = f'Resumed Working On: {point.text}'
|
|
status = Status(text=status_text, date=current_datetime.date(), time=current_datetime.strftime("%I:%M %p"), staff=request.user.staffprofile)
|
|
status.save()
|
|
|
|
|
|
|
|
task_id_str = task.task_id
|
|
|
|
showpoints_url = reverse('showpoints', args=[task_id_str])
|
|
return HttpResponseRedirect(showpoints_url)
|
|
|
|
|
|
|
|
@login_required
|
|
def mark_point_working_on_task_page(request, point_id, task_id):
|
|
task = get_object_or_404(Task, id=task_id)
|
|
point = get_object_or_404(Point, id=point_id)
|
|
point.status = 'Working On'
|
|
current_datetime = datetime.now()
|
|
|
|
point.save()
|
|
|
|
activity = PointActivity(
|
|
point = point,
|
|
start_time = datetime.now(),
|
|
)
|
|
activity.save()
|
|
|
|
if PointActivity.objects.filter(point=point).count() == 1:
|
|
status_text = f'Started Working On: {point.text}'
|
|
status = Status(text=status_text, date=current_datetime.date(), time=current_datetime.strftime("%I:%M %p"), staff=request.user.staffprofile)
|
|
status.save()
|
|
else:
|
|
status_text = f'Resumed Working On: {point.text}'
|
|
status = Status(text=status_text, date=current_datetime.date(), time=current_datetime.strftime("%I:%M %p"), staff=request.user.staffprofile)
|
|
status.save()
|
|
|
|
|
|
return redirect('detailed-task', task_id=task.task_id)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
def mark_point_paused(request, point_id, task_id):
|
|
task = get_object_or_404(Task, id=task_id)
|
|
point = get_object_or_404(Point, id=point_id)
|
|
point.status = 'Paused'
|
|
current_datetime = datetime.now()
|
|
|
|
|
|
point.save()
|
|
|
|
last_activity = PointActivity.objects.filter(point=point).last()
|
|
last_activity.end_time = datetime.now()
|
|
last_activity.save()
|
|
|
|
|
|
status_text = f'{point.text} - Paused'
|
|
status = Status(text=status_text, date=current_datetime.date(), time=current_datetime.strftime("%I:%M %p"), staff=request.user.staffprofile)
|
|
status.save()
|
|
|
|
|
|
|
|
task_id_str = task.task_id
|
|
|
|
showpoints_url = reverse('showpoints', args=[task_id_str])
|
|
return HttpResponseRedirect(showpoints_url)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
def mark_point_completed(request, point_id, task_id):
|
|
task = get_object_or_404(Task, id=task_id)
|
|
point = get_object_or_404(Point, id=point_id)
|
|
point.status = 'Completed'
|
|
current_datetime = datetime.now()
|
|
|
|
|
|
point.save()
|
|
|
|
last_activity = PointActivity.objects.filter(point=point).last()
|
|
last_activity.end_time = datetime.now()
|
|
last_activity.save()
|
|
|
|
|
|
status_text = f'{point.text} - Completed'
|
|
status = Status(text=status_text, date=current_datetime.date(), time=current_datetime.strftime("%I:%M %p"), staff=request.user.staffprofile)
|
|
status.save()
|
|
|
|
|
|
|
|
task_id_str = task.task_id
|
|
|
|
showpoints_url = reverse('showpoints', args=[task_id_str])
|
|
return HttpResponseRedirect(showpoints_url)
|
|
|
|
|
|
|
|
@login_required
|
|
def mark_point_completed_task_page(request, point_id, task_id):
|
|
task = get_object_or_404(Task, id=task_id)
|
|
point = get_object_or_404(Point, id=point_id)
|
|
point.status = 'Completed'
|
|
current_datetime = datetime.now()
|
|
|
|
|
|
point.save()
|
|
|
|
|
|
last_activity = PointActivity.objects.filter(point=point).last()
|
|
last_activity.end_time = datetime.now()
|
|
last_activity.save()
|
|
|
|
|
|
status_text = f'{point.text} - Completed'
|
|
status = Status(text=status_text, date=current_datetime.date(), time=current_datetime.strftime("%I:%M %p"), staff=request.user.staffprofile)
|
|
status.save()
|
|
|
|
|
|
|
|
task_id_str = task.task_id
|
|
|
|
return redirect('detailed-task', task_id=task.task_id) |