def list_of_import_in_database(request):
"""
controler of the template account that allow the user to see which calculation he contribute
:param request: variable wich contains the value of the page
:return: template html
"""
if not request.user.is_admin: # security to redirect user that aren't admin
return HttpResponseRedirect(reverse('accueil'))
query_form = QueryForm(request.GET or None)
page = request.GET.get('page', 1)
try: # get all imported file
list_imported_file = ImportFile.objects.all()
paginator = Paginator(list_imported_file.order_by("id_file"), 10)
except Exception as error:
print(error)
try:
history = paginator.page(page)
except PageNotAnInteger:
history = paginator.page(1)
except EmptyPage:
history = paginator.page(paginator.num_pages)
if request.GET and 'button-search' in request.GET:
if query_form.is_valid():
return HttpResponseRedirect(reverse('query'))
return render(request, 'admin_qcpia/admin_list_on_import_in_database.html',
{
'query_form': query_form,
"history": history
})
def user_history_import(request):
"""
controler of the template account that allow the user to see which calculation he contribute
:param request: variable wich contains the value of the page
:return: template html
"""
query_form = QueryForm(request.GET or None)
page = request.GET.get('page', 1)
try: # get all imported file
list_imported_file = ImportFile.objects.filter(id_user=request.user.id)
paginator = Paginator(list_imported_file.order_by("id_file"), 10)
except Exception as error:
print(error)
try:
history = paginator.page(page)
except PageNotAnInteger:
history = paginator.page(1)
except EmptyPage:
history = paginator.page(paginator.num_pages)
if request.GET and 'button-search' in request.GET:
if query_form.is_valid():
return HttpResponseRedirect('query')
return render(request, 'user_qcpia/user_history_import.html', {'query_form': query_form, "history": history})
def edit_rule_admin(request):
"""
controler of the template account that allow the to edit import rule
:param request: variable wich contains the value of the page
:return: template html
"""
if not request.user.is_admin: # security to redirect user that aren't admin
return HttpResponseRedirect(reverse('accueil'))
query_form = QueryForm(request.GET or None)
page = request.GET.get('page', 1)
paginator = None
try: # get all imported file
list_of_rules = ImportRule.objects.all()
paginator = Paginator(list_of_rules.order_by("id_rule"), 10)
except Exception as error:
print(error)
try:
rules = paginator.page(page)
except PageNotAnInteger:
rules = paginator.page(1)
except EmptyPage:
rules = paginator.page(paginator.num_pages)
if request.GET and 'button-search' in request.GET:
if query_form.is_valid():
return HttpResponseRedirect(reverse('query'))
return render(request, 'admin_qcpia/admin_edit_rule_import.html', {'query_form': query_form,
'rules': rules})
def accueil(request):
"""
controler of the template accueil.html
:param request: variable wich contains the value of the page
:return: template html
"""
query_form = QueryForm(request.GET or None)
if query_form.is_valid():
return HttpResponseRedirect(reverse('query'))
return render(request, 'common_qcpia/accueil.html', {'query_form': query_form})
def auth(request):
"""
controler that allow the user to login or register on the web site
:param request: request variable
:return: a view with both form (login and register)
"""
query_form = QueryForm(request.GET or None)
error_login = False
error_register = False
if query_form.is_valid():
return HttpResponseRedirect('query')
if request.method == 'POST' and 'btn-login' in request.POST:
login_form = LoginForm(request.POST)
if login_form.is_valid():
email = login_form.cleaned_data["email"]
password = login_form.cleaned_data["password"]
user = authenticate(
email=email, password=password
) # Nous vérifions si les données sont correctes
if user: # Si l'objet renvoyé n'est pas None
login(request, user) # nous connectons l'utilisateur
return HttpResponseRedirect('dashboard/history')
else: # sinon une erreur sera affichée
error_login = True
else:
login_form = LoginForm()
if request.method == 'POST' and 'btn-register' in request.POST:
register_form = SignUpForm(request.POST)
if register_form.is_valid():
user = register_form.save()
login(request, user)
return HttpResponseRedirect(reverse('accueil'))
else:
register_form = SignUpForm()
return render(
request, 'user_qcpia/auth.html', {
'query_form': query_form,
'register_form': register_form,
'login_form': login_form,
'error_login': error_login,
'error_register': error_register
})
def admin_edit_user(request, id):
"""
controler to edit all user profile
:param request: environement variable of http request
:param id: id of the user
:return: http response
"""
if not request.user.is_admin: # security to redirect user that aren't admin
return HttpResponseRedirect(reverse('accueil'))
current_user = Utilisateur.objects.get(id=id)
if request.method == 'POST':
if 'btn-admin-update-profil' in request.POST:
form_edit_utilisateur = AdminEditUtilisateur(data=request.POST,
user=current_user,
instance=current_user)
if form_edit_utilisateur.is_valid():
form_edit_utilisateur.save()
if 'btn-admin-update-password' in request.POST:
form_change_password = ChangePassword(data=request.POST,
instance=current_user)
if form_change_password.is_valid():
form_change_password.save()
form_edit_utilisateur = AdminEditUtilisateur(data=request.POST,
user=current_user,
instance=current_user)
form_change_password = ChangePassword(data=request.POST,
instance=current_user)
query_form = QueryForm(request.GET or None)
if query_form.is_valid():
return HttpResponseRedirect(reverse('query'))
return render(
request, 'admin_qcpia/admin_edit_user_profile.html', {
'query_form': query_form,
'form_edit_utilisateur': form_edit_utilisateur,
'form_change_password': form_change_password,
'id_user': id
})
def details(request):
"""
function that return the json of a molecule
:param request: request environment variable
:param id: id of the json that we want to show
:return: html template
"""
query_form = QueryForm(request.GET or None)
site_url = settings.SITE_ROOT_URL
data_dir = settings.DATA_DIR_URL
return render(request, 'query_qcpia/details.html', {
'query_form': query_form,
'site_url': site_url,
'data_dir': data_dir
})
def account(request):
"""
controler of the template account that allow to edit the user profile
:param request: variable wich contains the value of the page
:return: template html
"""
if request.method == 'POST' and 'btn-register' in request.POST:
form_edit_utilisateur = EditUtilisateur(data=request.POST,
user=request.user,
instance=request.user)
if form_edit_utilisateur.is_valid():
form_edit_utilisateur.save()
else:
form_edit_utilisateur = EditUtilisateur(data=request.POST,
user=request.user)
query_form = QueryForm(request.GET or None)
if query_form.is_valid():
return HttpResponseRedirect(reverse('query'))
if request.method == 'POST' and 'btn-password' in request.POST:
form_edit_password = PasswordChangeForm(data=request.POST,
user=request.user)
if form_edit_password.is_valid():
user = form_edit_password.save()
update_session_auth_hash(request, user) # Important!
else:
form_edit_password = PasswordChangeForm(request.user)
query_form = QueryForm(request.GET or None)
if query_form.is_valid():
return HttpResponseRedirect(reverse('query'))
return render(
request, 'user_qcpia/account.html', {
'query_form': query_form,
'form_edit_password': form_edit_password,
'form_edit_utilisateur': form_edit_utilisateur
})
def import_view(request):
"""
controler of the template account that allow the user to import file
:param request: variable wich contains the value of the page
:return: template html
"""
path_prefix = 'media/'
number_of_stand_by_import = 0
query_form = QueryForm(request.GET or None)
if query_form.is_valid():
return HttpResponseRedirect(reverse('query'))
if request.user.is_authenticated:
number_of_stand_by_import = len(
list(
ImportFile.objects.filter(id_user=request.user.id).filter(
status="stand-by")))
if request.method == 'POST' and 'btn_upload' in request.POST:
if not request.FILES['file']:
myfile = request.POST.get('file')
else:
myfile = request.FILES['file'] # work for dropzone only
# todo add json transform
content = ContentFile(myfile.read())
#dirpath = tempfile.mkdtemp(prefix="/var/www/html/media/to_import/tmp/")
dirpath = tempfile.mkdtemp(
prefix=os.path.join(MEDIA_ROOT, "to_import/tmp/"))
filepath = os.path.join(dirpath, "file.log")
default_storage.save(filepath, content)
file_list, json_list = process_logfile(
filepath, log_storage_path=os.path.dirname(dirpath))
for i, json_file in enumerate(json_list):
temps = ImportFile.objects.create(
path_file=path_prefix,
log_path_file=path_prefix,
id_user=request.user) # register in database
file_log = open(file_list[i], 'r')
file_log_content = file_log.read()
file_log.close()
log_final_path = store_in_temp(id_calcul=str(temps.id_file),
file=file_log_content,
type='log')
final_path = store_in_temp(id_calcul=str(temps.id_file),
file=json_file,
type="json")
temps.path_file = final_path
temps.log_path_file = log_final_path
temps.save()
# adding an import for this day to the user*
if request.user.is_authenticated:
if request.user.last_date_upload != datetime.datetime.today().date() \
or request.user.last_date_upload is None:
request.user.last_date_upload = datetime.datetime.today()
request.user.number_of_upload_this_day = 1
request.user.save()
else:
request.user.number_of_upload_this_day += 1
request.user.save()
request.user.refresh_from_db()
else:
# user == anonymous
pass
code_return_pol = register_soft_job_type_and_version(
settings.BASE_DIR + settings.MEDIA_URL + final_path)
if code_return_pol == 0:
temps.status = "error can't define policy"
temps.save()
# we do nothing in case of 1 because it's define by default
elif 3 in code_return_pol:
os.remove(temps.path_file)
temps.status = "import not supported yet"
temps.save()
elif 2 in code_return_pol:
# automatic import
try:
path = "media/" + temps.path_file
update_status_in_db(result_of_import=import_file(
path=file_list[i],
json_file=json_file,
id_user=temps.id_user.id),
import_object=temps)
except Exception as error:
print(error)
temps.status = 'import failed'
temps.save()
shutil.rmtree(dirpath)
return render(
request, 'user_qcpia/user_import.html', {
'query_form': query_form,
'number_of_stand_by_import': number_of_stand_by_import
})
def list_of_all_user(request):
"""
controler of the template admin which list all registred user and allow to find one
:param request: variable wich contains the value of the page
:return: template html
"""
if not request.user.is_admin: # security to redirect user that aren't admin
return HttpResponseRedirect(reverse('accueil'))
query_form = QueryForm(request.GET or None)
page = request.GET.get('page', 1)
search_user_form = SearchUserForm(request.GET or None)
media = settings.MEDIA_URL
try:
# switch on what we are looking for
if 'ID' in request.GET.get('typeQuery'):
list_of_user = Utilisateur.objects.filter(
id=int(request.GET.get('search')))
elif 'first_name' in request.GET.get('typeQuery'):
list_of_user = Utilisateur.objects.filter(
first_name__icontains=request.GET.get('search'))
elif 'last_name' in request.GET.get('typeQuery'):
# here we looking for inchi wich contain a part of what we looking for
list_of_user = Utilisateur.objects.filter(
last_name__icontains=request.GET.get('search'))
elif 'affiliation' in request.GET.get('typeQuery'):
list_of_user = Utilisateur.objects.filter(
affiliation__icontains=request.GET.get('search'))
elif 'mail' in request.GET.get('typeQuery'):
list_of_user = Utilisateur.objects.filter(
email__icontains=request.GET.get('search'))
else:
list_of_user = Utilisateur.objects.all()
paginator = Paginator(list_of_user.order_by("id"), 10)
except Exception as error:
print(error)
print("error in database")
list_of_user = Utilisateur.objects.all()
paginator = Paginator(list_of_user.order_by("id"), 10)
try:
users = paginator.page(page)
except PageNotAnInteger:
users = paginator.page(1)
except EmptyPage:
users = paginator.page(paginator.num_pages)
if request.GET and 'button-search' in request.GET:
if query_form.is_valid():
return HttpResponseRedirect(reverse('query'))
return render(
request, 'admin_qcpia/admin_list_user.html', {
'query_form': query_form,
'users': users,
'search_user_form': search_user_form,
'media': media
})
def query(request):
"""
controler that make research on different condition
:param request: environment variable that contains arguement of the research
:return: template html with dictionnary of value to display
"""
query_form = QueryForm(request.GET or None)
results = None
try:
page = int(request.GET.get('page'))
except Exception as error:
print(error)
page = 1
try:
nbrpp = int(request.GET.get('nbrpp')) # nombre de résultat par page
except Exception as error:
print(error)
nbrpp = 10
try:
# switch on what we are looking for
if 'CID' in request.GET.get('typeQuery'):
results = search_cid(cid_value=request.GET.get('search'), nbrpp=nbrpp, page=page)
if 'IUPAC' in request.GET.get('typeQuery'):
results = search_iupac(iupac_value=request.GET.get('search'), nbrpp=nbrpp, page=page)
if 'InChi' in request.GET.get('typeQuery'):
# here we looking for inchi wich contain a part of what we looking for
results = search_inchi(inchi_value=request.GET.get('search'), nbrpp=nbrpp, page=page)
if 'Formula' in request.GET.get('typeQuery'):
results = search_formula(formula_value=request.GET.get('search'), nbrpp=nbrpp, page=page)
if 'SMILES' in request.GET.get('typeQuery'):
results = search_smiles(smiles_value=request.GET.get('search'), nbrpp=nbrpp, page=page)
if 'id_log' in request.GET.get('typeQuery'):
# if we want to access to an id we forward it to the details page as a parameter
url = build_url('details', get={'id': request.GET.get('search')})
return HttpResponseRedirect(url)
if 'id_user' in request.GET.get('typeQuery'):
results = search_id_user(id_user=request.GET.get('search'), nbrpp=nbrpp, page=page)
except Exception as error:
print("error :")
print(error)
# if we have only one result we display the details of the molecule
if results is None:
results = '{"nbresult":0}'
test_result = json.loads(results)
if test_result['nbresult'] == 0 or len(test_result) == 1:
results = '{}'
test_result = json.loads(results)
if len(test_result) == 2 and 'id_user' not in request.GET.get('typeQuery'):
# if we have only one result we forward it to the detail page
url = build_url('details', get={'id': str(test_result["0"][0]["id_log"])})
return HttpResponseRedirect(url)
return render(request, 'query_qcpia/query.html', {'results': test_result, 'query_form': query_form})