TestPlatform

1
import json
2

3
from django.contrib.auth.decorators import login_required
4
from django.http import JsonResponse, HttpResponse
5
from django.shortcuts import render, redirect
6
from django.template import loader
7
from django.urls import reverse
8

9
from editor.forms import CreationProjectForm, CreationTaskForm, EditTaskInfo, EditProjectInfo, CreationExerciseForm, \
10
    CheckMarkDownForm, CreationStaticElementForm
11

12
from tests.models import Project, ProjectTask, ProjectTaskElement, BaseExercise, BaseStaticElement, \
13
    ChronologyExercise, MatchExercise, InputExercise, AnswerExercise, RadioExercise, StatementsExercise, \
14
    ImagesExercise, TitleElement, PictureElement, QuoteElement, DocumentElement, YandexMapsElement, \
15
    MatchListExercise
16

17

18
@login_required
19
def editor_page(request):
20
    template = loader.get_template('editor/tests_table.html')
21

22
    columns = ['ID', 'Название', 'Заданий', 'Дата создания', 'Изменено']
23
    published_tests_data = []
24
    development_tests_data = []
25

26
    projects = Project.objects.filter(author_id=request.user.id)
27

28
    for project in projects:
29
        if project.published:
30
            published_tests_data.append(project.get_json())
31
        else:
32
            development_tests_data.append(project.get_json())
33

34
    tests_context = {
35
        'columns': columns,
36
        'type': 'tests-list',
37
        'class': 'development_tests'
38
    }
39

40
    context = {
41
        'published_tests_table': template.render({**tests_context, 'rows': published_tests_data}),
42
        'development_tests_table': template.render({**tests_context, 'rows': development_tests_data}),
43
        'published_tests_exists': len(published_tests_data) != 0,
44
        'development_tests_exists': len(development_tests_data) != 0
45
    }
46

47
    return render(request, template_name='editor/editor.html', context=context)
48

49

50
@login_required
51
def create_project(request):
52
    if not request.POST:
53
        return render(request, template_name='editor/creation_project.html')
54

55
    project = Project(author=request.user)
56
    form = CreationProjectForm(request.POST, request.FILES, instance=project)
57

58
    project = Project.create(form)
59

60
    if not project is None:
61
        return redirect(reverse('editor:open_project', kwargs={'project_id': project.id}))
62

63

64
@login_required
65
def remove_project(request, project_id):
66
    if request.POST:
67
        project = Project.objects.get(id=project_id)
68
        if project.project_name == request.POST.get('input_projectname', None):
69
            project.delete()
70
            return redirect(reverse('editor:index'))
71

72
    return redirect(reverse('editor:open_project', kwargs={'project_id': project_id}))
73

74

75
@login_required
76
def open_project(request, project_id):
77
    if request.POST:
78
        data = json.loads(request.POST['json'])
79
        if 'tasks_table' in data:
80
            project = Project.objects.get(id=project_id)
81
            if len(data['tasks_table']) == project.number_of_tasks:
82
                for number, task_id in enumerate(data['tasks_table']):
83
                    task = ProjectTask.objects.get(id=task_id)
84
                    task.number = number + 1
85
                    task.save()
86

87
    template = loader.get_template('editor/tasks_table.html')
88

89
    context_table = {
90
        'type': 'tasks-list',
91
        'class': 'tasks-list',
92
        'columns': ['№', 'Название', 'Упражнений', 'Баллы'],
93
        'rows': []
94
    }
95

96
    is_empty = True
97

98
    for task in ProjectTask.objects.filter(project_id=project_id).order_by('number'):
99
        context_table['rows'].append(task.get_json())
100
        is_empty = False
101

102
    context = {
103
        'project': Project.objects.get(id=project_id),
104
        'tasks_table': template.render(context_table),
105
        'is_empty': is_empty
106
    }
107
    return render(request, 'editor/project/project_page.html', context)
108

109

110
@login_required
111
def create_task(request, project_id):
112
    if request.POST:
113

114
        project = Project.objects.get(id=project_id)
115
        task = ProjectTask(project=project)
116

117
        form = CreationTaskForm(request.POST, instance=task)
118

119
        if project.create_task(form):
120
            project.number_of_tasks += 1
121
            project.save()
122
            return redirect(reverse('editor:open_task', kwargs={'project_id': project_id, 'task_id': task.id}))
123

124
    return redirect(reverse('editor:open_project', kwargs={'project_id': project_id}))
125

126

127
@login_required
128
def remove_task(request, project_id, task_id):
129
    if request.POST:
130
        selected_task = ProjectTask.objects.get(id=task_id)
131
        number = selected_task.number
132
        for task in ProjectTask.objects.filter(project_id=project_id, number__gt=number).order_by('number'):
133
            task.number = number
134
            task.save()
135
            number += 1
136
        selected_task.delete()
137

138
        project = Project.objects.get(id=project_id)
139
        project.number_of_tasks -= 1
140
        project.save()
141

142
        return redirect(reverse('editor:open_project', kwargs={'project_id': project_id}))
143

144
    return redirect(reverse('editor:open_task', kwargs={'project_id': project_id, 'task_id': task_id}))
145

146

147
@login_required
148
def edit_project(request, project_id):
149
    if not request.POST:
150
        context = {
151
            'project': Project.objects.get(id=project_id)
152
        }
153
        return render(request, 'editor/project/project_edit.html', context)
154

155
    project = Project.objects.get(id=project_id)
156
    form = EditProjectInfo(request.POST, request.FILES, instance=project)
157

158
    project.edit_info(form)
159

160
    return redirect(reverse('editor:open_project', kwargs={'project_id': project_id}))
161

162

163
@login_required
164
def publish_project(request, project_id):
165
    project = Project.objects.get(id=project_id)
166
    project.publish()
167

168
    return redirect(reverse('editor:open_project', kwargs={'project_id': project_id}))
169

170

171

172
@login_required
173
def editor_not_allowed(request):
174
    return render(request, 'editor/editor_not_allowed.html')
175

176

177
@login_required
178
def templates(request):
179
    return render(request, 'develop_page.html')
180

181

182
@login_required
183
def stats(request):
184
    return render(request, 'develop_page.html')
185

186

187
@login_required
188
def editor_modal_window(request):
189
    return render(request, 'modal_window.html')
190

191

192
@login_required
193
def edit_task(request, project_id, task_id):
194
    if not request.POST:
195
        context = {
196
            'project': Project.objects.get(id=project_id),
197
            'task': ProjectTask.objects.get(id=task_id)
198
        }
199
        return render(request, 'editor/project/task/task_edit.html', context)
200

201
    task = ProjectTask.objects.get(id=task_id)
202
    form = EditTaskInfo(request.POST, request.FILES, instance=task)
203

204
    task.edit_info(form)
205

206
    return redirect(reverse('editor:open_task', kwargs={'project_id': project_id, 'task_id': task_id}))
207

208

209
@login_required
210
def open_task(request, project_id, task_id):
211
    if request.POST:
212
        data = json.loads(request.POST['json'])
213
        if 'elements-ordering' in data:
214
            number_of_elements = ProjectTaskElement.objects.filter(task_id=task_id).count()
215
            print(number_of_elements)
216
            if len(data['elements-ordering']) == number_of_elements:
217
                for index, elem_id in enumerate(data['elements-ordering']):
218
                    element = ProjectTaskElement.objects.get(element_id=elem_id)
219
                    element.order = index + 1
220
                    element.save()
221

222
    context = {
223
        'project': Project.objects.get(id=project_id),
224
        'task': ProjectTask.objects.get(id=task_id),
225
        'elements': map(lambda x: x.get_child(), ProjectTaskElement.objects.filter(task_id=task_id).order_by('order')),
226
        'creation_exercise_form': CreationExerciseForm(),
227
        'creation_element_form': CreationStaticElementForm()
228
    }
229

230
    print(context['elements'])
231

232
    return render(request, 'editor/project/task/task_page.html', context)
233

234

235
@login_required
236
def upload_project_description(request, project_id):
237

238
    form = CheckMarkDownForm(request.POST)
239

240
    if form.is_valid():
241
        project = Project.objects.get(id=project_id)
242
        project.description_md = request.POST.get('markdown_field')
243
        project.save()
244

245
    # return redirect(reverse('editor:open_project', kwargs={'project_id': project_id}))
246
    return JsonResponse({})
247

248

249
@login_required
250
def upload_task_description(request, project_id, task_id):
251

252
    form = CheckMarkDownForm(request.POST)
253

254
    if form.is_valid():
255
        task = ProjectTask.objects.get(id=task_id)
256
        task.description_md = request.POST.get('markdown_field')
257
        task.save()
258

259
    return JsonResponse({})
260

261

262
@login_required
263
def create_element(request, project_id, task_id):
264
    if request.POST:
265
        form = CreationStaticElementForm(request.POST)
266

267
        task = ProjectTask.objects.get(id=task_id)
268
        task.create_element(form)
269

270
    return redirect(reverse('editor:open_task', kwargs={'project_id': project_id, 'task_id': task_id}))
271

272

273
@login_required
274
def create_exercise(request, project_id, task_id):
275
    if request.POST:
276
        form = CreationExerciseForm(request.POST)
277

278
        task = ProjectTask.objects.get(id=task_id)
279
        task.create_exercise(form)
280

281
    return redirect(reverse('editor:open_task', kwargs={'project_id': project_id, 'task_id': task_id}))
282

283

284
@login_required
285
def remove_element(request, project_id, task_id):
286
    if request.POST and request.POST.get('element_id', False):
287
        elem_id = request.POST.get('element_id')
288
        selected_element = ProjectTaskElement.objects.get(element_id=elem_id)
289
        order = selected_element.order
290
        for element in ProjectTaskElement.objects.filter(task_id=task_id, order__gt=order).order_by('order'):
291
            element.order = order
292
            element.save()
293
            order += 1
294
        selected_element.delete()
295
        return redirect(reverse('editor:open_task', kwargs={'project_id': project_id, 'task_id': task_id}))
296

297
    return redirect(reverse('editor:open_task', kwargs={'project_id': project_id, 'task_id': task_id}))
298

299

300
@login_required
301
def change_element(request, project_id, task_id):
302
    print(request.POST)
303

304
    if request.POST and request.POST.get('element_id', False):
305
        elem_id = request.POST.get('element_id')
306
        selected_element = ProjectTaskElement.objects.get(element_id=elem_id).get_child()
307

308
        if selected_element.element_type == 0:
309

310
            if request.POST.get('title', False) or request.POST.get('title', False) == "":
311
                selected_element.title = request.POST.get('title')
312
                selected_element.save()
313

314
            if request.POST.get('only_title', False):
315
                return HttpResponse()
316

317
            return JsonResponse(eval(f'{BaseExercise.CLASSES[selected_element.exercise_type]}.process_request(request, selected_element)'))
318

319
        elif selected_element.element_type == 1:
320
            return JsonResponse(eval(f'{BaseStaticElement.CLASSES[selected_element.static_element_type]}.process_request(request, selected_element)'))
321

322
        return redirect(reverse('editor:open_project', kwargs={'project_id': project_id}))
323

324
    return redirect(reverse('editor:open_task', kwargs={'project_id': project_id, 'task_id': task_id}))
325

326

327