def post(self, request, id=None):
if request.FILES and request.FILES['file']:
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
try:
revision = ArticleRevision.objects.get(
article=form.cleaned_data['articleid'])
except ObjectDoesNotExist as e:
return make_response(error='Invalid article id')
except:
return make_response(error='Internal error')
else:
revision.attachments.add(
Attachment.objects.create(
file=form.cleaned_data['file'],
author=request.user,
title=form.cleaned_data['title'],
license=form.cleaned_data['license']))
revision.save()
return make_response()
else:
return make_response(validation=form._errors)
else:
return make_response(error='No files selected')
def put(self, request, discussion_id=None):
f = request.PUT.get('folder', None)
if not f:
return make_response(error='Folder is not specified')
d = Discussion.objects.get(id=discussion_id)
exist_folder_type = None
try:
folder = DiscussionFolder.objects.get(Q(discussions=d), Q(user=request.user))
folder.discussions.remove(d)
exist_folder_type = folder.type
except DiscussionFolder.DoesNotExist:
pass
if 'archive' == f.lower():
DiscussionFolder.objects.add_discussion(request.user, FOLDER_TYPES['ARCHIVE'], d)
d.participants.filter(user=request.user).update(is_active=True)
if 'trash' == f.lower():
d.participants.filter(user=request.user).update(is_active=False)
if FOLDER_TYPES['TRASH']['id'] != exist_folder_type:
self.__create_message__(request.user, d, 'has left discussion', message_type=DiscussionMessage.LEFT)
DiscussionFolder.objects.add_discussion(request.user, FOLDER_TYPES['TRASH'], d)
if 'inbox' == f.lower():
d.participants.filter(user=request.user).update(is_active=True)
DiscussionFolder.objects.add_discussion(request.user, FOLDER_TYPES['INBOX'], d)
if FOLDER_TYPES['TRASH']['id'] == exist_folder_type:
self.__create_message__(request.user, d, 'has joined discussion', message_type=DiscussionMessage.JOIN)
return make_response()
def article(request, id):
revision_id = int(request.POST['revision_id'])
disease = Disease.objects.get(id=int(id))
r = disease.current_revision
while r and revision_id != r.id:
r = r.previous_revision
if not r:
return make_response(error='Invalid revision')
disease.current_revision = ArticleRevision.objects.get(id=revision_id)
disease.save()
r = disease.current_revision
revisions = [{
'id': r.id,
'author': r.author.username,
'date': r.date.strftime(DATE_FORMAT)
}]
while r.previous_revision is not None:
r = r.previous_revision
revisions.append({
'id': r.id,
'author': r.author.username,
'date': r.date.strftime(DATE_FORMAT)
})
res = disease.to_json()
res['revisions'] = revisions
return make_response(res)
def delete(self, request, message_id=None):
try:
message = DiscussionMessage.objects.get(id=message_id)
if message.sender == request.user:
message.delete()
return make_response()
except DiscussionMessage.DoesNotExist:
return make_response(error='Invalid discussion message')
def delete(self, request, message_id=None):
try:
message=DiscussionMessage.objects.get(id=message_id)
if message.sender==request.user:
message.delete()
return make_response()
except DiscussionMessage.DoesNotExist:
return make_response(error='Invalid discussion message')
def get(self, request, patient_id=None):
if ROLES['DOCTOR']['id'] != request.user.role:
return make_response(error='Only doctors have own patients')
if patient_id:
patient = MedintUser.objects.get(id=patient_id)
user_info = PatientInfo.objects.get(id=patient.user_info_id)
else:
patients = [i.user.serialize_as_json() for i in request.user.patientinfo_set.all()]
return make_response(patients)
def put(self, request, message_id=None):
try:
message = DiscussionMessage.objects.get(id=message_id)
except DiscussionMessage.DoesNotExist:
return make_response(error='Invalid Discussion Message')
else:
if request.PUT.get('text'):
message.text = request.PUT.get('text')
message.save()
return make_response()
def put(self, request, message_id=None):
try:
message = DiscussionMessage.objects.get(id=message_id)
except DiscussionMessage.DoesNotExist:
return make_response(error='Invalid Discussion Message')
else:
if request.PUT.get('text'):
message.text = request.PUT.get('text')
message.save()
return make_response()
def post(self, request, parent=None):
uid = request.POST.get('uid')[:12]
if YubiKey.objects.filter(uid=uid):
return make_response(error='This key is already registered')
role = int(request.POST.get('role'))
if parent:
parent_user = MedintUser.objects.get(id=parent)
YubiKey.objects.create(uid=uid, role=role, creator=request.user, parent=parent_user)
else:
YubiKey.objects.create(uid=uid, role=role, creator=request.user)
return make_response()
def post(self, request, discussion_id=None):
if not discussion_id:
discussion = self.__create_discussion__(request)
else:
try:
discussion = Discussion.objects.get(id=discussion_id)
except Discussion.DoesNotExist:
return make_response(error='Invalid discussion')
f = MessageForm(request.POST)
if f.is_valid():
message = self.__create_message__(request.user, discussion, request.POST.get('text', '').strip(),
file_message_id=request.POST.get('filemessageid', None))
#email notifications
subject = 'Medical+Intelligence. You have a new message in a discussion \"' + discussion.subject + '\".'
text = f.cleaned_data['text']
sender = request.user
if sender != discussion.starter.user:
msg = {
'subject': subject,
'from_email': '*****@*****.**',
'to': [{'email': discussion.starter.user.user_info.email}],
'global_merge_vars': [
{'name': 'SENDER', 'content': sender.__str__()},
{'name': 'DISCUSSION', 'content': discussion.subject},
{'name': 'MESSAGE', 'content': text},
]
}
EmailThread('newMessage', msg).start()
for member in discussion.participants.filter(is_active=True):
if sender != member.user:
msg = {
'subject': subject,
'from_email':'*****@*****.**',
'to': [{'email': member.user.user_info.email}],
'global_merge_vars': [
{'name': 'SENDER', 'content': sender.__str__()},
{'name': 'DISCUSSION', 'content': discussion.subject},
{'name': 'MESSAGE', 'content': text},
]
}
EmailThread('newMessage', msg).start()
for f in discussion.discussionfolder_set.filter(
~Q(type=FOLDER_TYPES['INBOX']['id']), ~Q(type=FOLDER_TYPES['TRASH']['id'])):
f.discussions.remove(discussion)
DiscussionFolder.objects.add_discussion(f.user, FOLDER_TYPES['INBOX'], discussion)
return make_response({'messageId': message.id})
def post(self, request, discussion_id):
try:
discussion = Discussion.objects.get(id=discussion_id)
except Discussion.DoesNotExist:
return make_response(error='Invalid discussion')
u = MedintUser.objects.get(username__iexact=request.POST.get('username'))
discussion.participants.add(DiscussionMember.objects.create(user=u, join=timezone.now()))
DiscussionFolder.objects.add_discussion(u, FOLDER_TYPES['INBOX'], discussion)
DiscussionMessage.objects.create(
sender=u,
text='has joined discussion',
sent=timezone.now(),
discussion=discussion,
message_type=DiscussionMessage.JOIN)
return make_response()
def post(self, request, parent=None):
uid = request.POST.get('uid')[:12]
if YubiKey.objects.filter(uid=uid):
return make_response(error='This key is already registered')
role = int(request.POST.get('role'))
if parent:
parent_user = MedintUser.objects.get(id=parent)
YubiKey.objects.create(uid=uid,
role=role,
creator=request.user,
parent=parent_user)
else:
YubiKey.objects.create(uid=uid, role=role, creator=request.user)
return make_response()
def get(self, request, parent=None):
keys = []
if parent:
for k in YubiKey.objects.select_related(
'user',
'user__user_info').filter(creator=request.user).filter(
role=ROLES['PATIENT']['id']).filter(parent=parent):
key = {'uid': k.uid}
if k.user:
u = k.user
key['user'] = {
'id': u.id,
'username': u.username,
'firstName': u.user_info.first_name,
'lastName': u.user_info.last_name
}
keys.append(key)
else:
for k in YubiKey.objects.select_related(
'user',
'user__user_info').filter(creator=request.user).filter(
role=ROLES['DOCTOR']['id']):
key = {'uid': k.uid}
if k.user:
u = k.user
key['user'] = {
'id': u.id,
'username': u.username,
'firstName': u.user_info.first_name,
'lastName': u.user_info.last_name
}
keys.append(key)
return make_response(keys)
def post(self, request, discussion_id):
try:
discussion = Discussion.objects.get(id=discussion_id)
except Discussion.DoesNotExist:
return make_response(error='Invalid discussion')
u = MedintUser.objects.get(
username__iexact=request.POST.get('username'))
discussion.participants.add(
DiscussionMember.objects.create(user=u, join=timezone.now()))
DiscussionFolder.objects.add_discussion(u, FOLDER_TYPES['INBOX'],
discussion)
DiscussionMessage.objects.create(sender=u,
text='has joined discussion',
sent=timezone.now(),
discussion=discussion,
message_type=DiscussionMessage.JOIN)
return make_response()
def get(self, request):
f = OTPForm(request.GET)
if f.is_valid():
try:
print f.cleaned_data['otp'][:12]
if YubiKey.objects.filter(uid=f.cleaned_data['otp'][:12], user=None).exists():
if YubiKey.objects.filter(
uid=f.cleaned_data['otp'][:12],
user=None,
role=int(f.cleaned_data['role'])).exists():
print f.cleaned_data['otp'][:8]
if 'cucumber' == f.cleaned_data['otp'][:8]:
return make_response()
if verify_yubikey(f.cleaned_data['otp']):
return make_response()
else:
return make_response(error="Invalid Yubikey")
else:
return make_response(error='Invalid role')
else:
return make_response(error="Invalid Yubikey")
except YubiKey.DoesNotExist:
return make_response(error='Unregistered YubiKey')
return make_response(validation=f._errors)
def get(self, request):
f = OTPForm(request.GET)
if f.is_valid():
try:
print f.cleaned_data['otp'][:12]
if YubiKey.objects.filter(uid=f.cleaned_data['otp'][:12], user=None).exists():
if YubiKey.objects.filter(
uid=f.cleaned_data['otp'][:12],
user=None,
role=int(f.cleaned_data['role'])).exists():
print f.cleaned_data['otp'][:8]
if 'cucumber' == f.cleaned_data['otp'][:8]:
return make_response()
if verify_yubikey(f.cleaned_data['otp']):
return make_response()
else:
return make_response(error="Invalid Yubikey")
else:
return make_response(error='Invalid role')
else:
return make_response(error="Invalid Yubikey")
except YubiKey.DoesNotExist:
return make_response(error='Unregistered YubiKey')
return make_response(validation=f._errors)
def get(self, request):
res = []
for user in MedintUser.objects.filter(Q(role=ROLES['DOCTOR']['id']) | Q(role=ROLES['STAFF']['id'])):
u = {'username': user.username, 'role': user.role}
if user.user_info:
u['firstName'] = user.user_info.first_name
u['lastName'] = user.user_info.last_name
res.append(u)
return make_response(res)
def article(request, id):
revision_id = int(request.POST['revision_id'])
disease = Disease.objects.get(id=int(id))
r = disease.current_revision
while r and revision_id != r.id:
r = r.previous_revision
if not r:
return make_response(error='Invalid revision')
disease.current_revision = ArticleRevision.objects.get(id=revision_id)
disease.save()
r = disease.current_revision
revisions = [{'id': r.id, 'author': r.author.username, 'date': r.date.strftime(DATE_FORMAT)}]
while r.previous_revision is not None:
r = r.previous_revision
revisions.append({'id': r.id, 'author': r.author.username, 'date': r.date.strftime(DATE_FORMAT)})
res = disease.to_json()
res['revisions'] = revisions
return make_response(res)
def post(self, request):
f = LoginForm(request.POST)
if f.is_valid():
user = auth.authenticate(
username=f.cleaned_data['username'].lower(),
password=f.cleaned_data['password'],
otp=f.cleaned_data['otp'])
if not user:
return make_response(error='Invalid username or password.')
elif not user.is_active:
return make_response(
error='This account is not yet active - please stand by.'
'We will contact you soon!')
else:
auth.login(request, user)
return make_response()
else:
return make_response(validation=f._errors)
def post(self, request):
from random import choice
import string
if 'email' in request.POST:
mail = request.POST['email'].lower().strip()
user = None
try:
ui = UserInfo.objects.get(email__iexact=mail)
user = ui.user
except UserInfo.DoesNotExist:
try:
user = MedintUser.objects.get(username__iexact=mail)
ui = user.user_info
except MedintUser.DoesNotExist:
return make_response(error='User with this email or username does not exist')
try:
key = ''.join([choice(string.letters + string.digits) for i in range(20)])
RecoverKey.objects.create(user=user, key=key)
message = {
'subject': 'Password Recovery',
'from_email': '*****@*****.**',
'to': [{'email': ui.email}],
'global_merge_vars': [{'name': 'CURRENT_YEAR', 'content': timezone.now().year},
{'name': 'KEY', 'content': key},
{'name': 'SERVER', 'content': settings.SITE}]
}
EmailThread('recovery', message).start()
# subject, from_email, to = 'Password recovery', '*****@*****.**', ui.email
# text_content = 'To recover password visit http://%s/recover?key=%s' % (current_site, key)
# html_content = 'To recover password visit <a href="http://%s/recover?key=%s">' \
# 'http://%s/recover?key=%s</a>' % (current_site, key, current_site, key)
# msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
# msg.attach_alternative(html_content, "text/html")
# msg.send()
logging.debug('A password recovery message has been sent to the given email address.')
except:
logging.error('Cannot send E-mail')
logging.error(sys.exc_info()[0])
return make_response(error='Internal error')
return make_response()
else:
return make_response(error='E-mail is required')
def post(self, request):
f = LoginForm(request.POST)
if f.is_valid():
user = auth.authenticate(
username=f.cleaned_data['username'].lower(),
password=f.cleaned_data['password'],
otp=f.cleaned_data['otp']
)
if not user:
return make_response(error='Invalid username or password.')
elif not user.is_active:
return make_response(error='This account is not yet active - please stand by.'
'We will contact you soon!')
else:
auth.login(request, user)
return make_response()
else:
return make_response(validation=f._errors)
def get(self, request):
res = []
for user in MedintUser.objects.filter(
Q(role=ROLES['DOCTOR']['id']) | Q(role=ROLES['STAFF']['id'])):
u = {'username': user.username, 'role': user.role}
if user.user_info:
u['firstName'] = user.user_info.first_name
u['lastName'] = user.user_info.last_name
res.append(u)
return make_response(res)
def disease(request, id=None):
disease = Disease.objects.get(id=int(id))
r = disease.current_revision
revisions = [{'id': r.id, 'author': r.author.username, 'date': r.date.strftime(DATE_FORMAT)}]
while r.previous_revision is not None:
r = r.previous_revision
revisions.append({'id': r.id, 'author': r.author.username, 'date': r.date.strftime(DATE_FORMAT)})
res = disease.to_json()
res['revisions'] = revisions
print revisions
return make_response(res)
def post(self, request):
mail = request.POST['email']
RegistryEmail.objects.create(email=mail)
message = {
'subject': 'MedicalIntelligence Registration',
'from_email': '*****@*****.**',
'to': [{'email': settings.NOTIFICATION_EMAIL}],
'global_merge_vars': [{'name': 'EMAIL', 'content': mail},
{'name': 'SERVER', 'content': request.get_host()}]
}
EmailThread('ComingSoon', message).start()
return make_response()
def doctor_register(self, request):
f = DoctorRegisterForm(request.POST)
if f.is_valid():
mail = f.cleaned_data['email'].lower()
username = f.cleaned_data['username'].lower()
err = self.__validate_params__(username, mail, f.cleaned_data['yubiid'], ROLES['DOCTOR']['id'])
if err:
return make_response(error=err)
u = MedintUser.objects.create_doctor(
username,
email=mail,
password=f.cleaned_data['password'],
first_name=f.cleaned_data['firstname'],
last_name=f.cleaned_data['lastname'],
phone=f.cleaned_data['phone'],
address=f.cleaned_data['address'],
city=f.cleaned_data['city'],
state=f.cleaned_data['state'],
zipcode=f.cleaned_data['zipcode'],
speciality=f.cleaned_data['speciality'],
clinic=f.cleaned_data['clinic'],
officemng_firstname=f.cleaned_data['officemng_firstname'],
officemng_lastname=f.cleaned_data['officemng_lastname'],
officemng_email=f.cleaned_data['officemng_email'],
website=f.cleaned_data['website'],
uid=f.cleaned_data['yubiid']
)
message = {
'subject': 'MedicalIntelligence Registration',
'from_email': '*****@*****.**',
'to': [{'email': settings.NOTIFICATION_EMAIL}],
'global_merge_vars': [{'name': 'EMAIL', 'content': mail},
{'name': 'SERVER', 'content': request.get_host()}]
}
EmailThread('RegisterNotification', message).start()
print 'RETURN'
return make_response()
else:
logging.error(f._errors)
return make_response(validation=f._errors)
def post(self, request):
f = FeedbackForm(request.POST)
if f.is_valid():
msg_vars = [
{'name': 'NAME', 'content': f.cleaned_data['name']},
{'name': 'EMAIL', 'content': f.cleaned_data['email']},
{'name': 'TEXT', 'content': f.cleaned_data['text']},
{'name': 'TIME', 'content': f.cleaned_data['daytime']},
{'name': 'TIMEZONE', 'content': f.cleaned_data['timezone']}]
if f.cleaned_data['phone']:
msg_vars.append({'name': 'PHONE', 'content': f.cleaned_data['phone']})
message = {
'subject': 'MedicalIntelligence Feedback',
'from_email': '*****@*****.**',
'to': [{'email': settings.FEEDBACK_EMAIL}],
'global_merge_vars': msg_vars
}
EmailThread('Feedback', message).start()
else:
return make_response(validation=f._errors)
return make_response()
def put(self, request, discussion_id=None):
f = request.PUT.get('folder', None)
if not f:
return make_response(error='Folder is not specified')
d = Discussion.objects.get(id=discussion_id)
exist_folder_type = None
try:
folder = DiscussionFolder.objects.get(Q(discussions=d),
Q(user=request.user))
folder.discussions.remove(d)
exist_folder_type = folder.type
except DiscussionFolder.DoesNotExist:
pass
if 'archive' == f.lower():
DiscussionFolder.objects.add_discussion(request.user,
FOLDER_TYPES['ARCHIVE'], d)
d.participants.filter(user=request.user).update(is_active=True)
if 'trash' == f.lower():
d.participants.filter(user=request.user).update(is_active=False)
if FOLDER_TYPES['TRASH']['id'] != exist_folder_type:
self.__create_message__(request.user,
d,
'has left discussion',
message_type=DiscussionMessage.LEFT)
DiscussionFolder.objects.add_discussion(
request.user, FOLDER_TYPES['TRASH'], d)
if 'inbox' == f.lower():
d.participants.filter(user=request.user).update(is_active=True)
DiscussionFolder.objects.add_discussion(request.user,
FOLDER_TYPES['INBOX'], d)
if FOLDER_TYPES['TRASH']['id'] == exist_folder_type:
self.__create_message__(request.user,
d,
'has joined discussion',
message_type=DiscussionMessage.JOIN)
return make_response()
def post(self, request):
f = RegisterForm(request.POST)
if f.is_valid():
mail = f.cleaned_data['email'].lower()
username = f.cleaned_data['username'].lower()
err = self.__validate_params__(username, mail, f.cleaned_data['yubiid'], ROLES['STAFF']['id'])
if err:
return make_response(error=err)
u = MedintUser.objects.create_staff(
f.cleaned_data['username'],
email=mail,
password=f.cleaned_data['password'],
first_name=f.cleaned_data['firstname'],
last_name=f.cleaned_data['lastname'],
phone=f.cleaned_data['phone'],
uid=f.cleaned_data['yubiid'],
staff_role=int(f.cleaned_data['staff_role'])
)
return make_response()
else:
logging.error(f._errors)
return make_response(validation=f._errors)
def post(self, request, id=None):
if request.FILES and request.FILES['file']:
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
try:
revision = ArticleRevision.objects.get(article=form.cleaned_data['articleid'])
except ObjectDoesNotExist as e:
return make_response(error='Invalid article id')
except:
return make_response(error='Internal error')
else:
revision.attachments.add(Attachment.objects.create(
file=form.cleaned_data['file'],
author=request.user,
title=form.cleaned_data['title'],
license=form.cleaned_data['license']))
revision.save()
return make_response()
else:
return make_response(validation=form._errors)
else:
return make_response(error='No files selected')
def save(request):
a = request.POST['data'].strip()
id = request.POST['id'] if 'id' in request.POST else None
disease = Disease.objects.get(id=int(id)) if id else Disease()
previous_revision = disease.current_revision if hasattr(disease, 'current_revision') else None
rev = ArticleRevision.objects.create(author=request.user, previous_revision=previous_revision)
disease.icd9 = request.POST['icd9']
disease.icd10 = request.POST['icd10']
disease.title = request.POST['name']
headers = re.findall('#.*\n', a)
headers.insert(0, '')
attachments = previous_revision.attachments.all() if previous_revision else []
def create_field(field, content, prev=None):
return FieldContent.objects.create(
content=content,
field=field,
author=request.user,
active=True,
previous_revision=prev,
)
for (i, r) in enumerate(re.split('#.*\n', a)):
if 0 == i and 0 == len(r.strip()):
continue
name = headers[i][1:].strip() if i < len(headers) else ''
field, created = Field.objects.get_or_create(name__iexact=name, defaults={'name': name})
f = FieldContent.objects.filter(field=field).filter(article_revision=previous_revision)
if not f:
rev.fields.add(create_field(field, r.strip()))
elif f[0].content == r.strip():
rev.fields.add(f[0])
else:
f.active = False
f[0].save()
rev.fields.add(create_field(field, r.strip(), f[0]))
rev.attachments = attachments
rev.save()
disease.current_revision = rev
disease.save()
r = disease.current_revision
revisions = [{'id': r.id, 'author': r.author.username, 'date': r.date.strftime(DATE_FORMAT)}]
while r.previous_revision is not None:
r = r.previous_revision
revisions.append({'id': r.id, 'author': r.author.username, 'date': r.date.strftime(DATE_FORMAT)})
res = disease.to_json()
res['revisions'] = revisions
return make_response(res)
def post(self, request):
f = RegisterForm(request.POST)
if f.is_valid():
mail = f.cleaned_data['email'].lower()
username = f.cleaned_data['username'].lower()
err = self.__validate_params__(username, mail,
f.cleaned_data['yubiid'],
ROLES['STAFF']['id'])
if err:
return make_response(error=err)
u = MedintUser.objects.create_staff(
f.cleaned_data['username'],
email=mail,
password=f.cleaned_data['password'],
first_name=f.cleaned_data['firstname'],
last_name=f.cleaned_data['lastname'],
phone=f.cleaned_data['phone'],
uid=f.cleaned_data['yubiid'],
staff_role=int(f.cleaned_data['staff_role']))
return make_response()
else:
logging.error(f._errors)
return make_response(validation=f._errors)
def disease(request, id=None):
disease = Disease.objects.get(id=int(id))
r = disease.current_revision
revisions = [{
'id': r.id,
'author': r.author.username,
'date': r.date.strftime(DATE_FORMAT)
}]
while r.previous_revision is not None:
r = r.previous_revision
revisions.append({
'id': r.id,
'author': r.author.username,
'date': r.date.strftime(DATE_FORMAT)
})
res = disease.to_json()
res['revisions'] = revisions
print revisions
return make_response(res)
def search(request):
q = request.GET['q']
res = [{
'id': d.id,
'title': d.title
} for d in Disease.objects.filter(icd9__icontains=q)[:10]]
if not res:
u = 'http://apps.nlm.nih.gov/medlineplus/services/mpconnect_service.cfm?mainSearchCriteria.v.c=%s' % q
print u
f = urllib2.urlopen(u)
xml = '\n'.join(f)
d = parseString(xml)
e = d.getElementsByTagName('entry')
if e:
t = e[0].getElementsByTagName('title')[0].childNodes[0].data
s = e[0].getElementsByTagName('summary')[0].childNodes[0].data
s = html2text.html2text(s)
disease = Disease()
rev = ArticleRevision.objects.create(author=request.user)
disease.icd9 = q
disease.icd10 = ''
disease.title = t
field, created = Field.objects.get_or_create(name__iexact='',
defaults={'name': ''})
content = FieldContent.objects.create(
content=s,
field=field,
author=request.user,
active=True,
previous_revision=None,
)
rev.fields.add(content)
rev.save()
disease.current_revision = rev
disease.save()
# l = d.getElementsByTagName('link')[0].getAttribute('href') if d.getElementsByTagName('link') else ''
print t
print s
res = [{'id': disease.id, 'title': disease.title}]
return make_response(res)
def get(self, request, parent=None):
keys = []
if parent:
for k in YubiKey.objects.select_related('user', 'user__user_info').filter(creator=request.user).filter(
role=ROLES['PATIENT']['id']).filter(parent=parent):
key = {'uid': k.uid}
if k.user:
u = k.user
key['user'] = {'id': u.id, 'username': u.username, 'firstName': u.user_info.first_name,
'lastName': u.user_info.last_name}
keys.append(key)
else:
for k in YubiKey.objects.select_related('user', 'user__user_info').filter(creator=request.user).filter(
role=ROLES['DOCTOR']['id']):
key = {'uid': k.uid}
if k.user:
u = k.user
key['user'] = {'id': u.id, 'username': u.username, 'firstName': u.user_info.first_name,
'lastName': u.user_info.last_name}
keys.append(key)
return make_response(keys)
def get(self, request):
res = []
for f in DiscussionFolder.objects.filter(
Q(user=request.user) & ~Q(type=FOLDER_TYPES['TRASH']['id'])):
for d in f.discussions.all(): #TODO rewite it with raw sql!
da, created = DiscussionAccess.objects.get_or_create(
user=request.user, discussion=d)
c = d.discussionmessage_set.filter(
sent__gt=da.access_time).aggregate(count=Count('sent'))
c['max_date'] = d.discussionmessage_set.aggregate(
max_date=Max('sent'))['max_date']
diff = datetime.datetime.now() - c['max_date']
if diff.days >= 1:
timeago = False
else:
timeago = True
t = c['max_date']
t = t.__str__()
last_msg_time = t[:19]
last_msg_date = t[:10]
res.append({
'discussion':
d.id,
'count':
c['count'],
'lastMessage':
int(time.mktime(c['max_date'].timetuple())),
'folder':
f.name.lower(),
'last_msg_time':
last_msg_time,
'last_msg_date':
last_msg_date,
'timeago':
timeago
})
return make_response(res)
def get(self, request):
res = []
for f in DiscussionFolder.objects.filter(Q(user=request.user) & ~Q(type=FOLDER_TYPES['TRASH']['id'])):
for d in f.discussions.all(): #TODO rewite it with raw sql!
da, created = DiscussionAccess.objects.get_or_create(user=request.user, discussion=d)
c = d.discussionmessage_set.filter(sent__gt=da.access_time).aggregate(count=Count('sent'))
c['max_date'] = d.discussionmessage_set.aggregate(max_date=Max('sent'))['max_date']
diff=datetime.datetime.now()-c['max_date']
if diff.days>=1:
timeago=False
else:
timeago=True
t = c['max_date']
t = t.__str__()
last_msg_time= t[:19]
last_msg_date= t[:10]
res.append({'discussion': d.id, 'count': c['count'], 'lastMessage': int(time.mktime(c['max_date'].timetuple())),
'folder': f.name.lower(), 'last_msg_time':last_msg_time, 'last_msg_date':last_msg_date, 'timeago':timeago})
return make_response(res)
def search(request):
q = request.GET['q']
res = [{'id': d.id, 'title': d.title} for d in Disease.objects.filter(icd9__icontains=q)[:10]]
if not res:
u = 'http://apps.nlm.nih.gov/medlineplus/services/mpconnect_service.cfm?mainSearchCriteria.v.c=%s' % q
print u
f = urllib2.urlopen(u)
xml = '\n'.join(f)
d = parseString(xml)
e = d.getElementsByTagName('entry')
if e:
t = e[0].getElementsByTagName('title')[0].childNodes[0].data
s = e[0].getElementsByTagName('summary')[0].childNodes[0].data
s = html2text.html2text(s)
disease = Disease()
rev = ArticleRevision.objects.create(author=request.user)
disease.icd9 = q
disease.icd10 = ''
disease.title = t
field, created = Field.objects.get_or_create(name__iexact='', defaults={'name': ''})
content = FieldContent.objects.create(
content=s,
field=field,
author=request.user,
active=True,
previous_revision=None,
)
rev.fields.add(content)
rev.save()
disease.current_revision = rev
disease.save()
# l = d.getElementsByTagName('link')[0].getAttribute('href') if d.getElementsByTagName('link') else ''
print t
print s
res = [{'id': disease.id, 'title': disease.title}]
return make_response(res)
def revision(request, id):
rev = ArticleRevision.objects.get(id=int(id))
return make_response(rev.to_json())
def revision(request, id):
rev = ArticleRevision.objects.get(id=int(id))
return make_response(rev.to_json())
def get(self, request, discussion_id=None):
if discussion_id:
discussion_id = int(discussion_id)
d = Discussion.objects.get(id=discussion_id)
da = DiscussionAccess.objects.get_or_create(discussion=d, user=request.user)[0]
da.access_time = timezone.now()
da.save()
t = ""
last_messages = DiscussionMessage.objects.filter(discussion=d).order_by('-sent')[:1]
for last_message in last_messages:
diff = datetime.datetime.now()-last_message.sent
if diff.days >= 1:
timeago = False
else:
timeago = True
t = last_message.sent.__str__()
last_msg_time = t[:19]
last_msg_date = t[:10]
members = [m.serialize_as_json() for m in d.participants.filter(is_active=True)]
messages = [m.serialize_as_json() for m in DiscussionMessage.objects.filter(discussion=d)]
for m in messages:
m['editable'] = m['sender_id'] == request.user.id
return make_response({'id': d.id, 'subject': d.subject, 'starter': d.starter.serialize_as_json(),
'members': members, 'messages': messages, 'last_msg_time': last_msg_time,
'last_msg_date': last_msg_date, 'timeago':timeago})
f = request.GET.get('folder', 'unknown').lower()
if 'inbox' == f:
folder, created = DiscussionFolder.objects.get_or_create(user=request.user,
name=FOLDER_TYPES['INBOX']['name'],
type=FOLDER_TYPES['INBOX']['id'])
answer = []
discussions = folder.discussions.all().annotate(
last_msg_time=Max('discussionmessage__sent')).order_by('-last_msg_time')
t=""
for d in discussions:
diff=datetime.datetime.now()-d.last_msg_time
if diff.days >= 1:
timeago = False
else:
timeago = True
t=d.last_msg_time.__str__()
d.last_msg_time=t[:19]
d.last_msg_date=t[:10]
ans = {'timeago':timeago, 'last_msg_date':d.last_msg_date, 'last_msg_time': d.last_msg_time, 'id': d.id,
'subject': d.subject, 'count': 0, 'starter': d.starter.serialize_as_json()}
answer.append(ans)
return make_response(answer)
#return make_response([{'id': d.id, 'subject': d.subject, 'count': 0, 'starter': d.starter.serialize_as_json(),}
# for d in folder.discussions.all().annotate(s=Max('discussionmessage__sent')).order_by('-s')])
if 'archive' == f:
folder, created = DiscussionFolder.objects.get_or_create(user=request.user,
name=FOLDER_TYPES['ARCHIVE']['name'],
type=FOLDER_TYPES['ARCHIVE']['id'])
return make_response([
{'id': d.id, 'subject': d.subject, 'count': 0, 'starter': d.starter.serialize_as_json()}
for d in folder.discussions.all().annotate(s=Max('discussionmessage__sent')).order_by('-s')])
if 'trash' == f:
folder, created = DiscussionFolder.objects.get_or_create(user=request.user,
name=FOLDER_TYPES['TRASH']['name'],
type=FOLDER_TYPES['TRASH']['id'])
return make_response([{'id': d.id, 'subject': d.subject, 'count': 0, 'starter': d.starter.serialize_as_json()}
for d in folder.discussions.all().annotate(s=Max('discussionmessage__sent')).order_by('-s')])
return make_response([])
def delete(self, request, id=None):
Attachment.objects.get(id=int(id)).delete()
return make_response()
def get(self, request, id=None):
res = [
a.to_json() for a in ArticleRevision.objects.get(
article=int(id)).attachments.all()
]
return make_response(res)
def post(self, request, discussion_id=None):
if not discussion_id:
discussion = self.__create_discussion__(request)
else:
try:
discussion = Discussion.objects.get(id=discussion_id)
except Discussion.DoesNotExist:
return make_response(error='Invalid discussion')
f = MessageForm(request.POST)
if f.is_valid():
message = self.__create_message__(request.user,
discussion,
request.POST.get('text',
'').strip(),
file_message_id=request.POST.get(
'filemessageid', None))
#email notifications
subject = 'Medical+Intelligence. You have a new message in a discussion \"' + discussion.subject + '\".'
text = f.cleaned_data['text']
sender = request.user
if sender != discussion.starter.user:
msg = {
'subject':
subject,
'from_email':
'*****@*****.**',
'to': [{
'email': discussion.starter.user.user_info.email
}],
'global_merge_vars': [
{
'name': 'SENDER',
'content': sender.__str__()
},
{
'name': 'DISCUSSION',
'content': discussion.subject
},
{
'name': 'MESSAGE',
'content': text
},
]
}
EmailThread('newMessage', msg).start()
for member in discussion.participants.filter(is_active=True):
if sender != member.user:
msg = {
'subject':
subject,
'from_email':
'*****@*****.**',
'to': [{
'email': member.user.user_info.email
}],
'global_merge_vars': [
{
'name': 'SENDER',
'content': sender.__str__()
},
{
'name': 'DISCUSSION',
'content': discussion.subject
},
{
'name': 'MESSAGE',
'content': text
},
]
}
EmailThread('newMessage', msg).start()
for f in discussion.discussionfolder_set.filter(
~Q(type=FOLDER_TYPES['INBOX']['id']),
~Q(type=FOLDER_TYPES['TRASH']['id'])):
f.discussions.remove(discussion)
DiscussionFolder.objects.add_discussion(
f.user, FOLDER_TYPES['INBOX'], discussion)
return make_response({'messageId': message.id})
def save(request):
a = request.POST['data'].strip()
id = request.POST['id'] if 'id' in request.POST else None
disease = Disease.objects.get(id=int(id)) if id else Disease()
previous_revision = disease.current_revision if hasattr(
disease, 'current_revision') else None
rev = ArticleRevision.objects.create(author=request.user,
previous_revision=previous_revision)
disease.icd9 = request.POST['icd9']
disease.icd10 = request.POST['icd10']
disease.title = request.POST['name']
headers = re.findall('#.*\n', a)
headers.insert(0, '')
attachments = previous_revision.attachments.all(
) if previous_revision else []
def create_field(field, content, prev=None):
return FieldContent.objects.create(
content=content,
field=field,
author=request.user,
active=True,
previous_revision=prev,
)
for (i, r) in enumerate(re.split('#.*\n', a)):
if 0 == i and 0 == len(r.strip()):
continue
name = headers[i][1:].strip() if i < len(headers) else ''
field, created = Field.objects.get_or_create(name__iexact=name,
defaults={'name': name})
f = FieldContent.objects.filter(field=field).filter(
article_revision=previous_revision)
if not f:
rev.fields.add(create_field(field, r.strip()))
elif f[0].content == r.strip():
rev.fields.add(f[0])
else:
f.active = False
f[0].save()
rev.fields.add(create_field(field, r.strip(), f[0]))
rev.attachments = attachments
rev.save()
disease.current_revision = rev
disease.save()
r = disease.current_revision
revisions = [{
'id': r.id,
'author': r.author.username,
'date': r.date.strftime(DATE_FORMAT)
}]
while r.previous_revision is not None:
r = r.previous_revision
revisions.append({
'id': r.id,
'author': r.author.username,
'date': r.date.strftime(DATE_FORMAT)
})
res = disease.to_json()
res['revisions'] = revisions
return make_response(res)
def post(self, request):
return make_response()
def get(self, request, message_id=None):
m = DiscussionMessage.objects.get(id=message_id).serialize_as_json()
m['editable'] = m['sender_id'] == request.user.id
return make_response(m)
def get(self, request, discussion_id=None):
if discussion_id:
discussion_id = int(discussion_id)
d = Discussion.objects.get(id=discussion_id)
da = DiscussionAccess.objects.get_or_create(discussion=d,
user=request.user)[0]
da.access_time = timezone.now()
da.save()
t = ""
last_messages = DiscussionMessage.objects.filter(
discussion=d).order_by('-sent')[:1]
for last_message in last_messages:
diff = datetime.datetime.now() - last_message.sent
if diff.days >= 1:
timeago = False
else:
timeago = True
t = last_message.sent.__str__()
last_msg_time = t[:19]
last_msg_date = t[:10]
members = [
m.serialize_as_json()
for m in d.participants.filter(is_active=True)
]
messages = [
m.serialize_as_json()
for m in DiscussionMessage.objects.filter(discussion=d)
]
for m in messages:
m['editable'] = m['sender_id'] == request.user.id
return make_response({
'id': d.id,
'subject': d.subject,
'starter': d.starter.serialize_as_json(),
'members': members,
'messages': messages,
'last_msg_time': last_msg_time,
'last_msg_date': last_msg_date,
'timeago': timeago
})
f = request.GET.get('folder', 'unknown').lower()
if 'inbox' == f:
folder, created = DiscussionFolder.objects.get_or_create(
user=request.user,
name=FOLDER_TYPES['INBOX']['name'],
type=FOLDER_TYPES['INBOX']['id'])
answer = []
discussions = folder.discussions.all().annotate(last_msg_time=Max(
'discussionmessage__sent')).order_by('-last_msg_time')
t = ""
for d in discussions:
diff = datetime.datetime.now() - d.last_msg_time
if diff.days >= 1:
timeago = False
else:
timeago = True
t = d.last_msg_time.__str__()
d.last_msg_time = t[:19]
d.last_msg_date = t[:10]
ans = {
'timeago': timeago,
'last_msg_date': d.last_msg_date,
'last_msg_time': d.last_msg_time,
'id': d.id,
'subject': d.subject,
'count': 0,
'starter': d.starter.serialize_as_json()
}
answer.append(ans)
return make_response(answer)
#return make_response([{'id': d.id, 'subject': d.subject, 'count': 0, 'starter': d.starter.serialize_as_json(),}
# for d in folder.discussions.all().annotate(s=Max('discussionmessage__sent')).order_by('-s')])
if 'archive' == f:
folder, created = DiscussionFolder.objects.get_or_create(
user=request.user,
name=FOLDER_TYPES['ARCHIVE']['name'],
type=FOLDER_TYPES['ARCHIVE']['id'])
return make_response([{
'id': d.id,
'subject': d.subject,
'count': 0,
'starter': d.starter.serialize_as_json()
} for d in folder.discussions.all().annotate(
s=Max('discussionmessage__sent')).order_by('-s')])
if 'trash' == f:
folder, created = DiscussionFolder.objects.get_or_create(
user=request.user,
name=FOLDER_TYPES['TRASH']['name'],
type=FOLDER_TYPES['TRASH']['id'])
return make_response([{
'id': d.id,
'subject': d.subject,
'count': 0,
'starter': d.starter.serialize_as_json()
} for d in folder.discussions.all().annotate(
s=Max('discussionmessage__sent')).order_by('-s')])
return make_response([])
def get(self, request, message_id=None):
m = DiscussionMessage.objects.get(id=message_id).serialize_as_json()
m['editable'] = m['sender_id'] == request.user.id
return make_response(m)
def delete(self, request, id=None):
Attachment.objects.get(id=int(id)).delete()
return make_response()
def post(self, request):
return make_response()
def get(self, request, id=None):
res = [a.to_json() for a in ArticleRevision.objects.get(article=int(id)).attachments.all()]
return make_response(res)
