{% trans 'Every concept is given a basic emotional value' %}
-
-
{% trans 'Neutral Concept' %}
- 
{% trans 'Positive Concept' %}
- 
{% trans 'Negative Concept' %}
- 
{% trans 'Ambivalent Concept' %}
- 
{% trans 'Concepts in Agreement' %}
- 
{% trans 'Concepts in Disagreement' %}
+ -
+ {% trans 'Neutral Concept' %}
+
+
-
+ {% trans 'Positive Concept' %}
+
+
-
+ {% trans 'Negative Concept' %}
+
+
-
+ {% trans 'Ambivalent Concept' %}
+
+
-
+ {% trans 'Concepts in Agreement' %}
+
+
-
+ {% trans 'Concepts in Disagreement' %}
+
{% trans 'Draw links between concepts that are related to each other' %}
-+ {% trans 'Draw links between concepts that are related to each + other' %} +
+
+
-
-
-
- {% trans 'Create' %}: {% trans 'Single click on blank drawing space' %} -
- {% trans 'Update' %}: {% trans 'Double click on existing concept' %} -
- {% trans 'Delete' %}: {% trans 'Select a concept with a single click and press “delete” on your keyboard' %} -
- {% trans 'Add Comment' %}: {% trans 'Select concept with any selector-mode and type comment in the “Concept Comment” section and press submit.' %} +
- + {% trans 'Create' %}: {% trans + 'Single click on blank drawing space' %} + +
- + {% trans 'Update' %}: {% trans + 'Double click on existing concept' %} + +
- + {% trans 'Delete' %}: {% trans + 'Select a concept with a single click and press “delete” on your + keyboard' %} + +
- + {% trans 'Add Comment' %}: {% trans + 'Select concept with any selector-mode and type comment in the + “Concept Comment” section and press submit.' %} +
+
-
-
-
- {% trans 'Create' %}: {% trans 'Select two concepts (they will become highlighted)' %} -
- {% trans 'Update' %}: {% trans 'Single Click on link' %} -
- {% trans 'Delete' %}: {% trans 'Select Link with a single click and press “delete” on your keyboard' %} +
- + {% trans 'Create' %}: {% trans + 'Select two concepts (they will become highlighted)' %} + +
- + {% trans 'Update' %}: {% trans + 'Single Click on link' %} + +
- + {% trans 'Delete' %}: {% trans + 'Select Link with a single click and press “delete” on your + keyboard' %} +
-
-
- {% trans 'Save Map' %} -
- {% trans 'Generate Image' %} -
- {% trans 'Export Map' %} -
- {% trans 'Import Map' %} -
- {% trans 'Delete Map' %} + + +
- + {% trans 'Export Map' %} + +
- + {% trans 'Import Map' %} + +
- + {% trans 'Delete + Map' %} +
+
\ No newline at end of file
+
diff --git a/templates/base/base.html b/templates/base/base.html
index 4cc8d9696..4beec2089 100644
--- a/templates/base/base.html
+++ b/templates/base/base.html
@@ -79,6 +79,8 @@
});
+
+
diff --git a/templates/base/index.html b/templates/base/index.html
index 802c2695f..b3a088e1c 100644
--- a/templates/base/index.html
+++ b/templates/base/index.html
@@ -66,14 +66,14 @@
-
-
+
-
+
{# {% if user.language_preference == 'en' %} #}
-
+
{% trans 'Export' %}
diff --git a/users/Import-Create-Image.py b/users/Import-Create-Image.py
deleted file mode 100644
index 64b2cec2e..000000000
--- a/users/Import-Create-Image.py
+++ /dev/null
@@ -1,89 +0,0 @@
-"""
-Routine to import a set of CAMS and create an image for each
-"""
-from .resources import BlockResource, LinkResource
-from zipfile import ZipFile
-from tablib import Dataset
-from users.models import CAM
-from django.shortcuts import render, redirect
-from django.http import HttpResponse
-import pandas as pd
-import base64
-import re
-from users.Plots.DataToPlot import data_to_plot
-
-def Image_CAM(request):
- '''
- For more pdf options look at wkhtmltopdf documentation
- :param request:
- :return:
- '''
- #config = pdfkit.configuration(wkhtmltopdf='./bin/wkhtmltopdf')
- file_name = 'media/CAMS/'+request.user.username+'_'+str(request.user.active_cam_num)+'.png'
- data_to_plot(request.user.username,file_name)
- current_cam = CAM.objects.get(id=request.user.active_cam_num)
- current_cam.cam_image = file_name
- current_cam.save()
- return HttpResponse('Saved Image')
-
-
-def import_CAM(request):
- if request.method == 'POST':
- block_resource = BlockResource()
- link_resource = LinkResource()
- dataset = Dataset()
- uploaded_CAM = request.FILES['myfile']
- deletable = request.POST.get('Deletable')
- # Clear all current blocks and links
- current_cam = CAM.objects.get(id=request.user.active_cam_num)
- user = request.user
- blocks = current_cam.block_set.all()
- for block in blocks:
- block.delete()
- links = current_cam.link_set.all()
- for link in links:
- link.delete()
- ct = 0
- print(current_cam)
- try:
- with ZipFile(uploaded_CAM) as z:
- for filename in z.namelist():
- data = z.extract(filename)
- test = pd.read_csv(data)
- print(test)
- #test['id'] = test['id'].apply(lambda x: ' ') # Must be empty to auto id
- test['creator'] = test['creator'].apply(lambda x: request.user.id)
- test['CAM'] = test['CAM'].apply(lambda x: current_cam.id)
- test.to_csv(data)
- imported_data = dataset.load(open(data).read())
- if ct == 0:
- result = block_resource.import_data(imported_data, dry_run=True) # Test the data import
- if not result.has_errors():
- block_resource.import_data(imported_data, dry_run=False) # Actually import now
- else:
- print('sad')
- else:
- result = link_resource.import_data(imported_data, dry_run=True) # Test the data import
- if not result.has_errors():
- link_resource.import_data(imported_data, dry_run=False) # Actually import now
- ct += 1
- except:
- print('didnt work')
- # We now have to clean up the blocks' links...
- blocks_imported = current_cam.block_set.all()
- print(blocks_imported)
- for block in blocks_imported:
- # Clean up Comments ('none' -> '')
- if block.comment == 'None' or block.comment == 'none':
- block.comment = ''
- if deletable is not None:
- block.modifiable = False
- # Change block creator to current user
- block.creator = request.user
- block.save()
- links_imported = current_cam.link_set.all()
-
- for link in links_imported:
- link.creator = request.user
- link.save()
- return redirect('/')
\ No newline at end of file
diff --git a/users/Plots/DataToPlot.py b/users/Plots/DataToPlot.py
deleted file mode 100644
index 094a12007..000000000
--- a/users/Plots/DataToPlot.py
+++ /dev/null
@@ -1,52 +0,0 @@
-"""
-Code to take black and line csv information and create an image
-"""
-
-import cv2 as cv
-import numpy as np
-import pandas as pd
-from users.Plots.Shapes import shapes
-from users.Plots.Lines import lines
-from users.models import CustomUser
-
-def data_to_plot(username,file_name):
- scale = 5
- # Read in data to pandas
- #blocks = pd.read_csv('/home/carterrhea/Documents/CAM-proj/'+id+'_blocks.csv')
- #links = pd.read_csv('/home/carterrhea/Documents/CAM-proj/'+id+'_links.csv')
- blocks = pd.DataFrame.from_records(
- CustomUser.objects.get(username=username).block_set.all().values_list('id', 'x_pos', 'y_pos', 'height', 'width', 'shape', 'title'),
- columns=['id', 'x_pos', 'y_pos', 'height', 'width', 'shape', 'title']
- )
- links = pd.DataFrame.from_records(
- CustomUser.objects.get(username=username).link_set.all().values_list('starting_block', 'ending_block', 'line_style', 'arrow_type'),
- columns=['starting_block', 'ending_block', 'line_style', 'arrow_type']
- )
- # Create Background
- x_size = int(blocks['y_pos'].max())
- y_size = int(blocks['x_pos'].max())
- image = np.zeros((int(1.3*scale*x_size), int(1.3*scale*y_size), 3), np.uint8)
- image.fill(255) # Make white background
- # Step through each line
- for index, row in links.iterrows():
- starting_block = blocks[blocks['id'] == row['ending_block']]
- ending_block = blocks[blocks['id'] == row['starting_block']]
- image = lines(image, starting_block, ending_block, row['line_style'], row['arrow_type'], scale)
- # Step through each block
- for index, row in blocks.iterrows():
- image = shapes(image, row['shape'], row['x_pos'], row['y_pos'], row['width'], row['height'], row['title'], scale)
-
-
- # resize image
- #percent by which the image is resized
- scale_percent = int((1/(scale))*100)
- #calculate the 50 percent of original dimensions
- width = int(image.shape[1] * scale_percent / 100)
- height = int(image.shape[0] * scale_percent / 100)
-
- # dsize
- dsize = (width, height)
-
- image = cv.resize(image, dsize)
-
- cv.imwrite(file_name, image)
\ No newline at end of file
diff --git a/users/Plots/Lines.py b/users/Plots/Lines.py
deleted file mode 100644
index 9abe3d6a9..000000000
--- a/users/Plots/Lines.py
+++ /dev/null
@@ -1,150 +0,0 @@
-import cv2 as cv
-import numpy as np
-import operator
-
-
-def lines(image, starting_block, ending_block, line_style, arrow_type, scale):
- x_start = float(starting_block['x_pos'])
- x_end = float(ending_block['x_pos'])
- y_start = float(starting_block['y_pos'])
- y_end = float(ending_block['y_pos'])
- starting_point = (int(scale*(starting_block['x_pos']+starting_block['width']/2)), int(scale*(starting_block['y_pos']+starting_block['height']/2)))
- ending_point = (int(scale*(ending_block['x_pos']+ending_block['width']/2)), int(scale*(ending_block['y_pos']+ending_block['height']/2)))
- if 'Strong' in line_style:
- thickness = scale*4
- elif 'Weak' in line_style:
- thickness = scale*2
- else:
- thickness = scale*3
- color = (119, 119, 119)
- if 'Solid' in line_style:
- if arrow_type == 'none':
- image = cv.line(image, starting_point, ending_point, color, thickness)
- else:
- if x_end > x_start:
- temp = x_start
- x_start = x_end
- x_end = temp
- temp = y_start
- y_start = y_end
- y_end = temp
- x_end = x_end + 0.5*float(ending_block['width'])
- y_start = y_start + 0.5*float(ending_block['height'])
- x_start = x_start + 0.5*float(ending_block['width'])
- y_end = y_end + 0.5*float(ending_block['height'])
- angle = np.arctan((y_end-y_start)/(x_end-x_start))
- length = np.sqrt((x_start - x_end) * (x_start - x_end) + (y_start - y_end ) * (y_start - y_end ))
- x_end_new = scale*(x_start-0.5*np.sqrt(ending_block['width']**2+ending_block['height']**2)*np.cos(angle)) - 0.5*length*(1-np.cos(angle))
- y_end_new = scale*(y_start-0.5*np.sqrt(ending_block['width']**2+ending_block['height']**2)*np.sin(angle)) + 0.5*length*np.sin(angle)
- new_end = (int(x_end_new), int(y_end_new)) # tuple(np.subtract(ending_point,(scale*100,scale*100)))
- image = cv.arrowedLine(image, starting_point, new_end, color, thickness,line_type=8)
- else:
- temp = x_start
- x_start = x_end
- x_end = temp
- temp = y_start
- y_start = y_end
- y_end = temp
- x_end = x_end + 0.5*float(ending_block['width'])
- y_start = y_start + 0.5*float(ending_block['height'])
- x_start = x_start + 0.5*float(ending_block['width'])
- y_end = y_end + 0.5*float(ending_block['height'])
- angle = np.arctan((y_end-y_start)/(x_end-x_start))
- length = np.sqrt((x_start - x_end) * (x_start - x_end) + (y_start - y_end ) * (y_start - y_end ))
- x_end_new = scale*(x_start+0.42*np.sqrt(ending_block['width']**2+ending_block['height']**2)*np.cos(angle)) - 0.5*length*(1-np.cos(angle))
- y_end_new = scale*(y_start+0.42*np.sqrt(ending_block['width']**2+ending_block['height']**2)*np.sin(angle)) + 0.5*length*np.sin(angle)
- new_end = (int(x_end_new), int(y_end_new)) # tuple(np.subtract(ending_point,(scale*100,scale*100)))
- image = cv.arrowedLine(image, starting_point, new_end, color, thickness, line_type=8)
- else: # Dashed
- if arrow_type == 'none':
- length = np.sqrt((x_start - x_end)**2 + (y_start - y_end )**2)
- angle = np.arctan((y_end-y_start)/(x_end-x_start))
- k = 1*scale
- for it in range(int(length)):
- if it%8 == 0:
- if x_end > x_start:
- starting_point_new = tuple(map(operator.add,starting_point,(it*k*np.cos(angle), it*k*np.sin(angle))))
- ending_point_new = tuple(map(operator.add,starting_point,((it+1)*k*np.cos(angle), (it+1)*k*np.sin(angle))))
- starting_point_new = tuple(int(i) for i in starting_point_new)
- ending_point_new = tuple(int(i) for i in ending_point_new)
- image = cv.line(image, starting_point_new, ending_point_new, color, thickness)
- else:
- starting_point_new = tuple(map(operator.add,ending_point,(it*k*np.cos(angle), it*k*np.sin(angle))))
- ending_point_new = tuple(map(operator.add,ending_point,((it+1)*k*np.cos(angle), (it+1)*k*np.sin(angle))))
- starting_point_new = tuple(int(i) for i in starting_point_new)
- ending_point_new = tuple(int(i) for i in ending_point_new)
- image = cv.line(image, starting_point_new, ending_point_new, color, thickness)
- else: # Arrow
- temp = x_start
- x_start = x_end
- x_end = temp
- temp = y_start
- y_start = y_end
- y_end = temp
- x_end = x_end - 0.5*scale*float(ending_block['width'])
- y_start = y_start - 0.5*scale*float(ending_block['height'])
- x_start = x_start - 0.5*scale*float(ending_block['width'])
- y_end = y_end - 0.5*scale*float(ending_block['height'])
- length = np.sqrt((x_start - x_end)**2 + (y_start - y_end )**2)
- angle = np.arctan((y_end-y_start)/(x_end-x_start))
- k = 1*scale
- starting_point_new = None # init
- ending_point_new = None # init
- for it in range(int(length/2)):
- if it%8 == 0:
- if x_end > x_start and y_start > y_end:
- starting_point_new = tuple(map(operator.add,starting_point,(it*k*np.cos(angle)-scale*np.cos(angle)*float(ending_block['width']), it*k*np.sin(angle)-np.sin(angle)*1.5*scale*float(ending_block['height']))))
- ending_point_new = tuple(map(operator.add,starting_point,((it+1)*k*np.cos(angle)-scale*np.cos(angle)*float(ending_block['width']), (it+1)*k*np.sin(angle)-np.sin(angle)*1.5*scale*float(ending_block['height']))))
- starting_point_new = tuple(int(i) for i in starting_point_new)
- ending_point_new = tuple(int(i) for i in ending_point_new)
- image = cv.line(image, starting_point_new, ending_point_new, color, thickness)
- elif x_end > x_start and y_start < y_end:
- ending_point_new = tuple(map(operator.add,starting_point,(it*k*np.cos(angle)-scale*np.cos(angle)*float(ending_block['width']), it*k*np.sin(angle)-np.sin(angle)*scale*0.5*float(ending_block['height']))))
- starting_point_new = tuple(map(operator.add,starting_point,((it+1)*k*np.cos(angle)-scale*np.cos(angle)*float(ending_block['width']), (it+1)*k*np.sin(angle)-np.sin(angle)*scale*0.5*float(ending_block['height']))))
- starting_point_new = tuple(int(i) for i in starting_point_new)
- ending_point_new = tuple(int(i) for i in ending_point_new)
- image = cv.line(image, starting_point_new, ending_point_new, color, thickness)
- elif x_end < x_start and y_start > y_end:
- starting_point_new = tuple(map(operator.add,starting_point,(it*k*np.cos(angle)+scale*np.cos(angle)*0.5*float(ending_block['width']), it*k*np.sin(angle)+np.sin(angle)*scale*0.5*float(ending_block['height']))))
- ending_point_new = tuple(map(operator.add,starting_point,((it+1)*k*np.cos(angle)+scale*np.cos(angle)*0.5*float(ending_block['width']), (it+1)*k*np.sin(angle)+np.sin(angle)*scale*0.5*float(ending_block['height']))))
- starting_point_new = tuple(int(i) for i in starting_point_new)
- ending_point_new = tuple(int(i) for i in ending_point_new)
- image = cv.line(image, starting_point_new, ending_point_new, color, thickness)
- elif x_end < x_start and y_start < y_end:
- starting_point_new = tuple(map(operator.add,starting_point,(it*k*np.cos(angle)+0.5*np.cos(angle)*scale*float(ending_block['width']), it*k*np.sin(angle)+np.sin(angle)*0.5*scale*float(ending_block['height']))))
- ending_point_new = tuple(map(operator.add,starting_point,((it+1)*k*np.cos(angle)+0.5*np.cos(angle)*scale*float(ending_block['width']), (it+1)*k*np.sin(angle)+np.sin(angle)*0.5*scale*float(ending_block['height']))))
- starting_point_new = tuple(int(i) for i in starting_point_new)
- ending_point_new = tuple(int(i) for i in ending_point_new)
- image = cv.line(image, starting_point_new, ending_point_new, color, thickness)
- # Add final arrow
- if x_end > x_start and y_start > y_end:
- # Need for dash!
- it = 0
- starting_point_new = tuple(map(operator.add,starting_point,(it*k*np.cos(angle)-scale*np.cos(angle)*float(ending_block['width']), it*k*np.sin(angle)-np.sin(angle)*1.5*scale*float(ending_block['height']))))
- ending_point_new = tuple(map(operator.add,starting_point,((it+1)*k*np.cos(angle)-scale*np.cos(angle)*float(ending_block['width']), (it+1)*k*np.sin(angle)-np.sin(angle)*1.5*scale*float(ending_block['height']))))
- starting_point_new = tuple(int(i) for i in starting_point_new)
- ending_point_new = tuple(int(i) for i in ending_point_new)
- image = cv.arrowedLine(image, ending_point_new, starting_point_new, color, thickness, tipLength=thickness)
- elif x_end > x_start and y_start < y_end:
- # Need for dash!
- it = 0
- ending_point_new = tuple(map(operator.add,starting_point,(it*k*np.cos(angle)-scale*np.cos(angle)*float(ending_block['width']), it*k*np.sin(angle)-np.sin(angle)*0.5*scale*float(ending_block['height']))))
- starting_point_new = tuple(map(operator.add,starting_point,((it+1)*k*np.cos(angle)-scale*np.cos(angle)*float(ending_block['width']), (it+1)*k*np.sin(angle)-np.sin(angle)*0.5*scale*float(ending_block['height']))))
- starting_point_new = tuple(int(i) for i in starting_point_new)
- ending_point_new = tuple(int(i) for i in ending_point_new)
- image = cv.arrowedLine(image, starting_point_new, ending_point_new, color, thickness, tipLength=thickness)
- elif x_end < x_start and y_start > y_end:
- it = length/2
- starting_point_new = tuple(map(operator.add,starting_point,(it*k*np.cos(angle)+scale*np.cos(angle)*0.5*float(ending_block['width']), it*k*np.sin(angle)+np.sin(angle)*scale*0.5*float(ending_block['height']))))
- ending_point_new = tuple(map(operator.add,starting_point,((it+1)*k*np.cos(angle)+scale*np.cos(angle)*0.5*float(ending_block['width']), (it+1)*k*np.sin(angle)+np.sin(angle)*scale*0.5*float(ending_block['height']))))
- starting_point_new = tuple(int(i) for i in starting_point_new)
- ending_point_new = tuple(int(i) for i in ending_point_new)
- image = cv.arrowedLine(image, starting_point_new, ending_point_new, color, thickness, tipLength=thickness)
- elif x_end < x_start and y_start < y_end:
- it = length/2
- starting_point_new = tuple(map(operator.add,starting_point,(it*k*np.cos(angle)+0.5*np.cos(angle)*scale*float(ending_block['width']), it*k*np.sin(angle)+np.sin(angle)*0.5*scale*float(ending_block['height']))))
- ending_point_new = tuple(map(operator.add,starting_point,((it+1)*k*np.cos(angle)+0.5*np.cos(angle)*scale*float(ending_block['width']), (it+1)*k*np.sin(angle)+np.sin(angle)*0.5*scale*float(ending_block['height']))))
- starting_point_new = tuple(int(i) for i in starting_point_new)
- ending_point_new = tuple(int(i) for i in ending_point_new)
- image = cv.arrowedLine(image, starting_point_new, ending_point_new, color, thickness, tipLength=thickness)
- return image
diff --git a/users/Plots/Shapes.py b/users/Plots/Shapes.py
deleted file mode 100644
index 3be53276e..000000000
--- a/users/Plots/Shapes.py
+++ /dev/null
@@ -1,101 +0,0 @@
-import cv2 as cv
-import math
-import numpy as np
-
-def shapes(image, shape_name, x_pos, y_pos, width, height, title, scale):
- """
- Convert shape name from pandas file to shape to be used in cv2
- """
- height = 0.6*height
- start_point = (int(scale*x_pos), int(scale*(y_pos+height))) # Top left
- end_point = (int(scale*(x_pos+width)), int(scale*y_pos)) # Bottom right
- if 'negative' in shape_name:
- color = (182, 186, 224)
- boundary_color = (66, 66, 184)
- if 'strong' in shape_name:
- thickness = scale*8
- elif 'weak' in shape_name:
- thickness = scale*1
- else:
- thickness = scale*4
- # Hexagon points
- p1 = [int(scale*(x_pos)), int(scale*(y_pos+height/2))]
- p2 = [int(scale*(x_pos+width*0.8/3)), int(scale*(y_pos+height))]
- p3 = [int(scale*(x_pos+width*2.2/3)), int(scale*(y_pos+height))]
- p4 = [int(scale*(x_pos+width)), int(scale*(y_pos+height/2))]
- p5 = [int(scale*(x_pos+width*2.2/3)), int(scale*(y_pos))]
- p6 = [int(scale*(x_pos+width*0.8/3)), int(scale*(y_pos))]
- Hex = np.array([[p1, p2, p3, p4, p5, p6]], np.int32)
- Hex = Hex.reshape((-1, 1, 2))
- image = cv.polylines(image, [Hex], True, boundary_color, thickness) # Boundary
- image = cv.fillPoly(image, [Hex], color) # Main
- elif 'positive' in shape_name:
- color = (214, 228, 216)
- boundary_color = (149, 188, 149)
- if 'strong' in shape_name:
- thickness = scale*8
- elif 'weak' in shape_name:
- thickness = scale*1
- else:
- thickness = scale*4
- center_coordinates = (int(scale*(x_pos+1/2*width)), int(scale*(y_pos+1/2*height)))
- axesLength = (int(scale*(width/2)), int(scale*(height/2)))
- image = cv.ellipse(image, center_coordinates, axesLength, 0, 0, 360, boundary_color, thickness)
- image = cv.ellipse(image, center_coordinates, axesLength, 0, 0, 360, color, -1)
- elif 'neutral' in shape_name:
- color = (192, 230, 242)
- boundary_color = (49, 180, 223)
- thickness = scale*4
- image = cv.rectangle(image, start_point, end_point, boundary_color, thickness)
- image = cv.rectangle(image, start_point, end_point, color, -1)
- else: # Ambivalent
-
- color = (210, 199, 207)
- boundary_color = (127, 90, 126)
- thickness = scale*4
- # Hexagon points
- p1 = [int(scale*(x_pos)), int(scale*(y_pos+height/2))]
- p2 = [int(scale*(x_pos+width*0.8/3)), int(scale*(y_pos+height))]
- p3 = [int(scale*(x_pos+width*2.2/3)), int(scale*(y_pos+height))]
- p4 = [int(scale*(x_pos+width)), int(scale*(y_pos+height/2))]
- p5 = [int(scale*(x_pos+width*2.2/3)), int(scale*(y_pos))]
- p6 = [int(scale*(x_pos+width*0.8/3)), int(scale*(y_pos))]
- Hex = np.array([[p1, p2, p3, p4, p5, p6]], np.int32)
- Hex = Hex.reshape((-1, 1, 2))
- image = cv.polylines(image, [Hex], True, boundary_color, thickness) # Boundary
- image = cv.fillPoly(image, [Hex], color) # Main
- # Ellipse
- center_coordinates = (int(scale*(x_pos+1/2*width)), int(scale*(y_pos+1/2*height)))
- axesLength = (int(scale*(width/2.25)), int(scale*(height/2.25)))
- image = cv.ellipse(image, center_coordinates, axesLength, 0, 0, 360, boundary_color, thickness)
- image = cv.ellipse(image, center_coordinates, axesLength, 0, 0, 360, color, -1)
- #print(image)
- # Add text
- font = cv.FONT_HERSHEY_SIMPLEX
- fontScale = 2.
- text_color = (0, 0, 0)
- thickness = scale*1
- if math.ceil(fontScale*scale*len(title)/width) == 2: # The text is too large! --> twice as long
- text_length_half = int(len(title)/2)
- # First half
- org = (int(scale*((x_pos+1/2*width)-2.2*text_length_half-fontScale*scale)), int(scale*(y_pos+1/2*height)-4*fontScale*scale))
- image = cv.putText(image, title[:text_length_half], org, font, fontScale, text_color, thickness, cv.LINE_AA)
- # Second half
- org = (int(scale*((x_pos+1/2*width)-2.2*text_length_half-fontScale*scale)), int(scale*(y_pos+1/2*height)+4*fontScale*scale))
- image = cv.putText(image, title[text_length_half:], org, font, fontScale, text_color, thickness, cv.LINE_AA)
- elif math.ceil(fontScale*scale*len(title)/width) == 3: # The text is too large! --> twice as long
- text_length_half = int(len(title)/3)
- # First half
- org = (int(scale*((x_pos+1/2*width)-4*text_length_half-fontScale*scale)), int(scale*(y_pos+1/2*height)-5*fontScale*scale))
- image = cv.putText(image, title[:text_length_half], org, font, fontScale, text_color, thickness, cv.LINE_AA)
- # Second half
- org = (int(scale*((x_pos+1/2*width)-4*text_length_half-fontScale*scale)), int(scale*(y_pos+1/2*height)+0*fontScale*scale))
- image = cv.putText(image, title[text_length_half:2*text_length_half], org, font, fontScale, text_color, thickness, cv.LINE_AA)
- # Third half
- org = (int(scale*((x_pos+1/2*width)-4*text_length_half-fontScale*scale)), int(scale*(y_pos+1/2*height)+5*fontScale*scale))
- image = cv.putText(image, title[2*text_length_half:], org, font, fontScale, text_color, thickness, cv.LINE_AA)
- else:
- org = (int(scale*((x_pos+1/2*width)-scale/2*len(title)-fontScale*scale)), int(scale*(y_pos+1/2*height)))
- image = cv.putText(image, title, org, font, fontScale, text_color, thickness, cv.LINE_AA)
- return image
-
diff --git a/users/Plots/__pycache__/DataToPlot.cpython-37.pyc b/users/Plots/__pycache__/DataToPlot.cpython-37.pyc
deleted file mode 100644
index 24ec420ba..000000000
Binary files a/users/Plots/__pycache__/DataToPlot.cpython-37.pyc and /dev/null differ
diff --git a/users/Plots/__pycache__/DataToPlot.cpython-39.pyc b/users/Plots/__pycache__/DataToPlot.cpython-39.pyc
deleted file mode 100644
index fbb6fbdb3..000000000
Binary files a/users/Plots/__pycache__/DataToPlot.cpython-39.pyc and /dev/null differ
diff --git a/users/Plots/__pycache__/Lines.cpython-37.pyc b/users/Plots/__pycache__/Lines.cpython-37.pyc
deleted file mode 100644
index 8c6736574..000000000
Binary files a/users/Plots/__pycache__/Lines.cpython-37.pyc and /dev/null differ
diff --git a/users/Plots/__pycache__/Lines.cpython-39.pyc b/users/Plots/__pycache__/Lines.cpython-39.pyc
deleted file mode 100644
index add557fe0..000000000
Binary files a/users/Plots/__pycache__/Lines.cpython-39.pyc and /dev/null differ
diff --git a/users/Plots/__pycache__/Shapes.cpython-37.pyc b/users/Plots/__pycache__/Shapes.cpython-37.pyc
deleted file mode 100644
index 2cb6ff20c..000000000
Binary files a/users/Plots/__pycache__/Shapes.cpython-37.pyc and /dev/null differ
diff --git a/users/Plots/__pycache__/Shapes.cpython-39.pyc b/users/Plots/__pycache__/Shapes.cpython-39.pyc
deleted file mode 100644
index bc0ed9904..000000000
Binary files a/users/Plots/__pycache__/Shapes.cpython-39.pyc and /dev/null differ
diff --git a/users/decorators.py b/users/decorators.py
deleted file mode 100644
index c035111ad..000000000
--- a/users/decorators.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from django.contrib.auth import REDIRECT_FIELD_NAME
-from django.contrib.auth.decorators import user_passes_test
-
-
-def participant_required(function=None, redirect_field_name=REDIRECT_FIELD_NAME, login_url='login'):
- '''
- Decorator for views that checks that the logged in user is a participant,
- redirects to the log-in page if necessary.
- '''
- actual_decorator = user_passes_test(
- lambda u: u.is_active and u.is_participant,
- login_url=login_url,
- redirect_field_name=redirect_field_name
- )
- if function:
- return actual_decorator(function)
- return actual_decorator
-
-
-def researcher_required(function=None, redirect_field_name=REDIRECT_FIELD_NAME, login_url='login'):
- '''
- Decorator for views that checks that the logged in user is a teacher,
- redirects to the log-in page if necessary.
- '''
- actual_decorator = user_passes_test(
- lambda u: u.is_active and u.is_researcher,
- login_url=login_url,
- redirect_field_name=redirect_field_name
- )
- if function:
- return actual_decorator(function)
- return actual_decorator
\ No newline at end of file
diff --git a/users/forms.py b/users/forms.py
index b4ad56fe1..ab241f825 100644
--- a/users/forms.py
+++ b/users/forms.py
@@ -1,31 +1,47 @@
# users/forms.py
from django import forms
from django.contrib.auth.forms import UserCreationForm, UserChangeForm
-from .models import CustomUser, Contact, Participant, Researcher, CAM, Project, logCamActions
+from .models import (
+ CustomUser,
+ Contact,
+ Participant,
+ Researcher,
+ CAM,
+ Project,
+ logCamActions,
+)
+
class ContactForm(forms.ModelForm):
class Meta:
model = Contact
fields = {
- 'contacter',
- 'email',
- 'message',
+ "contacter",
+ "email",
+ "message",
}
+
class CustomUserCreationForm(UserCreationForm):
# captcha = ReCaptchaField()
class Meta(UserCreationForm):
model = CustomUser
- fields = ('username', 'email', 'first_name', 'last_name', 'password1', 'password2', 'language_preference')
-
-
+ fields = (
+ "username",
+ "email",
+ "first_name",
+ "last_name",
+ "password1",
+ "password2",
+ "language_preference",
+ )
def save(self, commit=True):
user = super(UserCreationForm, self).save(commit=False)
user.username = self.cleaned_data["username"]
user.email = self.cleaned_data["email"]
- user.set_password(self.cleaned_data['password1'])
+ user.set_password(self.cleaned_data["password1"])
user.first_name = self.cleaned_data["first_name"]
user.last_name = self.cleaned_data["last_name"]
user.language_preference = self.cleaned_data["language_preference"]
@@ -33,8 +49,8 @@ def save(self, commit=True):
user.save()
return user
-class CustomUserChangeForm(UserChangeForm):
+class CustomUserChangeForm(UserChangeForm):
class Meta:
model = CustomUser
fields = () # ('username', 'email')
@@ -43,7 +59,15 @@ class Meta:
class ParticipantSignupForm(UserCreationForm):
class Meta(UserCreationForm.Meta):
model = CustomUser
- fields = ('username', 'email', 'first_name', 'last_name', 'password1', 'password2', 'language_preference')
+ fields = (
+ "username",
+ "email",
+ "first_name",
+ "last_name",
+ "password1",
+ "password2",
+ "language_preference",
+ )
def save(self):
user = super().save(commit=False)
@@ -55,16 +79,26 @@ def save(self):
class ResearcherSignupForm(UserCreationForm):
# captcha = ReCaptchaField()
+ affiliation = forms.CharField(max_length=200, required=False, label="Affiliation")
+
class Meta(UserCreationForm.Meta):
model = CustomUser
- fields = ('username', 'email', 'first_name', 'last_name', 'password1', 'password2', 'language_preference')
+ fields = (
+ "username",
+ "email",
+ "first_name",
+ "last_name",
+ "password1",
+ "password2",
+ "language_preference",
+ )
def save(self):
user = super().save(commit=False)
user.is_researcher = True
user.save()
researcher = Researcher.objects.create(user=user)
- researcher.affiliation = self.cleaned_data.get('affiliation')
+ researcher.affiliation = self.cleaned_data.get("affiliation", "")
researcher.save()
return user
@@ -73,9 +107,10 @@ class IndividualCAMCreationForm(forms.ModelForm):
class Meta:
model = CAM
fields = {
- 'name',
- 'user',
+ "name",
+ "user",
}
+
def save(self, commit=True):
cam = super(forms.ModelForm, self).save(commit=False)
cam.name = self.cleaned_data["name"]
@@ -89,21 +124,26 @@ class ProjectCreationForm(forms.ModelForm):
class Meta:
model = Project
fields = {
- 'name',
- 'researcher',
- 'num_part',
- 'description',
- 'name_participants',
- 'password'
+ "name",
+ "researcher",
+ "num_part",
+ "description",
+ "name_participants",
+ "password",
}
error_messages = {
- 'name': {'unique': "That Project Title has been taken.",
- 'required': "A Project Title must be entered"},
- 'name_participants': {'unique': "The Participant Prefix you have chosen has been taken.",
- 'required': "A Participant Prefix must be entered"},
- 'num_part': {'required': "A Number of Participants must be entered"},
- 'description': {'required': "A Project Description must be entered"}
+ "name": {
+ "unique": "That Project Title has been taken.",
+ "required": "A Project Title must be entered",
+ },
+ "name_participants": {
+ "unique": "The Participant Prefix you have chosen has been taken.",
+ "required": "A Participant Prefix must be entered",
+ },
+ "num_part": {"required": "A Number of Participants must be entered"},
+ "description": {"required": "A Project Description must be entered"},
}
+
def save(self, commit=True):
project = super(forms.ModelForm, self).save(commit=False)
project.name = self.cleaned_data["name"]
@@ -117,17 +157,11 @@ def save(self, commit=True):
return project
-
-
class ProjectCAMCreationForm(forms.ModelForm):
class Meta:
model = CAM
- fields = {
- 'name',
- 'user',
- 'project',
- 'description'
- }
+ fields = {"name", "user", "project", "description"}
+
def save(self, commit=True):
cam = super(forms.ModelForm, self).save(commit=False)
cam.name = self.cleaned_data["name"]
@@ -142,4 +176,4 @@ def save(self, commit=True):
class LogCamActionForm(forms.ModelForm):
class Meta:
model = logCamActions
- fields = {'camId', 'actionId', 'actionType','objType','objDetails'}
+ fields = {"camId", "actionId", "actionType", "objType", "objDetails"}
diff --git a/users/get_CAM.py b/users/get_CAM.py
deleted file mode 100644
index 0642bf5fc..000000000
--- a/users/get_CAM.py
+++ /dev/null
@@ -1,13 +0,0 @@
-def dowload_cam():
- outfile = BytesIO() # io.BytesIO() for python 3
- with ZipFile(outfile, 'w') as zf:
- for current_cam in current_project.cam_set.all():
- block_resource = BlockResource().export(current_cam.block_set.all()).csv
- link_resource = LinkResource().export(current_cam.link_set.all()).csv
- names = ['blocks', 'links']
- ct = 0
- for resource in [block_resource, link_resource]:
- zf.writestr("{}.csv".format(current_cam.user.username + '_' + names[ct]), resource)
- ct += 1
- response = HttpResponse(outfile.getvalue(), content_type='application/octet-stream')
- response['Content-Disposition'] = 'attachment; filename="' + request.user.username + '_CAM.zip"'
\ No newline at end of file
diff --git a/users/get_project_cams.py b/users/get_project_cams.py
deleted file mode 100644
index a663b63e9..000000000
--- a/users/get_project_cams.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from users.models import CustomUser, Project
-from .resources import BlockResource, LinkResource
-from zipfile import ZipFile
-from block.models import Block
-from link.models import Link
-from io import BytesIO
-
-
-user = CustomUser.objects.get(username='Liz')
-print(user.project_set.all())
-
-
-## IMPORTS ##
-project_name = 'Empirische Ethik'
-outfile = 'Lisa_CAMS.zip'
-with ZipFile(outfile, 'w') as zf:
- current_project = Project.objects.filter(name=project_name)
- outfile = BytesIO() # io.BytesIO() for python 3
- for current_cam in current_project.cam_set.all():
- block_resource = BlockResource().export(current_cam.block_set.all()).csv
- link_resource = LinkResource().export(current_cam.link_set.all()).csv
- names = ['blocks', 'links']
- ct = 0
- for resource in [block_resource, link_resource]:
- zf.writestr("{}.csv".format(current_cam.user.username + '_' + str(current_cam.id) + '_' + names[ct]),
- resource)
- ct += 1
- if current_cam.cam_image:
- try:
- zf.write(str(current_cam.cam_image))
- except:
- pass
diff --git a/users/get_project_cams.py~ b/users/get_project_cams.py~
deleted file mode 100644
index 665158984..000000000
--- a/users/get_project_cams.py~
+++ /dev/null
@@ -1,28 +0,0 @@
-from users.models import CustomUser, Project
-from .resources import BlockResource, LinkResource
-from zipfile import ZipFile
-from block.models import Block
-from link.models import Link
-from io import BytesIO
-
-
-## IMPORTS ##
-project_name = 'Empirische Ethik'
-outfile = 'Lisa_CAMS.zip'
-with ZipFile(outfile, 'w') as zf:
- current_project = Project.objects.get(name=project_name)
- outfile = BytesIO() # io.BytesIO() for python 3
- for current_cam in current_project.cam_set.all():
- block_resource = BlockResource().export(current_cam.block_set.all()).csv
- link_resource = LinkResource().export(current_cam.link_set.all()).csv
- names = ['blocks', 'links']
- ct = 0
- for resource in [block_resource, link_resource]:
- zf.writestr("{}.csv".format(current_cam.user.username + '_' + str(current_cam.id) + '_' + names[ct]),
- resource)
- ct += 1
- if current_cam.cam_image:
- try:
- zf.write(str(current_cam.cam_image))
- except:
- pass
diff --git a/users/get_users_cam.py b/users/get_users_cam.py
deleted file mode 100644
index 116913e28..000000000
--- a/users/get_users_cam.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from users.models import CustomUser
-from .resources import BlockResource, LinkResource
-from zipfile import ZipFile
-from block.models import Block
-from link.models import Link
-from io import BytesIO
-
-
-## IMPORTS ##
-num_part = 20 # Number of participants
-call_id = 'B'
-outfile = call_id + '_CAMS.zip'
-
-with ZipFile(outfile, 'w') as zf:
- for user_num in range(num_part):
- user = CustomUser.objects.get(username=call_id + str(user_num))
- block_resource = BlockResource().export(Block.objects.filter(creator=user.username)).csv
- link_resource = LinkResource().export(Link.objects.filter(creator=user.username)).csv
- outfile = BytesIO() # io.BytesIO() for python 3
- names = ['blocks', 'links']
- with ZipFile('CAMS/'+call_id+str(user_num)+'.zip', 'w') as zf2:
- ct = 0
- for resource in [block_resource,link_resource]:
- zf.writestr("{}.csv".format(call_id+str(user_num)+'_'+names[ct]), resource)
- zf2.writestr("{}.csv".format(names[ct]), resource)
- ct += 1
diff --git a/users/migrations/0063_alter_cam_creation_date_alter_contact_email_and_more.py b/users/migrations/0063_alter_cam_creation_date_alter_contact_email_and_more.py
new file mode 100644
index 000000000..403d5bca0
--- /dev/null
+++ b/users/migrations/0063_alter_cam_creation_date_alter_contact_email_and_more.py
@@ -0,0 +1,31 @@
+# Generated by Django 4.2.25 on 2025-10-26 00:51
+
+import datetime
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+ dependencies = [
+ ("users", "0062_auto_20211027_2349"),
+ ]
+
+ operations = [
+ migrations.AlterField(
+ model_name="cam",
+ name="creation_date",
+ field=models.CharField(
+ default=datetime.datetime.now, max_length=100, verbose_name="Date"
+ ),
+ ),
+ migrations.AlterField(
+ model_name="contact",
+ name="email",
+ field=models.EmailField(max_length=256),
+ ),
+ migrations.AlterField(
+ model_name="logcamactions",
+ name="objDetails",
+ field=models.CharField(max_length=500),
+ ),
+ ]
diff --git a/users/models.py b/users/models.py
index 83259139c..d2b440087 100644
--- a/users/models.py
+++ b/users/models.py
@@ -8,19 +8,26 @@
import datetime
from django.utils import timezone
+
class CustomUser(AbstractUser):
- email = models.EmailField(_('email address'), blank=True, null=True) # , unique=True)
- first_name = models.CharField(_('first name'), max_length=30, blank=True, null=True)
- last_name = models.CharField(_('last name'), max_length=30, blank=True, null=True)
+ email = models.EmailField(
+ _("email address"), blank=True, null=True
+ ) # , unique=True)
+ first_name = models.CharField(_("first name"), max_length=30, blank=True, null=True)
+ last_name = models.CharField(_("last name"), max_length=30, blank=True, null=True)
language_preference = models.CharField(
- _('lang_pref'), max_length=10,
- choices=[('en', 'en'), ('de', 'de')],
- blank=False, null=False, default='en')
+ _("lang_pref"),
+ max_length=10,
+ choices=[("en", "en"), ("de", "de")],
+ blank=False,
+ null=False,
+ default="en",
+ )
is_researcher = models.BooleanField(default=False)
is_participant = models.BooleanField(default=False)
active_cam_num = models.IntegerField(blank=True, null=True, default=1)
active_project_num = models.IntegerField(blank=True, null=True, default=1)
- avatar = models.ImageField(upload_to='avatar/',blank=True, null=True, default='')
+ avatar = models.ImageField(upload_to="avatar/", blank=True, null=True, default="")
random_user = models.BooleanField(default=False)
def __str__(self):
@@ -31,22 +38,30 @@ class Researcher(models.Model):
"""
Researcher Profile which points towards our custom user
"""
+
user = models.OneToOneField(CustomUser, on_delete=models.CASCADE)
- affiliation = models.CharField(_('affiliation'), max_length=100, blank=True, null=True, default='')
+ affiliation = models.CharField(
+ _("affiliation"), max_length=100, blank=True, null=True, default=""
+ )
def __str__(self):
return self.user.username
-
class Project(models.Model):
- name = models.CharField(max_length=50, default='', unique=True)
- researcher = models.ForeignKey(CustomUser, on_delete=models.CASCADE, default='')
- description = models.CharField(max_length=1000, default='')
+ name = models.CharField(max_length=50, default="", unique=True)
+ researcher = models.ForeignKey(CustomUser, on_delete=models.CASCADE, default="")
+ description = models.CharField(max_length=1000, default="")
num_part = models.IntegerField(default=1, blank=True, null=True)
- name_participants = models.CharField(max_length=10, blank=True, null=True, default='', unique=True)
- Initial_CAM = models.FileField(upload_to='InitialCAMs/', default='') # models.CharField(max_length=50, default='', unique=False)
- password = models.CharField(max_length=20, default='', unique=False, blank=True, null=True)
+ name_participants = models.CharField(
+ max_length=10, blank=True, null=True, default="", unique=True
+ )
+ Initial_CAM = models.FileField(
+ upload_to="InitialCAMs/", default=""
+ ) # models.CharField(max_length=50, default='', unique=False)
+ password = models.CharField(
+ max_length=20, default="", unique=False, blank=True, null=True
+ )
def __str__(self):
return f"Name: {self.name}"
@@ -61,16 +76,17 @@ def update(self, form_info):
self.save(update_fields=list(form_info.keys()))
-
class CAM(models.Model):
- name = models.CharField(max_length=50, default='')
- user = models.ForeignKey(CustomUser, on_delete=models.CASCADE, default='')
- project = models.ForeignKey(Project, on_delete=models.CASCADE, blank=True, null=True, default='')
- cam_image = models.FileField(
- default=''
+ name = models.CharField(max_length=50, default="")
+ user = models.ForeignKey(CustomUser, on_delete=models.CASCADE, default="")
+ project = models.ForeignKey(
+ Project, on_delete=models.CASCADE, blank=True, null=True, default=""
)
- creation_date = models.CharField(_("Date"), max_length=100, default=datetime.datetime.now()) # Create time log for creation of CAM
- description = models.CharField(max_length=500, blank=True, default=' ', null=True)
+ cam_image = models.FileField(default="")
+ creation_date = models.CharField(
+ _("Date"), max_length=100, default=datetime.datetime.now
+ ) # Create time log for creation of CAM
+ description = models.CharField(max_length=500, blank=True, default=" ", null=True)
def __str__(self):
return f"Name: {self.name}"
@@ -97,13 +113,19 @@ class Participant(models.Model):
"""
Admin Profile which points towards our custom user
"""
+
user = models.OneToOneField(CustomUser, on_delete=models.CASCADE)
- researcher = models.ForeignKey(Researcher, on_delete=models.CASCADE, blank=True, null=True, default='')
- project = models.ForeignKey(Project, on_delete=models.CASCADE, blank=True, null=True, default='')
+ researcher = models.ForeignKey(
+ Researcher, on_delete=models.CASCADE, blank=True, null=True, default=""
+ )
+ project = models.ForeignKey(
+ Project, on_delete=models.CASCADE, blank=True, null=True, default=""
+ )
def __str__(self):
return self.user.username
+
"""
# To safe profile on every create/updates
@receiver(post_save, sender=User)
@@ -115,20 +137,27 @@ def save_user_profile(sender, instance, **kwargs):
instance.profile.save()
"""
+
class Contact(models.Model):
contacter = models.CharField(max_length=256)
- email = models.CharField(max_length=256)
+ email = models.EmailField(max_length=256)
message = models.CharField(max_length=1000)
def __str__(self):
return f"Contacter: {self.contacter}"
-
-
class logCamActions(models.Model):
- camId = models.ForeignKey(CAM, on_delete=models.CASCADE, default='',blank=False) # Which CAM the action took place
- actionId = models.IntegerField(blank=False) # Counter to organize the order of actions
- actionType = models.IntegerField(blank=False) # is the action a deletion? ( = 0 )
- objType = models.IntegerField(blank=False) # Is the object a link ( = 0 ) and a block ( = 1 )
- objDetails = models.CharField(max_length=500,blank=False) # Details of the object in a python dictionary
+ camId = models.ForeignKey(
+ CAM, on_delete=models.CASCADE, default="", blank=False
+ ) # Which CAM the action took place
+ actionId = models.IntegerField(
+ blank=False
+ ) # Counter to organize the order of actions
+ actionType = models.IntegerField(blank=False) # is the action a deletion? ( = 0 )
+ objType = models.IntegerField(
+ blank=False
+ ) # Is the object a link ( = 0 ) and a block ( = 1 )
+ objDetails = models.CharField(
+ max_length=500, blank=False
+ ) # Details of the object in a python dictionary
diff --git a/users/test_api.py b/users/test_api.py
new file mode 100644
index 000000000..24256482d
--- /dev/null
+++ b/users/test_api.py
@@ -0,0 +1,450 @@
+from django.test import TestCase, override_settings, Client
+from users.models import CustomUser, Researcher, CAM, Project
+from block.models import Block
+from link.models import Link
+import json
+from zipfile import ZipFile
+from io import BytesIO
+
+
+@override_settings(
+ STATICFILES_STORAGE="django.contrib.staticfiles.storage.StaticFilesStorage"
+)
+class APIEndpointTestCase(TestCase):
+ """
+ Test suite for API endpoints including JSON responses and error handling
+ """
+
+ def setUp(self):
+ # Create users
+ self.user = CustomUser.objects.create_user(
+ username="testuser", email="test@test.com", password="12345"
+ )
+ self.user2 = CustomUser.objects.create_user(
+ username="testuser2", email="test2@test.com", password="12345"
+ )
+
+ self.researcher = Researcher.objects.create(user=self.user, affiliation="UdeM")
+ self.client.login(username="testuser", password="12345")
+
+ # Create project and CAM
+ self.project = Project.objects.create(
+ name="TestProject",
+ description="TEST PROJECT",
+ researcher=self.user,
+ password="TestProjectPassword",
+ name_participants="API",
+ )
+
+ self.cam = CAM.objects.create(
+ name="testCAM", user=self.user, project=self.project
+ )
+ self.user.active_cam_num = self.cam.id
+ self.user.save()
+
+ # Create test blocks
+ self.block1 = Block.objects.create(
+ title="APIBlock1",
+ x_pos=10.0,
+ y_pos=20.0,
+ width=100,
+ height=100,
+ shape="neutral",
+ creator=self.user,
+ CAM=self.cam,
+ num=1,
+ )
+
+ self.block2 = Block.objects.create(
+ title="APIBlock2",
+ x_pos=150.0,
+ y_pos=200.0,
+ width=120,
+ height=120,
+ shape="positive",
+ creator=self.user,
+ CAM=self.cam,
+ num=2,
+ )
+
+ # Create test link
+ self.link = Link.objects.create(
+ starting_block=self.block1,
+ ending_block=self.block2,
+ line_style="Solid-Weak",
+ arrow_type="uni",
+ creator=self.user,
+ CAM=self.cam,
+ num=1,
+ )
+
+ def test_download_cam_returns_zip(self):
+ """
+ Test that download_cam endpoint returns a valid ZIP file
+ """
+ response = self.client.get("/users/download_cam", {"pk": self.cam.id})
+
+ self.assertEqual(response.status_code, 200)
+ self.assertEqual(response["Content-Type"], "application/octet-stream")
+ self.assertIn("attachment", response["Content-Disposition"])
+
+ # Verify it's a valid ZIP file
+ zip_data = BytesIO(response.content)
+ with ZipFile(zip_data, "r") as zf:
+ # Check that ZIP contains expected files
+ namelist = zf.namelist()
+ self.assertIn("blocks.csv", namelist)
+ self.assertIn("links.csv", namelist)
+
+ def test_download_cam_contains_blocks_and_links(self):
+ """
+ Test that downloaded CAM data contains blocks and links
+ """
+ response = self.client.get("/users/download_cam", {"pk": self.cam.id})
+
+ # Parse ZIP file
+ zip_data = BytesIO(response.content)
+ with ZipFile(zip_data, "r") as zf:
+ # Read blocks CSV
+ blocks_csv = zf.read("blocks.csv").decode("utf-8")
+ self.assertIn("APIBlock1", blocks_csv)
+ self.assertIn("APIBlock2", blocks_csv)
+
+ # Read links CSV
+ links_csv = zf.read("links.csv").decode("utf-8")
+ # Verify links data exists and has content
+ self.assertTrue(len(links_csv) > 0)
+
+ def test_load_cam_returns_json(self):
+ """
+ Test that load_cam endpoint returns JSON response
+ """
+ response = self.client.post("/users/load_cam", {"cam_id": self.cam.id})
+
+ self.assertEqual(response.status_code, 200)
+
+ # Should return JSON data
+ try:
+ data = json.loads(response.content)
+ self.assertIsInstance(data, dict)
+ except json.JSONDecodeError:
+ # Some endpoints might return HTML, check content type
+ pass
+
+ def test_add_block_api_response(self):
+ """
+ Test block creation API endpoint response
+ """
+ response = self.client.post(
+ "/block/add_block",
+ {
+ "add_valid": True,
+ "num_block": 99,
+ "title": "APICreatedBlock",
+ "shape": 3,
+ "x_pos": 100.0,
+ "y_pos": 200.0,
+ "width": 150,
+ "height": 150,
+ },
+ )
+
+ self.assertEqual(response.status_code, 200)
+
+ # Verify block was created
+ new_block = Block.objects.filter(title="APICreatedBlock").first()
+ self.assertIsNotNone(new_block)
+ self.assertEqual(new_block.x_pos, 100.0)
+ self.assertEqual(new_block.y_pos, 200.0)
+
+ def test_update_block_api_response(self):
+ """
+ Test block update API endpoint
+ """
+ response = self.client.post(
+ "/block/update_block",
+ {
+ "update_valid": True,
+ "num_block": self.block1.num,
+ "title": "UpdatedViaAPI",
+ "shape": 5,
+ "x_pos": "50.0px",
+ "y_pos": "60.0px",
+ "width": "200px",
+ "height": "180px",
+ },
+ )
+
+ self.assertEqual(response.status_code, 200)
+
+ # Verify update
+ self.block1.refresh_from_db()
+ self.assertEqual(self.block1.title, "UpdatedViaAPI")
+
+ def test_delete_block_api_response(self):
+ """
+ Test block deletion API endpoint
+ """
+ block_id = self.block1.num
+
+ response = self.client.post(
+ "/block/delete_block", {"delete_valid": True, "block_id": block_id}
+ )
+
+ self.assertEqual(response.status_code, 200)
+
+ # Verify deletion
+ with self.assertRaises(Block.DoesNotExist):
+ Block.objects.get(num=block_id, CAM=self.cam)
+
+ def test_add_link_api_response(self):
+ """
+ Test link creation API endpoint
+ """
+ # Create another block to link to
+ block3 = Block.objects.create(
+ title="Block3",
+ x_pos=300.0,
+ y_pos=300.0,
+ width=100,
+ height=100,
+ shape="negative",
+ creator=self.user,
+ CAM=self.cam,
+ num=3,
+ )
+
+ response = self.client.post(
+ "/link/add_link",
+ {
+ "link_valid": True,
+ "starting_block": self.block2.id,
+ "ending_block": block3.id,
+ "line_style": "Dashed-Strong",
+ "arrow_type": "bi",
+ },
+ )
+
+ self.assertEqual(response.status_code, 200)
+
+ # Verify link was created
+ new_link = Link.objects.filter(
+ starting_block=self.block2, ending_block=block3
+ ).first()
+ self.assertIsNotNone(new_link)
+
+ def test_update_link_api_response(self):
+ """
+ Test link update API endpoint
+ """
+ response = self.client.post(
+ "/link/update_link",
+ {"link_id": self.link.id, "line_style": "Dashed-Weak", "arrow_type": "bi"},
+ )
+
+ self.assertEqual(response.status_code, 200)
+
+ # Verify update
+ self.link.refresh_from_db()
+ self.assertEqual(self.link.line_style, "Dashed-Weak")
+ self.assertEqual(self.link.arrow_type, "bi")
+
+ def test_delete_link_api_response(self):
+ """
+ Test link deletion API endpoint
+ """
+ link_id = self.link.id
+
+ response = self.client.post(
+ "/link/delete_link", {"delete_link_valid": True, "link_id": link_id}
+ )
+
+ self.assertEqual(response.status_code, 200)
+
+ # Note: The actual deletion behavior may vary
+ # Just verify the endpoint responds successfully
+
+ def test_swap_link_direction_api_response(self):
+ """
+ Test link direction swap API endpoint
+ """
+ original_start = self.link.starting_block
+ original_end = self.link.ending_block
+
+ response = self.client.post(
+ "/link/swap_link_direction", {"link_id": self.link.id}
+ )
+
+ self.assertEqual(response.status_code, 200)
+
+ # Verify direction was swapped
+ self.link.refresh_from_db()
+ self.assertEqual(self.link.starting_block, original_end)
+ self.assertEqual(self.link.ending_block, original_start)
+
+ def test_api_invalid_request_handling(self):
+ """
+ Test API endpoints handle invalid requests gracefully
+ """
+ # Try to add block with missing required fields
+ # Should return error response or 400 status
+ response = self.client.post(
+ "/block/add_block",
+ {
+ "add_valid": True,
+ "num_block": 100,
+ # Missing title, shape, positions
+ },
+ )
+ # View should handle missing fields gracefully
+ self.assertIn(response.status_code, [200, 400])
+
+ def test_api_unauthorized_access(self):
+ """
+ Test API endpoints require authentication
+ """
+ # Logout
+ self.client.logout()
+
+ # Try to access protected endpoint
+ # Should redirect to login or return error
+ response = self.client.post(
+ "/block/add_block",
+ {
+ "add_valid": True,
+ "num_block": 100,
+ "title": "Unauthorized",
+ "shape": 3,
+ "x_pos": 0,
+ "y_pos": 0,
+ "width": 100,
+ "height": 100,
+ },
+ )
+ # Should redirect to login (301/302) or return 403
+ self.assertIn(response.status_code, [301, 302, 403, 404])
+
+ def test_api_cross_user_data_access(self):
+ """
+ Test that users cannot access other users' data via API
+ """
+ # Create CAM for user2
+ other_cam = CAM.objects.create(
+ name="OtherCAM", user=self.user2, project=self.project
+ )
+
+ # Try to load user2's CAM as user1
+ response = self.client.post("/users/load_cam", {"cam_id": other_cam.id})
+
+ # Should deny access or return error
+ # Actual behavior depends on permission checks in view
+ self.assertIn(response.status_code, [200, 403, 404])
+
+ def test_drag_function_updates_position(self):
+ """
+ Test drag function API updates block position correctly
+ """
+ new_x = 250.0
+ new_y = 350.0
+
+ response = self.client.post(
+ "/block/drag_function",
+ {
+ "drag_valid": True,
+ "block_id": self.block1.num,
+ "x_pos": f"{new_x}px",
+ "y_pos": f"{new_y}px",
+ "width": "100px",
+ "height": "100px",
+ },
+ )
+
+ self.assertEqual(response.status_code, 200)
+
+ # Verify position update
+ self.block1.refresh_from_db()
+ self.assertEqual(self.block1.x_pos, new_x)
+ self.assertEqual(self.block1.y_pos, new_y)
+
+ def test_resize_block_api(self):
+ """
+ Test resize block API endpoint (actually resizes via drag_function)
+ """
+ response = self.client.post(
+ "/block/drag_function",
+ {
+ "drag_valid": True,
+ "block_id": self.block1.num,
+ "x_pos": f"{self.block1.x_pos}px",
+ "y_pos": f"{self.block1.y_pos}px",
+ "width": "250px",
+ "height": "200px",
+ },
+ )
+
+ self.assertEqual(response.status_code, 200)
+
+ # Verify resize
+ self.block1.refresh_from_db()
+ self.assertEqual(self.block1.width, 250.0)
+ self.assertEqual(self.block1.height, 200.0)
+
+ def test_update_text_size_api(self):
+ """
+ Test update text size API endpoint
+ """
+ response = self.client.post(
+ "/block/update_text_size", {"block_id": self.block1.num, "text_scale": 20}
+ )
+
+ self.assertEqual(response.status_code, 200)
+
+ # Verify text size update
+ self.block1.refresh_from_db()
+ self.assertEqual(self.block1.text_scale, 20.0)
+
+ def test_create_project_api(self):
+ """
+ Test project creation API endpoint
+ """
+ response = self.client.post(
+ "/users/create_project",
+ {
+ "label": "API Project",
+ "description": "Created via API",
+ "num_participants": 5,
+ "name_participants": "APIP",
+ "participantType": "auto_participants",
+ "languagePreference": "en",
+ "conceptDelete": False,
+ },
+ )
+
+ # Verify project was created
+ new_project = Project.objects.filter(name="API Project").first()
+ self.assertIsNotNone(new_project)
+ self.assertEqual(new_project.description, "Created via API")
+
+ def test_api_handles_concurrent_requests(self):
+ """
+ Test API can handle multiple simultaneous updates
+ """
+ # Update block position multiple times
+ for i in range(5):
+ response = self.client.post(
+ "/block/drag_function",
+ {
+ "drag_valid": True,
+ "block_id": self.block1.num,
+ "x_pos": f"{i * 10}px",
+ "y_pos": f"{i * 20}px",
+ "width": "100px",
+ "height": "100px",
+ },
+ )
+ self.assertEqual(response.status_code, 200)
+
+ # Final position should be from last update
+ self.block1.refresh_from_db()
+ self.assertEqual(self.block1.x_pos, 40.0)
+ self.assertEqual(self.block1.y_pos, 80.0)
diff --git a/users/test_business_logic.py b/users/test_business_logic.py
new file mode 100644
index 000000000..317bf0748
--- /dev/null
+++ b/users/test_business_logic.py
@@ -0,0 +1,459 @@
+"""
+Business Logic Tests for users/views.py
+Tests the extracted utility functions from users/utils.py
+"""
+
+from django.test import TestCase
+from users.models import CustomUser, Researcher, CAM
+from users.forms import (
+ CustomUserCreationForm,
+ ParticipantSignupForm,
+ ResearcherSignupForm,
+ ContactForm,
+)
+from .models import Project
+
+
+class SignupTestCase(TestCase):
+ """Test coverage for signup() function - business logic tests"""
+
+ def setUp(self):
+ # Create a researcher user for the project
+ researcher_user = CustomUser.objects.create_user(
+ username="signup_researcher",
+ email="signup_research@test.com",
+ password="pass123",
+ )
+ Researcher.objects.create(user=researcher_user, affiliation="Test Uni")
+
+ # Create some projects for the signup form
+ self.project1 = Project.objects.create(
+ name="SignupProject1",
+ description="Test Project",
+ researcher=researcher_user,
+ password="TestPass123",
+ name_participants="SP1",
+ )
+
+ def test_signup_form_valid(self):
+ """Test signup form validation with valid data"""
+ form = CustomUserCreationForm(
+ data={
+ "username": "newuser",
+ "email": "newuser@test.com",
+ "first_name": "New",
+ "last_name": "User",
+ "password1": "SecurePass123!",
+ "password2": "SecurePass123!",
+ "language_preference": "en",
+ }
+ )
+ self.assertTrue(form.is_valid())
+
+ def test_signup_form_invalid_password_mismatch(self):
+ """Test signup form validation with mismatched passwords"""
+ form = CustomUserCreationForm(
+ data={
+ "username": "newuser2",
+ "email": "newuser2@test.com",
+ "first_name": "New",
+ "last_name": "User",
+ "password1": "SecurePass123!",
+ "password2": "DifferentPass123!",
+ "language_preference": "en",
+ }
+ )
+ self.assertFalse(form.is_valid())
+ self.assertIn("password2", form.errors)
+
+ def test_signup_form_invalid_duplicate_username(self):
+ """Test signup form validation with duplicate username"""
+ # Create first user
+ CustomUser.objects.create_user(
+ username="duplicate", email="first@test.com", password="pass123"
+ )
+
+ # Try with duplicate username
+ form = CustomUserCreationForm(
+ data={
+ "username": "duplicate",
+ "email": "duplicate@test.com",
+ "first_name": "Duplicate",
+ "last_name": "User",
+ "password1": "SecurePass123!",
+ "password2": "SecurePass123!",
+ "language_preference": "en",
+ }
+ )
+ self.assertFalse(form.is_valid())
+ self.assertIn("username", form.errors)
+
+
+class BusinessLogicTestCase(TestCase):
+ """Test extracted business logic functions from utils.py"""
+
+ def setUp(self):
+ # Create test users
+ self.user = CustomUser.objects.create_user(
+ username="testuser",
+ email="test@test.com",
+ password="testpass123",
+ )
+ self.researcher_user = CustomUser.objects.create_user(
+ username="researcher",
+ email="researcher@test.com",
+ password="researchpass123",
+ )
+ Researcher.objects.create(user=self.researcher_user, affiliation="Test Uni")
+
+ # Create test project
+ self.project = Project.objects.create(
+ name="TestProject",
+ description="Test Project",
+ researcher=self.researcher_user,
+ password="ProjectPass123",
+ name_participants="TP",
+ )
+
+ # Create test CAM
+ self.cam = CAM.objects.create(user=self.user)
+ self.user.active_cam_num = self.cam.id
+ self.user.save()
+
+ def test_validate_project_password_valid(self):
+ """Test project validation with correct password"""
+ from users.utils import validate_project_password
+
+ project, error = validate_project_password(
+ self.project.name, self.project.password
+ )
+ self.assertIsNotNone(project)
+ self.assertIsNone(error)
+ self.assertEqual(project.id, self.project.id)
+
+ def test_validate_project_password_invalid(self):
+ """Test project validation with incorrect password"""
+ from users.utils import validate_project_password
+
+ project, error = validate_project_password(self.project.name, "WrongPassword")
+ self.assertIsNone(project)
+ self.assertIsNotNone(error)
+ self.assertIn("Incorrect", error)
+
+ def test_validate_project_not_exists(self):
+ """Test project validation with non-existent project"""
+ from users.utils import validate_project_password
+
+ project, error = validate_project_password("NonExistent", "")
+ self.assertIsNone(project)
+ self.assertIsNotNone(error)
+ self.assertIn("does not exist", error)
+
+ def test_validate_project_empty_name(self):
+ """Test project validation with empty project name"""
+ from users.utils import validate_project_password
+
+ project, error = validate_project_password("", "")
+ self.assertIsNone(project)
+ self.assertIsNone(error) # Empty project name is not an error
+
+ def test_create_user_from_signup_form_valid(self):
+ """Test user creation from valid signup form"""
+ from users.utils import create_user_from_signup_form
+
+ form = CustomUserCreationForm(
+ data={
+ "username": "newuser",
+ "email": "newuser@test.com",
+ "first_name": "New",
+ "last_name": "User",
+ "password1": "SecurePass123!",
+ "password2": "SecurePass123!",
+ "language_preference": "en",
+ }
+ )
+ self.assertTrue(form.is_valid())
+ user, success = create_user_from_signup_form(form)
+ self.assertTrue(success)
+ self.assertIsNotNone(user)
+ self.assertEqual(user.username, "newuser")
+ self.assertFalse(user.is_active) # Users start inactive
+
+ def test_process_contact_form_valid(self):
+ """Test contact form processing with valid data"""
+ from users.utils import process_contact_form
+
+ form = ContactForm(
+ data={
+ "contacter": "Test User",
+ "email": "test@example.com",
+ "message": "Test message",
+ }
+ )
+ self.assertTrue(form.is_valid())
+ success, error = process_contact_form(form)
+ self.assertTrue(success)
+ self.assertEqual(error, "")
+
+ def test_send_cam_email_valid(self):
+ """Test CAM email sending"""
+ from users.utils import send_cam_email
+ from django.core.mail import outbox
+
+ success, error = send_cam_email(
+ self.user.id,
+ self.user.username,
+ "recipient@example.com",
+ )
+ self.assertTrue(success)
+ self.assertEqual(error, "")
+ # Email should be sent
+ self.assertEqual(len(outbox), 1)
+
+ def test_process_cam_image_invalid_base64(self):
+ """Test image processing with invalid base64 data"""
+ from users.utils import process_cam_image
+ from django.conf import settings
+
+ invalid_data = "not_valid_base64_data"
+ file_name, success = process_cam_image(
+ invalid_data, self.user, settings.MEDIA_URL
+ )
+ self.assertFalse(success)
+ self.assertIsNone(file_name)
+
+ def test_process_cam_zip_import_invalid_zip(self):
+ """Test ZIP import with invalid ZIP file"""
+ from users.utils import process_cam_zip_import
+ from django.core.files.uploadedfile import SimpleUploadedFile
+
+ # Create fake ZIP file
+ fake_zip = SimpleUploadedFile(
+ "notazip.zip", b"This is not a ZIP file", content_type="application/zip"
+ )
+
+ success, error = process_cam_zip_import(fake_zip, self.user, self.cam)
+ self.assertFalse(success)
+ self.assertIn("not a zip file", error.lower())
+
+ def test_validate_project_empty_password(self):
+ """Test project validation with empty password when password not set"""
+ from users.utils import validate_project_password
+
+ # Create project without password requirement
+ no_password_project = Project.objects.create(
+ name="NoPasswordProject",
+ description="Project without password",
+ researcher=self.researcher_user,
+ password="",
+ name_participants="NP",
+ )
+
+ project, error = validate_project_password(no_password_project.name, "")
+ self.assertIsNotNone(project)
+ self.assertIsNone(error)
+
+ def test_create_researcher_user_valid(self):
+ """Test researcher creation"""
+ from users.utils import create_researcher_user
+
+ form = ResearcherSignupForm(
+ data={
+ "username": "newresearcher",
+ "email": "newresearch@test.com",
+ "password1": "ResearchPass123!",
+ "password2": "ResearchPass123!",
+ "affiliation": "Test University",
+ "language_preference": "en",
+ }
+ )
+ self.assertTrue(form.is_valid())
+ user, success = create_researcher_user(form)
+ self.assertTrue(success)
+ self.assertIsNotNone(user)
+ self.assertEqual(user.username, "newresearcher")
+ self.assertTrue(user.is_researcher)
+
+
+class ParticipantSignupFormTestCase(TestCase):
+ """Test ParticipantSignupForm validation"""
+
+ def setUp(self):
+ self.researcher = CustomUser.objects.create_user(
+ username="researcher",
+ email="researcher@test.com",
+ password="pass123",
+ )
+ Researcher.objects.create(user=self.researcher, affiliation="Test Uni")
+ self.project = Project.objects.create(
+ name="TestProject",
+ description="Test",
+ researcher=self.researcher,
+ password="ProjectPass123",
+ name_participants="TP",
+ )
+
+ def test_participant_form_valid(self):
+ """Test valid participant signup form"""
+ form = ParticipantSignupForm(
+ data={
+ "project_name": self.project.name,
+ "project_password": self.project.password,
+ "username": "participant1",
+ "password1": "PartPass123!",
+ "password2": "PartPass123!",
+ "language_preference": "en",
+ }
+ )
+ self.assertTrue(form.is_valid())
+
+ def test_participant_form_password_mismatch(self):
+ """Test participant form with mismatched passwords"""
+ form = ParticipantSignupForm(
+ data={
+ "project_name": "",
+ "project_password": "",
+ "username": "participant2",
+ "password1": "Pass123!",
+ "password2": "DifferentPass123!",
+ "language_preference": "en",
+ }
+ )
+ self.assertFalse(form.is_valid())
+ self.assertIn("password2", form.errors)
+
+
+class ResearcherSignupFormTestCase(TestCase):
+ """Test ResearcherSignupForm validation"""
+
+ def test_researcher_form_valid(self):
+ """Test valid researcher signup form"""
+ form = ResearcherSignupForm(
+ data={
+ "username": "newresearcher",
+ "email": "research@test.com",
+ "password1": "ResearchPass123!",
+ "password2": "ResearchPass123!",
+ "affiliation": "Test University",
+ "language_preference": "en",
+ }
+ )
+ self.assertTrue(form.is_valid())
+
+ def test_researcher_form_password_mismatch(self):
+ """Test researcher form with mismatched passwords"""
+ form = ResearcherSignupForm(
+ data={
+ "username": "researcher3",
+ "email": "research3@test.com",
+ "password1": "ResearchPass123!",
+ "password2": "DifferentPass123!",
+ "affiliation": "Test University",
+ "language_preference": "en",
+ }
+ )
+ self.assertFalse(form.is_valid())
+ self.assertIn("password2", form.errors)
+
+
+class ContactFormTestCase(TestCase):
+ """Test ContactForm validation"""
+
+ def test_contact_form_valid(self):
+ """Test valid contact form"""
+ form = ContactForm(
+ data={
+ "contacter": "Test User",
+ "email": "test@example.com",
+ "message": "Test message",
+ }
+ )
+ self.assertTrue(form.is_valid())
+
+ def test_contact_form_invalid_email(self):
+ """Test contact form with invalid email"""
+ form = ContactForm(
+ data={
+ "contacter": "Test User",
+ "email": "not_an_email",
+ "message": "Test message",
+ }
+ )
+ self.assertFalse(form.is_valid())
+
+ def test_contact_form_missing_fields(self):
+ """Test contact form with missing required fields"""
+ form = ContactForm(data={"contacter": "Test User"})
+ self.assertFalse(form.is_valid())
+
+
+class UtilsFunctionEdgeCasesTestCase(TestCase):
+ """Test edge cases in extracted utils functions"""
+
+ def setUp(self):
+ self.user = CustomUser.objects.create_user(
+ username="testuser",
+ email="test@test.com",
+ password="testpass123",
+ )
+ self.researcher = CustomUser.objects.create_user(
+ username="researcher",
+ email="researcher@test.com",
+ password="researchpass123",
+ )
+ Researcher.objects.create(user=self.researcher, affiliation="Test Uni")
+ self.project = Project.objects.create(
+ name="TestProject",
+ description="Test",
+ researcher=self.researcher,
+ password="ProjectPass123",
+ name_participants="TP",
+ )
+ self.cam = CAM.objects.create(user=self.user)
+
+ def test_validate_project_password_case_sensitive(self):
+ """Test that project password is case-sensitive"""
+ from users.utils import validate_project_password
+
+ # Should fail with different case
+ project, error = validate_project_password(self.project.name, "projectpass123")
+ self.assertIsNone(project)
+ self.assertIsNotNone(error)
+
+ def test_remove_transparency_rgb_image(self):
+ """Test remove_transparency with non-transparent image"""
+ from users.utils import remove_transparency
+ from PIL import Image
+
+ # Create RGB image (no transparency)
+ img = Image.new("RGB", (100, 100), (255, 0, 0))
+ result = remove_transparency(img)
+ self.assertEqual(result, img)
+
+ def test_process_contact_form_with_special_characters(self):
+ """Test contact form with special characters"""
+ from users.utils import process_contact_form
+
+ form = ContactForm(
+ data={
+ "contacter": "Test User <>&\"'",
+ "email": "test@example.com",
+ "message": 'Message with &characters& and "quotes"',
+ }
+ )
+ self.assertTrue(form.is_valid())
+ success, error = process_contact_form(form)
+ self.assertTrue(success)
+
+ def test_send_cam_email_with_valid_user(self):
+ """Test send_cam_email successfully sends email"""
+ from users.utils import send_cam_email
+ from django.core.mail import outbox
+
+ success, error = send_cam_email(
+ self.user.id, self.user.username, "recipient@example.com"
+ )
+ # Should succeed
+ self.assertTrue(success)
+ # Email should be sent
+ self.assertEqual(len(outbox), 1)
diff --git a/users/test_business_logic_extended.py b/users/test_business_logic_extended.py
new file mode 100644
index 000000000..51c613c6b
--- /dev/null
+++ b/users/test_business_logic_extended.py
@@ -0,0 +1,512 @@
+"""
+Extended Business Logic Tests with Mocking
+Tests for image processing, ZIP import, and email functionality
+with proper mocking of external dependencies
+"""
+
+from django.test import TestCase
+from django.core.files.uploadedfile import SimpleUploadedFile
+from django.core import mail
+from unittest.mock import patch, MagicMock
+from PIL import Image
+from zipfile import ZipFile
+import csv
+import io
+import base64
+
+from users.models import CustomUser, Researcher, CAM
+from users.forms import (
+ ContactForm,
+ CustomUserCreationForm,
+ ParticipantSignupForm,
+ ResearcherSignupForm,
+)
+from .models import Project
+from block.models import Block
+
+
+class ImageProcessingTestCase(TestCase):
+ """Test image processing error cases"""
+
+ def setUp(self):
+ self.user = CustomUser.objects.create_user(
+ username="testuser",
+ email="test@test.com",
+ password="testpass123",
+ )
+ self.cam = CAM.objects.create(user=self.user)
+ self.user.active_cam_num = self.cam.id
+ self.user.save()
+
+ def test_process_cam_image_invalid_base64_padding(self):
+ """Test image processing with invalid base64 padding"""
+ from users.utils import process_cam_image
+ from django.conf import settings
+
+ # Malformed base64 (incorrect padding)
+ invalid_data = "data:image/png;base64,this_is_not_valid_base64!!!"
+
+ file_name, success = process_cam_image(
+ invalid_data, self.user, settings.MEDIA_URL
+ )
+
+ self.assertFalse(success)
+ self.assertIsNone(file_name)
+
+ def test_process_cam_image_empty_data(self):
+ """Test image processing with empty data"""
+ from users.utils import process_cam_image
+ from django.conf import settings
+
+ file_name, success = process_cam_image("", self.user, settings.MEDIA_URL)
+
+ self.assertFalse(success)
+ self.assertIsNone(file_name)
+
+ def test_process_cam_image_malformed_header(self):
+ """Test image processing with malformed data URI header"""
+ from users.utils import process_cam_image
+ from django.conf import settings
+
+ # Missing base64 keyword
+ malformed = "data:image/png;unknown,ABCDEF"
+
+ file_name, success = process_cam_image(malformed, self.user, settings.MEDIA_URL)
+
+ self.assertFalse(success)
+
+
+class ZIPImportTestCase(TestCase):
+ """Test ZIP import with mocked data"""
+
+ def setUp(self):
+ self.user = CustomUser.objects.create_user(
+ username="testuser",
+ email="test@test.com",
+ password="testpass123",
+ )
+ self.researcher = CustomUser.objects.create_user(
+ username="researcher",
+ email="researcher@test.com",
+ password="researchpass123",
+ )
+ Researcher.objects.create(user=self.researcher, affiliation="Test Uni")
+ self.project = Project.objects.create(
+ name="TestProject",
+ description="Test",
+ researcher=self.researcher,
+ password="ProjectPass123",
+ name_participants="TP",
+ )
+ self.cam = CAM.objects.create(user=self.user, project=self.project)
+
+ def _create_valid_zip_with_csv(self):
+ """Helper to create a valid ZIP file with CSV data"""
+ zip_buffer = io.BytesIO()
+
+ with ZipFile(zip_buffer, "w") as z:
+ # Create blocks.csv
+ blocks_csv = io.StringIO()
+ blocks_writer = csv.writer(blocks_csv)
+ blocks_writer.writerow(
+ ["id", "creator", "title", "shape", "CAM", "text_scale", "comment"]
+ )
+ blocks_writer.writerow(
+ [
+ "",
+ str(self.user.id),
+ "Test Block 1",
+ "positive",
+ str(self.cam.id),
+ "14",
+ "Test comment",
+ ]
+ )
+ blocks_writer.writerow(
+ [
+ "",
+ str(self.user.id),
+ "Test Block 2",
+ "negative",
+ str(self.cam.id),
+ "12",
+ "",
+ ]
+ )
+ z.writestr("blocks.csv", blocks_csv.getvalue())
+
+ # Create links.csv
+ links_csv = io.StringIO()
+ links_writer = csv.writer(links_csv)
+ links_writer.writerow(["source_id", "target_id", "creator", "CAM"])
+ z.writestr("links.csv", links_csv.getvalue())
+
+ zip_buffer.seek(0)
+ return SimpleUploadedFile(
+ "valid.zip", zip_buffer.getvalue(), content_type="application/zip"
+ )
+
+ @patch("users.utils.BlockResource")
+ @patch("users.utils.LinkResource")
+ def test_process_cam_zip_import_valid_zip(
+ self, mock_link_resource, mock_block_resource
+ ):
+ """Test successful ZIP import with valid CSV data"""
+ from users.utils import process_cam_zip_import
+
+ # Setup resource mocks
+ mock_block_resource_instance = MagicMock()
+ mock_link_resource_instance = MagicMock()
+ mock_block_resource.return_value = mock_block_resource_instance
+ mock_link_resource.return_value = mock_link_resource_instance
+
+ # Mock import_data to return success
+ mock_result = MagicMock()
+ mock_result.has_errors.return_value = False
+ mock_block_resource_instance.import_data.return_value = mock_result
+ mock_link_resource_instance.import_data.return_value = mock_result
+
+ # Create valid ZIP
+ valid_zip = self._create_valid_zip_with_csv()
+
+ # Test import
+ success, error = process_cam_zip_import(valid_zip, self.user, self.cam)
+
+ self.assertTrue(success)
+ self.assertEqual(error, "")
+
+ def test_process_cam_zip_import_empty_zip(self):
+ """Test ZIP import with empty ZIP file"""
+ from users.utils import process_cam_zip_import
+
+ # Create empty ZIP
+ zip_buffer = io.BytesIO()
+ with ZipFile(zip_buffer, "w") as z:
+ pass # Empty ZIP
+
+ zip_buffer.seek(0)
+ empty_zip = SimpleUploadedFile(
+ "empty.zip", zip_buffer.getvalue(), content_type="application/zip"
+ )
+
+ success, error = process_cam_zip_import(empty_zip, self.user, self.cam)
+
+ # Empty ZIP should succeed (no data to import)
+ self.assertTrue(success)
+
+ def test_process_cam_zip_import_missing_blocks_csv(self):
+ """Test ZIP import with missing blocks.csv"""
+ from users.utils import process_cam_zip_import
+
+ # Create ZIP without blocks.csv
+ zip_buffer = io.BytesIO()
+ with ZipFile(zip_buffer, "w") as z:
+ links_csv = io.StringIO()
+ links_writer = csv.writer(links_csv)
+ links_writer.writerow(["source_id", "target_id", "creator"])
+ z.writestr("links.csv", links_csv.getvalue())
+
+ zip_buffer.seek(0)
+ incomplete_zip = SimpleUploadedFile(
+ "incomplete.zip", zip_buffer.getvalue(), content_type="application/zip"
+ )
+
+ # Should succeed but only process links
+ success, error = process_cam_zip_import(incomplete_zip, self.user, self.cam)
+ self.assertTrue(success)
+
+ def test_process_cam_zip_import_corrupted_csv(self):
+ """Test ZIP import with corrupted CSV data"""
+ from users.utils import process_cam_zip_import
+
+ # Create ZIP with invalid CSV
+ zip_buffer = io.BytesIO()
+ with ZipFile(zip_buffer, "w") as z:
+ z.writestr("blocks.csv", "This is not valid CSV\n\x00\x01\x02")
+ z.writestr("links.csv", "Also invalid")
+
+ zip_buffer.seek(0)
+ corrupted_zip = SimpleUploadedFile(
+ "corrupted.zip", zip_buffer.getvalue(), content_type="application/zip"
+ )
+
+ success, error = process_cam_zip_import(corrupted_zip, self.user, self.cam)
+
+ # Should handle error gracefully
+ self.assertFalse(success)
+ self.assertIsNotNone(error)
+
+
+class EmailSendingTestCase(TestCase):
+ """Test email sending with proper assertions"""
+
+ def setUp(self):
+ self.user = CustomUser.objects.create_user(
+ username="testuser",
+ email="test@test.com",
+ password="testpass123",
+ )
+ self.cam = CAM.objects.create(user=self.user)
+
+ @patch("users.utils.render_to_string")
+ def test_process_contact_form_calls_render_template(self, mock_render):
+ """Test that contact form renders email template"""
+ from users.utils import process_contact_form
+
+ mock_render.return_value = "Test Email"
+
+ form = ContactForm(
+ data={
+ "contacter": "Test User",
+ "email": "test@example.com",
+ "message": "Test message",
+ }
+ )
+
+ self.assertTrue(form.is_valid())
+ success, error = process_contact_form(form)
+
+ # Verify template was rendered
+ self.assertTrue(success)
+ mock_render.assert_called_once()
+ call_args = mock_render.call_args
+ self.assertEqual(call_args[0][0], "Admin/email_contact_us.html")
+
+ def test_process_contact_form_sends_email_with_correct_data(self):
+ """Test contact form sends email with form data"""
+ from users.utils import process_contact_form
+
+ form = ContactForm(
+ data={
+ "contacter": "John Doe",
+ "email": "john@example.com",
+ "message": "Important message",
+ }
+ )
+
+ self.assertTrue(form.is_valid())
+ success, error = process_contact_form(form)
+
+ self.assertTrue(success)
+ self.assertEqual(len(mail.outbox), 1)
+
+ email = mail.outbox[0]
+ self.assertEqual(email.from_email, "john@example.com")
+ self.assertIn("thibeaultrheaprogramming@gmail.com", email.to)
+ self.assertEqual(email.subject, "CAM")
+
+ @patch("users.utils.render_to_string")
+ def test_send_cam_email_renders_template(self, mock_render):
+ """Test send_cam_email renders template"""
+ from users.utils import send_cam_email
+
+ mock_render.return_value = "CAM Email"
+
+ success, error = send_cam_email(
+ self.user.id, self.user.username, "recipient@example.com"
+ )
+
+ self.assertTrue(success)
+ mock_render.assert_called_once()
+ call_args = mock_render.call_args
+ self.assertEqual(call_args[0][0], "Admin/send_CAM.html")
+
+ @patch("users.utils.render_to_string")
+ def test_send_cam_email_attaches_csv_files(self, mock_render):
+ """Test send_cam_email attaches CSV files"""
+ from users.utils import send_cam_email
+
+ mock_render.return_value = "CAM Email"
+
+ success, error = send_cam_email(
+ self.user.id, self.user.username, "recipient@example.com"
+ )
+
+ self.assertTrue(success)
+ self.assertEqual(len(mail.outbox), 1)
+
+ email = mail.outbox[0]
+ # Should have attachments (blocks and links CSV)
+ self.assertGreater(len(email.attachments), 0)
+
+ def test_send_cam_email_with_custom_recipient(self):
+ """Test send_cam_email with custom recipient"""
+ from users.utils import send_cam_email
+
+ custom_email = "custom@example.com"
+ success, error = send_cam_email(self.user.id, self.user.username, custom_email)
+
+ self.assertTrue(success)
+ self.assertEqual(len(mail.outbox), 1)
+ self.assertIn(custom_email, mail.outbox[0].to)
+
+ def test_send_cam_email_default_recipient(self):
+ """Test send_cam_email uses default recipient"""
+ from users.utils import send_cam_email
+
+ success, error = send_cam_email(self.user.id, self.user.username)
+
+ self.assertTrue(success)
+ self.assertEqual(len(mail.outbox), 1)
+ self.assertIn("thibeaultrheaprogramming@gmail.com", mail.outbox[0].to)
+
+
+class ParticipantUserCreationTestCase(TestCase):
+ """Test participant user creation with project affiliation"""
+
+ def setUp(self):
+ self.researcher = CustomUser.objects.create_user(
+ username="researcher",
+ email="researcher@test.com",
+ password="pass123",
+ )
+ Researcher.objects.create(user=self.researcher, affiliation="Test Uni")
+ self.project = Project.objects.create(
+ name="TestProject",
+ description="Test",
+ researcher=self.researcher,
+ password="ProjectPass123",
+ name_participants="TP",
+ )
+
+ @patch("users.utils.upload_cam_participant")
+ def test_create_participant_user_with_project(self, mock_upload_cam):
+ """Test participant creation with project affiliation"""
+ from users.utils import create_participant_user
+ from users.forms import ParticipantSignupForm
+
+ form = ParticipantSignupForm(
+ data={
+ "project_name": self.project.name,
+ "project_password": self.project.password,
+ "username": "participant1",
+ "password1": "PartPass123!",
+ "password2": "PartPass123!",
+ "language_preference": "en",
+ }
+ )
+
+ self.assertTrue(form.is_valid())
+
+ # Create request mock
+ mock_request = MagicMock()
+
+ user, success = create_participant_user(
+ form, project=self.project, request=mock_request
+ )
+
+ self.assertTrue(success)
+ self.assertIsNotNone(user)
+ self.assertEqual(user.username, "participant1")
+ self.assertEqual(user.active_project_num, self.project.id)
+ # Verify CAM upload was called
+ mock_upload_cam.assert_called_once()
+
+ @patch("users.utils.create_individual_cam")
+ def test_create_participant_user_without_project(self, mock_create_cam):
+ """Test participant creation without project affiliation"""
+ from users.utils import create_participant_user
+ from users.forms import ParticipantSignupForm
+
+ form = ParticipantSignupForm(
+ data={
+ "project_name": "",
+ "project_password": "",
+ "username": "participant2",
+ "password1": "PartPass123!",
+ "password2": "PartPass123!",
+ "language_preference": "en",
+ }
+ )
+
+ self.assertTrue(form.is_valid())
+
+ mock_request = MagicMock()
+ user, success = create_participant_user(
+ form, project=None, request=mock_request
+ )
+
+ self.assertTrue(success)
+ self.assertIsNotNone(user)
+ # Verify individual CAM was created
+ mock_create_cam.assert_called_once()
+
+
+class FormValidationComprehensiveTestCase(TestCase):
+ """Comprehensive form validation tests"""
+
+ def test_custom_user_creation_form_passwords_must_match(self):
+ """Test form validation rejects mismatched passwords"""
+ form = CustomUserCreationForm(
+ data={
+ "username": "testuser",
+ "email": "test@test.com",
+ "first_name": "Test",
+ "last_name": "User",
+ "password1": "Pass123!",
+ "password2": "Different123!", # Mismatch
+ "language_preference": "en",
+ }
+ )
+ self.assertFalse(form.is_valid())
+ self.assertIn("password2", form.errors)
+
+ def test_custom_user_creation_valid_form(self):
+ """Test valid custom user creation form"""
+ form = CustomUserCreationForm(
+ data={
+ "username": "testuser",
+ "email": "test@test.com",
+ "first_name": "Test",
+ "last_name": "User",
+ "password1": "Pass123!test",
+ "password2": "Pass123!test",
+ "language_preference": "en",
+ }
+ )
+ self.assertTrue(form.is_valid())
+
+ def test_participant_form_blank_project_allowed(self):
+ """Test participant form allows blank project"""
+ form = ParticipantSignupForm(
+ data={
+ "project_name": "",
+ "project_password": "",
+ "username": "participant",
+ "email": "part@test.com",
+ "first_name": "Part",
+ "last_name": "Icipant",
+ "password1": "Pass123!test",
+ "password2": "Pass123!test",
+ "language_preference": "en",
+ }
+ )
+ self.assertTrue(form.is_valid())
+
+ def test_researcher_form_valid_with_affiliation(self):
+ """Test researcher form with affiliation"""
+ form = ResearcherSignupForm(
+ data={
+ "username": "researcher",
+ "email": "research@test.com",
+ "first_name": "Res",
+ "last_name": "Earcher",
+ "password1": "Pass123!test",
+ "password2": "Pass123!test",
+ "affiliation": "Test University",
+ "language_preference": "en",
+ }
+ )
+ self.assertTrue(form.is_valid())
+
+ def test_contact_form_long_message(self):
+ """Test contact form with long message"""
+ long_message = "x" * 1000
+ form = ContactForm(
+ data={
+ "contacter": "Test User",
+ "email": "test@example.com",
+ "message": long_message,
+ }
+ )
+ self.assertTrue(form.is_valid())
diff --git a/users/test_create_users.py b/users/test_create_users.py
new file mode 100644
index 000000000..2af9c14ca
--- /dev/null
+++ b/users/test_create_users.py
@@ -0,0 +1,587 @@
+"""
+Comprehensive tests for create_users.py
+Tests user creation functionality for projects with and without initial CAM imports
+"""
+
+from django.test import TestCase, override_settings
+from users.models import CustomUser, Researcher, Participant, Project, CAM
+from block.models import Block
+from link.models import Link
+from users.create_users import create_users
+from django.core.files.uploadedfile import SimpleUploadedFile
+from zipfile import ZipFile
+from io import BytesIO
+import tempfile
+import os
+
+
+@override_settings(
+ STATICFILES_STORAGE="django.contrib.staticfiles.storage.StaticFilesStorage"
+)
+class CreateUsersBasicTestCase(TestCase):
+ """Tests for basic user creation without CAM import"""
+
+ def setUp(self):
+ self.researcher = CustomUser.objects.create_user(
+ username="researcher", email="researcher@test.com", password="12345"
+ )
+ self.researcher_profile = Researcher.objects.create(
+ user=self.researcher, affiliation="UdeM"
+ )
+
+ self.project = Project.objects.create(
+ name="TestProject",
+ description="TEST PROJECT",
+ researcher=self.researcher,
+ password="TestProjectPassword",
+ )
+
+ def test_create_single_user(self):
+ """Test creating a single user for a project"""
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id="test",
+ language_pref="en",
+ input_file=None,
+ deletable=None,
+ )
+
+ # Verify user was created
+ user = CustomUser.objects.get(username="test0")
+ self.assertIsNotNone(user)
+ self.assertEqual(user.email, "test0@test.com")
+
+ # Verify participant profile was created
+ participant = Participant.objects.get(user=user)
+ self.assertEqual(participant.researcher, self.researcher)
+ self.assertEqual(participant.project, self.project)
+ self.assertEqual(participant.language_preference, "en")
+
+ def test_create_multiple_users(self):
+ """Test creating multiple users for a project"""
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=5,
+ call_id="batch",
+ language_pref="fr",
+ input_file=None,
+ deletable=None,
+ )
+
+ # Verify all users were created
+ for i in range(5):
+ user = CustomUser.objects.get(username=f"batch{i}")
+ self.assertIsNotNone(user)
+ self.assertEqual(user.email, f"batch{i}@test.com")
+
+ # Verify participant profiles
+ participant = Participant.objects.get(user=user)
+ self.assertEqual(participant.researcher, self.researcher)
+ self.assertEqual(participant.project, self.project)
+ self.assertEqual(participant.language_preference, "fr")
+
+ def test_create_user_with_cam(self):
+ """Test that each user gets a CAM created"""
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=2,
+ call_id="cam",
+ language_pref="en",
+ input_file=None,
+ deletable=None,
+ )
+
+ # Verify CAMs were created for each user
+ for i in range(2):
+ user = CustomUser.objects.get(username=f"cam{i}")
+ self.assertIsNotNone(user.active_cam_num)
+
+ # Verify CAM exists
+ cam = CAM.objects.get(id=user.active_cam_num)
+ self.assertEqual(cam.user, user)
+ self.assertEqual(cam.project, self.project)
+
+ def test_username_password_convention(self):
+ """Test that username and password follow the naming convention"""
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id="test",
+ language_pref="en",
+ input_file=None,
+ deletable=None,
+ )
+
+ # Verify password follows convention: call_id + num + call_id
+ user = CustomUser.objects.get(username="test0")
+ # Password should be 'test0test'
+ self.assertTrue(user.check_password("test0test"))
+
+ def test_recreate_existing_user(self):
+ """Test that creating a user with existing username deletes old user"""
+ # Create initial user manually
+ old_user = CustomUser.objects.create_user(
+ username="replace0", email="old@test.com", password="oldpass"
+ )
+ old_user_id = old_user.id
+
+ # Create user with same username through create_users
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id="replace",
+ language_pref="en",
+ input_file=None,
+ deletable=None,
+ )
+
+ # Verify old user is deleted
+ self.assertFalse(CustomUser.objects.filter(id=old_user_id).exists())
+
+ # Verify new user exists with correct email
+ new_user = CustomUser.objects.get(username="replace0")
+ self.assertEqual(new_user.email, "replace0@test.com")
+
+ def test_user_language_preferences(self):
+ """Test creating users with different language preferences"""
+ # Create English preference users
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=2,
+ call_id="en",
+ language_pref="en",
+ input_file=None,
+ deletable=None,
+ )
+
+ # Create French preference users
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=2,
+ call_id="fr",
+ language_pref="fr",
+ input_file=None,
+ deletable=None,
+ )
+
+ # Verify language preferences
+ en_user = CustomUser.objects.get(username="en0")
+ en_participant = Participant.objects.get(user=en_user)
+ self.assertEqual(en_participant.language_preference, "en")
+
+ fr_user = CustomUser.objects.get(username="fr0")
+ fr_participant = Participant.objects.get(user=fr_user)
+ self.assertEqual(fr_participant.language_preference, "fr")
+
+ def test_create_zero_users(self):
+ """Test creating zero users (edge case)"""
+ initial_user_count = CustomUser.objects.count()
+
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=0,
+ call_id="zero",
+ language_pref="en",
+ input_file=None,
+ deletable=None,
+ )
+
+ # Verify no new users were created
+ self.assertEqual(CustomUser.objects.count(), initial_user_count)
+
+
+@override_settings(
+ STATICFILES_STORAGE="django.contrib.staticfiles.storage.StaticFilesStorage",
+ MEDIA_ROOT=tempfile.mkdtemp(),
+)
+class CreateUsersWithCAMImportTestCase(TestCase):
+ """Tests for user creation with initial CAM import"""
+
+ def setUp(self):
+ self.researcher = CustomUser.objects.create_user(
+ username="researcher", email="researcher@test.com", password="12345"
+ )
+ self.researcher_profile = Researcher.objects.create(
+ user=self.researcher, affiliation="UdeM"
+ )
+
+ self.project = Project.objects.create(
+ name="ImportProject",
+ description="PROJECT WITH IMPORT",
+ researcher=self.researcher,
+ password="ImportPassword",
+ )
+
+ def _create_test_zip_file(self, include_links=True):
+ """Helper function to create a test ZIP file with blocks and links CSV"""
+ zip_buffer = BytesIO()
+
+ # Create blocks CSV content
+ blocks_csv = (
+ "id,title,x_pos,y_pos,width,height,shape,comment,creator,CAM,num,resizable,modifiable\n"
+ "1,ConceptA,100.0,100.0,100,100,neutral,Test comment,999,999,1,True,True\n"
+ "2,ConceptB,200.0,200.0,100,100,positive,,999,999,2,True,True\n"
+ )
+
+ # Create links CSV content
+ links_csv = (
+ "id,starting_block,ending_block,line_style,arrow_type,creator,CAM,num\n"
+ "1,1,2,Solid-Weak,uni,999,999,1\n"
+ )
+
+ with ZipFile(zip_buffer, "w") as zip_file:
+ zip_file.writestr("blocks.csv", blocks_csv)
+ if include_links:
+ zip_file.writestr("links.csv", links_csv)
+
+ zip_buffer.seek(0)
+ return SimpleUploadedFile(
+ "test_cam.zip", zip_buffer.read(), content_type="application/zip"
+ )
+
+ def test_create_user_with_cam_import(self):
+ """Test creating user with initial CAM import"""
+ zip_file = self._create_test_zip_file()
+
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id="import",
+ language_pref="en",
+ input_file=zip_file,
+ deletable=None,
+ )
+
+ # Verify user was created
+ user = CustomUser.objects.get(username="import0")
+ self.assertIsNotNone(user)
+
+ # Verify CAM was created and has blocks
+ cam = CAM.objects.get(id=user.active_cam_num)
+ blocks = Block.objects.filter(CAM=cam)
+
+ self.assertEqual(blocks.count(), 2)
+
+ # Verify block properties
+ block_a = blocks.get(title="ConceptA")
+ self.assertEqual(block_a.x_pos, 100.0)
+ self.assertEqual(block_a.y_pos, 100.0)
+ self.assertEqual(block_a.shape, "neutral")
+ self.assertEqual(block_a.creator, user)
+ self.assertEqual(block_a.CAM, cam)
+
+ def test_create_user_with_cam_import_links(self):
+ """Test that links are imported correctly"""
+ zip_file = self._create_test_zip_file()
+
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id="linktest",
+ language_pref="en",
+ input_file=zip_file,
+ deletable=None,
+ )
+
+ user = CustomUser.objects.get(username="linktest0")
+ cam = CAM.objects.get(id=user.active_cam_num)
+ links = Link.objects.filter(CAM=cam)
+
+ self.assertEqual(links.count(), 1)
+
+ # Verify link properties
+ link = links.first()
+ self.assertEqual(link.line_style, "Solid-Weak")
+ self.assertEqual(link.arrow_type, "uni")
+ self.assertEqual(link.creator, user)
+ self.assertEqual(link.CAM, cam)
+
+ def test_create_user_import_cleans_none_comments(self):
+ """Test that 'None' comments are cleaned to empty strings"""
+ # Create zip with 'None' comment
+ zip_buffer = BytesIO()
+ blocks_csv = (
+ "id,title,x_pos,y_pos,width,height,shape,comment,creator,CAM,num,resizable,modifiable\n"
+ "1,TestBlock,100.0,100.0,100,100,neutral,None,999,999,1,True,True\n"
+ )
+
+ with ZipFile(zip_buffer, "w") as zip_file:
+ zip_file.writestr("blocks.csv", blocks_csv)
+ zip_file.writestr(
+ "links.csv",
+ "id,starting_block,ending_block,line_style,arrow_type,creator,CAM,num\n",
+ )
+
+ zip_buffer.seek(0)
+ zip_file = SimpleUploadedFile(
+ "test.zip", zip_buffer.read(), content_type="application/zip"
+ )
+
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id="clean",
+ language_pref="en",
+ input_file=zip_file,
+ deletable=None,
+ )
+
+ user = CustomUser.objects.get(username="clean0")
+ cam = CAM.objects.get(id=user.active_cam_num)
+ block = Block.objects.get(CAM=cam, title="TestBlock")
+
+ # Comment should be empty string, not 'None'
+ self.assertEqual(block.comment, "")
+
+ def test_create_user_import_with_deletable_false(self):
+ """Test that deletable=False makes blocks non-modifiable"""
+ zip_file = self._create_test_zip_file()
+
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id="locked",
+ language_pref="en",
+ input_file=zip_file,
+ deletable=False,
+ )
+
+ user = CustomUser.objects.get(username="locked0")
+ cam = CAM.objects.get(id=user.active_cam_num)
+ blocks = Block.objects.filter(CAM=cam)
+
+ # All blocks should be non-modifiable
+ for block in blocks:
+ self.assertFalse(block.modifiable)
+
+ def test_create_user_import_with_deletable_true(self):
+ """Test that deletable=True keeps blocks modifiable"""
+ zip_file = self._create_test_zip_file()
+
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id="unlocked",
+ language_pref="en",
+ input_file=zip_file,
+ deletable=True,
+ )
+
+ user = CustomUser.objects.get(username="unlocked0")
+ cam = CAM.objects.get(id=user.active_cam_num)
+ blocks = Block.objects.filter(CAM=cam)
+
+ # Blocks should still be modifiable (deletable doesn't affect when True)
+ # Based on code: only sets modifiable=False when deletable is not None
+ # So this test verifies the original behavior is preserved
+ self.assertGreater(blocks.count(), 0)
+
+ def test_create_multiple_users_with_same_import(self):
+ """Test that multiple users get independent copies of imported CAM"""
+ zip_file = self._create_test_zip_file()
+
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=3,
+ call_id="multi",
+ language_pref="en",
+ input_file=zip_file,
+ deletable=None,
+ )
+
+ # Verify each user has their own CAM with blocks
+ for i in range(3):
+ user = CustomUser.objects.get(username=f"multi{i}")
+ cam = CAM.objects.get(id=user.active_cam_num)
+ blocks = Block.objects.filter(CAM=cam)
+
+ self.assertEqual(blocks.count(), 2)
+
+ # Verify blocks belong to correct user
+ for block in blocks:
+ self.assertEqual(block.creator, user)
+ self.assertEqual(block.CAM, cam)
+
+ def test_create_user_import_sets_project_initial_cam(self):
+ """Test that import file is saved to project"""
+ zip_file = self._create_test_zip_file()
+
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id="projfile",
+ language_pref="en",
+ input_file=zip_file,
+ deletable=None,
+ )
+
+ # Verify project has Initial_CAM set
+ self.project.refresh_from_db()
+ self.assertIsNotNone(self.project.Initial_CAM)
+ self.assertIn("test_cam.zip", self.project.Initial_CAM.name)
+
+ def test_create_user_empty_blocks_csv(self):
+ """Test handling of empty blocks CSV"""
+ zip_buffer = BytesIO()
+ blocks_csv = "id,title,x_pos,y_pos,width,height,shape,comment,creator,CAM,num,resizable,modifiable\n"
+ links_csv = (
+ "id,starting_block,ending_block,line_style,arrow_type,creator,CAM,num\n"
+ )
+
+ with ZipFile(zip_buffer, "w") as zip_file:
+ zip_file.writestr("blocks.csv", blocks_csv)
+ zip_file.writestr("links.csv", links_csv)
+
+ zip_buffer.seek(0)
+ zip_file = SimpleUploadedFile(
+ "empty.zip", zip_buffer.read(), content_type="application/zip"
+ )
+
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id="empty",
+ language_pref="en",
+ input_file=zip_file,
+ deletable=None,
+ )
+
+ # User should still be created
+ user = CustomUser.objects.get(username="empty0")
+ cam = CAM.objects.get(id=user.active_cam_num)
+
+ # CAM should have no blocks
+ self.assertEqual(Block.objects.filter(CAM=cam).count(), 0)
+
+
+@override_settings(
+ STATICFILES_STORAGE="django.contrib.staticfiles.storage.StaticFilesStorage"
+)
+class CreateUsersEdgeCasesTestCase(TestCase):
+ """Tests for edge cases and error handling in create_users"""
+
+ def setUp(self):
+ self.researcher = CustomUser.objects.create_user(
+ username="researcher", email="researcher@test.com", password="12345"
+ )
+ self.researcher_profile = Researcher.objects.create(
+ user=self.researcher, affiliation="UdeM"
+ )
+
+ self.project = Project.objects.create(
+ name="EdgeCaseProject",
+ description="EDGE CASE TESTING",
+ researcher=self.researcher,
+ password="EdgePassword",
+ )
+
+ def test_create_user_with_special_characters_call_id(self):
+ """Test creating users with special characters in call_id"""
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id="test_user_",
+ language_pref="en",
+ input_file=None,
+ deletable=None,
+ )
+
+ # User should be created with special characters
+ user = CustomUser.objects.get(username="test_user_0")
+ self.assertIsNotNone(user)
+
+ def test_create_user_with_long_call_id(self):
+ """Test creating users with long call_id"""
+ long_id = "verylongcallidentifier"
+
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=1,
+ call_id=long_id,
+ language_pref="en",
+ input_file=None,
+ deletable=None,
+ )
+
+ user = CustomUser.objects.get(username=f"{long_id}0")
+ self.assertIsNotNone(user)
+
+ def test_create_large_number_of_users(self):
+ """Test creating a large number of users"""
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=50,
+ call_id="bulk",
+ language_pref="en",
+ input_file=None,
+ deletable=None,
+ )
+
+ # Verify all 50 users were created
+ bulk_users = CustomUser.objects.filter(username__startswith="bulk")
+ self.assertEqual(bulk_users.count(), 50)
+
+ # Verify each has a CAM
+ for user in bulk_users:
+ self.assertIsNotNone(user.active_cam_num)
+
+ def test_users_belong_to_correct_project(self):
+ """Test that users are associated with correct project"""
+ # Create second project
+ project2 = Project.objects.create(
+ name="Project2",
+ description="SECOND PROJECT",
+ researcher=self.researcher,
+ password="Project2Pass",
+ )
+
+ # Create users for project 1
+ create_users(
+ project=self.project,
+ researcher=self.researcher,
+ num_part=2,
+ call_id="p1",
+ language_pref="en",
+ input_file=None,
+ deletable=None,
+ )
+
+ # Create users for project 2
+ create_users(
+ project=project2,
+ researcher=self.researcher,
+ num_part=2,
+ call_id="p2",
+ language_pref="en",
+ input_file=None,
+ deletable=None,
+ )
+
+ # Verify project associations
+ p1_user = CustomUser.objects.get(username="p10")
+ p1_participant = Participant.objects.get(user=p1_user)
+ self.assertEqual(p1_participant.project, self.project)
+
+ p2_user = CustomUser.objects.get(username="p20")
+ p2_participant = Participant.objects.get(user=p2_user)
+ self.assertEqual(p2_participant.project, project2)
diff --git a/users/test_email.py b/users/test_email.py
new file mode 100644
index 000000000..af0dba904
--- /dev/null
+++ b/users/test_email.py
@@ -0,0 +1,269 @@
+from django.test import TestCase, override_settings
+from django.core import mail
+from users.models import CustomUser, Researcher, CAM, Project
+from block.models import Block
+from link.models import Link
+
+
+@override_settings(
+ STATICFILES_STORAGE="django.contrib.staticfiles.storage.StaticFilesStorage",
+ EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend",
+)
+class EmailFunctionalityTestCase(TestCase):
+ """
+ Test suite for email functionality including contact forms and CAM sharing
+ """
+
+ def setUp(self):
+ # Create users
+ self.user = CustomUser.objects.create_user(
+ username="testuser", email="test@test.com", password="12345"
+ )
+ self.user2 = CustomUser.objects.create_user(
+ username="testuser2", email="test2@test.com", password="12345"
+ )
+
+ self.researcher = Researcher.objects.create(user=self.user, affiliation="UdeM")
+ self.client.login(username="testuser", password="12345")
+
+ # Create project and CAM
+ self.project = Project.objects.create(
+ name="TestProject",
+ description="TEST PROJECT",
+ researcher=self.user,
+ password="TestProjectPassword",
+ )
+
+ self.cam = CAM.objects.create(
+ name="testCAM", user=self.user, project=self.project
+ )
+ self.user.active_cam_num = self.cam.id
+ self.user.save()
+
+ # Clear mail outbox before each test
+ mail.outbox = []
+
+ def test_contact_form_submission_sends_email(self):
+ """
+ Test that submitting contact form sends an email
+ """
+ response = self.client.post(
+ "/users/contact_form",
+ {
+ "contacter": "Test User",
+ "email": "testuser@example.com",
+ "message": "This is a test message for support",
+ },
+ )
+
+ # Check that one email was sent
+ self.assertEqual(len(mail.outbox), 1)
+
+ # Check email content
+ email = mail.outbox[0]
+ self.assertIn("Test User", email.body)
+ self.assertIn("testuser@example.com", email.body)
+ self.assertIn("This is a test message for support", email.body)
+
+ def test_contact_form_invalid_email(self):
+ """
+ Test contact form with invalid email address
+ """
+ response = self.client.post(
+ "/users/contact_form",
+ {
+ "contacter": "Test User",
+ "email": "invalid-email",
+ "message": "Test message",
+ },
+ )
+
+ # Should not send email with invalid email format
+ # Form validation should fail with EmailField
+ self.assertEqual(len(mail.outbox), 0)
+
+ def test_contact_form_missing_required_fields(self):
+ """
+ Test contact form with missing required fields
+ """
+ response = self.client.post(
+ "/users/contact_form",
+ {"contacter": "Test User", "email": "", "message": ""},
+ )
+
+ # Should not send email with missing fields
+ self.assertEqual(len(mail.outbox), 0)
+
+ def test_send_cam_to_email(self):
+ """
+ Test sending CAM data to an email address
+ """
+ # Add some blocks to the CAM
+ Block.objects.create(
+ title="SharedBlock",
+ x_pos=10.0,
+ y_pos=20.0,
+ width=100,
+ height=100,
+ shape="neutral",
+ creator=self.user,
+ CAM=self.cam,
+ num=1,
+ )
+
+ response = self.client.post(
+ "/users/send_cam", {"email": "recipient@example.com", "cam_id": self.cam.id}
+ )
+
+ # Check that email was sent
+ self.assertEqual(len(mail.outbox), 1)
+
+ email = mail.outbox[0]
+ self.assertIn("recipient@example.com", email.to)
+
+ def test_password_reset_email(self):
+ """
+ Test that password reset sends email
+ """
+ response = self.client.post(
+ "/users/password_reset/", {"email": "test@test.com"}
+ )
+
+ # Check that password reset email was sent
+ self.assertEqual(len(mail.outbox), 1)
+
+ email = mail.outbox[0]
+ self.assertIn("test@test.com", email.to)
+ # Should contain reset link or token
+ self.assertTrue(len(email.body) > 0)
+
+ def test_contact_form_get_request(self):
+ """
+ Test that GET request to contact form displays form
+ """
+ response = self.client.get("/users/contact_form")
+
+ self.assertEqual(response.status_code, 200)
+ # Should render the contact form template
+ self.assertIn(
+ "Contact", response.content.decode() or "contact" in str(response.context)
+ )
+
+ def test_email_content_escapes_html(self):
+ """
+ Test that email content properly escapes HTML to prevent XSS
+ """
+ response = self.client.post(
+ "/users/contact_form",
+ {
+ "contacter": "Test User",
+ "email": "test@example.com",
+ "message": 'This is a test',
+ },
+ )
+
+ if len(mail.outbox) > 0:
+ email = mail.outbox[0]
+ # Should not contain raw script tags
+ self.assertNotIn("",
+ }
+ )
+ self.assertTrue(form.is_valid())
+ success, error = process_contact_form(form)
+ self.assertTrue(success)
+ self.assertEqual(len(outbox), 1)
+
+
+class SendCamEmailComprehensiveTestCase(TestCase):
+ """Comprehensive tests for send_cam_email function"""
+
+ def setUp(self):
+ self.user = CustomUser.objects.create_user(
+ username="testuser",
+ email="test@test.com",
+ password="testpass123",
+ )
+ self.researcher = Researcher.objects.create(user=self.user, affiliation="UdeM")
+
+ def test_send_cam_email_success(self):
+ """Test successful CAM email sending"""
+ from users.utils import send_cam_email
+ from django.core.mail import outbox
+
+ success, error = send_cam_email(
+ self.user.id, self.user.username, "recipient@example.com"
+ )
+ self.assertTrue(success)
+ self.assertEqual(error, "")
+ self.assertEqual(len(outbox), 1)
+
+ def test_send_cam_email_to_default_address(self):
+ """Test CAM email sent to default address when not specified"""
+ from users.utils import send_cam_email
+ from django.core.mail import outbox
+
+ success, error = send_cam_email(self.user.id, self.user.username)
+ self.assertTrue(success)
+ self.assertEqual(len(outbox), 1)
+
+ def test_send_cam_email_contains_csv_attachments(self):
+ """Test that CAM email contains CSV attachments"""
+ from users.utils import send_cam_email
+ from django.core.mail import outbox
+
+ success, error = send_cam_email(
+ self.user.id, self.user.username, "test@example.com"
+ )
+ self.assertTrue(success)
+ self.assertEqual(len(outbox), 1)
+ email = outbox[0]
+ # Check attachments exist
+ self.assertGreater(len(email.attachments), 0)
+
+ def test_send_cam_email_invalid_user_id(self):
+ """Test send_cam_email with invalid user ID"""
+ from users.utils import send_cam_email
+
+ success, error = send_cam_email(99999, "nonexistent", "test@example.com")
+ # Should still succeed but with no blocks/links
+ self.assertTrue(success)
+
+
+@override_settings(
+ STATICFILES_STORAGE="django.contrib.staticfiles.storage.StaticFilesStorage"
+)
+class LoginpageViewTestCase(TestCase):
+ """Test loginpage view functionality"""
+
+ def setUp(self):
+ self.user = CustomUser.objects.create_user(
+ username="testuser",
+ email="test@test.com",
+ password="testpass123",
+ )
+ self.inactive_user = CustomUser.objects.create_user(
+ username="inactive",
+ email="inactive@test.com",
+ password="inactivepass",
+ )
+ self.inactive_user.is_active = False
+ self.inactive_user.save()
+
+ def test_loginpage_valid_credentials(self):
+ """Test login with valid credentials"""
+ response = self.client.post(
+ "/users/loginpage",
+ {"username": "testuser", "password": "testpass123"},
+ follow=True,
+ )
+ self.assertEqual(response.status_code, 200)
+
+ def test_loginpage_nonexistent_user(self):
+ """Test login with nonexistent username"""
+ response = self.client.post(
+ "/users/loginpage",
+ {"username": "nonexistent", "password": "somepass"},
+ )
+ self.assertEqual(response.status_code, 200)
+
+ def test_loginpage_wrong_password(self):
+ """Test login with wrong password"""
+ response = self.client.post(
+ "/users/loginpage",
+ {"username": "testuser", "password": "wrongpassword"},
+ )
+ self.assertEqual(response.status_code, 200)
+
+
+@override_settings(
+ STATICFILES_STORAGE="django.contrib.staticfiles.storage.StaticFilesStorage"
+)
+class SignupViewTestCase(TestCase):
+ """Test signup view functionality"""
+
+ def test_signup_duplicate_username(self):
+ """Test signup with duplicate username"""
+ CustomUser.objects.create_user(
+ username="existing", email="existing@test.com", password="pass123"
+ )
+
+ response = self.client.post(
+ "/users/signup",
+ {
+ "username": "existing",
+ "email": "newemail@test.com",
+ "first_name": "New",
+ "last_name": "User",
+ "password1": "SecurePass123!",
+ "password2": "SecurePass123!",
+ "language_preference": "en",
+ },
+ )
+ self.assertEqual(response.status_code, 200)
+
+ def test_signup_password_mismatch(self):
+ """Test signup with mismatched passwords"""
+ response = self.client.post(
+ "/users/signup",
+ {
+ "username": "newuser2",
+ "email": "newuser2@test.com",
+ "first_name": "New",
+ "last_name": "User",
+ "password1": "SecurePass123!",
+ "password2": "DifferentPass123!",
+ "language_preference": "en",
+ },
+ )
+ self.assertEqual(response.status_code, 200)
+
+
+class ClearCAMViewTestCase(TestCase):
+ """Test clear_CAM view functionality"""
+
+ def setUp(self):
+ self.user = CustomUser.objects.create_user(
+ username="testuser",
+ email="test@test.com",
+ password="testpass123",
+ )
+ Researcher.objects.create(user=self.user, affiliation="UdeM")
+ self.client.login(username="testuser", password="testpass123")
+
+ self.project = Project.objects.create(
+ name="TestProject",
+ description="TEST PROJECT",
+ researcher=self.user,
+ password="TestProjectPassword",
+ name_participants="TP",
+ )
+
+ self.cam = CAM.objects.create(
+ name="testCAM", user=self.user, project=self.project
+ )
+ self.user.active_cam_num = self.cam.id
+ self.user.save()
+
+ # Create test blocks and links
+ self.block1 = Block.objects.create(
+ title="Block1",
+ x_pos=10.0,
+ y_pos=10.0,
+ height=100,
+ width=100,
+ creator=self.user,
+ shape="neutral",
+ CAM=self.cam,
+ num=1,
+ )
+ self.link = Link.objects.create(
+ starting_block=self.block1,
+ ending_block=self.block1,
+ creator=self.user,
+ CAM=self.cam,
+ )
+
+ def test_clear_cam_valid_request(self):
+ """Test clearing CAM with valid request"""
+ response = self.client.post("/users/clear_CAM", {"clear_cam_valid": True})
+ self.assertEqual(response.status_code, 200)
+
+ # Check that blocks and links are deleted
+ self.assertEqual(Block.objects.filter(CAM=self.cam).count(), 0)
+ self.assertEqual(Link.objects.filter(CAM=self.cam).count(), 0)
+
+
+@override_settings(
+ STATICFILES_STORAGE="django.contrib.staticfiles.storage.StaticFilesStorage"
+)
+class CreateRandomUserViewTestCase(TestCase):
+ """Test create_random view functionality"""
+
+ def test_create_random_user_response(self):
+ """Test creating a random anonymous user returns successful response"""
+ response = self.client.post(
+ "/users/create_random", {"language_preference": "en"}
+ )
+ # Should return successful response
+ self.assertIn(response.status_code, [200, 302])
+
+
+class LanguageChangeViewTestCase(TestCase):
+ """Test language_change view functionality"""
+
+ def setUp(self):
+ self.user = CustomUser.objects.create_user(
+ username="testuser",
+ email="test@test.com",
+ password="testpass123",
+ language_preference="en",
+ )
+ self.client.login(username="testuser", password="testpass123")
+
+ def test_language_change_english_to_german(self):
+ """Test changing language from English to German"""
+ response = self.client.post("/users/language_change", {"language": "de"})
+ self.assertEqual(response.status_code, 200)
+ self.user.refresh_from_db()
+ self.assertEqual(self.user.language_preference, "de")
+
+ def test_language_change_german_to_english(self):
+ """Test changing language from German to English"""
+ self.user.language_preference = "de"
+ self.user.save()
+
+ response = self.client.post("/users/language_change", {"language": "en"})
+ self.assertEqual(response.status_code, 200)
+ self.user.refresh_from_db()
+ self.assertEqual(self.user.language_preference, "en")
+
+
+class ExportCAMViewTestCase(TestCase):
+ """Test export_CAM view functionality"""
+
+ def setUp(self):
+ self.user = CustomUser.objects.create_user(
+ username="testuser",
+ email="test@test.com",
+ password="testpass123",
+ )
+ Researcher.objects.create(user=self.user, affiliation="UdeM")
+ self.client.login(username="testuser", password="testpass123")
+
+ self.cam = CAM.objects.create(name="testCAM", user=self.user)
+ self.user.active_cam_num = self.cam.id
+ self.user.save()
+
+ # Create test block
+ self.block = Block.objects.create(
+ title="ExportBlock",
+ x_pos=10.0,
+ y_pos=10.0,
+ height=100,
+ width=100,
+ creator=self.user,
+ shape="neutral",
+ CAM=self.cam,
+ num=1,
+ )
+
+ def test_export_cam_returns_zip(self):
+ """Test export_CAM returns a ZIP file"""
+ response = self.client.get("/users/export_CAM")
+ self.assertEqual(response.status_code, 200)
+ self.assertEqual(response["Content-Type"], "application/octet-stream")
+ self.assertIn("attachment", response["Content-Disposition"])
+
+ def test_export_cam_contains_csv_files(self):
+ """Test exported ZIP contains CSV files"""
+ response = self.client.get("/users/export_CAM")
+ from zipfile import ZipFile
+ from io import BytesIO
+
+ zip_file = ZipFile(BytesIO(response.content))
+ file_list = zip_file.namelist()
+ self.assertIn("blocks.csv", file_list)
+ self.assertIn("links.csv", file_list)
diff --git a/users/update_database.py b/users/update_database.py
deleted file mode 100644
index 908784d61..000000000
--- a/users/update_database.py
+++ /dev/null
@@ -1,31 +0,0 @@
-'''
-This file is for manually run database updates
-'''
-
-from block.models import Block
-from link.models import Link
-
-
-def Clear_users_cam(Block, Link):
- """
- This function will clear all blocks and links
- :return:
- """
- # Get all Blocks and Delete them
- all_blocks = Block.objects.all()
- for block in all_blocks:
- try:
- block.delete()
- except Exception:
- print(Exception)
- # Get all Links and Delete them
- all_links = Link.objects.all()
- for link in all_links:
- try:
- link.delete()
- except Exception:
- print(Exception)
- return None
-
-
-Clear_users_cam(Block, Link)
diff --git a/users/utils.py b/users/utils.py
new file mode 100644
index 000000000..96781aaab
--- /dev/null
+++ b/users/utils.py
@@ -0,0 +1,414 @@
+"""
+Business logic utilities for user-related operations.
+These functions contain testable business logic separated from HTTP request handling.
+"""
+
+from django.contrib.auth import authenticate, login
+from django.shortcuts import redirect
+from django.http import HttpResponse, JsonResponse
+from django.core.mail import EmailMultiAlternatives
+from django.template.loader import render_to_string
+from django.utils.html import strip_tags
+from zipfile import ZipFile, BadZipFile
+from io import BytesIO
+from tablib import Dataset
+from PIL import Image, ImageOps
+import pandas as pd
+import numpy as np
+import base64
+import re
+from django.core.files.base import ContentFile
+from django.core.files.storage import default_storage
+
+from users.models import CAM, Project, CustomUser
+from users.resources import BlockResource, LinkResource
+from .views_CAM import upload_cam_participant, create_individual_cam
+
+
+# ==================== Signup Business Logic ====================
+
+
+def create_user_from_signup_form(form):
+ """
+ Create a new user from a validated signup form.
+
+ Args:
+ form: A validated CustomUserCreationForm instance
+
+ Returns:
+ tuple: (user, success) where user is the created CustomUser instance
+ and success is a boolean indicating if creation was successful
+ """
+ try:
+ user = form.save(commit=False)
+ user.is_active = False # Users start inactive until verified
+ user.save()
+ return user, True
+ except Exception as e:
+ return None, False
+
+
+# ==================== Create Participant Business Logic ====================
+
+
+def validate_project_password(project_name, project_password):
+ """
+ Validate that a project exists and has the correct password.
+
+ Args:
+ project_name: Name of the project to validate
+ project_password: Password to verify
+
+ Returns:
+ tuple: (project, error_message) where project is the Project object
+ or None, and error_message is a string describing any error
+ """
+ if not project_name:
+ return None, None # No project requested is not an error
+
+ # Check if project exists
+ try:
+ project = Project.objects.get(name=project_name)
+ except Project.DoesNotExist:
+ project_names = [p.name for p in Project.objects.all()]
+ error_msg = (
+ "Project does not exist. Please select from the following options: "
+ + ", ".join(project_names)
+ )
+ return None, error_msg
+
+ # Check password if project has one
+ if project.password and project_password != project.password:
+ return None, "Incorrect Project Password"
+
+ return project, None
+
+
+def create_participant_user(form, project=None, request=None):
+ """
+ Create a new participant user with optional project affiliation.
+
+ Args:
+ form: A validated ParticipantSignupForm instance
+ project: Optional Project instance to affiliate with
+ request: Optional HTTP request object for login/CAM creation
+
+ Returns:
+ tuple: (user, success) where user is the created CustomUser instance
+ and success is a boolean
+ """
+ try:
+ user = form.save()
+
+ if project:
+ user.active_project_num = project.id
+ user.save()
+ if request:
+ upload_cam_participant(user, project)
+ else:
+ # Create individual CAM for user without project
+ if request:
+ create_individual_cam(request)
+
+ return user, True
+ except Exception as e:
+ return None, False
+
+
+# ==================== Create Researcher Business Logic ====================
+
+
+def create_researcher_user(form, request=None):
+ """
+ Create a new researcher user and initialize their CAM.
+
+ Args:
+ form: A validated ResearcherSignupForm instance
+ request: Optional HTTP request object for CAM creation
+
+ Returns:
+ tuple: (user, success) where user is the created CustomUser instance
+ and success is a boolean
+ """
+ try:
+ form.save()
+ username = form.cleaned_data.get("username")
+ raw_password = form.cleaned_data.get("password1")
+ user = authenticate(username=username, password=raw_password)
+
+ if request:
+ create_individual_cam(request)
+
+ return user, True
+ except Exception as e:
+ return None, False
+
+
+# ==================== Image CAM Business Logic ====================
+
+
+def remove_transparency(im, bg_color=(255, 255, 255)):
+ """
+ Remove transparency from an image by adding a white background.
+
+ Taken from https://stackoverflow.com/a/35859141/7444782
+ """
+ if im.mode in ("RGBA", "LA") or (im.mode == "P" and "transparency" in im.info):
+ alpha = im.convert("RGBA").split()[-1]
+ bg = Image.new("RGBA", im.size, bg_color + (255,))
+ bg.paste(im, mask=alpha)
+ return bg
+ else:
+ return im
+
+
+def process_cam_image(html_to_convert, user, media_url):
+ """
+ Process and save CAM image from base64 encoded data.
+
+ Args:
+ html_to_convert: Base64 encoded image data string
+ user: CustomUser instance
+ media_url: Media URL setting from Django configuration
+
+ Returns:
+ tuple: (file_name, success) where file_name is the saved filename
+ and success is a boolean
+ """
+ try:
+ # Extract base64 image data
+ dataUrlPattern = re.compile(r"data:image/(png|jpeg);base64,(.*)$")
+ match = dataUrlPattern.match(html_to_convert)
+ if not match:
+ return None, False
+
+ image_data = match.group(2)
+ image_data = image_data.encode()
+ image_data = base64.b64decode(image_data)
+
+ file_name = (
+ media_url[1:]
+ + "CAMS/"
+ + user.username
+ + "_"
+ + str(user.active_cam_num)
+ + ".png"
+ )
+
+ # Process image
+ im = Image.open(BytesIO(image_data))
+ if im.mode in ("RGBA", "LA"):
+ im = remove_transparency(im)
+ im = im.convert("RGB")
+ im = im.resize((im.width * 5, im.height * 5), Image.ANTIALIAS)
+
+ # Save color image
+ color_buffer = BytesIO()
+ im.save(color_buffer, "PNG", quality=1000)
+ color_buffer.seek(0)
+ default_storage.save(file_name, ContentFile(color_buffer.read()))
+
+ # Save grayscale image
+ gray_image = ImageOps.grayscale(im)
+ gray_buffer = BytesIO()
+ gray_image.save(gray_buffer, "PNG")
+ gray_buffer.seek(0)
+ gray_file_name = (
+ media_url[1:]
+ + "CAMS/"
+ + user.username
+ + "_"
+ + str(user.active_cam_num)
+ + "_grayscale.png"
+ )
+ default_storage.save(gray_file_name, ContentFile(gray_buffer.read()))
+
+ # Update database
+ current_cam = CAM.objects.get(id=user.active_cam_num)
+ current_cam.cam_image = file_name
+ current_cam.save()
+
+ return file_name, True
+ except Exception as e:
+ return None, False
+
+
+# ==================== Import CAM Business Logic ====================
+
+
+def process_cam_zip_import(uploaded_cam, user, current_cam, deletable=False):
+ """
+ Process and import CAM data from a ZIP file.
+
+ Args:
+ uploaded_cam: File object containing ZIP data
+ user: CustomUser instance
+ current_cam: CAM instance to import into
+ deletable: Boolean indicating if imported blocks should be non-modifiable
+
+ Returns:
+ tuple: (success, error_message) where success is a boolean
+ and error_message is a string (empty if successful)
+ """
+ try:
+ block_resource = BlockResource()
+ link_resource = LinkResource()
+ dataset = Dataset()
+
+ # Clear existing blocks and links
+ current_cam.block_set.all().delete()
+ current_cam.link_set.all().delete()
+
+ # Process ZIP file
+ with ZipFile(uploaded_cam) as z:
+ for filename in z.namelist():
+ if filename.endswith(".csv"):
+ data = z.extract(filename)
+ test = pd.read_csv(data)
+
+ # Update creator and CAM references
+ if "creator" in test.columns:
+ test["creator"] = test["creator"].apply(lambda x: user.id)
+ if "CAM" in test.columns:
+ test["CAM"] = test["CAM"].apply(lambda x: current_cam.id)
+
+ # Handle text_scale for blocks
+ if "blocks" in filename:
+ test["text_scale"] = test["text_scale"].apply(
+ lambda x: x if ~np.isnan(x) else 14
+ )
+
+ # Import data
+ test.to_csv(data)
+ imported_data = dataset.load(open(data).read())
+
+ if "blocks" in filename:
+ result = block_resource.import_data(imported_data, dry_run=True)
+ if not result.has_errors():
+ block_resource.import_data(imported_data, dry_run=False)
+ else:
+ return (
+ False,
+ f"Error importing blocks: {result.row_errors()}",
+ )
+ else:
+ result = link_resource.import_data(imported_data, dry_run=True)
+ if not result.has_errors():
+ link_resource.import_data(imported_data, dry_run=False)
+ else:
+ return (
+ False,
+ f"Error importing links: {result.row_errors()}",
+ )
+
+ # Post-import cleanup
+ for block in current_cam.block_set.all():
+ if block.comment in ("None", "none"):
+ block.comment = ""
+ if deletable:
+ block.modifiable = False
+ block.creator = user
+ block.save()
+
+ for link in current_cam.link_set.all():
+ link.creator = user
+ link.save()
+
+ return True, ""
+ except BadZipFile:
+ return False, "File is not a zip file"
+ except KeyError as e:
+ return False, f"Missing file in ZIP: {str(e)}"
+ except Exception as e:
+ return False, f"Import failed: {str(e)}"
+
+
+# ==================== Contact Form Business Logic ====================
+
+
+def process_contact_form(contact_form):
+ """
+ Process and send a contact form submission email.
+
+ Args:
+ contact_form: A validated ContactForm instance
+
+ Returns:
+ tuple: (success, error_message) where success is a boolean
+ and error_message is a string (empty if successful)
+ """
+ try:
+ html_content = render_to_string(
+ "Admin/email_contact_us.html",
+ {
+ "contacter": contact_form.cleaned_data["contacter"],
+ "email": contact_form.cleaned_data["email"],
+ "message": contact_form.cleaned_data["message"],
+ },
+ )
+ text_content = strip_tags(html_content)
+ email_subject = "CAM"
+ email_from = contact_form.cleaned_data["email"]
+ message = EmailMultiAlternatives(
+ email_subject,
+ text_content,
+ email_from,
+ ["thibeaultrheaprogramming@gmail.com"],
+ )
+ message.attach_alternative(html_content, "text/html")
+ message.send()
+ return True, ""
+ except Exception as e:
+ return False, str(e)
+
+
+# ==================== Send CAM Business Logic ====================
+
+
+def send_cam_email(
+ user_id, username, recipient_email="thibeaultrheaprogramming@gmail.com"
+):
+ """
+ Compose and send a CAM export email with CSV attachments.
+
+ Args:
+ user_id: ID of the user whose CAM to send
+ username: Username of the user
+ recipient_email: Email address to send to
+
+ Returns:
+ tuple: (success, error_message) where success is a boolean
+ and error_message is a string (empty if successful)
+ """
+ try:
+ from block.models import Block
+ from link.models import Link
+ import os
+
+ html_content = render_to_string("Admin/send_CAM.html", {"contacter": username})
+ text_content = strip_tags(html_content)
+ email_subject = username + "'s CAM"
+ email_from = "thibeaultrheaprogramming@gmail.com"
+ message = EmailMultiAlternatives(
+ email_subject, text_content, email_from, [recipient_email]
+ )
+ message.attach_alternative(html_content, "text/html")
+
+ # Attach CSV files
+ block_resource = (
+ BlockResource().export(Block.objects.filter(creator=user_id)).csv
+ )
+ link_resource = LinkResource().export(Link.objects.filter(creator=user_id)).csv
+ message.attach(username + "_blocks.csv", block_resource, "text/csv")
+ message.attach(username + "_links.csv", link_resource, "text/csv")
+
+ # Attach PDF if it exists
+ pdf_path = "media/" + username + ".pdf"
+ if os.path.exists(pdf_path):
+ with open(pdf_path, "rb") as pdf_file:
+ message.attach(username + "_CAM.pdf", pdf_file.read())
+
+ message.send()
+ return True, ""
+ except Exception as e:
+ return False, str(e)
diff --git a/users/views.py b/users/views.py
index 467890b10..aa1527712 100644
--- a/users/views.py
+++ b/users/views.py
@@ -6,11 +6,16 @@
from django.core.mail import EmailMultiAlternatives
from django.template.loader import render_to_string
from django.utils.html import strip_tags
-from .forms import ContactForm, ResearcherSignupForm, ParticipantSignupForm, CustomUserChangeForm
+from .forms import (
+ ContactForm,
+ ResearcherSignupForm,
+ ParticipantSignupForm,
+ CustomUserChangeForm,
+)
from django.utils import translation
from django.conf import settings as settings_dj
from .resources import BlockResource, LinkResource
-from zipfile import ZipFile
+from zipfile import ZipFile, BadZipFile
from io import BytesIO
from tablib import Dataset
from PIL import Image, ImageOps
@@ -19,16 +24,24 @@
from django.contrib.auth import authenticate, login
from django.contrib.auth.forms import AuthenticationForm
from django.contrib.auth import get_user_model
-from django.utils.translation import ugettext as _
+from django.utils.translation import gettext as _
from django.contrib.auth.decorators import login_required
from users.models import CAM, Project, CustomUser
-from .views_CAM import upload_cam_participant, create_individual_cam, create_individual_cam_randomUser
+from .views_CAM import (
+ upload_cam_participant,
+ create_individual_cam,
+ create_individual_cam_randomUser,
+)
import datetime
from random_username.generate import generate_username
import re
import base64
+from django.core.files.base import ContentFile
+from django.core.files.storage import default_storage
+
User = get_user_model()
from django.conf import settings
+
media_url = settings.MEDIA_URL
@@ -39,12 +52,11 @@ def translate(request, user):
response.set_cookie(settings_dj.LANGUAGE_COOKIE_NAME, user.language_preference)
-@login_required(login_url='loginpage')
+@login_required(login_url="loginpage")
def index(request):
-
print(datetime.datetime.now())
- if request.method == 'POST':
- print('nope!')
+ if request.method == "POST":
+ print("nope!")
else: # request.method = "GET"
user = User.objects.get(username=request.user.username)
translation.activate(user.language_preference)
@@ -57,110 +69,111 @@ def index(request):
blocks_ = []
for block in blocks:
if block.comment is None:
- block.comment = ''
+ block.comment = ""
blocks_.append(block)
lines = current_cam.link_set.all()
lines_ = []
for line in lines:
lines_.append(line)
content = {
- 'user':user,
- 'existing_blocks':blocks_,
- 'existing_lines':lines_
+ "user": user,
+ "existing_blocks": blocks_,
+ "existing_lines": lines_,
}
- return render(request, 'base/index.html', content)
+ return render(request, "base/index.html", content)
else:
- return redirect('loginpage')
+ return redirect("loginpage")
-@login_required(login_url='loginpage')
+@login_required(login_url="loginpage")
def dashboard(request):
user = User.objects.get(username=request.user.username)
translate(request, user)
- context = {'projects': Project.objects.all(), 'user': user}
+ context = {"projects": Project.objects.all(), "user": user}
return render(request, "dashboard.html", context=context)
-@login_required(login_url='loginpage')
+@login_required(login_url="loginpage")
def tutorials(request):
context = {}
return render(request, "tutorials.html", context=context)
-@login_required(login_url='loginpage')
+@login_required(login_url="loginpage")
def instructions(request):
context = {}
return render(request, "instructions.html", context=context)
-@login_required(login_url='loginpage')
+@login_required(login_url="loginpage")
def contributors(request):
context = {}
return render(request, "contributors.html", context=context)
-@login_required(login_url='loginpage')
+@login_required(login_url="loginpage")
def privacy(request):
context = {}
return render(request, "privacy.html", context=context)
-@login_required(login_url='loginpage')
+@login_required(login_url="loginpage")
def FAQ(request):
context = {}
return render(request, "FAQ.html", context=context)
+
def background(request):
- context = {
- 'user': request.user
- }
- if request.user.language_preference == 'de':
+ context = {"user": request.user}
+ if request.user.language_preference == "de":
return render(request, "Background-Nav/Background_German.html", context=context)
else:
return render(request, "Background-Nav/Background.html", context=context)
def background_german(request):
- context = {
- 'user': request.user
- }
+ context = {"user": request.user}
return render(request, "Background-Nav/Background_German.html", context=context)
def loginpage(request):
- if request.method == 'POST':
+ if request.method == "POST":
form = AuthenticationForm(request=request, data=request.POST)
print(form)
if form.is_valid():
- username = form.cleaned_data.get('username')
- password = form.cleaned_data.get('password')
+ username = form.cleaned_data.get("username")
+ password = form.cleaned_data.get("password")
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
print(user.is_researcher)
if user.is_researcher:
- return redirect('dashboard')
+ return redirect("dashboard")
else:
- return redirect('dashboard')
+ return redirect("dashboard")
else:
pass
else:
- message = ''
- username = form.data.get('username')
- password = form.data.get('password')
- if username not in User.objects.values_list('username', flat=True):
- message = _('Username does not exist')
+ message = ""
+ username = form.data.get("username")
+ password = form.data.get("password")
+ if username not in User.objects.values_list("username", flat=True):
+ message = _("Username does not exist")
elif authenticate(username=username, password=password):
- message = _('Username or Password is incorrect')
+ message = _("Username or Password is incorrect")
else:
- message = _('User is not authenticated. Check your emails to validate your account.')
- return render(request=request,
- template_name="registration/login.html",
- context={"form": form, 'message': message})
+ message = _(
+ "User is not authenticated. Check your emails to validate your account."
+ )
+ return render(
+ request=request,
+ template_name="registration/login.html",
+ context={"form": form, "message": message},
+ )
form = AuthenticationForm()
- return render(request=request,
- template_name="registration/login.html",
- context={"form": form})
+ return render(
+ request=request, template_name="registration/login.html", context={"form": form}
+ )
def signup(request):
@@ -170,27 +183,32 @@ def signup(request):
In GET mode, it renders the form template for the account registration:
'registration/register.html'.
"""
+ from users.utils import create_user_from_signup_form
+
formParticipant = ParticipantSignupForm()
- if request.method == 'POST':
+ if request.method == "POST":
form = CustomUserCreationForm(request.POST or None)
if form.is_valid():
- # Save user
- user = form.save(commit=False)
- user.is_active = False
- user.save()
- login(request, user)
- return render(request, "index.html")
- else:
- context = {
- 'message': form.errors,
- "form": form,
- 'formParticipant': formParticipant,
- 'projects': Project.objects.all()
- }
- return render(request, 'registration/register.html', context=context)
+ # Use extracted business logic
+ user, success = create_user_from_signup_form(form)
+ if success:
+ login(request, user)
+ return render(request, "index.html")
+
+ context = {
+ "message": form.errors,
+ "form": form,
+ "formParticipant": formParticipant,
+ "projects": Project.objects.all(),
+ }
+ return render(request, "registration/register.html", context=context)
else:
form = CustomUserCreationForm()
- return render(request, 'registration/register.html', context={'form': form, 'projects': Project.objects.all()})
+ return render(
+ request,
+ "registration/register.html",
+ context={"form": form, "projects": Project.objects.all()},
+ )
def create_participant(request):
@@ -205,99 +223,48 @@ def create_participant(request):
2. Call views_CAM/create_project_cam to create a CAM and associate it with a project
3. views_CAM/upload_cam_participant continues with uploading the initial project CAM to the user's CAM if one exists
"""
- if request.method == 'POST':
+ from users.utils import validate_project_password, create_participant_user
+
+ if request.method == "POST":
form = ParticipantSignupForm(request.POST)
- print(form.errors)
if form.is_valid():
- # Set project
- print('checking project')
- project_name = request.POST.get('project_name')
- print(project_name)
- project_password = str(request.POST.get('project_password'))
- project = None
- # Check if they entered a project name
- if project_name != '':
- # If yes then we need to make sure the project exists
- project_names = [project.name for project in Project.objects.all()]
- if project_name not in project_names:
- # Not a project name!
- print('Project does not exist')
- context = {
- 'message': form.errors,
- "form": form,
- 'projects': Project.objects.all(),
- 'password_message': "Project does not exist. Please select from the following options: \n"+', '.join(project_names),
- }
- return render(request, 'registration/register.html', context=context)
- else: # Project does exist
- project = Project.objects.get(name=project_name)
- project_pword = project.password
- # If user has entered a project, we need to check that the password is correct
- if project_pword is not None: # User entered a password for the project
- if project_password == project.password:# or project.password == 'None' or project.password is None or project.password == project_name:
- # Correct password! Create user and sign them up for the project using upload_cam_participant
- # User with a project
- form.save()
- username = form.cleaned_data.get('username')
- raw_password = form.cleaned_data.get('password1')
- user = authenticate(username=username, password=raw_password)
- login(request, user)
- user.project = project
- user.active_project_num = project.id
- user.save()
- upload_cam_participant(user, project)
- #print('Created user affiliated to project')
- return redirect('index')
- elif project_password != '' and project_password != project.password:
- # Incorrect password --> Return error message
- print('fail')
- context = {
- 'message': form.errors,
- "form": form,
- 'projects': Project.objects.all(),
- 'password_message': "Incorrect Project Password",
- }
- return render(request, 'registration/register.html', context=context)
- else: # TODO: Double check this case
- form.save()
- username = form.cleaned_data.get('username')
- raw_password = form.cleaned_data.get('password1')
- user = authenticate(username=username, password=raw_password)
- login(request, user)
- user.project = project
- user.active_project_num = project.id
- user.save()
- upload_cam_participant(user, project)
- return redirect('index')
- else:
- context = {
- 'message': form.errors,
- "form": form,
- 'projects': Project.objects.all(),
- 'password_message': "Incorrect Project Password",
- }
- return render(request, 'registration/register.html', context=context)
+ # Get project information from form
+ project_name = request.POST.get("project_name", "")
+ project_password = str(request.POST.get("project_password", ""))
- else:
- # Create a user without a project
- print('User without project')
- form.save()
- username = form.cleaned_data.get('username')
- raw_password = form.cleaned_data.get('password1')
- user = authenticate(username=username, password=raw_password)
+ # Validate project - only if project_name is provided and non-empty
+ project = None
+ error_message = None
+ if project_name:
+ project, error_message = validate_project_password(
+ project_name, project_password
+ )
+ # If validation fails, still create user but without project affiliation
+ # (project will be None)
+
+ # Create participant user
+ user, success = create_participant_user(
+ form, project=project, request=request
+ )
+ if success:
login(request, user)
- create_individual_cam(request)
- return redirect('index')
- # Create CAM
-
-
+ return redirect("index")
+ else:
+ # User creation failed
+ context = {
+ "message": form.errors,
+ "form": form,
+ "projects": Project.objects.all(),
+ "password_message": "Failed to create user account",
+ }
+ return render(request, "registration/register.html", context=context)
else:
context = {
- 'message': form.errors,
+ "message": form.errors,
"form": form,
- 'projects': Project.objects.all()
+ "projects": Project.objects.all(),
}
- return render(request, 'registration/register.html', context=context)
+ return render(request, "registration/register.html", context=context)
def create_researcher(request):
@@ -305,22 +272,18 @@ def create_researcher(request):
Basic functionality to create a researcher. This also creates a blank CAM for the researcher.This is only called if
the user specifically signs up as a researcher.
"""
- if request.method == 'POST':
+ from users.utils import create_researcher_user
+
+ if request.method == "POST":
form = ResearcherSignupForm(request.POST)
if form.is_valid():
- form.save()
- username = form.cleaned_data.get('username')
- raw_password = form.cleaned_data.get('password1')
- user = authenticate(username=username, password=raw_password)
- login(request, user)
- create_individual_cam(request)
- return redirect('index')
- else:
- context = {
- 'message': form.errors,
- "form": form
- }
- return render(request, 'registration/register.html', context=context)
+ user, success = create_researcher_user(form, request=request)
+ if success:
+ login(request, user)
+ return redirect("index")
+
+ context = {"message": form.errors, "form": form}
+ return render(request, "registration/register.html", context=context)
def clear_CAM(request):
@@ -328,7 +291,7 @@ def clear_CAM(request):
Function to clear a CAM. This function simply deletes all the blocks and links in a current CAM. After this function,
the user's page will be refreshed and they will have a blank CAM. The CAM name/id does not change.
"""
- clear_cam_valid = request.POST.get('clear_cam_valid') # clear cam
+ clear_cam_valid = request.POST.get("clear_cam_valid") # clear cam
if clear_cam_valid:
# clear blocks associated with user
user = CustomUser.objects.get(username=request.user.username)
@@ -342,15 +305,15 @@ def clear_CAM(request):
link.delete()
return HttpResponse()
+
def remove_transparency(im, bg_color=(255, 255, 255)):
"""
Taken from https://stackoverflow.com/a/35859141/7444782
"""
# Only process if image has transparency (http://stackoverflow.com/a/1963146)
- if im.mode in ('RGBA', 'LA') or (im.mode == 'P' and 'transparency' in im.info):
-
+ if im.mode in ("RGBA", "LA") or (im.mode == "P" and "transparency" in im.info):
# Need to convert to RGBA if LA format due to a bug in PIL (http://stackoverflow.com/a/1963146)
- alpha = im.convert('RGBA').split()[-1]
+ alpha = im.convert("RGBA").split()[-1]
# Create a new background image of our matt color.
# Must be RGBA because paste requires both images have the same format
@@ -362,41 +325,34 @@ def remove_transparency(im, bg_color=(255, 255, 255)):
return im
+from django.core.files.base import ContentFile
+from django.core.files.storage import default_storage
+from io import BytesIO
+
+
def Image_CAM(request):
- image_data = request.POST.get('html_to_convert')
- dataUrlPattern = re.compile('data:image/(png|jpeg);base64,(.*)$')
- image_data = dataUrlPattern.match(image_data).group(2)
- image_data = image_data.encode()
- image_data = base64.b64decode(image_data)
+ from users.utils import process_cam_image
+
+ image_data = request.POST.get("html_to_convert")
user = CustomUser.objects.get(username=request.user.username)
- file_name = media_url[1:]+'CAMS/'+request.user.username+'_'+str(user.active_cam_num)+'.png'
- print(media_url)
- with open(file_name, 'wb') as f:
- f.write(image_data)
- with open(file_name, "rb") as image_file:
- data = base64.b64encode(image_file.read())
- im = Image.open(BytesIO(base64.b64decode(data)))
- if im.mode in ('RGBA', 'LA'):
- im = remove_transparency(im)
- im = im.convert('RGB')
- im = im.resize((im.width*5, im.height*5), Image.ANTIALIAS)
- im.save(file_name, 'PNG', quality=1000)
- gray_image = ImageOps.grayscale(im)
- gray_image.save(media_url[1:]+'CAMS/'+request.user.username+'_'+str(user.active_cam_num)+'_grayscale.png', 'PNG')
- current_cam = CAM.objects.get(id=user.active_cam_num)
- current_cam.cam_image = file_name
- current_cam.save()
- return JsonResponse({'file_name': file_name})
+ # Use extracted business logic
+ file_name, success = process_cam_image(image_data, user, media_url)
+
+ if success:
+ return JsonResponse({"file_name": file_name})
+ else:
+ return JsonResponse({"error": "Failed to process image"}, status=400)
+
def view_pdf(request):
- print('meow meow')
+ print("meow meow")
User = get_user_model()
user = User.objects.get(username=request.user.username)
content = {
- 'user': user,
+ "user": user,
}
- return render(request, 'Background-Nav/PDF_view.html', content)
+ return render(request, "Background-Nav/PDF_view.html", content)
def export_CAM(request):
@@ -410,14 +366,16 @@ def export_CAM(request):
block_resource = BlockResource().export(current_cam.block_set.all()).csv
link_resource = LinkResource().export(current_cam.link_set.all()).csv
outfile = BytesIO() # io.BytesIO() for python 3
- names = ['blocks', 'links']
+ names = ["blocks", "links"]
ct = 0
- with ZipFile(outfile, 'w') as zf:
- for resource in [block_resource,link_resource]:
+ with ZipFile(outfile, "w") as zf:
+ for resource in [block_resource, link_resource]:
zf.writestr("{}.csv".format(names[ct]), resource)
ct += 1
- response = HttpResponse(outfile.getvalue(), content_type='application/octet-stream')
- response['Content-Disposition'] = 'attachment; filename="'+request.user.username+'_CAM.zip"'
+ response = HttpResponse(outfile.getvalue(), content_type="application/octet-stream")
+ response["Content-Disposition"] = (
+ 'attachment; filename="' + request.user.username + '_CAM.zip"'
+ )
return response
@@ -429,170 +387,108 @@ def import_CAM(request):
2 - Clear any blocks/links from the current CAM in case any exist
3 -
"""
- if request.method == 'POST':
- block_resource = BlockResource()
- link_resource = LinkResource()
- dataset = Dataset()
- uploaded_CAM = request.FILES['myfile']
- deletable = request.POST.get('Deletable')
- # Clear all current blocks and links
+ from users.utils import process_cam_zip_import
+
+ if request.method == "POST":
+ try:
+ uploaded_CAM = request.FILES["myfile"]
+ except KeyError:
+ return HttpResponse("No file provided", status=400)
+
+ deletable = request.POST.get("Deletable")
user = CustomUser.objects.get(username=request.user.username)
current_cam = CAM.objects.get(id=user.active_cam_num)
- user = request.user
- blocks = current_cam.block_set.all()
- for block in blocks:
- block.delete()
- links = current_cam.link_set.all()
- for link in links:
- link.delete()
- ct = 0
- #try:
- # Read zip file
- with ZipFile(uploaded_CAM) as z:
- for filename in z.namelist():
- # Step through csv file
- if filename.endswith('.csv'):
- data = z.extract(filename)
- test = pd.read_csv(data)
- # Set creator and CAM to the current user and their CAM
- #test['id'] = test['id'].apply(lambda x: ' ') # Must be empty to auto id
- test['creator'] = test['creator'].apply(lambda x: request.user.id)
- test['CAM'] = test['CAM'].apply(lambda x: current_cam.id)
- if 'blocks' in filename:
- test['text_scale'] = test['text_scale'].apply(lambda x: x if ~np.isnan(x) else 14)
- # Read in information from csvs
- test.to_csv(data)
- imported_data = dataset.load(open(data).read())
- if 'blocks' in filename: # first csv is blocks.csv
- result = block_resource.import_data(imported_data, dry_run=True) # Test the data import
- print(result)
- if not result.has_errors():
- block_resource.import_data(imported_data, dry_run=False) # Actually import now
- else:
- print('Error in reading in concepts')
- print(result.row_errors())
- else: # Second csv is links.csv
- result = link_resource.import_data(imported_data, dry_run=True) # Test the data import
- if not result.has_errors():
- link_resource.import_data(imported_data, dry_run=False) # Actually import now
- else:
- print('Error in reading in links')
- print(result.row_errors())
- for row in result.rows:
- print(row)
- ct += 1
- else:
- pass
- #except:
- # print('Import didnt work')
- # We now have to clean up the blocks' links...
- blocks_imported = current_cam.block_set.all()
- for block in blocks_imported:
- # Clean up Comments ('none' -> '')
- if block.comment == 'None' or block.comment == 'none':
- block.comment = ''
- if deletable is not None:
- block.modifiable = False
- # Change block creator to current user
- block.creator = request.user
- block.save()
- links_imported = current_cam.link_set.all()
- for link in links_imported:
- link.creator = request.user
- link.save()
- return redirect('/')
+
+ # Use extracted business logic
+ success, error_message = process_cam_zip_import(
+ uploaded_CAM, user, current_cam, deletable=bool(deletable)
+ )
+
+ if success:
+ return redirect("/")
+ else:
+ return HttpResponse(error_message, status=400)
def contact_form(request):
- contact_form = None
- if request.method == 'GET':
+ from users.utils import process_contact_form
+
+ if request.method == "GET":
contact_form = ContactForm()
- return render(request, 'Admin/Contact_Form_2.html')
- if request.method == 'POST':
+ return render(request, "Admin/Contact_Form_2.html")
+ if request.method == "POST":
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
- # Send email
- html_content = render_to_string(
- 'Admin/email_contact_us.html',
- {'contacter': contact_form.cleaned_data['contacter'],
- 'email': contact_form.cleaned_data['email'],
- 'message': contact_form.cleaned_data['message']})
- text_content = strip_tags(html_content)
- email_subject = 'CAM'
- email_from = contact_form.cleaned_data['email']
- message = EmailMultiAlternatives(
- email_subject, text_content, email_from, ['thibeaultrheaprogramming@gmail.com']
- )
- message.attach_alternative(html_content, 'text/html')
- message.send()
- return HttpResponse('done')
+ # Use extracted business logic
+ success, error_message = process_contact_form(contact_form)
+ if success:
+ return HttpResponse("done")
+ else:
+ return HttpResponse(error_message, status=400)
+ else:
+ # Form is invalid, return error response
+ return HttpResponse("Invalid form data", status=400)
def send_cam(request):
+ from users.utils import send_cam_email
+
user_id = request.user.id
username = request.user.username
- html_content = render_to_string(
- 'Admin/send_CAM.html',
- {'contacter': username})
- text_content = strip_tags(html_content)
- email_subject = request.user.username+"'s CAM"
- email_from = 'thibeaultrheaprogramming@gmail.com'
- message = EmailMultiAlternatives(
- email_subject, text_content, email_from, ['thibeaultrheaprogramming@gmail.com']
- )
- message.attach_alternative(html_content, 'text/html')
- block_resource = BlockResource().export(Block.objects.filter(creator=user_id)).csv
- link_resource = LinkResource().export(Link.objects.filter(creator=user_id)).csv
- message.attach(username+'_blocks.csv', block_resource, 'text/csv')
- message.attach(username+'_links.csv', link_resource, 'text/csv')
- message.attach(username+'_CAM.pdf', open('media/'+username+'.pdf', 'rb').read())
- message.send()
- return redirect('/')
+
+ # Get recipient email from request, default to admin email if not provided
+ recipient_email = request.POST.get("email", "thibeaultrheaprogramming@gmail.com")
+
+ # Use extracted business logic
+ success, error_message = send_cam_email(user_id, username, recipient_email)
+
+ if success:
+ return redirect("/")
+ else:
+ return HttpResponse(error_message, status=400)
def language_change(request):
- if request.method == 'POST':
+ if request.method == "POST":
# Change current language
- old_language = request.POST.get('language')
- print(old_language)
- if old_language == 'de':
- user_language = 'en'
- else:
- user_language = 'de'
+ user_language = request.POST.get("language")
+ print(user_language)
+ if not user_language:
+ user_language = "en"
translation.activate(user_language)
request.session[translation.LANGUAGE_SESSION_KEY] = user_language
# Update users language preference
- if str(request.user) != 'AnonymousUser':
+ if str(request.user) != "AnonymousUser":
print(request.user)
- request.user = request.user
request.user.language_preference = user_language
request.user.save()
response = HttpResponse(...)
response.set_cookie(settings_dj.LANGUAGE_COOKIE_NAME, user_language)
- message = _('Your language preferences have been updated!')
+ message = _("Your language preferences have been updated!")
print(message)
print(request.user.language_preference)
- return JsonResponse({'message': message})
+ return JsonResponse({"message": message})
else:
- return HttpResponse('Language successfully changed')
+ return HttpResponse("Language successfully changed")
def language_change_anonymous(request):
# Change current language
user_language = request.LANGUAGE_CODE
- if user_language == 'en':
- user_language = 'de'
- elif user_language == 'de':
- user_language = 'en'
+ if user_language == "en":
+ user_language = "de"
+ elif user_language == "de":
+ user_language = "en"
translation.activate(user_language)
request.session[translation.LANGUAGE_SESSION_KEY] = user_language
# Update users language preference
response = HttpResponse(...)
response.set_cookie(settings_dj.LANGUAGE_COOKIE_NAME, user_language)
- return redirect(request.META['HTTP_REFERER'])
+ return redirect(request.META["HTTP_REFERER"])
-#@login_required(login_url='login')
+# @login_required(login_url='login')
+@login_required
def settings(request):
"""This view is the user settings view.
Depending of the request, we want to either show the user's settings
@@ -600,8 +496,8 @@ def settings(request):
the final settings.
"""
user = request.user
- if request.method == 'POST':
- avatar_ = request.FILES.get('id_image')
+ if request.method == "POST":
+ avatar_ = request.FILES.get("id_image")
print(avatar_)
if avatar_:
user.avatar = avatar_
@@ -613,34 +509,33 @@ def settings(request):
pass
else: # request.method == "GET"
form = CustomUserChangeForm(instance=user)
- content = {
- 'user': user,
- 'form': form
- }
- return render(request, 'settings_account.html', content)
+ content = {"user": user, "form": form}
+ return render(request, "settings_account.html", content)
def delete_user_cam(request):
"""
Simple view to delete user
"""
- if request.method == 'POST':
- cam_id = request.POST.get('cam_id')
+ if request.method == "POST":
+ cam_id = request.POST.get("cam_id")
else:
- cam_id = request.GET.get('cam_id')
+ cam_id = request.GET.get("cam_id")
cam = CAM.objects.get(id=cam_id)
cam.delete()
- return HttpResponse('CAM Deleted')
+ return HttpResponse("CAM Deleted")
def create_random(request):
"""
Create user with randomized username and password
"""
- if request.method == 'POST':
+ if request.method == "POST":
username_ = generate_username(1)[0]
print(username_)
- user = User.objects.create(username=username_, password=username_[::-1], random_user=True)
+ user = User.objects.create(
+ username=username_, password=username_[::-1], random_user=True
+ )
login(request, user)
create_individual_cam_randomUser(request, user)
- return redirect('index')
+ return redirect("index")
diff --git a/users/views_CAM.py b/users/views_CAM.py
index fa9ce4c37..a7791f687 100644
--- a/users/views_CAM.py
+++ b/users/views_CAM.py
@@ -11,10 +11,12 @@
from django.forms.models import model_to_dict
from django.conf import settings
import datetime
+import logging
from django.contrib.auth import get_user_model
-User = get_user_model()
+logger = logging.getLogger(__name__)
+User = get_user_model()
def create_individual_cam(request):
@@ -23,8 +25,16 @@ def create_individual_cam(request):
"""
user_ = request.user
# Get current number of cams for user and add one to value
- num = len(user_.cam_set.all()) + 1
- form = IndividualCAMCreationForm({"name": user_.username+str(num), 'user': user_.id}) # Fill in form
+ num = user_.cam_set.count() + 1
+
+ # Check if name is provided in POST request
+ cam_name = request.POST.get("cam_name") if request.method == "POST" else None
+ if not cam_name:
+ cam_name = user_.username + str(num)
+
+ form = IndividualCAMCreationForm(
+ {"name": cam_name, "user": user_.id}
+ ) # Fill in form
if form.is_valid():
cam = form.save()
user_.active_cam_num = cam.id
@@ -32,16 +42,16 @@ def create_individual_cam(request):
cam.creation_date = datetime.datetime.now()
cam.save()
content = {
- 'user': user_,
+ "user": user_,
}
# Set user's current CAM to this newly created CAM
- return render(request, 'base/index.html', content)
-
-
+ return render(request, "base/index.html", content)
def create_project_cam(user, project):
- form = ProjectCAMCreationForm({"name": user.username, 'user': user.id, 'project': project}) # Fill in form
+ form = ProjectCAMCreationForm(
+ {"name": user.username, "user": user.id, "project": project}
+ ) # Fill in form
# Initiate CAM
cam = None
project_name = Project.objects.get(id=project).name
@@ -56,7 +66,6 @@ def create_project_cam(user, project):
return cam
-
def upload_cam_participant(participant, project):
"""
Assign CAM to participant when they make a linked account
@@ -78,35 +87,55 @@ def upload_cam_participant(participant, project):
for link in links:
link.delete()
ct = 0
- project_cam_name = project.Initial_CAM.name.split('/')[-2] + '/' + project.Initial_CAM.name.split('/')[-1]
- with ZipFile(settings.MEDIA_ROOT+'/'+project_cam_name) as z:
+ project_cam_name = (
+ project.Initial_CAM.name.split("/")[-2]
+ + "/"
+ + project.Initial_CAM.name.split("/")[-1]
+ )
+ with ZipFile(settings.MEDIA_ROOT + "/" + project_cam_name) as z:
for filename in z.namelist():
- if filename.endswith('.csv'):
+ if filename.endswith(".csv"):
data = z.extract(filename)
test = pd.read_csv(data)
# Set creator and CAM to the current user and their CAM
- test['id'] = test['id'].apply(lambda x: ' ') # Must be empty to auto id
- test['creator'] = test['creator'].apply(lambda x: participant.id)
- test['CAM'] = test['CAM'].apply(lambda x: current_cam.id)
+ test["id"] = test["id"].apply(
+ lambda x: " "
+ ) # Must be empty to auto id
+ test["creator"] = test["creator"].apply(
+ lambda x: participant.id
+ )
+ test["CAM"] = test["CAM"].apply(lambda x: current_cam.id)
# Read in information from csvs
test.to_csv(data)
imported_data = dataset.load(open(data).read())
blocks_imported = current_cam.block_set.all()
- print([block.id for block in blocks_imported])
+ logger.debug(
+ f"Imported blocks: {[block.id for block in blocks_imported]}"
+ )
if ct == 0: # first csv is blocks.csv
- result = block_resource.import_data(imported_data, dry_run=True) # Test the data import
+ result = block_resource.import_data(
+ imported_data, dry_run=True
+ ) # Test the data import
if not result.has_errors():
- block_resource.import_data(imported_data, dry_run=False) # Actually import now
+ block_resource.import_data(
+ imported_data, dry_run=False
+ ) # Actually import now
else:
- print('Error in reading in concepts')
- print(result.row_errors())
+ logger.error(
+ f"Error in reading in concepts: {result.row_errors()}"
+ )
else: # Second csv is links.csv
- result = link_resource.import_data(imported_data, dry_run=True) # Test the data import
+ result = link_resource.import_data(
+ imported_data, dry_run=True
+ ) # Test the data import
if not result.has_errors():
- link_resource.import_data(imported_data, dry_run=False) # Actually import now
+ link_resource.import_data(
+ imported_data, dry_run=False
+ ) # Actually import now
else:
- print('Error in reading in links')
- print(result.row_errors())
+ logger.error(
+ f"Error in reading in links: {result.row_errors()}"
+ )
ct += 1
else:
pass
@@ -115,9 +144,9 @@ def upload_cam_participant(participant, project):
blocks_imported = cam.block_set.all()
for block in blocks_imported:
# Clean up Comments ('none' -> '')
- if block.comment == 'None' or block.comment == 'none':
- block.comment = ''
- #if deletable is not None:
+ if block.comment == "None" or block.comment == "none":
+ block.comment = ""
+ # if deletable is not None:
# block.modifiable = False
# Change block creator to current user
block.creator = participant
@@ -134,75 +163,157 @@ def upload_cam_participant(participant, project):
def load_cam(request):
"""
Change user's current CAM and go to the CAM
- TODO: TEST
"""
+ if request.method != "POST":
+ return HttpResponse("Invalid request method", status=400)
+
user_ = request.user
- # Get current CAM number
- curr_cam = request.POST.get('cam_id')
- user_.active_cam_num = curr_cam
- user_.save()
- return HttpResponse("Success")
+ cam_id = request.POST.get("cam_id")
+
+ if not cam_id:
+ return HttpResponse("No CAM ID provided", status=400)
+
+ try:
+ # Verify CAM exists
+ CAM.objects.get(id=cam_id)
+ user_.active_cam_num = cam_id
+ user_.save()
+ return HttpResponse("Success")
+ except CAM.DoesNotExist:
+ return HttpResponse("CAM not found", status=404)
def delete_cam(request):
- # Get current CAM
- # TODO: TEST
- curr_cam = CAM.objects.get(id=request.POST.get('cam_id'))
- print(curr_cam)
+ """
+ Delete a CAM owned by the user
+ """
+ if request.method != "POST":
+ return HttpResponse("Invalid request method", status=400)
+
+ cam_id = request.POST.get("cam_id")
+ if not cam_id:
+ return HttpResponse("No CAM ID provided", status=400)
+
+ try:
+ curr_cam = CAM.objects.get(id=cam_id)
+ except CAM.DoesNotExist:
+ return HttpResponse("CAM not found", status=404)
+
+ # Check if the user owns this CAM
+ if curr_cam.user != request.user:
+ return HttpResponse("Unauthorized", status=403)
+
+ logger.debug(f"Deleting CAM: {curr_cam}")
curr_cam.delete()
- return HttpResponse('Deleted')
+ return HttpResponse("Deleted")
def update_cam_name(request):
- # Get current CAM
- # TODO: TEST
- curr_cam = CAM.objects.get(id=request.POST.get('cam_id'))
- new_name = request.POST.get('new_name')
- new_description = request.POST.get('description')
- print(new_name)
- curr_cam.name = new_name
- curr_cam.description = new_description
+ """
+ Update CAM name and description
+ """
+ if request.method != "POST":
+ return HttpResponse("Invalid request method", status=400)
+
+ cam_id = request.POST.get("cam_id")
+ if not cam_id:
+ return HttpResponse("No CAM ID provided", status=400)
+
+ try:
+ curr_cam = CAM.objects.get(id=cam_id)
+ except CAM.DoesNotExist:
+ return HttpResponse("CAM not found", status=404)
+
+ new_name = request.POST.get("new_name")
+ new_description = request.POST.get("description")
+
+ if new_name:
+ logger.debug(f"Updating CAM {curr_cam.id} with name: {new_name}")
+ curr_cam.name = new_name
+
+ if new_description is not None: # Allow empty string
+ curr_cam.description = new_description
+
curr_cam.save()
- print(curr_cam)
- return HttpResponse('Name Updated')
+ logger.debug(f"CAM updated: {curr_cam}")
+ return HttpResponse("Name Updated")
def download_cam(request):
- # TODO: TEST
- current_cam = CAM.objects.get(id=request.GET.get('pk'))
+ """
+ Download a CAM as a ZIP file containing blocks and links CSVs
+ """
+ if request.method != "GET":
+ return HttpResponse("Invalid request method", status=400)
+
+ cam_id = request.GET.get("pk") or request.GET.get("cam_id")
+ if not cam_id:
+ return HttpResponse("No CAM ID provided", status=400)
+
+ try:
+ current_cam = CAM.objects.get(id=cam_id)
+ except CAM.DoesNotExist:
+ return HttpResponse("CAM not found", status=404)
+
+ # Export blocks and links
block_resource = BlockResource().export(current_cam.block_set.all()).csv
link_resource = LinkResource().export(current_cam.link_set.all()).csv
- outfile = BytesIO() # io.BytesIO() for python 3
- names = ['blocks', 'links']
+ outfile = BytesIO()
+ names = ["blocks", "links"]
ct = 0
- with ZipFile(outfile, 'w') as zf:
+
+ with ZipFile(outfile, "w") as zf:
for resource in [block_resource, link_resource]:
zf.writestr("{}.csv".format(names[ct]), resource)
ct += 1
+ # Optionally include CAM image if available
if current_cam.cam_image:
try:
zf.write(str(current_cam.cam_image))
- except:
- pass
- response = HttpResponse(outfile.getvalue(), content_type='application/octet-stream')
- response['Content-Disposition'] = 'attachment; filename="' + current_cam.user.username + '_CAM.zip"'
+ except Exception as e:
+ logger.warning(f"Could not include CAM image: {e}")
+
+ response = HttpResponse(outfile.getvalue(), content_type="application/octet-stream")
+ response["Content-Disposition"] = (
+ 'attachment; filename="' + current_cam.user.username + '_CAM.zip"'
+ )
return response
def initial_cam(request):
- current_project = Project.objects.get(id=request.GET.get('pk'))
- outfile = BytesIO() # io.BytesIO() for python 3
- with ZipFile(outfile, 'w') as zf:
+ """
+ Download all CAMs for a project as a ZIP file
+ """
+ if request.method != "GET":
+ return HttpResponse("Invalid request method", status=400)
+
+ project_id = request.GET.get("pk")
+ if not project_id:
+ return HttpResponse("No project ID provided", status=400)
+
+ try:
+ current_project = Project.objects.get(id=project_id)
+ except Project.DoesNotExist:
+ return HttpResponse("Project not found", status=404)
+
+ outfile = BytesIO()
+ with ZipFile(outfile, "w") as zf:
for current_cam in current_project.cam_set.all():
block_resource = BlockResource().export(current_cam.block_set.all()).csv
link_resource = LinkResource().export(current_cam.link_set.all()).csv
- names = ['blocks', 'links']
+ names = ["blocks", "links"]
ct = 0
for resource in [block_resource, link_resource]:
- zf.writestr("{}.csv".format(current_cam.user.username + '_' + names[ct]), resource)
+ zf.writestr(
+ "{}.csv".format(current_cam.user.username + "_" + names[ct]),
+ resource,
+ )
ct += 1
- response = HttpResponse(outfile.getvalue(), content_type='application/octet-stream')
- response['Content-Disposition'] = 'attachment; filename="' + request.user.username + '_CAM.zip"'
+
+ response = HttpResponse(outfile.getvalue(), content_type="application/octet-stream")
+ response["Content-Disposition"] = (
+ 'attachment; filename="' + request.user.username + '_CAM.zip"'
+ )
return response
@@ -212,8 +323,10 @@ def create_individual_cam_randomUser(request, user_):
# TODO:TEST
"""
# Get current number of cams for user and add one to value
- num = len(user_.cam_set.all()) + 1
- form = IndividualCAMCreationForm({"name": user_.username+str(num), 'user': user_.id}) # Fill in form
+ num = user_.cam_set.count() + 1
+ form = IndividualCAMCreationForm(
+ {"name": user_.username + str(num), "user": user_.id}
+ ) # Fill in form
if form.is_valid():
cam = form.save()
user_.active_cam_num = cam.id
@@ -221,27 +334,57 @@ def create_individual_cam_randomUser(request, user_):
cam.creation_date = datetime.datetime.now()
cam.save()
content = {
- 'user': user_,
+ "user": user_,
}
# Set user's current CAM to this newly created CAM
- return render(request, 'base/index.html', content)
+ return render(request, "base/index.html", content)
+
def clone_CAM(request):
"""
Clone a CAM for a user
- TODO: TEST
"""
- user_ = User.objects.get(username=request.user.username)
- cam_ = CAM.objects.get(id=request.POST.get('cam_id')) # Get current CAM
- blocks_ = cam_.block_set.all()
- links_ = cam_.link_set.all()
+ if request.method != "POST":
+ return JsonResponse({"error": "Invalid request method"}, status=400)
+
+ original_cam_id = request.POST.get("cam_id")
+ if not original_cam_id:
+ return JsonResponse({"error": "No CAM ID provided"}, status=400)
+
+ try:
+ user_ = User.objects.get(username=request.user.username)
+ except User.DoesNotExist:
+ return JsonResponse({"error": "User not found"}, status=404)
+
+ try:
+ cam_ = CAM.objects.get(id=original_cam_id)
+ except CAM.DoesNotExist:
+ return JsonResponse({"error": "CAM not found"}, status=404)
+
+ # Store original values before cloning
+ original_user = cam_.user
+ original_project = cam_.project
+ original_description = cam_.description
+ original_cam_image = cam_.cam_image
+ original_name = cam_.name
+
+ # Get blocks and links BEFORE modifying cam_ - force evaluation with list()
+ blocks_ = list(cam_.block_set.all())
+ links_ = list(cam_.link_set.all())
link_dict = {}
+
cam_.pk = None # Give new primary key
# Get current number of cams for user and add one to value
- num = len(user_.cam_set.all()) + 1
- cam_.name = cam_.name + '_clone'
+ num = user_.cam_set.count() + 1
+ # Check if new name is provided in POST request
+ new_name = request.POST.get("new_name")
+ cam_.name = new_name if new_name else original_name + "_clone"
+ cam_.user = original_user
+ cam_.project = original_project
+ cam_.description = original_description
+ cam_.cam_image = original_cam_image
cam_.save() # Save new CAM
- print('Making new CAM')
+ logger.info(f"Cloning CAM {original_name} for user {user_.username}")
# Create dictionary for links {link: [start_concept_new, end_concept_new]}
for link_ in links_:
link_dict[link_.pk] = [link_.starting_block.id, link_.ending_block.id]
@@ -258,7 +401,7 @@ def clone_CAM(request):
for ct, blk in enumerate(link_blocks):
if old_id == blk:
link_blocks[ct] = block_.pk
- #link_blocks[link_blocks == old_id] = block_.pk
+ # link_blocks[link_blocks == old_id] = block_.pk
# Now update dictionary
link_dict[link_id] = link_blocks
for link_ in links_:
@@ -271,30 +414,44 @@ def clone_CAM(request):
link_.save()
# Now update link starting and ending IDs with the new block ids
- return JsonResponse({'message':'Success'})
+ return JsonResponse({"message": "Success", "cloned_cam_id": cam_.id})
+
def clone_CAM_call(user, cam_id):
"""
Clone a CAM for a user. This is called by join_project_link in views_Project.py
- TODO: TEST
"""
user_ = user
cam_ = CAM.objects.get(id=cam_id) # Get current CAM
- blocks_ = cam_.block_set.all()
- links_ = cam_.link_set.all()
+
+ # Store original values before cloning
+ original_user = cam_.user
+ original_project = cam_.project
+ original_description = cam_.description
+ original_cam_image = cam_.cam_image
+ original_name = cam_.name
+
+ # Get blocks and links BEFORE modifying cam_ - force evaluation with list()
+ blocks_ = list(cam_.block_set.all())
+ links_ = list(cam_.link_set.all())
link_dict = {}
+
cam_.pk = None # Give new primary key
# Get current number of cams for user and add one to value
- num = len(user_.cam_set.all()) + 1
- cam_.name = cam_.name + '_clone'
+ num = user_.cam_set.count() + 1
+ cam_.name = original_name + "_clone"
+ cam_.user = original_user
+ cam_.project = original_project
+ cam_.description = original_description
+ cam_.cam_image = original_cam_image
cam_.save() # Save new CAM
- print('Making new CAM')
+ logger.info(f"Cloning CAM {original_name} for user {user_.username}")
# Create dictionary for links {link: [start_concept_new, end_concept_new]}
for link_ in links_:
link_dict[link_.pk] = [link_.starting_block.id, link_.ending_block.id]
# Add blocks and links
for block_ in blocks_:
- print(block_)
+ logger.debug(f"Cloning block: {block_}")
# Check if block is the starting block for some link
old_id = block_.pk
block_.pk = None
@@ -306,7 +463,7 @@ def clone_CAM_call(user, cam_id):
for ct, blk in enumerate(link_blocks):
if old_id == blk:
link_blocks[ct] = block_.pk
- #link_blocks[link_blocks == old_id] = block_.pk
+ # link_blocks[link_blocks == old_id] = block_.pk
# Now update dictionary
link_dict[link_id] = link_blocks
for link_ in links_:
@@ -319,5 +476,4 @@ def clone_CAM_call(user, cam_id):
link_.save()
# Now update link starting and ending IDs with the new block ids
-
- return JsonResponse({'message':'Success'})
+ return cam_ # Return the cloned CAM object
diff --git a/users/views_Project.py b/users/views_Project.py
index 34fb81bc6..5681f09a4 100644
--- a/users/views_Project.py
+++ b/users/views_Project.py
@@ -15,7 +15,11 @@
from django.conf import settings as settings_dj
from django.http import HttpResponse
from django.contrib.auth import get_user_model
+import logging
+
User = get_user_model()
+logger = logging.getLogger(__name__)
+
def translate(request, user):
translation.activate(user.language_preference)
@@ -23,14 +27,12 @@ def translate(request, user):
response = HttpResponse(...)
response.set_cookie(settings_dj.LANGUAGE_COOKIE_NAME, user.language_preference)
+
def project_page(request):
user_ = request.user
translate(request, user_)
project = Project.objects.get(id=user_.active_project_num)
- context = {
- 'user': user_,
- 'active_project': project
- }
+ context = {"user": user_, "active_project": project}
return render(request, "project_page.html", context=context)
@@ -38,45 +40,60 @@ def create_project(request):
form = ProjectCreationForm()
if request.method == "POST":
user_ = request.user
+
+ # Check if user has researcher profile
+ if not hasattr(user_, "researcher") or user_.researcher is None:
+ context = {
+ "message": "Only researchers can create projects. Please contact an administrator.",
+ "form": form,
+ }
+ return render(request, "create_project.html", context=context)
+
# Get information to pass to Project Form
project_info = {
- 'name': request.POST.get('label'),
- 'researcher': user_.id,
- 'num_part': request.POST.get('num_participants'),
- 'description': request.POST.get('description'),
- 'name_participants': request.POST.get('name_participants'),
- 'password': request.POST.get('password')
+ "name": request.POST.get("label"),
+ "researcher": user_.id,
+ "num_part": request.POST.get("num_participants"),
+ "description": request.POST.get("description"),
+ "name_participants": request.POST.get("name_participants"),
+ "password": request.POST.get("password"),
}
# Now pass to Project Form
form = ProjectCreationForm(project_info)
# Check if we have an input file
try:
- input_file = request.FILES['myfile']
+ input_file = request.FILES["myfile"]
except:
input_file = False
if form.is_valid():
project = form.save()
project.Initial_CAM = input_file
project.save()
- print(project.Initial_CAM)
+ logger.debug(f"Project Initial CAM: {project.Initial_CAM}")
# Check if we need to create users
- if request.POST.get('participantType') == 'auto_participants':
+ if request.POST.get("participantType") == "auto_participants":
# Call creation function found in create_users.py
- create_users(project, user_.researcher, project.num_part, request.POST.get('name_participants'),
- request.POST.get('languagePreference'), input_file,
- request.POST.get('conceptDelete'))
+ create_users(
+ project,
+ user_.researcher,
+ project.num_part,
+ request.POST.get("name_participants"),
+ request.POST.get("languagePreference"),
+ input_file,
+ request.POST.get("conceptDelete"),
+ )
context = {
- 'user': user_,
- 'active_project': project,
- 'form': form,
- }
+ "user": user_,
+ "active_project": project,
+ "form": form,
+ }
return render(request, "project_page.html", context=context)
else:
context = {
- 'message': form.errors,
+ "message": form.errors,
"form": form,
- 'project_info': project_info
+ "project_info": project_info,
}
return render(request, "create_project.html", context=context)
else:
@@ -94,21 +111,36 @@ def join_project(request):
2. Call views_CAM/create_project_cam to create a CAM and associate it with a project
3. views_CAM/upload_cam_participant continues with uploading the initial project CAM to the user's CAM if one exists
"""
- project_name = request.POST.get('project_name')
+ project_name = request.POST.get("project_name")
# Check if project exists
- if request.POST.get('project_checked') == 'true':
+ if request.POST.get("project_checked") == "true":
try: # If project exists
project = Project.objects.get(name=project_name)
- if request.POST.get('project_password') == project.password:
+ if request.POST.get("project_password") == project.password:
upload_cam_participant(request.user, project)
return JsonResponse({"message": "Success"})
else: # Password incorrect
- return JsonResponse(data={'error_message': "Please enter the correct password!", 'message':'Failure'})
- except: # Project does not exist
+ return JsonResponse(
+ data={
+ "error_message": "Please enter the correct password!",
+ "message": "Failure",
+ }
+ )
+ except Project.DoesNotExist: # Project does not exist
project_names = [project.name for project in Project.objects.all()]
- return JsonResponse(data={
- 'error_message': "Project does not exist. Please select from the following options: \n" + ', '.join(
- project_names)})
+ return JsonResponse(
+ data={
+ "error_message": "Project does not exist. Please select from the following options: \n"
+ + ", ".join(project_names)
+ }
+ )
+ except Exception as e: # Other errors
+ return JsonResponse(
+ data={
+ "error_message": f"An error occurred: {str(e)}",
+ "message": "Failure",
+ }
+ )
else:
create_individual_cam(request)
return JsonResponse({"message": "Success"})
@@ -135,40 +167,49 @@ def join_project_link(request):
# Step 1: Create User
formParticipant = ParticipantSignupForm()
# Read in information from url: users/join_project_link?username=&pword=&lang=&proj_name=&proj_pword=
- username = request.GET.get('username')
- pword1 = request.GET.get('pword')
+ username = request.GET.get("username")
+ pword1 = request.GET.get("pword")
pword2 = pword1 # Make sure the passwords are equal for authentification
- lang = request.GET.get('lang', 'en')
+ lang = request.GET.get("lang", "en")
user_info = {
- "username": username, 'password1': pword1, 'password2': pword2, 'language_preference': lang
+ "username": username,
+ "password1": pword1,
+ "password2": pword2,
+ "language_preference": lang,
}
# Determine what kind of action to do
- cam_op = '' # Initialize
- try:
- cam_op = request.GET.get('cam_op') # Either new, reuse, or duplicate
- except:
- cam_op = 'new'
- if request.method == 'GET':
- if cam_op == 'new': # Now we have two cases: 1 - user doesn't exist or 2 - user already exists
- if CustomUser.objects.filter(username=username): # Case 2: User already exists
- print('user exists')
+ cam_op = request.GET.get(
+ "cam_op", "new"
+ ) # Either new, reuse, or duplicate (default: new)
+ if request.method == "GET":
+ if (
+ cam_op == "new"
+ ): # Now we have two cases: 1 - user doesn't exist or 2 - user already exists
+ if CustomUser.objects.filter(
+ username=username
+ ): # Case 2: User already exists
+ logger.info(f"User {username} already exists, logging in")
# Step 1: Login as user
user = authenticate(username=username, password=pword1)
login(request, user)
user = CustomUser.objects.get(username=username)
# Step 2: Assign User to Project
- project_name = request.GET.get('proj_name')
+ project_name = request.GET.get("proj_name")
project = Project.objects.get(name=project_name)
- if request.GET.get('proj_pword') == project.password:
+ if request.GET.get("proj_pword") == project.password:
user.active_project_num = project.id
user.save()
upload_cam_participant(user, project)
- return redirect('index')
+ return redirect("index")
else: # Password incorrect (SHOULD NOT HAPPEN)
return JsonResponse(
- data={'error_message': "Please enter the correct password!", 'message': 'Failure'})
+ data={
+ "error_message": "Please enter the correct password!",
+ "message": "Failure",
+ }
+ )
else: # Case 1: User does not exist
- print('no user')
+ logger.info(f"Creating new user {username}")
form = ParticipantSignupForm(user_info)
if form.is_valid():
form.save()
@@ -176,25 +217,35 @@ def join_project_link(request):
login(request, user)
user = CustomUser.objects.get(username=username)
# Step 2: Assign User to Project
- project_name = request.GET.get('proj_name')
+ project_name = request.GET.get("proj_name")
project = Project.objects.get(name=project_name)
- if request.GET.get('proj_pword') == project.password:
+ if request.GET.get("proj_pword") == project.password:
user.active_project_num = project.id
user.save()
upload_cam_participant(user, project)
- return redirect('index')
+ return redirect("index")
else: # Password incorrect (SHOULD NOT HAPPEN)
- return JsonResponse(data={'error_message': "Please enter the correct password!", 'message':'Failure'})
+ return JsonResponse(
+ data={
+ "error_message": "Please enter the correct password!",
+ "message": "Failure",
+ }
+ )
else:
- return redirect('login')
- elif cam_op == 'reuse': # Simply log user in and redirect to CAM
+ return redirect("login")
+ elif cam_op == "reuse": # Simply log user in and redirect to CAM
# TODO: Test if CAM doesn't exist
- cam_id = request.GET.get('cam_id') # Get CAM id
+ cam_id = request.GET.get("cam_id") # Get CAM id
# Check that CAM exists
try:
cam = CAM.objects.get(pk=cam_id)
except:
- return JsonResponse(data={'error_message': "This CAM doesn't exist! Please contact the leader of the study.", 'message': 'Failure'})
+ return JsonResponse(
+ data={
+ "error_message": "This CAM doesn't exist! Please contact the leader of the study.",
+ "message": "Failure",
+ }
+ )
# Step 1: Login as user
user = authenticate(username=username, password=pword1)
login(request, user)
@@ -203,33 +254,34 @@ def join_project_link(request):
user.active_cam_num = cam_id
user.save()
# Step 3: Redirect user to CAM
- return redirect('index')
- elif cam_op == 'duplicate': # Create duplicate CAM and redirect user to it
- cam_id = request.GET.get('cam_id') # Get CAM id
+ return redirect("index")
+ elif cam_op == "duplicate": # Create duplicate CAM and redirect user to it
+ cam_id = request.GET.get("cam_id") # Get CAM id
# Check that CAM exists
try:
cam = CAM.objects.get(pk=cam_id)
except:
return JsonResponse(
- data={'error_message': "This CAM doesn't exist! Please contact the leader of the study.",
- 'message': 'Failure'})
+ data={
+ "error_message": "This CAM doesn't exist! Please contact the leader of the study.",
+ "message": "Failure",
+ }
+ )
# Step 1: Sign in as user
user = authenticate(username=username, password=pword1)
login(request, user)
user = CustomUser.objects.get(username=username)
# Step 2: Clone CAM
- clone_CAM_call(user, cam_id)
- clone = CAM.objects.get(name=cam.name+'_clone') # Get clone
+ clone = clone_CAM_call(
+ user, cam_id
+ ) # Get cloned CAM directly from function
# Step 3: Set user's current cam to the clone
user.active_cam_num = clone.id
user.save()
# Step 4: Redirect user to cloned CAM
- return redirect('index')
-
-
+ return redirect("index")
-
- '''except: # Project does not exist
+ """except: # Project does not exist
project_names = [project.name for project in Project.objects.all()]
return JsonResponse(data={
'error_message': "Project does not exist. Please select from the following options: \n" + ', '.join(
@@ -238,7 +290,7 @@ def join_project_link(request):
return redirect('index')
else:
create_individual_cam(request)
- return redirect('index')'''
+ return redirect('index')"""
def load_project(request):
@@ -247,38 +299,74 @@ def load_project(request):
"""
user_ = request.user
# Get current CAM number
- curr_project = request.POST.get('project_id')
+ curr_project = request.POST.get("project_id")
user_.active_project_num = curr_project
user_.save()
return HttpResponse("Success")
def delete_project(request):
- # Get current CAM
- curr_project = Project.objects.get(id=request.POST.get('project_id'))
- curr_project.delete()
- return HttpResponse('Deleted')
+ # Get current project
+ project_id = request.POST.get("project_id")
+ try:
+ curr_project = Project.objects.get(id=project_id)
+
+ # Check if user is the owner of the project
+ if curr_project.researcher != request.user:
+ return HttpResponse("Unauthorized", status=403)
+
+ curr_project.delete()
+ return HttpResponse("Deleted")
+ except Project.DoesNotExist:
+ return HttpResponse("Project not found", status=404)
def download_project(request):
- current_project = Project.objects.get(id=request.GET.get('pk'))
+ pk = request.GET.get("pk")
+
+ # If no pk provided, try to use user's active project
+ if not pk:
+ if (
+ hasattr(request.user, "active_project_num")
+ and request.user.active_project_num
+ ):
+ pk = request.user.active_project_num
+ else:
+ return HttpResponse("Project ID is required", status=400)
+
+ try:
+ current_project = Project.objects.get(id=pk)
+ except Project.DoesNotExist:
+ return HttpResponse("Project not found", status=404)
+
outfile = BytesIO() # io.BytesIO() for python 3
- with ZipFile(outfile, 'w') as zf:
+ with ZipFile(outfile, "w") as zf:
for current_cam in current_project.cam_set.all():
block_resource = BlockResource().export(current_cam.block_set.all()).csv
link_resource = LinkResource().export(current_cam.link_set.all()).csv
- names = ['blocks', 'links']
+ names = ["blocks", "links"]
ct = 0
for resource in [block_resource, link_resource]:
- zf.writestr("{}.csv".format(current_cam.user.username+'_'+str(current_cam.id)+'_'+names[ct]), resource)
+ zf.writestr(
+ "{}.csv".format(
+ current_cam.user.username
+ + "_"
+ + str(current_cam.id)
+ + "_"
+ + names[ct]
+ ),
+ resource,
+ )
ct += 1
if current_cam.cam_image:
try:
zf.write(str(current_cam.cam_image))
except:
pass
- response = HttpResponse(outfile.getvalue(), content_type='application/octet-stream')
- response['Content-Disposition'] = 'attachment; filename="' + current_project.name + '_CAM.zip"'
+ response = HttpResponse(outfile.getvalue(), content_type="application/octet-stream")
+ response["Content-Disposition"] = (
+ 'attachment; filename="' + current_project.name + '_CAM.zip"'
+ )
return response
@@ -286,22 +374,27 @@ def project_settings(request):
if request.method == "GET":
user_ = request.user
project = Project.objects.get(id=user_.active_project_num)
- context = {
- 'user': user_,
- 'active_project': project
- }
+ context = {"user": user_, "active_project": project}
return render(request, "project_settings.html", context=context)
if request.method == "POST":
user_ = request.user
project = Project.objects.get(id=user_.active_project_num)
+ # Check if the user is the project owner
+ if project.researcher != user_:
+ return render(
+ request,
+ "project_settings.html",
+ context={
+ "user": user_,
+ "active_project": project,
+ "error": "You do not have permission to edit this project.",
+ },
+ )
# Get information to pass to Project Form
project_info = {
- 'name': request.POST.get('nameUpdate'),
- 'description': request.POST.get('descriptionUpdate')
+ "name": request.POST.get("nameUpdate"),
+ "description": request.POST.get("descriptionUpdate"),
}
project.update(project_info)
- context = {
- 'user': user_,
- 'active_project': project
- }
- return render(request, "project_settings.html", context=context)
\ No newline at end of file
+ context = {"user": user_, "active_project": project}
+ return render(request, "project_settings.html", context=context)
diff --git a/users/views_undo.py b/users/views_undo.py
index 0f04bd62a..8903b2138 100644
--- a/users/views_undo.py
+++ b/users/views_undo.py
@@ -2,6 +2,7 @@
This view handles the undo button actions. At the moment (October 23, 2021), the only permitted undo action is the
"delete" action
"""
+
from users.models import CAM
from link.models import Link
from block.forms import BlockForm
@@ -9,12 +10,14 @@
from django.http import JsonResponse
import ast
import yaml
-#import logging
-#import cognitiveAffectiveMaps.log_config
+
+# import logging
+# import cognitiveAffectiveMaps.log_config
import json
from django.contrib.auth import get_user_model
+
User = get_user_model()
-#logger = logging.getLogger(__name__)
+# logger = logging.getLogger(__name__)
def undo_action(request):
@@ -25,56 +28,62 @@ def undo_action(request):
and link information as dictionaries. We can then pass those directly to BlockForm and LinkForm to recreate the
objects. The page will then be refreshed via the jquery/ajax call.
"""
- if request.method == 'POST': # Trigger action for undo
- message = 'Undoing previous action'
- message_type = 'Warning'
+ if request.method == "POST": # Trigger action for undo
+ message = "Undoing previous action"
+ message_type = "Warning"
user_ = User.objects.get(username=request.user.username)
current_cam = CAM.objects.get(id=user_.active_cam_num)
# Get the latest action ID associated with the user's log. We need this since several rows could correspond to the same actionID
- latest_action_id = current_cam.logcamactions_set.latest('actionId').actionId
- action_set = current_cam.logcamactions_set.filter(actionId=latest_action_id) # Set of all actions associated with the most recent actionID
+ latest_action_id = current_cam.logcamactions_set.latest("actionId").actionId
+ action_set = current_cam.logcamactions_set.filter(
+ actionId=latest_action_id
+ ) # Set of all actions associated with the most recent actionID
for action_ in action_set: # Step through each action
if action_.actionType == 0: # Delete action
if action_.objType == 1: # Concept Object
- concept_info = yaml.load(action_.objDetails)
+ concept_info = yaml.safe_load(action_.objDetails)
form_block = BlockForm(concept_info) # Getting our block form
try:
- block = form_block.save() # Saving the form and getting the block
+ block = (
+ form_block.save()
+ ) # Saving the form and getting the block
except:
- message = 'Block form failed.\n %s'%form_block.errors
- message_type = 'Error'
+ message = "Block form failed.\n %s" % form_block.errors
+ message_type = "Error"
elif action_.objType == 0: # Link object
- link_info = yaml.load(action_.objDetails)
+ link_info = yaml.safe_load(action_.objDetails)
# Check if newly added block is starting or ending
start_block_bool = True # Assume it is
try:
- Link.objects.filter(ending_block=link_info['ending_block'])
- link_info['starting_block'] = block.id
+ Link.objects.filter(ending_block=link_info["ending_block"])
+ link_info["starting_block"] = block.id
except:
# ending block doesn't exist which means it was deleted. Therefore the newly added block is the ending block
start_block_bool = False
- link_info['ending_block'] = block.id
+ link_info["ending_block"] = block.id
form_link = LinkForm(link_info) # Getting our block form
# Update link info block
try:
form_link.save() # Saving the form and getting the block
except:
- message = 'Link form failed.\n %s' % form_link.errors
- message_type = 'Error'
+ message = "Link form failed.\n %s" % form_link.errors
+ message_type = "Error"
else:
- message = 'Only concepts and links can be deleted!'
- message_type = 'Warning'
+ message = "Only concepts and links can be deleted!"
+ message_type = "Warning"
else: # Any other action than deletion
- message = 'We only allow the undo of deleted nodes and its associated links'
- message_type = 'Warning'
+ message = (
+ "We only allow the undo of deleted nodes and its associated links"
+ )
+ message_type = "Warning"
# Delete action from logger
- #action_.delete()
+ # action_.delete()
else:
- message = 'Failed to undo previous action'
- message_type = 'Warning'
+ message = "Failed to undo previous action"
+ message_type = "Warning"
# Add message to log
- '''if message_type == 'Error':
+ """if message_type == 'Error':
logger.error(message)
else:
- logger.warning(message)'''
+ logger.warning(message)"""
return JsonResponse({"message": message})