--- /dev/null
+# -*- coding: utf-8 -*-
+
+from django import template
+from teleforma.models.crfpa import Period
+
+register = template.Library()
+
+@register.inclusion_tag('admin/webclass/webclassrecord/add_records_links.html', takes_context=True)
+def add_records_links(context):
+
+ periods = Period.objects.filter(is_open=True)
+ return {
+ 'periods':periods,
+ }
from teleforma.models import *
from teleforma.forms import *
from teleforma.models.appointment import AppointmentPeriod
-from teleforma.webclass.models import Webclass, WebclassSlot
+from teleforma.webclass.models import Webclass, WebclassSlot, WebclassRecord
from telemeta.views import *
import jqchat.models
from xlwt import Workbook
webclass_slot = webclass.get_slot(self.request.user)
context['webclass'] = webclass
context['webclass_slot'] = webclass_slot
+
+ print(WebclassRecord.get_records(context['period'], course))
return context
@method_decorator(login_required)
class WebclassRecordAdmin(admin.ModelAdmin):
list_filter = ('course', 'period')
- list_display = ('course', 'period')
+ list_display = ('course', 'period', 'created')
search_fields = ['id', 'course__code', 'course__title']
# def get_form(self, request, obj=None, **kwargs):
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from datetime import datetime
+from django.forms import Form, ModelChoiceField, ChoiceField
+from teleforma.models.core import Course, Period
+from teleforma.webclass.models import get_records, WebclassSlot, WebclassRecord
+from django.core.exceptions import ValidationError
+
+class WebclassRecordsForm(Form):
+ # period = ModelChoiceField(label='Période',
+ # queryset=Period.objects.filter(is_open=True))
+
+ class Meta:
+ pass
+
+
+ def __init__(self, *args, **kwargs):
+ self.period_id = kwargs.pop('period_id')
+ self.period = Period.objects.get(pk=self.period_id)
+ super(WebclassRecordsForm, self).__init__(*args, **kwargs)
+
+ courses = Course.objects.all()
+ all_records = self.get_records_by_course()
+ for course in courses:
+ webclass = course.webclass.count()
+ if course.webclass.count():
+ rooms = []
+ for webclass in course.webclass.all():
+ for slot in webclass.slots.all():
+ rooms.append(slot.room_id)
+
+ field_name = 'course_%d' % course.id
+ records = all_records.get(course.id, [])
+
+ vocabulary = [('none', 'Aucun')]
+ for record in records:
+ print(record)
+ webclass_slot = WebclassSlot.objects.get(pk=record['slot_id'])
+ label = u"%s à %s - %s" % (record['start_date'].strftime('%d/%m/%Y %H:%M'), record['end_date'].strftime('%H:%M'), webclass_slot.professor.user.last_name)
+ vocabulary.append((record['id'], label))
+ self.fields[field_name] = ChoiceField(label=course.title, choices=vocabulary, required=False)
+
+ def get_records_by_course(self):
+ records = get_records(period_id=self.period_id)
+ by_course = {}
+ for record in records:
+ by_course.setdefault(record['course_id'], []).append(record)
+ return by_course
+
+ def save_records(self):
+ for key, value in self.data.items():
+ if key.startswith('course') and value != 'none':
+ course_id = key.replace('course_', '')
+ course = Course.objects.get(pk=course_id)
+ record = WebclassRecord(course=course, period=self.period, record_id=value)
+ record.save()
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('period', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['teleforma.Period'])),
('course', self.gf('django.db.models.fields.related.ForeignKey')(related_name='webclass_records', to=orm['teleforma.Course'])),
- ('url', self.gf('django.db.models.fields.CharField')(max_length=255)),
- ('created', self.gf('django.db.models.fields.DateTimeField')()),
+ ('record_id', self.gf('django.db.models.fields.CharField')(max_length=255)),
+ ('created', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, blank=True)),
))
db.send_create_signal('webclass', ['WebclassRecord'])
'webclass.webclassrecord': {
'Meta': {'object_name': 'WebclassRecord', 'db_table': "'teleforma_webclass_record'"},
'course': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'webclass_records'", 'to': "orm['teleforma.Course']"}),
- 'created': ('django.db.models.fields.DateTimeField', [], {}),
+ 'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'period': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['teleforma.Period']"}),
- 'url': ('django.db.models.fields.CharField', [], {'max_length': '255'})
+ 'record_id': ('django.db.models.fields.CharField', [], {'max_length': '255'})
},
'webclass.webclassslot': {
'Meta': {'object_name': 'WebclassSlot', 'db_table': "'teleforma_webclass_slot'"},
class MetaCore:
app_label = 'webclass'
-def get_all_records():
- all_records = []
- recordings = []
- recordings_xml = self.bbb.get_recordings(self.room_id).get_field('recordings')
- if hasattr(recordings_xml, 'get'):
- recordings = recordings_xml['recording']
- if type(recordings) is XMLDictNode:
- recordings = [recordings]
- for recording in recordings:
- recording.prettyprint()
- url = recording.get('playback', {}).get('format', {}).get('url')
- if url:
- url = url.decode()
- data = {
- 'start': int(recording['startTime'].decode()),
- 'end': int(recording['endTime'].decode()),
- 'url': url,
- 'state': recording['state'].decode(),
- }
- data['duration'] = data['end'] - data['start']
- all_records.append(data)
+def get_records_from_bbb(**kwargs):
+ """get records info from bbb xml"""
+ records = []
+ for server in BBBServer.objects.all():
+ recordings_xml = server.get_instance().get_recordings(**kwargs).get_field('recordings')
+ if hasattr(recordings_xml, 'get'):
+ recordings = recordings_xml['recording']
+ if type(recordings) is XMLDictNode:
+ recordings = [recordings]
+ for recording in recordings:
+ recording.prettyprint()
+ url = recording.get('playback', {}).get('format', {}).get('url')
+ if url:
+ url = url.decode()
+ if not recording['metadata'].get('periodid'):
+ continue
+ start = int(recording['startTime'].decode()[:-3])
+ end = int(recording['endTime'].decode()[:-3])
+ data = {
+ 'id': recording['recordID'].decode(),
+ 'start': start,
+ 'start_date': datetime.datetime.fromtimestamp(start),
+ 'end': end,
+ 'end_date': datetime.datetime.fromtimestamp(end),
+ 'url': url,
+ 'state': recording['state'].decode(),
+ 'period_id': int(recording['metadata'].get('periodid').decode()),
+ 'course_id': int(recording['metadata'].get('courseid').decode()),
+ 'slot_id': int(recording['metadata'].get('slotid').decode()),
+ }
+ data['duration'] = data['end'] - data['start']
+ records.append(data)
+ return records
+
+def get_records(period_id=None, course_id=None, rooms=None, recording_id=None):
+ """ get all records, filtered """
+ # if not rooms:
+ # rooms = ';'.join([slot.room_id for slot in self.slots.all()])
+ # print(rooms)
+ meta = {}
+ if period_id:
+ meta['periodid'] = period_id
+ if course_id:
+ meta['courseid'] = period_id
+ meta['origin'] = 'crfpa'
+
+ all_records = get_records_from_bbb(meta=meta)
+ # vocabulary = [('Aucun', 'none')]
if not all_records:
return []
- all_records = sorted(all_records, key=lambda record:-record['duration'])
- vocabulary = []
- for record in all_records:
- vocabulary.append((record['url'], record['duration']))
- return longest_record
+ all_records = sorted(all_records, key=lambda record:-record['start'])
+ # for record in all_records:
+ # vocabulary.append((record['url'], record['start']))
+ return all_records
def __unicode__(self):
return "Serveur %d" % self.id
+
class Webclass(models.Model):
department = models.ForeignKey('teleforma.Department', related_name='webclass', verbose_name=_('department'), on_delete=models.SET_NULL, blank=True, null=True)
return None
+
class WebclassSlot(models.Model):
""" Webclass slot """
webclass = models.ForeignKey('Webclass', related_name='slots')
'bannerColor': "#003768",
# 'customStyleUrl': site_url+"/static/teleforma/css/bbb.css"
}
+ meta = {
+ 'origin':'crfpa',
+ 'periodid': webclass.period.id,
+ 'courseid': webclass.course.id,
+ 'webclassid': webclass.id,
+ 'slotid': self.id,
+ 'professor': self.professor.last_name,
+ }
print params
try:
- result = self.bbb.create_meeting(self.room_id, params=params)
+ result = self.bbb.create_meeting(self.room_id, params=params, meta=meta)
except BBBException as e:
print(e)
raise
period = models.ForeignKey('teleforma.Period', verbose_name=_('period'))
course = models.ForeignKey('teleforma.Course', related_name='webclass_records', verbose_name=_('course'))
- url = models.CharField("Enregistrement BBB", max_length=255)
- created = models.DateTimeField("Date de la conférence")
+ record_id = models.CharField("Enregistrement BBB", max_length=255)
+ created = models.DateTimeField("Date de la conférence", auto_now_add=True)
class Meta(MetaCore):
db_table = app_label + '_' + 'webclass_record'
def __unicode__(self):
return "Enregistrement webclass %d" % self.id
+
+
+ @staticmethod
+ def get_records(period, course):
+ records = []
+ for record in WebclassRecord.objects.filter(period=period, course=course):
+ records.append(record.record_id)
+
+ records = get_records_from_bbb(recording_id=','.join(records))
+ print(records)
+ return records
+
+
--- /dev/null
+<div class="object-tools">
+ {% for period in periods %}
+ <a class="btn btn-success" href="{% url teleforma-webclass-records-form period.id %}"><i class="icon-plus-sign icon-white"></i>{{ period.name}} </a>
+ {% endfor %}
+</div>
\ No newline at end of file
--- /dev/null
+{% extends "admin/change_list.html" %}
+{% load webclass %}
+
+{% block object-tools %}
+{% add_records_links %}
+{{ block.super }}
+{% endblock %}
\ No newline at end of file
--- /dev/null
+{% extends "admin/base.html" %}
+{% load teleforma_tags %}
+{% load i18n %}
+
+{% block head_title %}Gestion des enregistrements{% endblock %}
+
+{% block title %}Gestion des enregistrements{% endblock %}
+
+{% block content %}
+<form method="post">{% csrf_token %}
+
+ <p>Vous pouvez choisir un/plusieurs enregistrements qui seront ajoutés à la page de cours.</p>
+ {{ form.as_p }}
+ <input type="submit" value="Ajouter">
+</form>
+{% endblock %}
\ No newline at end of file
url(r'^desk/webclass_appointments/(?P<pk>.*)$', WebclassAppointment.as_view(),
name="teleforma-webclass-appointments"),
url(r'^desk/webclass_calendar/$', WebclassProfessorAppointments.as_view(), name="teleforma-webclass-professor"),
+ url(r'^admin/periods/(?P<period_id>.*)/webclass_records_form/$', WebclassRecordsFormView.as_view(), name="teleforma-webclass-records-form"),
url(r'^desk/webclass/(?P<pk>.*)/join/$',
join_webclass,
name="teleforma-webclass-join"),
# -*- coding: utf-8 -*-
-from django.views.generic import View, TemplateView
+from django.views.generic import View, TemplateView, FormView
from django.contrib import messages
from django.http import HttpResponse
from django.shortcuts import redirect, get_object_or_404, render
from django.core.cache import cache
from teleforma.webclass.models import Webclass, WebclassSlot
+from teleforma.webclass.forms import WebclassRecordsForm
from teleforma.views.core import get_periods, get_courses
# return data
+class WebclassRecordsFormView(FormView):
+ template_name = 'webclass/records_form.html'
+ form_class = WebclassRecordsForm
+ success_url = '/admin/django/webclass/webclassrecord'
+
+ def get_form_kwargs(self):
+ kwargs = super(WebclassRecordsFormView, self).get_form_kwargs()
+ kwargs['period_id'] = int(self.kwargs['period_id'])
+ return kwargs
+
+ def form_valid(self, form):
+ form.save_records()
+ return super(WebclassRecordsFormView, self).form_valid(form)
+
def join_webclass(request, pk):
webclass_slot = WebclassSlot.objects.get(pk=int(pk))
projects / teleforma.git / commitdiff