def task_add_edit(request, polity_id, task_id=None):
polity = get_object_or_404(Polity, id=polity_id)
if not (polity.is_member(request.user)
or polity.is_wrangler(request.user)):
raise PermissionDenied()
if task_id:
task = get_object_or_404(Task, id=task_id, polity=polity)
# We don't want to edit anything that has already done.
if task.is_done:
raise PermissionDenied()
else:
task = Task(polity=polity)
if request.method == 'POST':
form = TaskForm(request.POST, instance=task)
if form.is_valid():
task = form.save()
return redirect(reverse('task_detail', args=(polity_id, task.id)))
else:
form = TaskForm(instance=task)
ctx = {
'polity': polity,
'form': form,
}
return render(request, 'tasks/task_add_edit.html', ctx)
def add_project_task(request, slug):
if request.user.is_authenticated():
project = Project.objects.get(slug=slug)
if request.POST:
form = TaskForm(request.POST)
if form.is_valid():
data = form.cleaned_data
td = data['end_date'] - data['start_date']
if td.total_seconds() > 0:
task = Task()
task.name = data['name']
task.description = data['description']
task.start_date = data['start_date']
task.end_date = data['end_date']
task.user = data['user']
task.project = project
task.save()
else:
messages.add_message(request, messages.ERROR,
" end date is less than start date!")
return (redirect(reverse('Task:add_task')))
return (redirect(reverse('Home:manager')))
else:
messages.add_message(request, messages.ERROR, "invalid form")
return (redirect(reverse('Task:add_task')))
else:
form = TaskForm()
send_dict = {}
context_instance = RequestContext(request)
send_dict['project'] = project
send_dict['form'] = form
return render_to_response('tasks/add_task.html', send_dict,
context_instance)
else:
return redirect(reverse('Login:login'))
def edit(request, task_id):
# if this is a POST request we need to process the form data
current_user = request.user
controller = TaskController(current_user.id)
task = controller.get_task_by_id(task_id)
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = TaskForm(request.POST)
# check whether it's valid:
if form.is_valid():
data = form.cleaned_data
controller.edit_task(
task_id, {
'title': data['title'],
'text': data['text'],
'status': data['status'],
'tags': data['tags']
})
return HttpResponseRedirect('/tasks')
# if a GET (or any other method) we'll create a blank form
else:
form = TaskForm(data=task)
return render(request, 'tasks/edit-task.html', {
'form': form,
'task': task
})
def task_create(request):
if request.method == "GET":
if request.user.role == "ADMIN" or request.user.is_superuser:
users = User.objects.filter(is_active=True).order_by("email")
accounts = Account.objects.filter(status="open")
# elif request.user.google.all():
# users = []
# accounts = Account.objects.filter(created_by=request.user).filter(status="open")
else:
users = User.objects.filter(role="ADMIN").order_by("email")
accounts = Account.objects.filter(
Q(created_by=request.user) | Q(assigned_to__in=[request.user])
).filter(status="open")
form = TaskForm(request_user=request.user, request_obj=request)
return render(
request,
"task_create.html",
{
"form": form,
"users": users.filter(company=request.company),
"accounts": accounts.filter(company=request.company),
"teams": Teams.objects.filter(company=request.company),
},
)
if request.method == "POST":
form = TaskForm(request.POST, request_user=request.user, request_obj=request)
if form.is_valid():
task = form.save(commit=False)
task.created_by = request.user
task.company = request.company
task.save()
task.assigned_to.add(*request.POST.getlist("assigned_to"))
task.contacts.add(*request.POST.getlist("contacts"))
if request.POST.getlist("teams", []):
user_ids = Teams.objects.filter(
id__in=request.POST.getlist("teams")
).values_list("users", flat=True)
assinged_to_users_ids = task.assigned_to.all().values_list(
"id", flat=True
)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
task.assigned_to.add(user_id)
if request.POST.getlist("teams", []):
task.teams.add(*request.POST.getlist("teams"))
kwargs = {"domain": request.get_host(), "protocol": request.scheme}
assigned_to_list = list(task.assigned_to.all().values_list("id", flat=True))
send_email.delay(task.id, assigned_to_list, **kwargs)
success_url = reverse("tasks:tasks_list")
if request.POST.get("from_account"):
success_url = reverse(
"accounts:view_account", args=(request.POST.get("from_account"),)
)
return JsonResponse({"error": False, "success_url": success_url})
else:
return JsonResponse({"error": True, "errors": form.errors})
def post(self, request):
# crear el formulario con los datos del POST
task_with_user = Task(owner=request.user)
form = TaskForm(request.POST, instance=task_with_user)
# validar el formulario
if form.is_valid():
# crear la tarea
task = form.save()
# mostrar mensaje de exito
message = 'Tarea creada con éxito! <a href="{0}">Ver tarea</a>'.format(
reverse('tasks_detail',
args=[task.pk
]) # genera la URL de detalle de esta tarea
)
# limpiamos el formulario creando uno vacío para pasar a la plantilla
form = TaskForm()
else:
# mostrar mensaje de error
message = "Se ha producido un error"
# renderizar la plantilla
context = {"form": form, "message": message}
return render(request, 'tasks/new.html', context)
def task_edit(request, task_id):
task_obj = get_object_or_404(Task, pk=task_id)
accounts = Account.objects.filter(status="open")
if not (request.user.role == 'ADMIN' or request.user.is_superuser or task_obj.created_by == request.user or request.user in task_obj.assigned_to.all()):
raise PermissionDenied
if request.method == 'GET':
if request.user.role == 'ADMIN' or request.user.is_superuser:
users = User.objects.filter(is_active=True).order_by('email')
elif request.user.google.all():
users = []
else:
users = User.objects.filter(role='ADMIN').order_by('email')
# form = TaskForm(request_user=request.user)
form = TaskForm(instance=task_obj, request_user=request.user)
return render(request, 'task_create.html', {'form': form, 'task_obj': task_obj,
'users': users, 'accounts': accounts, "teams": Teams.objects.all(), })
if request.method == 'POST':
form = TaskForm(request.POST, instance=task_obj,
request_user=request.user)
if form.is_valid():
task = form.save(commit=False)
task.updated_by = request.user
previous_assigned_to_users = list(
task_obj.assigned_to.all().values_list('id', flat=True))
task.save()
form.save_m2m()
# task.assigned_to.clear()
# task.contacts.clear()
# task.assigned_to.add(*request.POST.getlist('assigned_to'))
# task.contacts.add(*request.POST.getlist('contacts'))
if request.POST.getlist('teams', []):
user_ids = Teams.objects.filter(id__in=request.POST.getlist(
'teams')).values_list('users', flat=True)
assinged_to_users_ids = task.assigned_to.all().values_list('id', flat=True)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
task.assigned_to.add(user_id)
if request.POST.getlist('teams', []):
task.teams.clear()
task.teams.add(*request.POST.getlist('teams'))
else:
task.teams.clear()
kwargs = {'domain': request.get_host(), 'protocol': request.scheme}
assigned_to_list = list(
task.assigned_to.all().values_list('id', flat=True))
recipients = list(set(assigned_to_list) -
set(previous_assigned_to_users))
send_email.delay(task.id, recipients, **kwargs)
success_url = reverse('tasks:tasks_list')
if request.POST.get('from_account'):
success_url = reverse('accounts:view_account', args=(
request.POST.get('from_account'),))
return JsonResponse({'error': False, 'success_url': success_url})
else:
return JsonResponse({'error': True, 'errors': form.errors})
def task_create(request):
if request.method == 'GET':
if request.user.role == 'ADMIN' or request.user.is_superuser:
users = User.objects.filter(is_active=True).order_by('email')
elif request.user.google.all():
users = []
else:
users = User.objects.filter(role='ADMIN').order_by('email')
form = TaskForm(request_user=request.user)
return render(request, 'task_create.html', {
'form': form,
'users': users
})
if request.method == 'POST':
form = TaskForm(request.POST, request_user=request.user)
if form.is_valid():
task = form.save(commit=False)
task.created_by = request.user
task.save()
task.assigned_to.add(*request.POST.getlist('assigned_to'))
task.contacts.add(*request.POST.getlist('contacts'))
kwargs = {'domain': request.get_host(), 'protocol': request.scheme}
send_email.delay(task.id, **kwargs)
return JsonResponse({
'error': False,
'success_url': reverse('tasks:tasks_list')
})
else:
return JsonResponse({'error': True, 'errors': form.errors})
def add_task(request):
if request.method == 'POST':
form = TaskForm(request.POST)
if form.is_valid():
new_task = Task(description=request.POST.get('description', ''))
new_task.save()
return HttpResponseRedirect(reverse('task-list'))
form = TaskForm()
return render(request, 'tasks/add.html', {'form': form})
def update_task(request, pk):
task = Task.objects.get(id=pk)
form = TaskForm(instance=task)
if request.method == 'POST':
form = TaskForm(request.POST, instance=task)
if form.is_valid():
form.save()
return redirect('/todo/')
return render(request, 'tasks/update_task.html', context={'form': form})
def task_create(request):
if request.method == 'GET':
if request.user.role == 'ADMIN' or request.user.is_superuser:
users = User.objects.filter(is_active=True).order_by('email')
accounts = Account.objects.filter(status="open")
# elif request.user.google.all():
# users = []
# accounts = Account.objects.filter(created_by=request.user).filter(status="open")
else:
users = User.objects.filter(role='ADMIN').order_by('email')
accounts = Account.objects.filter(
Q(created_by=request.user)
| Q(assigned_to__in=[request.user])).filter(status="open")
form = TaskForm(request_user=request.user)
return render(
request, 'task_create.html', {
'form': form,
'users': users,
'accounts': accounts,
"teams": Teams.objects.all(),
})
if request.method == 'POST':
form = TaskForm(request.POST, request_user=request.user)
if form.is_valid():
task = form.save(commit=False)
task.created_by = request.user
task.save()
task.assigned_to.add(*request.POST.getlist('assigned_to'))
task.contacts.add(*request.POST.getlist('contacts'))
if request.POST.getlist('teams', []):
user_ids = Teams.objects.filter(
id__in=request.POST.getlist('teams')).values_list(
'users', flat=True)
assinged_to_users_ids = task.assigned_to.all().values_list(
'id', flat=True)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
task.assigned_to.add(user_id)
if request.POST.getlist('teams', []):
task.teams.add(*request.POST.getlist('teams'))
kwargs = {'domain': request.get_host(), 'protocol': request.scheme}
assigned_to_list = list(task.assigned_to.all().values_list(
'id', flat=True))
send_email.delay(task.id, assigned_to_list, **kwargs)
success_url = reverse('tasks:tasks_list')
if request.POST.get('from_account'):
success_url = reverse(
'accounts:view_account',
args=(request.POST.get('from_account'), ))
return JsonResponse({'error': False, 'success_url': success_url})
else:
return JsonResponse({'error': True, 'errors': form.errors})
def update(request, pk):
task = Task.objects.get(pk=pk)
form = TaskForm(instance=task)
context = {'task': task, 'form': form}
if request.method == 'POST':
form = TaskForm(request.POST, instance=task)
if form.is_valid():
form.save()
return redirect('index')
return render(request, 'tasks/update.html', context)
def index(request):
consulta = Task.objects.all()
form = TaskForm()
if request.method == 'POST':
form = TaskForm(request.POST)
if form.is_valid():
form.save()
return redirect('/')
context = {'info':consulta,'temp':form}
return render(request,"tasks/list.html", context)
def updateTask(request, pk):
item = Task.objects.get(id=pk)
form_update = TaskForm(instance=item)
if request.method == 'POST':
form_update = TaskForm(request.POST, instance = item)
if form_update.is_valid():
form_update.save()
return redirect('/')
context = {'form_update':form_update}
return render(request, 'tasks/update_task.html',context)
def index(request):
tasks = Task.objects.all()
form = TaskForm()
if request.method == 'POST':
form = TaskForm(request.POST)
if form.is_valid():
form.save()
return redirect('/')
context = {'tasks': tasks, 'form': form}
return render(request, 'tasks/list.html', context)
def update_task(request, pk):
"""Updates specific task requested to be updated (recieving pk/id of the task) that belongs to the loggedin user by the loggedin user"""
task = Task.objects.get(id=pk) # getting the requested task as object by id from db.
task_update_form = TaskForm(instance=task) # displaying a form for updating with displaying an instance of the last saved date of the task.
if request.method == "POST": # if request method is POST (which is sent by html form):
task_update_form = TaskForm(request.POST, instance=task) # pass the request POST data to the form and any instance of task data that hasn't got changed
if task_update_form.is_valid(): # if form is valid:
task_update_form.save(commit=True) # save changes recieved from the form to the database.
return redirect("index") # redirect to home page
else: # if form is not valid
messages.info(request, "Invalid data requirements") # create a message to display to the user
return redirect("update_task", pk=pk) # refresh the page of task update of its specific id/pk.
return render(request, "tasks/task_update.html", {"form": task_update_form}) # return rendering the request, the template, and the form as context dictionary.
def task_edit(request, task_id):
task_obj = get_object_or_404(Task, pk=task_id)
if not (request.user.role == 'ADMIN' or request.user.is_superuser
or task_obj.created_by == request.user):
raise PermissionDenied
if request.method == 'GET':
if request.user.role == 'ADMIN' or request.user.is_superuser:
users = User.objects.filter(is_active=True).order_by('email')
elif request.user.google.all():
users = []
else:
users = User.objects.filter(role='ADMIN').order_by('email')
# form = TaskForm(request_user=request.user)
form = TaskForm(instance=task_obj, request_user=request.user)
return render(request, 'task_create.html', {
'form': form,
'task_obj': task_obj,
'users': users
})
if request.method == 'POST':
form = TaskForm(request.POST,
instance=task_obj,
request_user=request.user)
if form.is_valid():
task = form.save(commit=False)
form.save_m2m()
# task.assigned_to.clear()
# task.contacts.clear()
# task.assigned_to.add(*request.POST.getlist('assigned_to'))
# task.contacts.add(*request.POST.getlist('contacts'))
if request.POST.getlist('teams', []):
user_ids = Teams.objects.filter(
id__in=request.POST.getlist('teams')).values_list(
'users', flat=True)
assinged_to_users_ids = task.assigned_to.all().values_list(
'id', flat=True)
for user_id in user_ids:
if user_id not in assinged_to_users_ids:
task.assigned_to.add(user_id)
kwargs = {'domain': request.get_host(), 'protocol': request.scheme}
send_email.delay(task.id, **kwargs)
return JsonResponse({
'error': False,
'success_url': reverse('tasks:tasks_list')
})
else:
return JsonResponse({'error': True, 'errors': form.errors})
def index(request):
tasks = Task.objects.all()
form = TaskForm()
if request.method == "POST":
form = TaskForm(request.POST)
if form.is_valid():
form.save()
else:
print('error')
return redirect('/')
context = {'tasks': tasks, 'form': form}
return render(request, 'tasks/index.html', context)
def create_task(request):
"""Allowing user to create new task."""
task_create_form = TaskForm() # displaying task creation form for the user and taking it to a handler.
if request.method == "POST":
task_create_form = TaskForm(request.POST) # pass the request POST data to the django form.
if task_create_form.is_valid(): # if form is valid:
new_task = task_create_form.save(commit=False) # giving new_task handler the responsibility of what to do after validation, without commiting data the user entered to the db.
new_task.user = request.user # setting the user of task to the loggedin user who sent the request.
new_task.save() # commiting and saving the task to the db.
return redirect("index") # redirect to the home page.
else: # if form is not valid:
messages.info(request, "Invalid data requirements.") # create a message for the user that displays after refreshing the page.
return redirect("create_task") # redirecting the page to itself (refreshing)
else: # if request is not POST
return render(request, "tasks/task_create.html", {"form": task_create_form})
def create_task(request, column_id, board_id):
if request.method == "POST":
column = Column.objects.get(id=column_id)
form = TaskForm(request.POST)
if form.is_valid():
task = form.save(commit=False)
task.column = column
task.author = request.user
task.pub_date = timezone.now()
task.save()
column.task.add(task)
return redirect('/boards/{}'.format(board_id))
else:
form = TaskForm()
return render(request, "tasks/create_task.html", {'form': form})
def newTask():
consulta = """
SELECT id, name, apellidos FROM empleados;
"""
empleados = dbQuery(consulta)
mychoices = [(-1, 'Seleccione Empleado')] + [
(e['id'], '{} {}'.format(e['name'], e['apellidos'])) for e in empleados
]
form = TaskForm(request.form)
form.updateChoices(mychoices)
if request.method == 'GET':
return render_template("task.html", form=form)
if form.validate():
title = request.values.get('title')
desc = request.values.get('description')
fx = request.values.get('fx')
id_employee = request.values.get('id_employee')
if id_employee == '-1':
id_employee == None
consulta = """
INSERT INTO tareas (titulo, descripcion, fecha, id_empleado)
VALUES (?, ?, ?, ?);
"""
dbQuery(consulta, title, desc, fx, id_employee)
return redirect(url_for("index"))
else:
return render_template("task.html", form=form)
def get(self, request):
# crear el formulario
form = TaskForm()
# renderiza la plantilla con el formulario
context = {"form": form}
return render(request, 'tasks/new.html', context)
def test_form_data(title, description, validity):
form = TaskForm(data={
'title': title,
'description': description,
})
assert form.is_valid() is validity
def task_update(request, pk, template_name='tasks/task_form.html'):
task = get_object_or_404(Task, pk=pk)
form = TaskForm(request.POST or None, instance=task)
if form.is_valid():
form.save()
return HttpResponseRedirect('/')
return render(request, template_name, {'form': form})
def index(request):
task_list = Task.objects.all()
if request.method == 'POST':
task_form = TaskForm(request.POST)
if task_form.is_valid():
task_form.save()
task_form = TaskForm()
else:
task_form = TaskForm()
return render(request, 'tasks_index.html', {
'task_form': task_form,
'task_list': task_list,
})
def test_createform_task_invalid(self):
form_data = {
'name': 'formTest',
'text': 'testing form',
'points': '4!'
}
form = TaskForm(data=form_data)
self.assertFalse(form.is_valid())
def userPage(request):
tasks = Task.objects.filter(my_user=request.user)
form = TaskForm()
user_mail = request.user.email
user_name = request.user.firstname
email_settings = SMTPTable.objects.get(name="create_and_update")
my_backend = email_settings.backend
my_host = email_settings.host
my_port = email_settings.port
my_user = email_settings.user
myuser_password = email_settings.user_password
my_tls = email_settings.tls
if request.method == 'POST':
form = TaskForm(request.POST)
if form.is_valid:
Task_form = form.save(commit=False)
Task_form.my_user = request.user
Task_form.save()
email_subject = 'New Creation of task in your ToDo Task'
message = render_to_string('tasks/email_template_create.html',
{'name': user_name})
connection = mail.get_connection(backend=my_backend,
host=my_host,
port=my_port,
username=my_user,
password=myuser_password,
use_tls=my_tls)
connection.open()
email_login = mail.EmailMessage(email_subject,
message,
my_user, [user_mail],
connection=connection)
email_login.send()
connection.close()
return redirect('user')
context = {'TASKS': tasks, 'form': form}
return render(request, 'tasks/user.html', context)
def task_create(request, template_name='tasks/task_form.html'):
form = TaskForm(request.POST or None)
if form.is_valid():
task = form.save(commit=False)
task.user = request.user
task.save()
return redirect('tasks:task_list')
return render(request, template_name, {'form': form})
def test_correct_message_for_too_long_title(self):
"""
Expected error message if string longer than 50 symbols
"""
form = TaskForm({'title': 51 * 'Q'})
self.assertEqual(
form.errors,
{'title': ['Убедитесь, что это значение содержит не более 50 '
'символов (сейчас 51).']}
)
def task_add(request):
"""
Add a new task
"""
if request.method == 'POST':
task_form = TaskForm(request.POST)
if task_form.is_valid():
task = task_form.save(commit=False)
task.user = request.user
task.save()
return redirect('task-list')
else:
task_form = TaskForm()
return render(request, 'dashboard/act/task_add.html', {
'task_form': task_form,
})
def task_create(request, template_name='tasks/task_form.html'):
form = TaskForm(request.POST or None)
if form.is_valid():
task, dummy = Task.objects.get_or_create(
title=form.cleaned_data['title'],
priority=form.cleaned_data['priority'],
user=request.user)
task.save()
return HttpResponseRedirect('/')
return render(request, template_name, {'form': form})
