def create_request():
"""
Create new request for logged in user
"""
auth_header = request.headers["Authorization"] # get authorization header
token = auth_header.split(" ")[1] # split header to obtain token
if token:
user = User.decode_token(token)
# check if user is a string
if not isinstance(user, str):
if request.json and request.json.get('title') and \
request.json.get('description') and request.json.get('location'):
title = request.json.get('title')
description = request.json.get('description')
location = request.json.get('location')
req = Request(
title=title,
description=description,
location=location,
created_by=user["id"]
)
req.save()
return make_response(jsonify({
"title": req.title,
"description": req.description,
"location": req.location,
"created_by": req.created_by
})), 201
return make_response(jsonify({
"message": "Please provide the title, description, and location of your request."
})), 400
return make_response(jsonify({"message": str(user)})), 401
return make_response(jsonify({"message": "Invalid request"})), 500
def decline_request(update: Update, context: CallbackContext):
tel_to = update.callback_query.message.chat.id
tel_id = active_requests.get(tel_to, None)
if tel_id:
tel_id = tel_id[0]
del active_requests[tel_to]
del active_requests[tel_id]
delete_msg(tel_id, context)
delete_msg(tel_to, context)
active_commands[tel_id] = context.bot.send_message(
text=f'``` Request Cancelled ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id).message_id
active_commands[tel_to] = context.bot.send_message(
text=f'``` Request Cancelled ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to).message_id
Db.get_instance().update_user_disconnected(tel_id)
Db.get_instance().update_user_disconnected(tel_to)
req = Request()
req.make(tel_id, tel_to, 2)
Db.get_instance().update_request(req)
else:
delete_msg(tel_to, context)
active_commands[tel_to] = context.bot.send_message(
text=f'``` Expired Request ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to).message_id
def accept_request(update: Update, context: CallbackContext):
tel_to = update.callback_query.message.chat.id
tel_id = active_requests.get(tel_to, None)
if tel_id:
tel_id = tel_id[0]
active_chats[tel_id] = active_requests[tel_id][0]
active_chats[active_chats[tel_id]] = tel_id
del active_requests[tel_id]
del active_requests[active_chats[tel_id]]
delete_msg(tel_id, context)
delete_msg(tel_to, context)
active_commands[tel_id] = context.bot.send_message(
text=f'``` Request Accepted ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id).message_id
context.bot.send_message(
text=
f'``` The Messages Now on (except Commands will be visible to the Anonymous '
f'person) ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id)
context.bot.send_message(
text=
f'``` The Messages Now on (except Commands will be visible to the Anonymous '
f'person) ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to)
res = Db.get_instance().get_common_interests(tel_id, tel_to)
data = [INTEREST_LIST[x] for x in res[0].intersection(res[1])]
if len(data) != 0:
context.bot.send_message(
text=f'``` Common Interest {" ".join(data)}```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id)
context.bot.send_message(
text=f'``` Common Interest {" ".join(data)} ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to)
else:
context.bot.send_message(
text=
f'``` Interests the Anonymous User have:- {" ".join([INTEREST_LIST[i] for i in res[1]])}```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id)
context.bot.send_message(
text=
f'``` Interests the Anonymous User have:- {" ".join([INTEREST_LIST[i] for i in res[0]])} ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to)
req = Request()
req.make(tel_id, tel_to, 3)
Db.get_instance().update_request(req)
else:
delete_msg(tel_to, context)
active_commands[tel_to] = context.bot.send_message(
text=f'``` Expired Request ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to).message_id
def read_request_id(self, tel_id: int) -> Request:
self.c.execute("""SELECT * FROM requests WHERE id=? OR to_id=?""",
(tel_id, tel_id))
data = self.c.fetchone()
if data:
request = Request()
request.make(data[0], data[1], data[2])
return request
return data
def read_requests(self):
self.c.execute("""SELECT * FROM requests""")
requests = []
for request in self.c.fetchall():
new_request = Request()
new_request.make(request[0], request[1], request[2])
requests.append(new_request)
for request in requests:
print(request.tel_to)
def teacher_request():
form = forms.RequestForm()
form.goals.choices = [(i.key, i.name) for i in Goal.query.all()]
if request.method == 'POST':
if form.validate_on_submit():
form.goals.data = Goal.query.filter(
Goal.key == form.data['goals']).first()
Request.add(**form.data).commit()
return render_template('request_done.html', form=form)
return render_template('request.html', form=form)
def get_values(self, data):
try:
arr = data.split("\r\n")
method, query, protocol = self.method_query_protocol(arr[0])
url = self.url(query)
connection = self.get_connection()
except BaseException as e:
self._log.debug('parsing exc: {}'.format(e))
return Request("unknown", "unknown", "unknown", "unknown")
return Request(method, protocol, url, connection)
def complete_ride(request_id):
"""
Marks a ride request as completed.
:param request_id:
:return:
"""
print "Going to mark the ride with request id {request_id} as COMPLETED".format(request_id=request_id)
updated_args = {
"req_status": ReqStatus.COMPLETED,
"completed_at": datetime.utcnow()
}
Request.filter_and_update(filter_args={"id": request_id}, updated_args=updated_args)
def get_values(data):
arr = data.split(b'\n')
values = arr[0].split()
method = values[0]
query = values[1].split(b'?')[0]
protocol = values[2]
return Request(method, protocol, query, get_connection())
def main():
try:
url = sys.argv[1]
except IndexError:
url = 'http://ogp.me/'
page_html = Request(url).get_page_html()
if page_html[:9] == 'HTTPError':
res = json.dumps({
'STATUS': 'ERROR',
'MSG': "bad url request error, page not found",
"CATEGORIES": page_html,
'CODE': "404"
})
print(res)
return res
page_bsoup = BSoup(page_html).return_bSoup_object_from_page_html()
res = ResponseBuilder(OpenGraph(page_bsoup)).get_response_object_in_json()
if res == '{}':
res = json.dumps({
'STATUS': 'ERROR',
'MSG': "No open graph meta was found for the given url",
"CATEGORIES": "no open graph meta tags",
'CODE': "404"
})
print(res)
return res
def get_requests():
"""
:return: All ```request(s)``` in json format.
"""
from models.request import Request
requests = Request.all()
return map(lambda r: r.as_dict(), requests)
def serve_request(driver_id, request_id):
"""
Responsible for serving a request(If not served in past, i.e. waiting request) from driver app. And schedule a completion
job for this request, at ```now + RIDE_COMPLETION_DURATION_IN_SEC```
:param driver_id:
:param request_id:
:return: status & message
"""
from services.taxi_scheduler import schedule
from taxi import app
try:
updated_args = {
"req_status": ReqStatus.ONGOING,
"driver_id": driver_id,
"picked_up": datetime.utcnow()
}
request = Request.filter_and_update(filter_args={"id": request_id, "req_status": ReqStatus.WAITING}, updated_args=updated_args)
if request:
schedule(app.config['RIDE_COMPLETION_DURATION_IN_SEC'], complete_ride, (request_id,))
else:
res = {"status": "warning", "message": "No such request found or request may already be selected/served."}
return res
except Exception as e:
print e
res = {"status": "error", "message": "Couldn't serve request."}
return res
res = {
"status": "success",
"message": "Accepted request successfully."
}
return res
def post(self):
args = CreateRequest.parser.parse_args()
request = Request(user_email=args.get('user_email'), quantity=args.get('quantity'),
urgency=args.get('urgency'), item=args.get('item'), is_surplus=args.get('is_surplus'))
session.add(request)
session.commit()
return {'response': 'success'}
def parse(self, data: str) -> Optional[Request]:
method = self._parse_method(data)
protocol = self._parse_protocol(data)
url = self._parse_url(data)
params = self._parse_params(data)
headers = self._parse_headers(data)
return Request(method=method,
protocol=protocol,
url=url,
params=params,
headers=headers)
def cancel_chat(update: Update, context: CallbackContext):
tel_id = active_chats.get(update.callback_query.message.chat.id, None)
if tel_id:
Db.get_instance().update_user_disconnected(tel_id)
Db.get_instance().update_user_disconnected(active_chats[tel_id])
req = Request()
req.make(tel_id, active_chats[tel_id], 1)
Db.get_instance().update_request(req)
req.make(active_chats[tel_id], tel_id, 1)
Db.get_instance().update_request(req)
delete_msg(tel_id, context)
delete_msg(active_chats[tel_id], context)
active_commands[tel_id] = context.bot.send_message(
text=f'``` Chat Cancelled ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id).message_id
active_commands[active_chats[tel_id]] = context.bot.send_message(
text=f'``` Chat Cancelled ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=active_chats[tel_id]).message_id
context.bot.send_message(text="/chat for chat settings",
parse_mode=ParseMode.MARKDOWN,
chat_id=active_chats[tel_id])
context.bot.send_message(text="/chat for chat settings",
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id)
del active_chats[active_chats[tel_id]]
del active_chats[tel_id]
def open_connection(socket, client_conn, data, router):
request = None
try:
payload = json.loads(data)
request = Request(**payload)
request.connection = client_conn
try:
response = router.resolve(request)
if response != None:
socket.sendto(response.encode(), client_conn)
except Exception as e:
print(e)
socket.sendto(
Response(code=codes.INTERNAL_ERROR,
body="Internal error").encode(), client_conn)
except Exception as e:
print(e)
socket.sendto(
Response(code=codes.BAD_REQUEST,
body="Invalid request").encode(), client_conn)
def get_requests_by_status(status=ReqStatus.WAITING,driver_id=None):
"""
Filters request(s) on the basis of ```req_status``` & ```driver_id```
:param status:
:param driver_id:
:return: Filtered request(s)
"""
filter_criteria = {
"req_status": status
}
if driver_id is not None:
filter_criteria['driver_id'] = driver_id
requests = Request.filter(filter_criteria)
return map(lambda r: r.as_dict(), requests)
def catch_all(path):
path = "/" + path
c = db_session.query(Client).filter(
Client.ip == request.remote_addr).first()
if c is None:
c = Client(ip=request.remote_addr)
db_session.add(c)
r = Request(route=path,
time=datetime.datetime.now(),
post_data=request.get_data(),
headers=request.headers,
client=c,
method=request.method)
db_session.add(r)
db_session.commit()
return "", 200
def ride(customer_id):
"""
Responsible for creating a new ride request from customer app.
:param customer_id:
:return:
"""
try:
Request(customer_id).create()
except Exception as e:
print e
res = {"status": "error", "message": "Couldn't submit request for this ride."}
return res
res = {
"status": "success",
"message": "Request for the ride has been submitted successfully."
}
return res
async def handle(self, reader, writer):
data = b''
while True:
chunk = await reader.read(CHUNK_SIZE)
data += chunk
if not data or reader.at_eof() or data[-4:] == b'\r\n\r\n':
break
if len(data) > 0:
request = Request(data)
response_data = await self.executor.execute(request)
response = await self.serializer.dump(response_data)
writer.write(response)
await writer.drain()
writer.close()
def load_empresa(self):
selected_emp = str(self.select_empresa.currentText())
if selected_emp not in '':
self.empresa = self.empresas.get(selected_emp)
reqs = Request.get_by_empresa_id(self.empresa.id)
self.tbl_request.setRowCount(len(reqs))
for i, r in enumerate(reqs):
self.tbl_request.setItem(i, 0, QTableWidgetItem(str(r.name)))
self.tbl_request.setItem(i, 1,
QTableWidgetItem(str(r.init_date)))
self.tbl_request.setItem(i, 2,
QTableWidgetItem(str(r.end_date)))
self.tbl_request.setItem(i, 3, QTableWidgetItem(str(r.state)))
self.tbl_request.setItem(
i, 4, QTableWidgetItem(str(r.numero_cfdis or '-')))
self.tbl_request.setItem(
i, 5, QTableWidgetItem(str(r.estado_solicitud or '-')))
self.tbl_request.setItem(
i, 6, QTableWidgetItem(str(r.mensaje or '-')))
self.tbl_request.setItem(i, 7, QTableWidgetItem(str(r.id)))
if len(Fiel.get_by_empresa_id(self.empresa.id)) > 0:
self.btn_add_request.setEnabled(True)
self.tbl_request.itemClicked.connect(self.activate_request_buttons)
def post(self, eventId, guardianId):
'''The visitor is not an authenticated guardian'''
if not SubscriptionLoginHandler.isAuthenticatedGuardian():
self.redirect('/inschrijven/')
return
'''The guardian is not authorized to the given'''
if not self.isAuthorized(eventId, guardianId):
SubscriptionLoginHandler.redirectToSubscriptionPage(self)
return
event = Event.get_by_id(int(eventId))
days = Day.gql("WHERE event = :1", event).fetch(999)
guardian = Guardian.get_by_key_name(guardianId)
students = Student.gql("WHERE guardian = :1", guardian).fetch(999, 0)
students_subjects = self.getStudentsSubjects(students)
notifications = []
templVal = {
'event': event,
'days': days,
'guardian': guardian,
'students': students_subjects,
'notifications': notifications
}
if not (event and days and guardian and students):
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
self.showError(templVal)
return
subscriptionDetailsList = SubscriptionDetails.gql("WHERE event = :1 AND guardian = :2", event, guardian).fetch(1, 0)
if not subscriptionDetailsList:
notifications.append('Pagina niet gevonden.')
self.showError(templVal)
return
subscriptionDetails = subscriptionDetailsList[0]
if subscriptionDetails and subscriptionDetails.requested:
notifications.append('U kunt geen verzoeken meer indienen.')
self.showError(templVal)
return
studentKeys = [str(k.replace('subject_', '')) for k in self.request.arguments() if re.match("subject_.+", k)]
requests = []
dayPrefs = []
for s in students[:]:
if str(s.key().name()) not in studentKeys:
students.remove(s)
if not students:
notifications.append('U kunt geen verzoek indienen als u geen enkel vak geselecteerd heeft. ')
for student in students[:]:
subjectCodes = [c for c in self.request.get_all("subject_" + str(student.key().name()))]
subjects = Subject.get_by_key_name(subjectCodes)
if len(subjectCodes) > 3:
notifications.append('U kunt maximaal 3 vakken per leerling bespreken.')
if len(subjectCodes) != len(subjects):
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
for subject in subjects:
combination = Combination.gql("WHERE class_id = :1 AND subject = :2", student.class_id, subject).fetch(1,0)[0]
if not combination:
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
self.showError(templVal)
return
request = Request()
request.event = event
request.guardian = guardian
request.student = student
request.combination = combination
requests.append(request)
'''Process timepreference'''
timePref = TimePreference()
timePref.event = event
timePref.guardian = guardian
timePref.preference = 0
if not (self.request.get('time_pref') and (int(self.request.get('time_pref')) in [0,1,2])):
notifications.append('U moet een voorkeur voor tijd aangeven.')
else:
timePref.preference = int(self.request.get('time_pref'))
'''Check if dates from the form match the dates from the event '''
dayKeys = [long(k.replace('date_', '')) for k in self.request.arguments() if re.match("date_.+", k)]
dayKeysFromStore= [day.key().id() for day in days]
daysOk = True
for dayKey in dayKeys:
if dayKey not in dayKeysFromStore:
daysOk = False
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
self.showError(templVal)
return
'''Check if the daypreference are correct filled in'''
dayPrefsList = [int(self.request.get(k)) for k in self.request.arguments() if re.match("date_.+", k)]
dayPrefsList.sort()
dayPrefsOk = True
if dayPrefsList != [1,2,3]:
dayPrefsOk = False
notifications.append('U moet een eerste, een tweede en een derde voorkeur aangeven')
'''Process daypreferences'''
if daysOk and dayPrefsOk:
for day in days:
dayPref = DayPreference()
dayPref.day = day
dayPref.guardian = guardian
dayPref.rank = int(self.request.get("date_" + str(day.key().id())))
dayPrefs.append(dayPref)
if notifications:
path = os.path.join(os.path.dirname(__file__), '../templates/subscription/subscription.html')
self.response.out.write(template.render(path, templVal))
return
'''Store the requests'''
for request in requests:
request.put()
for dayPref in dayPrefs:
dayPref.put()
timePref.put()
subscriptionDetails.requested = True
subscriptionDetails.put()
SubscriptionLogoutHandler.logoutGuardian()
path = os.path.join(os.path.dirname(__file__), '../templates/subscription/subscription-success.html')
self.response.out.write(template.render(path, templVal))
return
def get(self, arg):
event = Event.get_by_id(int(arg))
notifications = []
if not event:
notifications.append("De bewerking kon niet worden voltooid omdat het event niet bestaat.")
events = Event.all()
path = os.path.join(os.path.dirname(__file__), '../templates/administration/event-list.html')
template_values = {'events': events, 'logoutlink': users.create_logout_url("/") , 'notifications': notifications }
self.response.out.write(template.render(path, template_values))
return
requests = event.requests.fetch(9999)
guardians_keys = []
for request in requests:
if request.guardian.key().name() not in guardians_keys:
guardians_keys.append(request.guardian.key().name())
if not guardians_keys:
notifications.append("Er zijn geen voogden met verzoeken")
events = Event.all()
path = os.path.join(os.path.dirname(__file__), '../templates/administration/event-list.html')
template_values = {'events': events, 'logoutlink': users.create_logout_url("/") , 'notifications': notifications }
self.response.out.write(template.render(path, template_values))
return
for guardian_num, guardian_key in enumerate(guardians_keys):
guardian = Guardian.get_by_key_name(guardian_key)
guardian_requests = Request.gql("WHERE guardian = :1 AND event = :2", guardian, event).fetch(999)
guardian_appointments = [guardian_request.appointment.get() for guardian_request in guardian_requests if guardian_request.appointment.get()]
day_ids = [appointment.day.key().id() for appointment in guardian_appointments if appointment]
day_ids = list(set(day_ids))
if not guardian_appointments:
continue
mail = Email()
message = 'Beste ' + guardian.title
if not guardian.preposition == '':
message += ' ' + guardian.preposition
message += ' ' + guardian.lastname + ',\n\n'
message += 'Er zijn afspraken ingepland voor de ouderavond(en) van het ' + event.event_name + ". "
message += 'Hieronder vind u de afspraken die voor u zijn gemaakt:\n\n'
for day_id in day_ids:
day = Day.get_by_id(day_id)
message += 'Op ' + str(day.date.day) + ' ' + AdministrationInviteGuardiansHandler.getMonthText(self, day.date.month) + ' ' + str(day.date.year) + ':\n'
for appointment in guardian_appointments:
if appointment.day.key().id() == day_id:
student = appointment.request.student
m = event.talk_time * appointment.slot
d = timedelta(minutes=m)
time = day.date + d
message += 'Tijd: ' + str(time.hour) + ':' + str(time.minute) + '\n'
message += 'Tafel: ' + str(appointment.table) + '\n'
message += 'Leerling: ' + student.firstname + ' ' + student.preposition + ' ' + student.lastname + '\n'
message += 'Vak: ' + appointment.request.combination.subject.name + '\n'
message += 'Docent: ' + appointment.request.combination.teacher.name + '\n'
message += 'Docentcode: ' + appointment.request.combination.teacher.key().name() + '\n\n'
# mail.sendMail(guardian.email, 'Afspraken ouderavond(en) ' + event.event_name, message)
if guardian_num == 0:
print message
return
def set_up_random_chat(update: Update, context: CallbackContext) -> None:
data = status_code(update.callback_query.message.chat_id)
if data == 1:
context.bot.send_message(
text=f'``` Close the current chat portal to start a new one ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=update.callback_query.message.chat.id,
)
return
if data == 0:
data = active_requests.get(update.callback_query.message.chat.id, None)
delete_msg(update.callback_query.message.chat_id, context)
print(data)
if data[1] == 1:
keyboard = [[
InlineKeyboardButton(
"CANCEL REQUEST",
callback_data=CANCEL_REQUEST_CALLBACK_DATA)
]]
msg_id = context.bot.send_message(
update.callback_query.message.chat.id,
"""``` You are in request phase Waiting for Accepting```""",
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(keyboard)).message_id
active_commands[update.callback_query.message.chat.id] = msg_id
elif data[1] == -1:
keyboard = [
[
InlineKeyboardButton("ACCEPT",
callback_data=ACCEPT_CALLBACK_DATA),
InlineKeyboardButton("DECLINE",
callback_data=DECLINE_CALLBACK_DATA),
],
]
msg_id = context.bot.send_message(
update.callback_query.message.chat.id,
"""``` You are in request phase```""",
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(keyboard)).message_id
active_commands[update.callback_query.message.chat.id] = msg_id
return
data = Db.get_instance().read_available_users(
update.callback_query.message.chat.id)
if len(data) == 0:
context.bot.send_message(
text=f'``` Oops! No Users Available try after some time ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=update.callback_query.message.chat.id,
)
else:
user = sample(data, 1)[0]
request = Request()
request.make(update.callback_query.message.chat.id, user.tel_id, 0)
Db.get_instance().write_request(request)
active_requests[request.tel_id] = (request.tel_to, 1)
active_requests[request.tel_to] = (request.tel_id, -1)
delete_msg(request.tel_id, context)
keyboard = [[
InlineKeyboardButton("CANCEL REQUEST",
callback_data=CANCEL_REQUEST_CALLBACK_DATA)
]]
active_commands[request.tel_id] = context.bot.send_message(
text=f'``` Waiting for Confirmation ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=request.tel_id,
reply_markup=InlineKeyboardMarkup(keyboard)).message_id
keyboard = [
[
InlineKeyboardButton("ACCEPT",
callback_data=ACCEPT_CALLBACK_DATA),
InlineKeyboardButton("DECLINE",
callback_data=DECLINE_CALLBACK_DATA),
],
]
delete_msg(request.tel_to, context)
active_commands[request.tel_to] = context.bot.send_message(
text=f'``` Anonymous Chat Request ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=request.tel_to,
reply_markup=InlineKeyboardMarkup(keyboard)).message_id
Db.get_instance().update_user_connected(request.tel_id)
Db.get_instance().update_user_connected(request.tel_to)
def _row_to_request(self, row):
request = Request()
request.id = row[0]
request.kind_premises = row[1]
request.post_code = row[2]
request.region = row[3]
request.city_type = row[4]
request.city = row[5]
request.street_type = row[6]
request.street = row[7]
request.house = row[8]
request.block = row[9]
request.flat = row[10]
request.adress = row[11]
request.try_num = row[12]
return request
def get_selected_request(self):
id_req = self.tbl_request.item(self.tbl_request.currentRow(), 7).text()
return Request.find_by_id(id_req)
time.guardian = guardian
time.preference = random.randint(0, 2)
time.save()
days = event.days.fetch(999)
random.shuffle(days)
for i, day in enumerate(days):
day_pref = DayPreference()
day_pref.guardian = guardian
day_pref.day = day
day_pref.rank = i
day_pref.save()
for child in guardian.children:
subjects = Combination.all().filter('class_id', child.class_id).fetch(999)
selection = random.sample(subjects, int(random.triangular(0, 4, 0)))
for choice in selection:
request = Request()
request.event = event
request.guardian = guardian
request.student = child
request.combination = choice
request.save()
class DisplayRequestsHandler(webapp.RequestHandler):
def get(self):
path = os.path.join(os.path.dirname(__file__), 'templates/requests.html')
template_values = {
'event': Event.all().filter('event_name', 'paasrapport').fetch(1),
'guardians': Guardian.all().fetch(9999)
}
def get(self):
print ""
print "<html><body style='font-family: Helvetica; font-size: 0.9em;'>"
print time.strftime("%H:%M:%S", time.localtime()) + ": Start<br>"
logging.info("Fetching all info")
# if arg != None:
# event = Event.get_by_id(int(arg))
# else:
event = Event.all().filter("event_name", "paasrapport").get()
days = Day.all().filter("event", event).fetch(999)
days.sort(key=lambda day: day.date)
max_requests = 0
max_timepref = 0
max_rank = 0
allguardians = Guardian.all().fetch(9999)
guardians = []
requests = []
for guardian in allguardians:
requests = Request.all().filter("guardian", guardian).filter("event", event).fetch(999)
if len(requests) > 0:
max_requests = max([max_requests, len(requests)])
guardian.requests = requests
guardian.day_prefs = []
for day in days:
guardian.day_prefs.append(DayPreference.all().filter("guardian", guardian).filter("day", day).get())
guardian.day_prefs.sort(key=lambda day: day.rank)
max_rank = max([max_rank, max([day.rank for day in guardian.day_prefs])])
guardian.time_pref = TimePreference.all().filter("guardian", guardian).filter("event", event).get()
max_timepref = max([max_timepref, guardian.time_pref.preference])
if len(requests) > 5:
guardianCopy = copy.deepcopy(guardian)
guardian.requests = guardian.requests[: int(len(requests) / 2)]
guardianCopy.requests = guardianCopy.requests[int(len(requests) / 2) :]
guardianCopy.day_prefs[0].rank = 999
guardians.append(guardianCopy)
guardians.append(guardian)
timepref_options = range(max_timepref + 1)
timepref_options = [1, 2, 0]
planning = Planning(event, days)
logging.info("All guardians/requests collected")
for length in range(max_requests, 0, -1):
for timepref in timepref_options:
for rank in range(0, max_rank + 1):
for day_num, day in enumerate(days):
for guardian in filter(
lambda guardian: (len(guardian.requests) == length)
and (guardian.time_pref.preference == timepref)
and (
filter(lambda day_pref: day_pref.day.date == day.date, guardian.day_prefs)[0].rank
== rank
),
guardians,
):
# try to place these requests
placed = planning.place(guardian, day_num)
# on succes, remove guardian from guardian
# on fail, the guardian will return on a less preferable round
if placed:
guardians.remove(guardian)
logging.info("Placed")
for dayIndex, day in enumerate(planning.days):
start = time.clock()
lowestValue = 0
for i, slot in enumerate(day[0]):
lowestValue += len(planning.conflictedTeachers(day, i))
logging.info("conflicts: " + str(lowestValue))
# <--- Build a list of all regions
logging.info("Building regions")
regions = []
for tableIndex, table in enumerate(day):
region = [tableIndex, 0, -1]
previousGuardian = ""
for slotIndex, slot in enumerate(table):
guardianId = planning.getGuardianIdFromRequest(slot)
block = table[region[1] : region[2] + 1]
if guardianId == "":
if len(block) == 0:
region = [tableIndex, slotIndex, slotIndex]
elif block.count(None) == 0:
if previousGuardian != "":
region[2] = slotIndex
regions.append(region)
region = [tableIndex, 0, -1]
elif block.count(None) > 0:
if len(block) > block.count(None):
regions.append(region)
region = [tableIndex, slotIndex, slotIndex]
previousGuardian = ""
else:
if guardianId != previousGuardian and previousGuardian != "":
regions.append(region)
region = [tableIndex, slotIndex, slotIndex]
region[2] = slotIndex
previousGuardian = guardianId
block = table[region[1] : region[2] + 1]
if len(block) > block.count(None) > 0:
regions.append(region)
logging.info("Regions built")
permutationSets = {}
preconflicts = 0
pre_max_conflicts = 0
for i, slot in enumerate(day[0]):
slotConflicts = len(planning.conflictedTeachers(day, i))
pre_max_conflicts = max([pre_max_conflicts, slotConflicts])
preconflicts += slotConflicts
logging.info("Starting conflicts: " + str(preconflicts))
logging.info("Starting max slotconflicts: " + str(pre_max_conflicts))
for set in regions:
block = day[set[0]][set[1] : set[2] + 1]
block.sort(key=lambda x: planning.getTeacherStringFromRequest(x))
day[set[0]][set[1] : (set[2] + 1)] = block
sortedconflicts = 0
sorted_max_conflicts = 0
for i, slot in enumerate(day[0]):
slotConflicts = len(planning.conflictedTeachers(day, i))
sorted_max_conflicts = max([sorted_max_conflicts, slotConflicts])
sortedconflicts += slotConflicts
logging.info("Conflicts after sorting: " + str(sortedconflicts))
logging.info("Max slotconflicts after sorting: " + str(sorted_max_conflicts))
conflicts = 9999
max_conflicts = 9999
while (
conflicts >= preconflicts
and conflicts >= sortedconflicts
and max_conflicts >= pre_max_conflicts
and max_conflicts >= sorted_max_conflicts
):
for set in regions:
block = day[set[0]][set[1] : set[2] + 1]
random.shuffle(block)
day[set[0]][set[1] : (set[2] + 1)] = block
conflicts = 0
max_conflicts = 0
for i, slot in enumerate(day[0]):
slotConflicts = len(planning.conflictedTeachers(day, i))
max_conflicts = max([max_conflicts, slotConflicts])
conflicts += slotConflicts
logging.info("Conflicts after shuffling: " + str(conflicts))
logging.info("Max slotconflicts after shuffling: " + str(max_conflicts))
# <--- Cycle through conflicted regions
loop = 0
while lowestValue > 0:
logging.info("Dropping non-conflicted regions")
conflictedRegions = [
region
for region in regions
if planning.numberOfConflictsPerRegion(day, region) > 0 and (region[2] - region[1]) < 7
]
logging.info("Sorting regions to start with smallest region with highest number of conflicts")
conflictedRegions.sort(
key=lambda set: (set[2] - set[1], -planning.numberOfConflictsPerRegion(day, set))
)
logging.info(str(conflictedRegions))
loop += 2
if loop > len(conflictedRegions):
loop = len(conflictedRegions)
for set in conflictedRegions[:loop]:
logging.info("Working on set: " + str(set))
logging.info("Set size: " + str(set[2] - set[1] + 1))
# logging.info("Number of conflicts in region: "+str(planning.numberOfConflictsPerRegion(day, set)))
if planning.numberOfConflictsPerRegion(day, set) <= 0:
logging.info("Already fixed; moving on...")
continue
if not tuple(set) in permutationSets:
# logging.info("This set is new to the dictionary")
block = day[set[0]][set[1] : set[2] + 1]
permutations = itertools.permutations(block)
permutations = list(permutations)
permutationSets[tuple(set)] = permutations
else:
# logging.info("This set was already in the dictionary")
permutations = permutationSets[tuple(set)]
conflictCounter = []
for permIndex, perm in enumerate(permutations):
block = day[set[0]][set[1] : (set[2] + 1)]
day[set[0]][set[1] : (set[2] + 1)] = perm
conflicts = 0
for i, slot in enumerate(day[0]):
conflicts += len(planning.conflictedTeachers(day, i))
conflictCounter.append(conflicts)
lowestValue = min(conflictCounter)
bestOptions = [enum for enum, x in enumerate(conflictCounter) if x == lowestValue]
bestOption = random.choice(bestOptions)
newList = permutations[bestOption]
day[set[0]][set[1] : set[2] + 1] = newList
logging.info("Total conflicts: " + str(lowestValue))
if lowestValue == 0:
break
if lowestValue == 0:
break
if time.clock() - start > 600:
break
planning.outputHTML()
for dayIndex, day in enumerate(planning.days):
for tableIndex, table in enumerate(day):
for slotIndex, slot in enumerate(table):
if slot != None:
new_appointment = Appointment(
request=slot, day=days[dayIndex], table=tableIndex, slot=slotIndex
)
new_appointment.put()
def __call__(self, inputs):
# prepare analyses
analyses = [WebGL()]
group_analyses = [Mean(), WebGLGroup()]
# render
render = Render()
# parse request
Logger.info("Parsing request arguments ... [@performance]")
begin_time = time.time()
req = Request(**inputs)
Logger.info("Parsing request arguments finished, time cost: " +
str(time.time() - begin_time) + "s [@performance]")
# get the corresponding subjects
subjects = getattr(Subjects, req.semantic_model)
# do computation and analyses for each contrast
output = []
for contrast in req.contrasts:
# create tasks
tasks = [
Task(req.name, sub, contrast, analyses) for sub in subjects
]
# parallely compute individuals
ret = parallelize_tasks(tasks)
# run in sequence
# import time
# ret = []
# t_begin = time.time()
# for t in tasks:
# begin = time.time()
# ret.append(t.run())
# log_info = 'In sequence each task finishes in {0} seconds'.format(time.time() - begin)
# Logger.debug(log_info)
# log_info = 'In sequence all the tasks finished in {0} seconds'.format(time.time() - t_begin)
# collect results
sub_res, data = zip(*ret)
sub_res = {
sub.name:
{k: v
for i in res for k, v in i.serialize().items()}
for res, sub in zip(sub_res, subjects)
}
# execute group evaluation
next_data = {'contrast_results': data}
grp_res = {}
for ga in group_analyses:
begin_time = time.time()
res = ga(req.name, subjects, contrast, **next_data)
Logger.info(
"Executing group analysis {0} costs {1} s [@performance]".
format(clsname(ga), str(time.time() - begin_time)))
if isinstance(res, Serializable):
grp_res.update(res.serialize())
elif isinstance(res, dict):
next_data.update(res)
output.append(render.render(contrast, grp_res, sub_res))
ret = json.dumps(output)
Logger.debug(ret)
update_contrast_result(ret)
return ret
async def mentors(message):
user = await message.get_author()
Request.create(user.name, datetime.utcnow(), message.text)
def add_request(self):
data = self.get_request_data()
req = Request(**data)
req.save_to_db()
def xslx_to_db():
wb = load_workbook(filename=cfg.request_xls_file_path)
sheet_ranges = wb.get_active_sheet()
i = 2
next_str = sheet_ranges[i]
while next_str[0].value:
r = Request()
r.kind_premises = next_str[0].value
r.post_code = next_str[1].value
r.region = next_str[2].value
r.city_type = next_str[3].value
r.city = next_str[4].value
r.street_type = next_str[5].value
r.street = next_str[6].value
r.house = next_str[7].value
r.block = next_str[8].value
r.flat = next_str[9].value
r.adress = next_str[10].value
db = DB()
db.insert(r, 'request')
i += 1
next_str = sheet_ranges[i]
