def editUserPass(request, utilisateur):
if request.user.is_superuser == 1 or request.user.username == utilisateur:
if request.POST:
global password_cur, user
global is_error
password_new = request.POST["password_new"]
password_conf = request.POST["password_conf"]
is_error = 0
if password_new != password_conf:
error_password_new = "Les deux mot de passe ne sont pas identiques"
return render(request, 'edit_user_password.html', locals())
else:
try:
user = User.objects.filter(username=utilisateur)[0]
except:
is_error = 1
if is_error == 0:
if request.user.is_superuser == 1:
try:
#utilisateur=Utilisateur.objects.filter(idUtilisateur=idUtilisateur)[0]
user = User.objects.filter(username=utilisateur)[0]
user.set_password(password_new)
user.save()
except:
is_error = 1
if is_error == 0:
log = Log()
log.utilisateur = request.user.username
log.action = "Modification mot de passe utilisateur " + user.username
log.save()
return redirect(listeUsers)
else:
password_cur = request.POST["password_cur"]
if user.check_password(password_cur):
user.set_password(password_new)
user.save()
log = Log()
log.utilisateur = request.user.username
log.action = "Modification mot de passe utilisateur " + user.username
log.save()
return redirect(logoutview)
else:
errer_password = "******"
return render(request, 'edit_user_password.html',
locals())
else:
return render(request, 'edit_user_password.html', locals())
def deleteUserPost(request):
global personne
if request.user.is_superuser:
is_error = 0
try:
idUtilisateur = request.POST["idUtilisateur"]
utilisateur = Utilisateur.objects.filter(
idUtilisateur=idUtilisateur)[0]
personne = Personne.objects.filter(utilisateur=utilisateur)[0]
personne.estSupprimer = 1
personne.save()
log = Log()
log.utilisateur = request.user.username
log.action = "Suppression utilisateur " + utilisateur.user.username
log.save()
except:
is_error = 1
if is_error == 0:
#return redirect(listeUsers)
message = u"Utilisateur " + decodeString(
personne.nomPersonne) + " " + decodeString(
personne.prenomPersonne) + u" supprimé avec succès"
else:
message = "error"
return HttpResponse(message)
def login(request):
'''登陆视图'''
template_var = {}
form = LoginForm()
if request.method == 'POST':
form = LoginForm(request.POST.copy())
if form.is_valid():
ret = False
ret = _login(request, form.cleaned_data["username"],
form.cleaned_data["password"])
if ret:
# 获取登录IP
RemoteIp = request.META.get('REMOTE_ADDR')
Log(username=request.user.username,
content="execute login user:"******" ip:" + RemoteIp + " success!",
level=1).save()
if request.user.userprofile.user_type == 3: # 超级管理员
return render_to_response(
"common/index.html",
{'account_usertype_dict': account_usertype_dict},
context_instance=RequestContext(request))
else: # 其他人员
retdir = {}
retdir['base_type'] = 0
hotspots = Hotspot.objects.order_by('-level')[:10]
retdir['hotspots'] = hotspots
retdir['account_usertype_dict'] = account_usertype_dict
return render_to_response(
'tender/index.html',
retdir,
context_instance=RequestContext(request))
else:
vardict = {"message": "登录失败！"}
Log(username=form.cleaned_data["username"],
content="execute login user error!",
level=1).save()
return render_to_response(
"account/login.html",
vardict,
context_instance=RequestContext(request))
template_var["form"] = form
return render_to_response("account/login.html",
template_var,
context_instance=RequestContext(request))
def answer(request):
question = request.POST.get('question')
answer = request.POST.get('answer')
question = get_object_or_404(UserAnswer, id = question)
answer = get_object_or_404(Alternative, id = answer)
log_action = "finish"
insert_log = False
userquest = question.user_quest
if not UserAnswer.objects.filter(user_quest = userquest, answer__isnull = False).exists():
insert_log = True
log_action = "start"
question.answer = answer
question.is_correct = answer.is_correct
question.save()
userquest.last_update = datetime.now()
userquest.save()
#add request context to log
questionary_data = userquest.questionary
request.log_context = {}
request.log_context["question_id"] = userquest.questionary.id
request.log_context["is_correct"] = question.is_correct
request.log_context["time_to_answer"] = (question.created_at - question.question.created_at).total_seconds()
request.log_context["subject_id"] = questionary_data.topic.subject.id
request.log_context["category_id"] = questionary_data.topic.subject.category.id
request.log_context["topic_id"] = questionary_data.topic.id
request.log_context["topic_slug"] = questionary_data.topic.slug
request.log_context["topic_name"] = questionary_data.topic.name
if not UserAnswer.objects.filter(user_quest = userquest, answer__isnull = True).exists() or insert_log:
log = Log()
log.user = str(request.user)
log.user_id = request.user.id
log.user_email = request.user.email
log.component = "resources"
log.action = log_action
log.resource = "questionary"
log.context = {}
log.context["subject_id"] = questionary_data.topic.subject.id
log.context["category_id"] = questionary_data.topic.subject.category.id
log.context["topic_id"] = questionary_data.topic.id
log.context["topic_slug"] = questionary_data.topic.slug
log.context["topic_name"] = questionary_data.topic.name
log.context['questionary_id'] = questionary_data.id
log.context['questionary_name'] = questionary_data.name
log.context['questionary_slug'] = questionary_data.slug
log.save()
return JsonResponse({'last_update': formats.date_format(userquest.last_update, "SHORT_DATETIME_FORMAT"), 'answered': userquest.useranswer_userquest.filter(answer__isnull = False).count()})
def creerCategorie(request,idEntite):
global myfile
if request.user.is_authenticated() and request.user.is_superuser:
is_error = 0
try:
entite = Entite.objects.filter(idEntit=idEntite)[0]
except:
is_error = 1
if is_error == 0:
listeImage=Image.objects.filter(estSupprimer=0,type=2)
if request.POST:
libelle=request.POST["libelle"]
descript=request.POST["descript"]
libelle=request.POST["libelle"]
image=int(request.POST["image"])
if libelle=="":
is_error=1
error_libelle="veuillez remplier ce champs"
if descript=="":
is_error=1
error_descript="veuillez remplier ce champs"
save_plus = request.POST.getlist('save_and')
if image==0:
is_error=1
error_logo = "veuillez selectionner une image"
if is_error==0:
ima = Image.objects.filter(idImage=image)[0]
categorie=Categorie()
categorie.logoCat=ima
categorie.createurCat=request.user
categorie.entite=entite
categorie.libelleCat=libelle
categorie.descriptionCat=descript
categorie.save()
#entite.logoEntite="images/uploads/"+nom+"/"+logo_name
log = Log()
log.utilisateur = request.user.username
log.action = u"Création catégorie pour entité " + entite.nomEntite
log.save()
messages.success(request, u'Catégorie ajoutée avec succès')
try:
_next = int(save_plus[0])
except:
_next = 0
if _next == 0:
return redirect(listeCategorie,idEntite)
else:
libelle = ""
descript=""
return render(request, 'nouveau_categorie.html', locals())
else:
return render(request, 'nouveau_categorie.html', locals())
else:
return render(request, 'nouveau_categorie.html', locals())
else:
message = "page introuvable"
return render(request, '404.html', locals())
def editerLivreur(request,idLivreur):
global var, livreur
if request.user.is_authenticated():
user_connecter = request.user
if request.user.is_active:
if request.user.is_staff:
is_error = 0
try:
livreur = Livreur.objects.filter(idLivreur=idLivreur)[0]
except:
is_error = 1
if is_error == 0:
if request.POST:
is_error = 0
nom = request.POST["nom"]
prenom = request.POST["prenom"]
numero = request.POST["numero"]
if nom == "":
errer_nom = "veuiller remplir ce champs"
is_error = 1
if prenom == "":
errer_prenom= "veuiller remplir ce champs"
is_error = 1
if numero == "":
errer_numero= "veuiller remplir ce champs"
is_error = 1
else:
if re.search(r"^[0-9]{9}$", numero) is None:
is_error = 1
errer_numero = "numero incorrect"
if is_error == 0:
personne=livreur.personne
personne.nomPersonne=nom
personne.prenomPersonne=prenom
personne.numeroPersonne=numero
personne.save()
livreur.save()
listeLivreur = Livreur.objects.all()
log = Log()
log.utilisateur = request.user.username
log.action = "modification livreur " + livreur.personne.nomPersonne +" "+ livreur.personne.prenomPersonne
log.save()
messages.success(request, 'livreur modifié avec succès')
return render(request, 'liste_livreur.html', locals())
else:
return render(request, 'create_livreur.html', locals())
else:
nom = livreur.personne.nomPersonne
prenom = livreur.personne.prenomPersonne
numero = livreur.personne.numeroPersonne
return render(request, 'editer_livreur.html', locals())
else:
message = "page introuvable"
return render(request, '404.html', locals())
def togglepembayaran(request, peminjaman_id=0):
if request.method == 'POST':
# Berusaha mendapat model peminjam yang ingin diubah data pembayarannya
try:
selected_peminjaman = Peminjaman.objects.get(id=peminjaman_id)
except Exception as e:
return JsonResponse({'result': ""})
if selected_peminjaman.jumlah_tagihan > 0:
if selected_peminjaman.waktu_bayar:
selected_peminjaman.waktu_bayar = None
selected_peminjaman.save()
new_log = Log(
peminjaman=selected_peminjaman,
peminjaman_str=selected_peminjaman.__str__(),
tanggal=date.today(),
deskripsi="Ubah status pembayaran ke 'Belum Lunas'",
aksi="Ubah")
new_log.save()
return JsonResponse({'result': "Belum Lunas"})
else:
selected_peminjaman.waktu_bayar = date.today().strftime(
"%Y-%m-%d")
selected_peminjaman.save()
new_log = Log(
peminjaman=selected_peminjaman,
peminjaman_str=selected_peminjaman.__str__(),
tanggal=date.today(),
deskripsi="Ubah status pembayaran ke 'Lunas pada " +
selected_peminjaman.waktu_bayar.__str__() + "'",
aksi="Ubah")
new_log.save()
return JsonResponse(
{'result': selected_peminjaman.waktu_bayar})
else:
return JsonResponse({'result': selected_peminjaman.waktu_bayar})
return JsonResponse({'result': 'Nope'})
def editerCategorie(request,idCategorie):
global myfile
if request.user.is_authenticated() and request.user.is_superuser:
is_error = 0
is_image_change = 0
try:
categorie = Categorie.objects.filter(idCategorie=idCategorie)[0]
except:
is_error = 1
if is_error == 0:
listeImage = Image.objects.filter(estSupprimer=0, type=2)
if request.POST:
libelle=request.POST["libelle"]
descript=request.POST["descript"]
libelle=request.POST["libelle"]
image = int(request.POST["image"])
if libelle=="":
is_error=1
error_libelle="veuillez remplier ce champs"
if descript=="":
is_error=1
error_descript="veuillez remplier ce champs"
save_plus = request.POST.getlist('save_and')
if image!=0:
is_image_change = 1
if is_error==0:
entite=Entite.objects.filter(categorie=categorie)[0]
if is_image_change==1:
ima = Image.objects.filter(idImage=image)[0]
categorie.logoCat=ima
categorie.modificateurCat=request.user
categorie.libelleCat=libelle
categorie.descriptionCat=descript
categorie.estModifier=categorie.estModifier+1
categorie.save()
log = Log()
log.utilisateur = request.user.username
log.action = u"modification catégorie pour entité " + entite.nomEntite
log.save()
messages.success(request, u'Catégorie modifiée avec succès')
libelle = ""
descript=""
return redirect(listeCategorie,entite.idEntit)
else:
return render(request, 'editer_categorie.html', locals())
else:
entite=Entite.objects.filter(categorie=categorie)[0]
libelle=categorie.libelleCat
descript=categorie.descriptionCat
return render(request, 'editer_categorie.html', locals())
else:
message = "page introuvable"
return render(request, '404.html', locals())
def process_view(self, request, view_func, view_args, view_kwargs):
path = request.path
method = request.method
client_ip = request.META['REMOTE_ADDR']
if method == 'GET':
query = request.GET.urlencode()
elif method == 'POST':
query = request.POST.copy().urlencode()
else:
query = ''
Log(path=path, method=method, client_ip=client_ip, query=query).save()
return None
def log_write(request, user, operation_type, target_type, detail_type, item_id,
item_name, memo):
_log = Log()
_log.user = user
_log.operation_type = operation_type
_log.target_type = target_type
_log.detail_type = detail_type
_log.item_id = item_id
_log.item_name = item_name
_log.ip = GetRemoteIpAddress(request)
_log.request_url = request.get_full_path()
_log.memo = memo
_log.save()
return _log.id
def api_create_log_view(request):
u = User.objects.get(ident=2222)
logs = Log(who=u)
if request.method=="POST":
my_data=request.data.copy()
ids=request.data.__getitem__('who')
try: what=Log.objects.filter(who=ids).order_by('when_in').reverse()[0].what
except: what=False
if what == False: what=True
else: what=False
my_data.__setitem__('what', what )
serializer = LogSerializer(logs, data=my_data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.data,serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def do(self):
set_notifications()
admins = User.objects.filter(is_staff=True)
if admins.count() > 0:
admin = admins[0]
log = Log(component="notifications",
action="cron",
resource="notifications",
user=str(admin),
user_id=admin.id,
user_email=admin.email,
context={})
log.save()
def formdelete(request, peminjaman_id=0, errormsg=''):
try:
object_peminjaman = Peminjaman.objects.get(id=peminjaman_id)
new_log = Log(peminjaman=None,
peminjaman_str=object_peminjaman.__str__(),
tanggal=date.today(),
deskripsi="",
aksi="Hapus")
new_log.save()
if object_peminjaman.foto:
object_peminjaman.foto.delete()
object_peminjaman.delete()
except Peminjaman.DoesNotExist:
pass
return redirect(reverse('peminjaman:index'))
def activerProduit(request,idProduit):
if request.user.is_authenticated():
if request.user.is_superuser or request.user.utilisateur.isManager==0 :
is_error=0
try:
produit = Produit.objects.filter(idProduit=idProduit)[0]
except:
is_error=1
if is_error==0:
produit.estDesactiver=0
produit.save()
log = Log()
log.utilisateur = request.user.username
log.action = u"activation produit pour entité " + produit.categorie.entite.nomEntite
log.save()
messages.success(request, u'Produit activé avec succès')
return redirect(listeProduit, produit.categorie.entite.idEntit, 0)
message = "page introuvable"
return render(request, '404.html', locals())
def test_log_list(self):
""" Test the list view for the Log admin """
self.client.login(username=self.user.username, password='******')
list_url = self._admin_url(Log)
add_url = self._admin_url(Log, Log())
eq_(list_url, '/admin/log/log/')
res = self.client.get(list_url)
self.assertContains(res, '4 logs')
self.assertContains(res, add_url)
log = LogFactory(user=self.user)
log.save()
change_url = self._admin_url(Log, log)
res = self.client.get(list_url)
self.assertContains(res, '5 logs')
self.assertContains(res, change_url)
self.assertContains(res, add_url)
def insertreq(self):
url = self.host + "wulogser.php?dir=req"
r = rq.get(url)
print(r.text)
jsonr = r.json()
print(jsonr)
attack = Attack()
for key in jsonr:
jlog = json.loads(jsonr[key])
ip = jlog['ip']
time = datetime.strptime(jlog['time'], "%Y-%m-%d %H:%M:%S")
method = jlog['method'].lower()
attack_type = []
if jlog['post']:
for p in jlog['post']:
kind = attack.is_attack(jlog['post'][p])
if kind:
attack_type.append(kind)
if jlog['get']:
for g in jlog['get']:
print("here")
kind = attack.is_attack(jlog['get'][g])
if kind:
attack_type.append(kind)
if jlog['file']:
for g in jlog['file']:
# print(g)
try:
kind = attack.is_attack(base64.b64decode(g['content']).decode())
if kind:
attack_type.append(kind)
except Exception as e:
print(e)
print('file is binary')
log = Log(attackip=ip, attacktime=time, method=method, path=jlog['path'], headers=jlog['headers'],
post=jlog['post'], get=jlog['get'], uid=jlog['uid'], file=jlog['file'], attacktype=str(attack_type))
log.save()
self.stdout.write(self.style.SUCCESS('Successfully insert log "%s" attack type: %s' % (ip, str(attack_type))))
def deleteUser(request, idUtilisateur):
if request.user.is_superuser:
is_error = 0
try:
utilisateur = Utilisateur.objects.filter(
idUtilisateur=idUtilisateur)[0]
personne = Personne.objects.filter(utilisateur=utilisateur)[0]
personne.estSupprimer = 1
personne.save()
log = Log()
log.utilisateur = request.user.username
log.action = "Suppression utilisateur " + utilisateur.user.username
log.save()
except:
is_error = 1
if is_error == 0:
return redirect(listeUsers)
else:
message = "page introuvable"
return render(request, '404.html', locals())
def enableUser(request, idUtilisateur):
if request.user.is_superuser:
is_error = 0
try:
utilisateur = Utilisateur.objects.filter(
idUtilisateur=idUtilisateur)[0]
user = User.objects.filter(utilisateur=utilisateur)[0]
user.is_active = 1
user.save()
log = Log()
log.utilisateur = request.user.username
log.action = "Activation utilisateur " + user.username
log.save()
except:
is_error = 1
if is_error == 0:
return redirect(listeUsers)
else:
message = "page introuvable"
return render(request, '404.html', locals())
def activerCategorie(request,idCategorie):
global myfile
if request.user.is_authenticated() and request.user.is_superuser:
is_error = 0
try:
categorie = Categorie.objects.filter(idCategorie=idCategorie)[0]
except:
is_error = 1
if is_error == 0:
categorie.estDesactiver=0
categorie.save()
log = Log()
log.utilisateur = request.user.username
log.action = u"activation catégorie pour entité " + categorie.entite.nomEntite
log.save()
messages.success(request, u'Catégorie activée avec succès')
return redirect(listeCategorie, categorie.entite.idEntit)
else:
message = "page introuvable"
return render(request, '404.html', locals())
def showOnMapRestaurant(request):
global message, restaurant
if request.user.is_authenticated():
if request.user.is_superuser :
idRestaurant = request.POST["idRestaurant"]
is_error = 0
try:
restaurant = Restaurant.objects.filter(idRestaurant=idRestaurant)[0]
except:
is_error = 1
if is_error == 0:
restaurant.estSupprimer = 1
restaurant.save()
log = Log()
log.utilisateur = request.user.username
log.action = u"suppréssion du restaurant " + decodeString(restaurant.entite.nomEntite)
log.save()
message = u"Restaurant supprimé avec succès"
else:
message = "error"
return HttpResponse(message)
def activerFormule(request, idFormule):
if request.user.is_authenticated():
if request.user.is_superuser or request.user.utilisateur.isManager == 0:
is_error = 0
try:
forlmule = Formule.objects.filter(idFormule=idFormule)[0]
except:
is_error = 1
if is_error == 0:
forlmule.estDesactiver = 0
forlmule.save()
log = Log()
log.utilisateur = request.user.username
log.action = u"Activation formule pour entité " + decodeString(
forlmule.entite.nomEntite)
log.save()
messages.success(request, u'formule activée avec succès')
return redirect(listeFormule, forlmule.entite.idEntit)
else:
message = "page introuvable"
return render(request, '404.html', locals())
def selecteddelete(request):
ids = request.POST.get('ids', None)
if ids:
users = User.objects.extra(where=['id IN (' + ids + ')'])
for user in users:
if request.user.username == user.username:
return HttpResponse(simplejson.dumps({
"statusCode":
302,
"navTabId":
request.POST.get('navTabId', 'accountindex'),
"callbackType":
request.POST.get('callbackType', None),
"message":
u'选中的用户组中包含自己不能批量删除'
}),
mimetype='application/json')
Log(username=request.user.username,
content="execute selecteddelete user:"******" success!",
level=1).save()
users.delete()
return HttpResponse(simplejson.dumps({
"status":
1,
"statusCode":
200,
"navTabId":
request.POST.get('navTabId', 'accountindex'),
"callbackType":
request.POST.get('callbackType', None),
"message":
u'删除成功',
"info":
u'删除成功',
"result":
u'删除成功'
}),
mimetype='application/json')
def save():
if not line_id:
return
s = '\n'.join(lines)
print([s])
row = Log()
row.jenis_id = jenis_id
row.line = s
row.line_id = line_id
row.tgl = waktu
row.kategori_id = KATEGORI.index(kategori)
DBSession.add(row)
try:
DBSession.flush()
except IntegrityError as err:
s_err = str(err)
if s_err.find(duplicate_key_message) > -1:
print(' sudah ada')
DBSession.rollback()
else:
raise (err)
DBSession.commit()
def logout(request):
username = request.user.username
user_type = request.user.userprofile.user_type
'''注销视图'''
auth_logout(request)
Log(username=username, content="execute logout user success!",
level=1).save()
if user_type == 3: # 超级管理员
return render_to_response("account/login.html", {},
context_instance=RequestContext(request))
else: # 其他人员
retdir = {}
retdir['base_type'] = 0
hotspots = Hotspot.objects.order_by('-level')[:10]
retdir['hotspots'] = hotspots
# HttpResponseRedirect（）只有一个参数，就是要转向的web page，
# 要带参数的话还是用render_to_response(“****.html”, {"web_page_variable":parameters})
# 或者用get传 递参数
#return HttpResponseRedirect('/tender/')
return render_to_response('tender/index.html',
retdir,
context_instance=RequestContext(request))
def acounts(request):
ip = get_ip(request)
acounts = SSAcount.objects.order_by('ping')
if len(acounts) > 0:
acount = acounts[0]
if acount.server_aes == '':
aes = base64.encodestring(acount.server)
aes = aes.replace('\n', '').replace(' ', '')
acount.server_aes = aes
acount.save()
t = datetime.now().strftime('%m-%d-%y %H:%M:%S')
output = (
'{ "local_port": %s, "method": "%s", "password": "******", "server": "%s", "server_aes": "%s", "server_port": "%s" , "time": "%s"}'
% (1080, acount.method, acount.password, acount.server,
acount.server_aes, acount.server_port, t))
#log it
l = Log(retserver=acount.server, clinetip=ip, time=datetime.now())
l.save()
return HttpResponse(output)
else:
return HttpResponse('Error,No Data')
def process_request(self, request):
if not request.user.is_authenticated():
return
now = datetime.now()
if '_session_security' not in request.session:
return
delta = now - get_last_activity(request.session)
expire_seconds = EXPIRE_AFTER
if delta >= timedelta(seconds=expire_seconds):
log = Log()
log.user = str(request.user)
log.user_id = request.user.id
log.user_email = request.user.email
log.context = {'condition': 'session_expire'}
log.component = "user"
log.action = "logout"
log.resource = "system"
log.save()
users = User.objects.all().exclude(email=request.user.email)
notification = {
"type": "user_status",
"user_id": str(request.user.id),
"status": _u("Offline"),
"status_class": "",
"remove_class": "away"
}
notification = json.dumps(notification)
for u in users:
Group("user-%s" % u.id).send({'text': notification})
def desactiverRestaurant(request,idRestaurant):
global myfile, restaurant
if request.user.is_authenticated():
if request.user.is_superuser :
global ckeck
try:
restaurant=Restaurant.objects.filter(idRestaurant=idRestaurant)[0]
check=1
except:
check=0
if check ==1:
restaurant.estDesactiver=1
restaurant.save()
log = Log()
log.utilisateur = request.user.username
log.action = u"Désactivation restaurant " + decodeString(restaurant.nomRestaurant) + " pour l'entite " + decodeString(
restaurant.entite.nomEntite)
log.save()
messages.success(request, 'Restaurant désactivé avec succès')
return redirect(profilEntite, restaurant.entite.idEntit)
else:
message = "page introuvable"
return render(request, '404.html', locals())
def add(request):
if request.POST:
username = request.POST.get('username', None)
content = request.POST.get('content', None)
level = request.POST.get('level', None)
log = Log(username=username, content=content, level=level)
log.save()
return HttpResponse(simplejson.dumps({
"statusCode":
200,
"navTabId":
request.POST.get('navTabId', 'logindex'),
"callbackType":
request.POST.get('callbackType', 'closeCurrent'),
"message":
u'添加成功'
}),
mimetype='application/json')
else:
# 弹出新建窗口
return render_to_response('log/add.html',
{'log_level_dict': log_level_dict})
def supprimerLivreur(request,idLivreur):
global var, livreur
if request.user.is_authenticated():
user_connecter = request.user
if request.user.is_active:
if request.user.is_staff:
is_error = 0
try:
livreur = Livreur.objects.filter(idLivreur=idLivreur)[0]
except:
is_error = 1
if is_error == 0:
livreur.estSupprimer=1
livreur.save()
log = Log()
log.utilisateur = request.user.username
log.action = "Activation livreur " + livreur.personne.nomPersonne + " " + livreur.personne.prenomPersonne
log.save()
messages.success(request, 'livreur supprimé avec succès')
return redirect(listeLivreur)
else:
message = "page introuvable"
return render(request, '404.html', locals())
def delete(request, id):
user = User.objects.get(id=id)
if request.user.is_authenticated():
if request.user.username == user.username:
return HttpResponse(simplejson.dumps({
"statusCode":
302,
"navTabId":
request.POST.get('navTabId', 'accountindex'),
"callbackType":
request.POST.get('callbackType', None),
"message":
u'不能删除自己'
}),
mimetype='application/json')
else:
Log(username=request.user.username,
content="execute delete user:"******" success!",
level=1).save()
user.delete()
return HttpResponse(simplejson.dumps({
"status":
1,
"statusCode":
200,
"navTabId":
request.POST.get('navTabId', 'accountindex'),
"callbackType":
request.POST.get('callbackType', None),
"message":
u'删除成功',
"info":
u'删除成功',
"result":
u'删除成功'
}),
mimetype='application/json')
