def setUp(self):
self.first_schedule = Schedule({
'begin': '20/11/2016 13:00',
'end': '20/11/2016 15:00'
})
self.second_schedule = Schedule({
'begin': '20/11/2016 13:00',
'end': '20/11/2016 16:00'
})
def download_and_deliver(self, user):
try:
user: User = jsonpickle.loads(user,
classes=[User, User.REMOVED, Schedule])
# Clear user db entry and downloads
file_manager.remove_schedule(user.uid)
if file_manager.does_path_exist(
file_manager.get_user_download_path(user.uid)):
file_manager.delete_user_file(user.uid)
path = ''
if user.deliver_voicenote:
path = file_manager.download_user_file(user)
# Update/create database entry for logging and management
logger.debug('Scheduled time: %s' % user.REMOVED.scheduled_date)
schedule_id = file_manager.create_db_schedule(user, path)
schedule = file_manager.downloads_collection.find_one(
{"_id": ObjectId(schedule_id)})
schedule = Schedule(user, schedule['path'])
user_json = jsonpickle.dumps(user)
schedule_json = jsonpickle.dumps(schedule)
deliver.apply_async(args=[user_json, schedule_json], queue='deliver')
return user, schedule
except SoftTimeLimitExceeded as e:
self.retry(exc=e)
def execute(self):
session = DbConnexion.session()
if 'id' in self.param:
schedule = session.query(Schedule).get(int(self.param['id'])) or Schedule(id=int(self.param['id']))
else:
schedule = Schedule(modified=datetime.now())
if 'begin' in self.param:
schedule.begin = self.param['begin']
if 'end' in self.param:
schedule.end = self.param['end']
if 'teacher' in self.param:
schedule.teacher = session.query(Person).filter(Person.type == 'teacher')\
.filter(Person.id == self.param['teacher']).first()
if 'promotions' in self.param:
promo_ids = eval(self.param['promotions'])
schedule.promotions = session.query(Promotion).filter(Promotion.id.in_(promo_ids)).all()
if 'classrooms' in self.param:
classrooms_ids = eval(self.param['classrooms'])
schedule.classrooms = session.query(ClassRoom).filter(ClassRoom.id.in_(classrooms_ids)).all()
if 'terminals' in self.param:
terminal_ids = eval(self.param['terminals'])
schedule.terminals = session.query(Terminal).filter(Terminal.id.in_(terminal_ids)).all()
session.add(schedule)
session.commit()
pass
def add_schedule(self, new_schedule):
if not hasattr(self, 'schedules'):
self.schedules = []
for schedule in self.schedules:
if(Schedule(schedule).colides_with_other_schedule(new_schedule)):
raise RoomAlreadyHasScheduleInGivenPeriodError()
self.schedules.append(new_schedule.__dict__)
def create_period_from( scheduleParser ):
SECONDS = '0'
MINUTES = '1'
HOURS = '2'
DAYS = '3'
WEEKS = '4'
MONTHS = '5'
period_type = scheduleParser.getPeriodType()
frequency = scheduleParser.getFrequency()
runHours = scheduleParser.getHours()
runDays = scheduleParser.getRunDays()
runMonths = scheduleParser.getMonths()
start_minute = scheduleParser.getMinute()
start_hour = scheduleParser.getHour()
if period_type == SECONDS:
return None
elif period_type == MINUTES:
schedule = Schedule.createMinuteSchedule( frequency, runHours, runDays, start_minute )
return PeriodMinute( schedule )
elif period_type == HOURS:
schedule = Schedule.createHourSchedule ( frequency, runHours, runDays, start_minute )
return PeriodHour ( schedule )
elif period_type == DAYS:
schedule = Schedule.createDaySchedule ( runDays, start_hour, start_minute )
return PeriodDay ( schedule )
elif period_type == WEEKS:
schedule = Schedule.createWeekSchedule ( runDays, start_hour, start_minute )
return PeriodWeek ( schedule )
elif period_type == MONTHS:
return None
else:
return None
def find(self, room_id, schedule_id):
room = self.room_collection.find_one(
{
'_id': ObjectId(room_id),
'schedules._id': ObjectId(schedule_id)
}, {'schedules.$': 1})
if not room or not 'schedules' in room:
raise ScheduleNotFoundError()
schedule = room['schedules'][0]
return Schedule(schedule)
def create_db_schedule(self, user: User, path):
# Create download_collection object for insertion into database
schedule = Schedule(user, path)
# Insert object into downloads_collection and log database id
try:
schedule_id = self.downloads_collection.insert_one(
schedule.__dict__).inserted_id
self.logger.info('Schedule inserted in database with ID ' +
str(schedule_id))
return schedule_id
except WriteError:
self.logger.info('Entry exists for user %s & url %s' %
(user.uid, user.REMOVED.audio_url))
return None
def all(self, room_id, begin_at_or_after=None, begin_at_or_before=None):
room = Room(self.room_service.find(room_id))
if not begin_at_or_after and not begin_at_or_before:
return room.schedules
result = []
for entry in room.schedules:
schedule = Schedule(entry)
if begin_at_or_after and schedule.begin.date() < begin_at_or_after:
continue
if begin_at_or_before and schedule.begin.date(
) > begin_at_or_before:
continue
result.append(schedule.__dict__)
return result
def createPeriod(runDaysOfWeek, startHour, startMinute):
schedule = Schedule.createDaySchedule(runDaysOfWeek, startHour,
startMinute)
return PeriodDay(schedule)
def execute(self):
session = DbConnexion.session()
session.execute("DELETE FROM promotion")
session.execute("DELETE FROM person")
session.execute("DELETE FROM terminal")
session.execute("DELETE FROM terminal")
session.execute("DELETE FROM presence")
session.execute("DELETE FROM schedule")
promos = []
for i in range(2013, 2016):
promos.append(Promotion(label='RIL', academic_year=i))
promos.append(Promotion(label='RAR', academic_year=i))
session.add_all(promos)
session.commit()
persons = []
for i in range(1, 100):
promo = promos[random.randint(0, len(promos) - 1)]
persons.append(Person(firstname='firstname%s' % (i,),
lastname='lastname%s' % (i,),
type='student',
promotion=promo))
session.add_all(persons)
session.commit()
teachers = []
for i in range(100, 115):
teachers.append(Person(firstname='firstname%s' % (i,),
lastname='lastname%s' % (i,),
type='teacher'))
session.add_all(teachers)
session.commit()
teachers.append(None)
classrooms = []
for i in range(1, 21):
classrooms.append(ClassRoom(label='Class%s' % (i,), capacity=random.randint(15, 70)))
session.add_all(classrooms)
session.commit()
terminals = []
for i in range(1, 35):
terminals.append(Terminal(label='Terminal%s' % (i,),
classroom=classrooms[randint(0, len(classrooms) - 1)],
ip_address='%s.%s.%s.%s' % (randint(0, 255), randint(0, 255), randint(0, 255), randint(0, 255))))
for i in range(35, 41):
terminals.append(Terminal(label='Terminal%s' % (i,),
ip_address='%s.%s.%s.%s' % (randint(0, 255), randint(0, 255), randint(0, 255), randint(0, 255))))
session.add_all(terminals)
session.commit()
schedules = []
today = datetime.now()
for i in range(1, 50):
tclassrooms = []
tclassrooms.append(classrooms[randint(0, len(classrooms) - 1)])
tclass2 = classrooms[randint(0, len(classrooms) - 1)]
if tclassrooms[0].id != tclass2.id:
tclassrooms.append(tclass2)
tpromos = []
tpromos.append(promos[randint(0, len(promos) - 1)])
tpromo2 = promos[randint(0, len(promos) - 1)]
if tpromos[0].id != tpromo2.id:
tpromos.append(tpromo2)
tterminal = []
while today.weekday() == 6 or today.weekday() == 5:
today = today + timedelta(days=1)
s = Schedule(teacher=teachers[random.randint(1, len(teachers) - 1)])
s.begin = datetime(today.year, today.month, today.day, 8, 30)
s.end = datetime(today.year, today.month, today.day, 12, 30)
s.classrooms = tclassrooms
s.promotions = tpromos
schedules.append(s)
s = Schedule(teacher=s.teacher)
s.begin = datetime(today.year, today.month, today.day, 13, 30)
s.end = datetime(today.year, today.month, today.day, 17, 30)
s.classrooms = tclassrooms
s.promotions = tpromos
schedules.append(s)
today = today + timedelta(days=1)
session.add_all(schedules)
session.commit()
pass
def createPeriod(frequency, runHours, runDays, startMinute):
schedule = Schedule.createMinuteSchedule(frequency, runHours, runDays,
startMinute)
return PeriodMinute(schedule)
def test_creation_of_minute_task(self):
schedule = Schedule.createMinuteSchedule("2", "3", "4", "5")
self.assertEqual(schedule.frequency, "2")
self.assertEqual(schedule.runHours, "3")
self.assertEqual(schedule.runDaysOfWeek, "4")
self.assertEqual(schedule.startMinute, "5")
def test_creation_of_day_task(self):
schedule = Schedule.createDaySchedule("runDaysOfWeek", "startHour",
"startMinute")
self.assertEqual(schedule.runDaysOfWeek, "runDaysOfWeek")
self.assertEqual(schedule.startHour, "startHour")
self.assertEqual(schedule.startMinute, "startMinute")
class SchedulesTest(unittest.TestCase):
def setUp(self):
self.first_schedule = Schedule({
'begin': '20/11/2016 13:00',
'end': '20/11/2016 15:00'
})
self.second_schedule = Schedule({
'begin': '20/11/2016 13:00',
'end': '20/11/2016 16:00'
})
def test_colides_with_other_schedule_equals_begin_datetime(self):
assert_that(
self.first_schedule.colides_with_other_schedule(
self.second_schedule)).is_true()
def test_colides_with_other_schedule_begin_between_begin_and_end_of_other(
self):
self.second_schedule.set_begin('20/11/2016 13:30')
assert_that(
self.first_schedule.colides_with_other_schedule(
self.second_schedule)).is_true()
def test_colides_with_other_schedule_equals_ends(self):
self.second_schedule.set_begin('20/11/2016 09:00')
self.second_schedule.set_end('20/11/2016 15:00')
assert_that(
self.first_schedule.colides_with_other_schedule(
self.second_schedule)).is_true()
def test_colides_with_other_other_ends_on_begin_of_self(self):
self.second_schedule.set_begin('20/11/2016 09:00')
self.second_schedule.set_end('20/11/2016 13:00')
assert_that(
self.first_schedule.colides_with_other_schedule(
self.second_schedule)).is_true()
def create_schedule(title, participants, begin, end, room_id):
schedule = Schedule(request.json)
schedule_service.add(room_id, schedule)
return (dumps({'message': 'Created Schedule'}), 201)
def createPeriod(frequency, runHours, runDaysOfWeek, startMinute):
schedule = Schedule.createHourSchedule(frequency, runHours, runDaysOfWeek,
startMinute)
return PeriodHour(schedule)
