def article_file_form(request, article_name):
# art_form = ArticleForm()
message = None
if article_name:
pk = decrypt_text(article_name)
try:
art_info = Article.objects.get(id__exact=pk)
# art_form = ArticleForm(initial=model_to_dict(art_info))
art_files = ArticleFile.objects.filter(article=art_info)
for x in art_files:
print(x.file_name, '---')
# form.fields['patient_hospid'].initial = admitted.patient.patient_hospid
return render(
request, 'articles/article_submission.html', {
'system_name': 'Article Form - Files',
'art_files': 'active',
'art_info': art_info,
'article_files': art_files,
})
except Article.DoesNotExist or Article:
message = 'Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
else:
message = 'Invalid Data.<a href="articles/articles-list"> Click here</a> to see article list'
return HttpResponse(message)
def get_article_info(request, article_name=None):
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
print('article_info')
message = None
pk = decrypt_text(article_name)
art_info = None
art_auths = None
try:
art_info = Article.objects.get(id__exact=pk)
art_auths = ArticleAuthor.objects.filter(article=art_info)
# message=art_info.title +'- Article .<a href="/articles/articles-list/"> Click here</a> to see article list'
except Article.DoesNotExist or Article:
message = 'Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
if 'joumsy_message' in request.session:
message = request.session.get('joumsy_message')
del request.session['joumsy_message']
return render(
request, 'articles/article_info.html', {
'system_name': 'Article Info',
'art_info': art_info,
'author_list': art_auths,
'message': message
})
def submit_article(request, article_name=None):
message = None
if article_name:
pk = decrypt_text(article_name)
dt = datetime.today()
try:
art_info = Article.objects.get(id__exact=pk)
try:
ArticleFile.objects.get(main=True, article=art_info)
art_info.is_submitted = True
art_info.date_submitted = dt
art_info.state = 'ACC'
art_info.save()
except ArticleFile.DoesNotExist or ArticleFile:
request.session[
'joumsy_message'] = "Please Complete Submission"
direct = '/articles/submission_info/' + encrypt_text(
str(art_info.id))
return HttpResponseRedirect(direct)
message = art_info.title + '- has been submitted.'
request.session['joumsy_message'] = message
except Article.DoesNotExist or Article:
message = 'Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
direct = '/articles/submission_info/' + encrypt_text(str(art_info.id))
return HttpResponseRedirect(direct)
return HttpResponse(message)
def get_jms_article_info(request, article_name=None):
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
message=None
pk = decrypt_text(article_name)
art_info=None
art_auths=None
assigned_eddie=None
eds_decision=None
main_file=None
try:
art_info = Article.objects.get(id__exact=pk)
art_auths = ArticleAuthor.objects.filter(article = art_info)
art_files = ArticleFile.objects.filter(article = art_info )
try:
main_file = ArticleFile.objects.get(article = art_info, main=True)
except ArticleFile.DoesNotExist or ArticleFile:
main_file=None
try:
assigned_eddie = AssignEditor.objects.get(article=art_info, is_accepted=True, is_active=True)
except AssignEditor.DoesNotExist or AssignEditor:
assigned_eddie = None
if EditorDecision.objects.filter(article=art_info).exists():
eds_decision = EditorDecision.objects.filter(article=art_info, decided=True).latest('date_decided')
# message=art_info.title +'- Article .<a href="/articles/articles-list/"> Click here</a> to see article list'
except Article.DoesNotExist or Article:
message='Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
if 'joumsy_message' in request.session:
message = request.session.get('joumsy_message')
del request.session['joumsy_message']
return render(
request,
'journals/jms_article_info.html',
{
'system_name': 'Submission InReview',
'art_info':art_info,
'author_list': art_auths,
'art_files_list': art_files,
'assigned_eddie':assigned_eddie,
'message':message,
'art_meta':'active',
'eds_decision':eds_decision,
'main_file':main_file,
}
)
def search_reviewer(request, art_state=None):
search_val = request.GET.get('search_text')
art_pk = request.GET.get('art')
pk = decrypt_text(art_pk)
url = 'journals/reviewer_list.html';
# url = request.GET.get('url')
# s_type = request.GET.get('opd_search_filter')
# print(url)
pname = request.GET.get('search_text').split()
SYSTEM_NAME = 'Search Result'
qset1 = reduce(Q.__or__, [Q(first_name__istartswith=query) | Q(last_name__istartswith=query) for query in pname])
revs = User.objects.filter((qset1) & Q(groups__id__exact=2) )
reviewers_list =[]
try:
art_info = Article.objects.get(id__exact=pk)
for x in revs:
chk=ReviewDetails.objects.filter(reviewer= x,article=art_info).exists()
if not chk:
h = {
'reviewers_name': x.first_name +" "+x.last_name,
'reviewer_info': x,
'done_review':ReviewDetails.objects.filter(reviewer= x,is_done=True).count(),
# 'current_invitation':ReviewDetails.objects.filter(reviewer= x,is_invited=True).count(),
}
reviewers_list.append(h)
except Article.DoesNotExist or Article:
message='Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
data ={
'reviewers_list':reviewers_list,
'art_info':art_info
}
return render(request, url, data)
def search_editor(request, art_state=None):
search_val = request.GET.get('search_text')
art_pk = request.GET.get('art')
pk = decrypt_text(art_pk)
url = 'journals/editor_list.html';
# url = request.GET.get('url')
# s_type = request.GET.get('opd_search_filter')
# print(url)
pname = request.GET.get('search_text').split()
SYSTEM_NAME = 'Search Result'
qset1 = reduce(Q.__or__, [Q(first_name__istartswith=query) | Q(last_name__istartswith=query) for query in pname])
eddie = User.objects.filter( (qset1) & Q(groups__id__exact=4) )
assoc_editors_list = []
try:
art_info = Article.objects.get(id__exact=pk)
for x in eddie:
chk=EditorDecision.objects.filter(editor= x,article=art_info).exists()
is_auth = ArticleAuthor.objects.filter(author= x, article=art_info).exists()
if not is_auth and not chk:
h = {
'editor_name': x.first_name +" "+x.last_name,
'assoc_editor_info': x,
'done_decision':EditorDecision.objects.filter(editor= x, decided=True, is_rescind_descision=False).count(),
'current_work':AssignEditor.objects.filter(assoc_editor= x, is_accepted= True, is_active=True, is_done=False).count(),
}
assoc_editors_list.append(h)
except Article.DoesNotExist or Article:
message='Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
data ={
'assoc_editors_list':assoc_editors_list,
'art_info':art_info,
'from_search':search_val
}
return render(request, url, data)
def review_form_save(request, ref_det=None):
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
pk = decrypt_text(ref_det)
art_info = None
art_auths = None
dt = datetime.datetime.now()
if request.method == 'POST':
rev_form = Review_Submission_Form(request.POST, request.FILES)
try:
rev_info = ReviewDetails.objects.get(id__exact=pk)
print(rev_info.article.title, '--rev_article----')
rev_info.recommendation = request.POST.get('recommendation')
rev_info.acceptability = request.POST.get('acceptability')
rev_info.clarity = request.POST.get('clarity')
rev_info.quality = request.POST.get('quality')
rev_info.abstract_review = request.POST.get('abstract_review')
rev_info.comments_for_editor = request.POST.get(
'comments_for_editor')
rev_info.comments_for_author = request.POST.get(
'comments_for_author')
rev_info.save()
art_auths = ArticleAuthor.objects.filter(article=rev_info.article)
art_files = ArticleFile.objects.filter(article=rev_info.article,
state='SUP')
return HttpResponseRedirect('/reviews/submission_meta/' +
encrypt_text(str(rev_info.id)))
# message=art_info.title +'- Article .<a href="/articles/articles-list/"> Click here</a> to see article list'
except ReviewDetails.DoesNotExist or Article:
message = 'Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
else:
return HttpResponseRedirect("Denied")
def assign_issue_article_display(request, article_name):
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
message=None
issue_select_form = IssueSelectionForm()
pk = decrypt_text(article_name)
art_info=None
art_auths=None
eddie_decision=None
try:
art_info = Article.objects.get(id__exact=pk)
art_auths = ArticleAuthor.objects.filter(article = art_info)
art_files = ArticleFile.objects.filter(article = art_info )
try:
eddie_decision = EditorDecision.objects.filter(article=art_info, decided=True, decision='ACC')
except EditorDecision.DoesNotExist or EditorDecision:
print('unable to retrieve decision!!!')
except Article.DoesNotExist or Article:
message='Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
if 'joumsy_message' in request.session:
message = request.session.get('joumsy_message')
del request.session['joumsy_message']
return render(
request,
'journals/inedit_article_info.html',
{
'system_name': 'Submission InEdit',
'art_info':art_info,
'author_list': art_auths,
'art_files_list': art_files,
'eddie_decision':eddie_decision,
'message':message,
'issue_select_form':issue_select_form,
}
)
def upload_article_file(request, article_name=None):
message = None
if article_name:
pk = decrypt_text(article_name)
dt = datetime.today()
many_files = request.FILES.getlist('artfiles')
# file_name = models.CharField(max_length=100, null= True)
# file_path = models.FileField(upload_to='article_file')
# date_created = models.DateTimeField(auto_now = True)
# article = models.ForeignKey(Article, null=True)
# uploader = models.ForeignKey(User, null=True)
try:
art_info = Article.objects.get(id__exact=pk)
creator = request.user
for x in many_files:
a_file = ArticleFile(file_name=x.name,
file_path=x,
article=art_info,
date_created=dt,
uploader=creator,
main=False,
state='SUP')
a_file.save()
return HttpResponse('Files uploaded! ')
except Article.DoesNotExist or Article:
message = 'Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
# direct='/articles/submission_info/'+encrypt_text(str(art_info.id))
# return HttpResponseRedirect(direct)
return HttpResponse(message)
def get_review_article_info(request, ref_det=None):
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
message = None
pk = decrypt_text(ref_det)
art_info = None
art_auths = None
rev_form = None
try:
rev_info = ReviewDetails.objects.get(id__exact=pk,
invitation_declined=False)
if rev_info.invitation_accepted == True:
rev_form = 'active'
art_auths = ArticleAuthor.objects.filter(article=rev_info.article)
art_files = ArticleFile.objects.filter(article=rev_info.article,
state='SUP')
art_submission_file = ArticleFile.objects.get(article=rev_info.article,
main=True)
# message=art_info.title +'- Article .<a href="/articles/articles-list/"> Click here</a> to see article list'
except ReviewDetails.DoesNotExist or Article:
message = 'Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
return render(
request, 'reviews/submission_review.html', {
'system_name': 'Article Info',
'rev_info': rev_info,
'author_list': art_auths,
'files_list': art_files,
'message': message,
'art_meta': 'active',
'is_accepted': rev_form,
'art_submission_file': art_submission_file,
})
def accept_review(request, ref_det=None):
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
message = None
pk = decrypt_text(ref_det)
art_info = None
art_auths = None
dt = datetime.datetime.now()
try:
rev_info = ReviewDetails.objects.get(id__exact=pk)
print(rev_info.article.title, '--rev_article----')
rev_info.invitation_accepted = True
rev_info.is_active = True
rev_info.date_confirmed = dt
rev_info.save()
# rev_info.article.status='REV'
# rev_info.article.save()
# check if updating article state is_saved
art_auths = ArticleAuthor.objects.filter(article=rev_info.article)
art_files = ArticleFile.objects.filter(article=rev_info.article,
state='SUP')
return HttpResponseRedirect('/reviews/submission_meta/' +
encrypt_text(str(rev_info.id)) + '/')
# message=art_info.title +'- Article .<a href="/articles/articles-list/"> Click here</a> to see article list'
except ReviewDetails.DoesNotExist or Article:
message = 'Invalid Data.<a href="/reviews/"> Click here</a> to see article list'
return HttpResponse(message)
return HttpResponseRedirect('/reviews/submission_meta/' +
encrypt_text(str(rev_info.id)) + '/')
def article_author_update_form(request, article_info=None, auth_info=None):
art_auths = User.objects.get(id=auth_info)
arts = decrypt_text(article_info)
art_info = Article.objects.get(id=arts)
auth_form = Author_Form(initial=model_to_dict(art_auths))
# return HttpResponseRedirect('/articles/')
# iss = Issue.objects.filter(is_published = True)
message = None
if 'auth_prof_message' in request.session:
message = request.session.get('auth_prof_message')
del request.session['auth_prof_message']
return render(
request, 'profile_display.html', {
'system_name': 'User - ' + request.user.username,
'author_form': auth_form,
'curr_user': art_auths,
'message': message,
'art_info': art_info,
})
def display_review_form(request, ref_det=None):
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
message = None
pk = decrypt_text(ref_det)
jms_rev_details_form = None
art_info = None
art_files = None
try:
rev_info = ReviewDetails.objects.get(id__exact=pk,
invitation_declined=False)
if rev_info.invitation_accepted == True:
rev_form = 'active'
jms_rev_details_form = Review_Submission_Form(
initial=model_to_dict(rev_info))
art_info = Article.objects.get(id=rev_info.article.id)
art_files = ArticleFile.objects.filter(article=rev_info.article)
# message=art_info.title +'- Article .<a href="/articles/articles-list/"> Click here</a> to see article list'
except ReviewDetails.DoesNotExist or Article:
message = 'Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
return render(
request, 'reviews/submission_review.html', {
'system_name': 'Review Form',
'rev_info': rev_info,
'message': message,
'is_accepted': rev_form,
'art_rev_form': 'active',
'review_form': jms_rev_details_form,
'art_info': art_info,
'art_files': art_files,
})
def article_author_form(request, article_name=None):
# art_form = ArticleForm()
# print('asdasdas')
message = None
art_auths = None
if article_name:
pk = decrypt_text(article_name)
try:
art_info = Article.objects.get(id__exact=pk)
art_auths = ArticleAuthor.objects.filter(article=art_info)
# form.fields['patient_hospid'].initial = admitted.patient.patient_hospid
added = None
auth_form = Author_Form()
if 'article_auths' in request.session:
added = request.session['article_auths']
return render(
request, 'articles/article_submission.html', {
'system_name': 'Article Form - Author',
'author_form': auth_form,
'art_auth': 'active',
'art_info': art_info,
'author_list': art_auths,
'newly_add': added,
})
except Article.DoesNotExist or Article:
message = 'Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
else:
message = 'Invalid Data.<a href="articles/articles-list"> Click here</a> to see article list'
return HttpResponse(message)
def get_invite_template(request):
temp_key = request.GET.get('tempform')
artid= request.GET.get('sub_info')
_id_art=decrypt_text(artid)
rev = request.GET.get('assigned_reviewer')
rev_id = decrypt_text(rev)
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
message=""
# user = request.user
# a = User.objects.get(username=user)
dt = datetime.datetime.now()
dt= dt+ timedelta(days=2)
try:
email_temp = JMSTemplate.objects.get( template_title = temp_key )
assigned_reviewer = User.objects.get(id=rev_id)
art_info = Article.objects.get(id=_id_art)
art_auths=ArticleAuthor.objects.filter(article=art_info)
a_names=""
for x in art_auths:
a_names=a_names+ x.author.last_name.title() +', '+x.author.first_name.title()+'<br />'
userpicks=dict()
userpicks['article_authors'] = a_names
userpicks['reviewer'] = assigned_reviewer.get_full_name()
userpicks['date_response_review'] = dt.strftime('We are the %b %d, %Y')
userpicks['date_ended']='December 2, 2016'
userpicks['article_title'] = art_info.title
userpicks['article_abstract'] = art_info.abstract
userpicks['article_review_url'] = 'http://localhost:8000/articles/submission/'+str(art_info.id)
userpicks['reset_url_password'] = '******'
edit = User.objects.get(username=request.user)
userpicks['editor_name'] =edit.get_full_name()
userpicks['affiliation']= edit.affiliation
userpicks['email_address']=edit.email
userpicks['web_main_address']='http://localhost:8000/'
test_content=email_temp.content
email_format = test_content.format(**userpicks)
except JMSTemplate.DoesNotExist or JMSTemplate:
message="template does no longer_exist"
return render(
request,
'journals/email_template.html',
{
'page_title': 'List of Article',
'email_title':email_temp.title,
'email_content':email_format,
'to_user':assigned_reviewer,
'art_details': art_info.id,
}
)
def article_author_save(request):
message = None
if request.method == 'POST':
print('saving author data...')
art_form = Author_Form(request.POST)
art_id_ = request.POST.get('submission_meta')
_id = decrypt_text(art_id_)
arts = Article.objects.get(id=_id)
if art_form.is_valid():
print('author form valid...')
dt = datetime.today()
article_auth = User(
user_type='AUTH',
gender='0',
contact_no=art_form.cleaned_data['contact_no'],
address=art_form.cleaned_data['address'],
email=art_form.cleaned_data['email'],
affiliation=art_form.cleaned_data['affiliation'],
department=art_form.cleaned_data['department'],
position_title=art_form.cleaned_data['position_title'],
first_name=art_form.cleaned_data['first_name'],
last_name=art_form.cleaned_data['last_name'],
# middle_name = art_form.cleaned_data['middle_name'],
username=genEmpUsername(),
is_superuser=False,
is_staff=True,
is_active=False,
# degree = models.CharField(max_length = 120, null=True)
# research_interest = models.CharField(max_length = 420, null=True)
# fax_number = models.CharField(max_length = 20 , null=True)
)
article_auth.save()
# User.save()
# if not is_author_exists(arts,article_auth):
sub_author = ArticleAuthor(
author=article_auth,
article=arts,
date_added=dt,
main_author=False,
)
sub_author.save()
# class Meta():
# db_table = 'article_author'
direct = '/articles/submission/' + art_id_ + '/authors'
request.session['article_auths'] = art_form.cleaned_data[
'first_name'] + ', ' + art_form.cleaned_data['last_name']
return HttpResponseRedirect(direct)
else:
print('form is not valid')
print(art_form.errors)
return render(
request, 'articles/article_submission.html', {
'system_name': 'Article Form - Author',
'auth_form': art_form,
'art_auth': 'active',
'art_info': arts,
'author_list': None,
})
else:
return HttpResponse('notpost !')
def del_article_author(request):
art_auth_id_ = request.GET.get('art_auth')
art_auth_id_ = decrypt_text(art_auth_id_)
ArticleAuthor.objects.get(id=art_auth_id_).delete()
return HttpResponse('yes')
def update_article_info(request, article_name=None):
message = None
main_file = None
if article_name:
pk = decrypt_text(article_name)
try:
art_info = Article.objects.get(id__exact=pk)
# request.session['article'] = pk
# message=art_info.title +'- Article .<a href="/articles/articles-list/"> Click here</a> to see article list'
if ArticleFile.objects.filter(article=art_info,
main=True).exists():
main_file = ArticleFile.objects.get(article=art_info,
main=True)
except Article.DoesNotExist or Article:
message = 'Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
art_form = ArticleForm(initial=model_to_dict(art_info))
return render(
request, 'articles/article_submission.html', {
'system_name': 'Article Form',
'meta_form': art_form,
'art_meta': 'active',
'art_info': art_info,
'main_file': main_file,
})
else:
if request.method == 'POST':
artform = ArticleForm(request.POST, request.FILES)
print("we got the form")
dt = datetime.today()
if artform.is_valid():
print("checking for duplicate file", )
# old = request.session['article']
old = request.POST.get('art_detail')
old_art = Article.objects.get(id=old)
check = False
# datetime.today()
try:
pasyente = Article.objects.exclude(
id__exact=old_art.id).get(
title__iexact=request.POST.get('title'))
check = True
message = 'Article Info exist.'
except Article.DoesNotExist or Article:
pass
if not check:
print("no duplicate")
old_art.title = artform.cleaned_data['title']
old_art.section = artform.cleaned_data['section']
old_art.references = artform.cleaned_data['references']
old_art.keywords = artform.cleaned_data['keywords']
old_art.abstract = artform.cleaned_data['abstract']
old_art.is_featured = False
old_art.pub_date = None
old_art.require_review = False
date_modified = dt
old_art.save()
if 'main_file' in request.FILES:
# print(request.FILES['image_path'])
art_file = request.FILES['main_file']
if ArticleFile.objects.filter(article=old_art,
main=True).exists():
main_art_file = ArticleFile.objects.get(
article=old_art, main=True)
os.unlink(main_art_file.file_path.path)
main_art_file.file_name = art_file.name + '_1'
main_art_file.file_path = art_file
main_art_file.date_created = dt
main_art_file.save()
else:
a_file = ArticleFile(file_name=art_file.name,
file_path=art_file,
article=old_art,
date_created=dt,
uploader=request.user,
state='AUTH',
main=True,
stage=1)
a_file.save()
# saved_pats = str(request.session['patient']) + patientform.cleaned_data['firstname'] + patientform.cleaned_data['lastname']
# delete session
# del request.session['article']
# request.session['article_auths']
request.session[
'updated_succ_messages'] = 'Article Successfully updated.'
direct = ('/articles/submission/' +
encrypt_text(str(old_art.id)))
return HttpResponseRedirect(direct)
else:
return HttpResponseRedirect('/error-404/')
else:
print("form is not valid")
main_file = None
old = request.POST.get('art_detail')
if ArticleFile.objects.filter(article=art_info,
main=True).exists():
main_file = ArticleFile.objects.get(article=art_info,
main=True)
art_info = Article.objects.get(id=old)
form = ArticleForm()
form.fields['title'].initial = request.POST.get('title')
form.fields['abstract'].initial = request.POST.get('abstract')
form.fields['keywords'].initial = request.POST.get('keywords')
form.fields['references'].initial = request.POST.get(
'references')
# del request.session['article']
return render(
request, 'articles/article_submission.html', {
'system_name': 'Article Form',
'meta_form': form,
'art_meta': 'active',
'art_info': art_info,
'message':
'Please fill form properly. Unable to update data.',
'main_file': main_file,
})
return HttpResponse(message)
def jms_article_info_review(request, article_name=None):
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
message=None
pk = decrypt_text(article_name)
art_info=None
art_auths=None
assigned_eddie = None
invited_eddie = None
eds_decision = None
try:
art_info = Article.objects.get(id__exact=pk)
art_auths = ArticleAuthor.objects.filter( article = art_info )
art_files = ArticleFile.objects.filter( article = art_info )
try:
main_file = ArticleFile.objects.get(article = art_info, main=True)
except ArticleFile.DoesNotExist or ArticleFile:
main_file=None
if EditorDecision.objects.filter(article=art_info).exists():
eds_decision = EditorDecision.objects.filter(article=art_info, decided=True).latest('date_decided')
try:
assigned_eddie = AssignEditor.objects.get(article = art_info, is_accepted=True)
except AssignEditor.DoesNotExist or AssignEditor:
assigned_eddie = None
invited_eddie = AssignEditor.objects.filter(article = art_info, is_accepted=False)
revs = User.objects.filter(groups__id__exact=2)
reviewers_list =[]
for x in revs:
chk=ReviewDetails.objects.filter(reviewer= x,article=art_info).exists()
if not chk:
rev_info=ReviewDetails.objects.filter(reviewer= x)
h = {
'reviewers_name': x.first_name +" "+x.last_name,
'reviewer_info': x,
'done_review':rev_info.filter(is_done=True).count(),
'active_review':rev_info.filter(invitation_accepted=True, is_done=False, is_active=True).count(),
}
reviewers_list.append(h)
submit_reviewers=ReviewDetails.objects.filter(article=art_info)
# message=art_info.title +'- Article .<a href="/articles/articles-list/"> Click here</a> to see article list'
except Article.DoesNotExist or Article:
message='Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
if 'joumsy_message' in request.session:
message = request.session.get('joumsy_message')
del request.session['joumsy_message']
return render(
request,
'journals/jms_article_info.html',
{
'system_name': 'Submission InReview',
'art_info':art_info,
'author_list': art_auths,
'art_files_list': art_files,
'reviewers_list': reviewers_list,
'message':message,
'art_review':'active',
'assigned_eddie':assigned_eddie,
'invited_eddie':invited_eddie,
'submit_reviewers':submit_reviewers,
'eds_decision':eds_decision,
'main_file':main_file,
}
)
def assign_accept_editor(request):
edie = request.GET.get('ass_editor')
edie_id = decrypt_text(edie)
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
message = ""
dt = datetime.datetime.now()
art_info = None
outs = None
chk = False
eddie =None
try:
with transaction.atomic():
try:
eddie = AssignEditor.objects.get(id=edie_id)
chk=True
has_assigned=hasAssignedEditor(eddie.article,'article')
if not has_assigned:
eddie.is_accepted=True
eddie.save()
print('asdasd---',eddie.assoc_editor.username)
art_log= ArticleSubmissionLog(
creator = request.user,
# desc of work done
work_desc = 'Accepted role - Assigned Editor -'+ eddie.assoc_editor.username +' - to article -'+ str( eddie.article.id),
# dictionary of model and id
att_obj = str(eddie.id)+'-'+'AssignEditor',
)
art_log.save()
outs={
'success':'yes',
'art_title':eddie.article.title,
'ass_edit':eddie.assoc_editor.first_name+', '+eddie.assoc_editor.last_name,
'ass_edit_info':eddie.id,
'art_ident':encrypt_text(str(eddie.article.id)),
}
else:
chk=False
message="Article has been assigned"
except AssignEditor.DoesNotExist or AssignEditor:
chk= False
except:
print('accept-assign not saved. error occurs on data insertion!')
if chk:
data=outs
else:
data={
'success':'no',
'message': message,
}
json_response = json.dumps(data)
return HttpResponse(json_response, content_type="application/json")
def assign_editor(request):
art_det = request.GET.get('art_curr')
edie = request.GET.get('ass_editor')
enddate = request.GET.get('date_due')
edie_id = decrypt_text(edie)
pk= decrypt_text(art_det)
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
message=""
dt = datetime.datetime.now()
art_info=None
outs=None
chk=False
# try:
# with transaction.atomic():
try:
eddie = User.objects.get(id=edie_id)
chk=True
print('Getting User editor Info')
try:
art_info = Article.objects.get(id__exact=pk)
print('Getting article Info')
has_assigned=hasAssignedEditor(art_info,'article')
if not has_assigned:
accept= False
if eddie.id == request.user.id:
accept= True
# article has been assigned notify other user
assign_eddie = AssignEditor(
assoc_editor = eddie,
article = art_info,
date_assigned = dt,
can_edit = True,
can_review = True,
date_notified = dt,
assigned_by = request.user,
is_accepted = accept,
)
assign_eddie.save()
art_info.state='REV'
art_info.date_review_start=dt
art_info.save()
# print(get_editor_assign_template('assign_editor', eddie.id ,art_info.id, request.user))
# notif_message= JMSMessage(
# creator = request.user,
# target = eddie
# content = 'content',
# title = 'title',
# is_opened = False,
# date_sent = dt,
# # date_update =
# )
# notif_message.save()
outs={
'success':'yes',
'art_title':art_info.title,
'ass_edit':eddie.first_name+', '+eddie.last_name,
'ass_edit_info':eddie.id,
'art_ident':encrypt_text(str(art_info.id)),
}
art_log= ArticleSubmissionLog(
creator = request.user,
# desc of work done
work_desc = 'Assigned Editor '+ eddie.username +' to article '+ str( art_info.id),
# dictionary of model and id
att_obj = str(eddie.id)+'-'+'AssignEditor',
)
art_log.save()
else:
chk=False
message="Article has been assigned"
except Article.DoesNotExist or Article:
message='Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
return HttpResponse(message)
except User.DoesNotExist or User:
chk= False
# except:
# message ='Unable to assign Editor. Some error occurs.'
# print('Unable to process editor decision. Some error occurs.')
if chk:
data=outs
else:
data={
'success':'no',
'message': message,
}
json_response = json.dumps(data)
return HttpResponse(json_response, content_type="application/json")
def assign_reviewer(request):
temp_key = request.GET.get('sub_info')
rev = request.GET.get('assigned_reviewer')
enddate = request.GET.get('date_due')
rev_id = decrypt_text(rev)
pk= decrypt_text(temp_key)
if not request.user.is_authenticated():
return HttpResponseRedirect('/sign-in/')
message=""
dt = datetime.datetime.now()
outs=None
rev_user=None
try:
art_info = Article.objects.get(id__exact=pk)
rev_exists=False
if User.objects.filter(id__exact=rev_id).exists():
rev_user=User.objects.get(id__exact=rev_id)
rev_exists = ReviewDetails.objects.filter(article=art_info, reviewer=rev_user).exists()
if not rev_exists:
rev = ReviewDetails(
article = art_info,
reviewer = rev_user,
date_start = dt,
date_ended = enddate,
review_rounds = 1,
is_done = False,
assigned_by = request.user,
is_invited = True,
date_invited= dt,
is_active = False,
)
rev.save()
outs={
'success':'yes',
'submit_reviewer': rev.reviewer.last_name[0].upper()+', '+rev.reviewer.first_name,
'submission':rev.article.title.title(),
}
else:
outs={
'success':'no',
'message':'Review already assigned to this submission'
}
else:
outs={
'success':'no',
'message':'User info does not exist.'
}
except Article.DoesNotExist or Article:
outs={
'success':'no',
'message':'Invalid Data.<a href="articles/articles-list/"> Click here</a> to see article list'
}
return HttpResponseRedirect("message")
# user = request.user
# a = User.objects.get(username=user)
data=outs
json_response = json.dumps(data)
return HttpResponse(json_response, content_type="application/json")
