async def post_poll(model: RequestPoll, user=Depends(
authenticator.get_current_superuser)):
inserted = []
for question in model.questions:
uuid: Binary = generate_uuid()
created_at: datetime = datetime.utcnow()
ngram_forms = [x['value'] for x in question.forms if x]
question_doc: Question = {
'_id': uuid,
'user_id': user.id,
'created_at': created_at,
'question': question.question,
'forms': question.forms,
'type': question.type,
'ngrams': make_ngrams([question.question, ngram_forms])
}
res = await database['questions'].insert_one(question_doc)
if res.acknowledged:
inserted.append(UUID(bytes=res.inserted_id))
if len(inserted) > 0:
document = {'_id': generate_uuid(), 'questions': inserted}
await database['polls'].insert_one(document)
async def patch_vote(hex, model: RequestVote, user=Depends(
authenticator.get_current_active_user)):
try:
req_uuid = UUID(hex=hex, version=4)
except (TypeError, ValueError):
raise HTTPException(
status_code=404, detail='Invalid identifier')
d = dict(model)
inserted = []
updated = []
if d['reply'] == 'undefined':
raise HTTPException(
status_code=400, detail='Invalid option provided')
document = {'$set': d}
query = {'question_id': req_uuid,
'option_id': d['reply'][0], 'user_id': user.id}
res = await database['votes'].update_one(query, document)
if res.modified_count == 0:
uuid: Binary = generate_uuid()
d['_id'] = uuid
d['question_id'] = req_uuid
d['user_id'] = user.id
res = await database['votes'].insert_one(d)
if res.acknowledged:
inserted.append(UUID(bytes=res.inserted_id))
else:
updated.append(req_uuid)
if len(updated) > 0 or len(inserted) > 0:
query = {'question_id': req_uuid, 'option_id': d['reply']}
document = {'$set': {'option_id': d['reply']},
'$addToSet': {'votes': {'$each': inserted}}}
res = await database['answers'].update_one(query, document)
if res.modified_count == 0:
uuid: Binary = generate_uuid()
answer_doc = {
'_id': uuid,
'option_id': d['reply'],
'question_id': req_uuid,
'votes': inserted
}
await database['answers'].insert_one(answer_doc)
return d['reply']
else:
raise HTTPException(status_code=400, detail='Answer not updated')
async def post_event(request: Event,
user=Depends(authenticator.get_current_superuser)):
event_times = generate_interval(request)
request_doc = dict(request)
inserted = []
for event_time in event_times:
uuid: Binary = generate_uuid()
created_at: datetime = datetime.utcnow()
event_doc: Event = {
'_id': uuid,
'author': user.name,
'created_at': created_at,
'event_time': event_time,
'titles': request_doc['titles'],
'location': request_doc['location'],
'repeat_unit': request_doc['repeat_unit'],
'descriptions': request_doc['descriptions'],
'repeat_interval': request_doc['repeat_interval'],
'min_participants': request_doc['min_participants'],
'max_participants': request_doc['max_participants'],
'contact_person': request_doc['contact_person'],
'start_time': request_doc['start_time'],
'end_time': request_doc['end_time'],
'ngrams': make_ngrams([
request_doc['contact_person'],
request_doc['descriptions'],
request_doc['repeat_unit'],
request_doc['location'],
request_doc['titles']]
)
}
res = await database['events'].insert_one(event_doc)
if res.acknowledged:
inserted.append(res.inserted_id)
uuid: Binary = generate_uuid()
calendar_doc: Calendar = {
'_id': uuid,
'events': inserted,
'start_time': request_doc['start_time'],
'end_time': request_doc['end_time']
}
res = await database['calendars'].insert_one(calendar_doc)
if res.acknowledged:
return {'detail': 'Events successfully created'}
else:
raise HTTPException(
status_code=400, detail='Error creating calendar')
async def setup_translations(database):
files = os.listdir('./setup/translations')
for file in files:
po = pofile(f'./setup/translations/{file}')
lang = file.split('.')[1]
r = [{
x.msgid: x.msgstr,
'type': 'textarea'
} if len(x.msgstr) > 32 else {
x.msgid: x.msgstr,
'type': 'input'
} for x in po]
translation_doc: UpdateTranslation = {}
translation_doc['modified_at']: datetime = datetime.utcnow()
translation_doc['translation'] = r
query = {'lang': lang}
document = {'$set': translation_doc}
res = await database['translations'].update_one(query, document)
if res.modified_count == 0:
uuid: Binary = generate_uuid()
created_at: datetime = datetime.utcnow()
translation_doc: Translation = {
'_id': uuid,
'created_at': created_at,
'translation': r,
'lang': lang
}
await database['translations'].insert_one(translation_doc)
async def post_translation(lang,
model: RequestTranslation,
user=Depends(
authenticator.get_current_superuser)):
query = {'lang': lang}
docs = await database['translations'].count_documents(query)
res = await database['translations'].find(query).to_list(length=docs)
i = model.input
t = model.textarea
l1 = [{
x[0]: x[1],
'type': 'textarea'
} if len(x[1]) > 32 else {
x[0]: x[1],
'type': 'input'
} for x in i.items()]
l2 = [{
x[0]: x[1],
'type': 'textarea'
} if len(x[1]) > 32 else {
x[0]: x[1],
'type': 'input'
} for x in t.items()]
if len(res) == 0:
uuid: Binary = generate_uuid()
created_at: datetime = datetime.utcnow()
translation_doc: Translation = {
'_id': uuid,
'created_at': created_at,
'translation': l1 + l2,
'lang': lang
}
res = await database['translations'].insert_one(translation_doc)
if res.acknowledged:
return {'detail': 'Translation was created'}
else:
raise HTTPException(status_code=400,
detail='Error creating translation')
translation_doc: UpdateTranslation = {}
translation_doc['modified_at']: datetime = datetime.utcnow()
translation_doc['translation'] = l1 + l2
query = {'lang': lang}
document = {'$set': translation_doc}
res = await database['translations'].update_one(query, document)
if res.acknowledged:
return {'detail': 'Updated translation translation'}
else:
raise HTTPException(status_code=400,
detail='Error creating translation')
async def post_address(model: RequestAddress, user=Depends(
authenticator.get_current_superuser)):
address_uuid: Binary = generate_uuid()
address_doc = dict(model)
address_doc['_id'] = address_uuid
res = await database['addresses'].insert_one(address_doc)
if res.acknowledged:
organization_uuid: Binary = generate_uuid()
address_doc: Organization = {}
address_doc['_id'] = organization_uuid
address_doc['address_id'] = address_uuid
res = await database['organizations'].insert_one(address_doc)
if res.acknowledged:
return UUID(bytes=res.inserted_id)
raise HTTPException(
status_code=400, detail='Organization not created')
raise HTTPException(
status_code=400, detail='Address not created')
async def post_subscribe_event(hex,
user=Depends(
authenticator.get_current_superuser)):
try:
req_uuid = UUID(hex=hex, version=4)
except TypeError:
raise HTTPException(status_code=404, detail='Event was not found')
query = {'user_id': user.id}
res = await database['subscriptions'].find(query).to_list(length=150)
if len(res) == 0:
uuid: Binary = generate_uuid()
created_at: datetime = datetime.utcnow()
subscription_doc: Subscription = {
'_id': uuid,
'user_id': user.id,
'created_at': created_at,
'events': [req_uuid]
}
res = await database['subscriptions'].insert_one(subscription_doc)
if res.acknowledged:
return {'detail': 'Subscription was created'}
else:
raise HTTPException(status_code=400,
detail='Error creating subscription')
subscription_doc: Subscription = {}
subscription_doc['modified_at']: datetime = datetime.utcnow()
document = {
'$set': subscription_doc,
'$addToSet': {
'events': req_uuid
}
}
query = {'user_id': user.id}
res = await database['subscriptions'].update_one(query, document)
if res.acknowledged:
return {'detail': 'Updated event subscription'}
else:
raise HTTPException(status_code=400,
detail='Error creating subscription')
async def post_template(topic,
locale,
model: Template,
user=Depends(authenticator.get_current_superuser)):
d = dict(model)
d['_id'] = generate_uuid()
d['topic'] = topic
d['locale'] = locale
d['ngrams'] = make_ngrams([d['subject'], d['message']])
res = await database['templates'].insert_one(d)
if res.acknowledged:
return UUID(bytes=res.inserted_id)
else:
raise HTTPException(status_code=400,
detail='Mail template not created')
async def patch_position(hex, model: RequestPosition, user=Depends(
authenticator.get_current_superuser)):
try:
req_uuid = UUID(hex=hex, version=4)
except (TypeError, ValueError):
raise HTTPException(
status_code=404, detail='Invalid identifier')
doc = parse_obj_as(List[Position], dict(model)['positions'])
positions = [dict(x) for x in doc]
query = {'_id': req_uuid}
res = await database['organizations'].find_one(query)
if res is not None:
for position in positions:
# TODO: title should be refactored with as _id
query = {'title': position['title']}
doc = {'$set': {**position}}
res = await database['positions'].update_one(query, doc)
if res.modified_count == 0 and res.matched_count == 0:
position_uuid: Binary = generate_uuid()
doc = {**position}
doc['_id'] = position_uuid
res = await database['positions'].insert_one(doc)
if res.acknowledged:
query = {'_id': req_uuid}
doc = {'$addToSet': {'positions': position_uuid}}
await database['organizations'].update_one(query, doc)
else:
raise HTTPException(
status_code=404, detail='Organization not updated')
async def patch_event(hex: str,
request: UpdateEvent,
user=Depends(authenticator.get_current_superuser)):
try:
req_uuid = UUID(hex=hex, version=4)
except (TypeError, ValueError):
raise HTTPException(status_code=404, detail='Invalid identifier')
query = {'events': {'$in': [req_uuid]}}
res = await database['calendars'].find(query).to_list(length=1)
if len(res) == 0:
raise HTTPException(status_code=404,
detail='Calender was not found')
updated = []
inserted = []
deleted = []
event_times = generate_interval(request)
existing_events = len(res[0]['events'])
interval_events = len(event_times)
for event_time_index, event_time in enumerate(event_times):
modified_at: datetime = datetime.utcnow()
request_doc = dict(request)
try:
poll_id = UUID(hex=request_doc['poll_id'])
except (TypeError, ValueError):
poll_id = None
event_doc: Event = {
'_id':
uuid,
'creator':
user.id,
'created_at':
created_at,
'title':
request_doc['title'],
'location':
request_doc['location'],
'repeat_unit':
request_doc['repeat_unit'],
'description':
request_doc['description'],
'repeat_interval':
request_doc['repeat_interval'],
'max_participants':
request_doc['max_participants'],
'readaccess':
request_doc['readaccess'],
'start_time':
request_doc['start_time'],
'end_time':
request_doc['end_time'],
'poll_id':
poll_id,
'ngrams':
make_ngrams([
request_doc['contact_person'], request_doc['descriptions'],
request_doc['repeat_unit'], request_doc['location'],
request_doc['titles']
])
}
if existing_events > 0:
event_doc['modified_by'] = user.id
event_doc['modified_at'] = modified_at
document = {'$set': event_doc}
query = {'_id': {'$in': [res[0]['events'][event_time_index]]}}
update_res = await database['events'].update_many(
query, document)
if update_res.acknowledged:
updated.append(res[0]['events'][event_time_index])
elif existing_events < 0 and existing_events < interval_events:
created_at: datetime = datetime.utcnow()
uuid: Binary = generate_uuid()
event_doc['_id'] = uuid
event_doc['author'] = user.name
event_doc['created_at'] = created_at
insert_res = await database['events'].insert_one(event_doc)
if insert_res.acknowledged:
inserted.append(insert_res.inserted_id)
existing_events = existing_events - 1
interval_events = interval_events - 1
delete_uuids = set(res[0]['events']) - set(updated)
if len(delete_uuids) > 0:
for uuid in delete_uuids:
query = {'_id': uuid}
delete_res = await database['events'].delete_one(query)
if delete_res.deleted_count > 0:
deleted.append(uuid)
if len(inserted) > 0:
calendar_doc: Calendar = {
'start_time': request_doc['start_time'],
'end_time': request_doc['end_time']
}
query = {'events': {'$in': [req_uuid]}}
document = {
'$set': calendar_doc,
'$addToSet': {
'events': {
'$each': inserted
}
}
}
await database['calendars'].update_one(query, document)
if len(updated) > 0:
calendar_doc: Calendar = {
'start_time': request_doc['start_time'],
'end_time': request_doc['end_time']
}
query = {'events': {'$in': [req_uuid]}}
document = {'$set': calendar_doc}
await database['calendars'].update_one(query, document)
if len(deleted) > 0:
calendar_doc: Calendar = {
'start_time': request_doc['start_time'],
'end_time': request_doc['end_time']
}
query = {'events': {'$in': [req_uuid]}}
document = {'$pullAll': {'events': deleted}}
await database['calendars'].update_one(query, document)
if len(updated) > 0 or len(inserted) > 0 or len(deleted) > 0:
return {
'updated': len(updated),
'inserted': len(inserted),
'deleted': len(deleted)
}
else:
raise HTTPException(status_code=400, detail='Calendar not updated')
def gen_request_queue_uuid():
return REQUEST_QUEUE_ID_PREFIX + uuid.generate_uuid()
def gen_rpc_uuid():
return RPC_ID_PREFIX + uuid.generate_uuid()
def gen_service_uuid():
return SERVICE_ID_PREFIX + uuid.generate_uuid()
