def excluir_requisito(request, requisito_id):
requisito = Requisito.objects.get(id=requisito_id)
if not dono_anuncio(request, requisito.anuncio):
return erro_autorizacao(
'detectada possível manipulação do ID do Requisito')
anuncio_id = requisito.anuncio_id
conectar_mongo().requisitos.delete_one(
{"_id": ObjectId(requisito.id_mongo)})
requisito.delete()
return redirect('requisito_index', anuncio_id)
def atualizar(request):
usuario_editado = preencher(request)
usuario_editado.id = request.session['usuario_id']
usuario_editado.save()
conectar_mongo().usuarios.update_one(
{"_id": ObjectId(request.session['usuario_mongo_id'])}, {
"$set": {
'nome': request.POST['nome'],
'descricao': request.POST['descricao']
}
})
return redirect('index')
def remover(request, pet_id):
pet = Pet.objects.get(id=pet_id)
conectar_mongo().pets.delete_one({"_id": ObjectId(pet.id_mongo)})
fotos = list(Foto.objects.filter(pet=pet))
for foto in fotos:
foto.delete()
visitas = list(Visita.objects.filter(pet=pet))
for visita in visitas:
visita.delete()
pet.delete()
return redirect('pets_index')
def excluir(request, anuncio_id):
try:
anuncio = AnuncioDoacao.objects.get(id=anuncio_id)
if not dono_anuncio(request, anuncio):
return erro_autorizacao(
'detectada possível manipulação do ID do Anúncio de Doação')
id_mongo = anuncio.id_mongo
anuncio.delete(
) # se der erro de integridade referencial, não excluir do MongoDB!!!
conectar_mongo().anuncios.delete_one({"_id": ObjectId(id_mongo)})
except ProtectedError:
messages.warning(request, 'Ainda há candidatos!')
return redirect('anuncio_index')
def atualizar_requisito(request):
requisito = Requisito.objects.get(id=request.POST['requisito_id'])
if not dono_anuncio(request, requisito.anuncio):
return erro_autorizacao(
'detectada possível manipulação do ID do Requisito')
requisito = preencher_requisito(requisito, request)
requisito.save()
conectar_mongo().requisitos.update_one(
{"_id": ObjectId(requisito.id_mongo)}, {
"$set": {
'titulo': request.POST['titulo'],
'descricao': request.POST['descricao']
}
})
return redirect('requisito_index', requisito.anuncio_id)
def atualizar(request):
if not dono_pet(request, 'pet_id'):
return erro_autorizacao('detectada possível manipulação do ID do Pet')
existente = AnuncioDoacao.objects.get(id=request.POST['anuncio_id'])
if not dono_anuncio(request, existente):
return erro_autorizacao(
'detectada possível manipulação do ID do Anúncio de Doação')
anuncio = preencher_anuncio(existente, request)
anuncio.save()
conectar_mongo().anuncios.update_one(
{"_id": ObjectId(anuncio.id_mongo)},
{"$set": {
'descricao': request.POST['descricao']
}})
return redirect('anuncio_index')
def criar(request):
# print(request.POST)
novo_post = preencher(request)
novo_post.save()
resultado = conectar_mongo().posts.insert_one({
'id_postgres':
novo_post.id,
#'id_usuario': request.session["usuario_id"],
'texto':
request.POST['texto']
})
novo_post.id_mongo = str(resultado.inserted_id)
novo_post.save()
marcados = set(request.POST.getlist('marcados'))
for marcado in marcados:
email = marcado.split('(')[1]
email = email[:len(email) - 1]
usuario = Usuario.objects.get(email=email)
marcadoNoPost = MarcadoNoPost()
marcadoNoPost.usuario_id = usuario.id
post = Post.objects.get(id_mongo=novo_post.id_mongo)
marcadoNoPost.post_id = post.id
marcadoNoPost.save()
return redirect('perfil')
def postsOutros(request, user_id):
if int(user_id) == int(request.session["usuario_id"]) or user_id == '':
user_id = request.session["usuario_id"]
owner = True
else:
owner = False
try:
posts = Post.objects.filter(usuario_id=user_id).order_by('-data_hora')
for post in posts:
texto_mongo = conectar_mongo().posts.find_one(
{"id_postgres": post.id})
if texto_mongo:
post.texto = texto_mongo['texto']
except Exception:
posts = []
for post in posts:
marcados = MarcadoNoPost.objects.filter(post_id=post.id)
post.marcados = []
for marcado in marcados:
pessoa = Usuario.objects.get(id=marcado.usuario_id)
aux = Tageados(pessoa.nome, pessoa.id)
post.marcados += [aux]
return render(request, 'lista_posts.html', {
"posts": posts,
"editavel": owner
})
def perfilOutros(request, user_id):
if int(user_id) == int(request.session["usuario_id"]) or user_id == '':
user_id = request.session["usuario_id"]
owner = True
else:
owner = False
usuario = Usuario.objects.get(id=user_id)
doc = conectar_mongo().usuarios.find_one(
{"_id": ObjectId(usuario.id_mongo)})
if doc:
descricao = doc['descricao']
else:
descricao = ''
try:
posts = Post.objects.filter(
usuario_id=user_id).order_by('-data_hora')[0:5]
for post in posts:
texto_mongo = conectar_mongo().posts.find_one(
{"id_postgres": post.id})
if texto_mongo:
post.texto = texto_mongo['texto']
except Exception:
posts = []
for post in posts:
marcados = MarcadoNoPost.objects.filter(post_id=post.id)
post.marcados = []
for marcado in marcados:
pessoa = Usuario.objects.get(id=marcado.usuario_id)
aux = Tageados(pessoa.nome, pessoa.id)
post.marcados += [aux]
pets = list(Pet.objects.filter(dono_id=usuario.id))
return render(
request, 'perfil.html', {
"usuario": usuario,
"descricao": descricao,
"posts": posts,
"editavel": owner,
"pets": pets
})
def atualizar(request):
pet = preencher(request)
pet.id = request.session["pet_id"]
pet.id_mongo = request.session['pet_mongo_id']
pet.save()
try:
fotos = request.FILES.getlist('arquivo')
fs = FileSystemStorage()
for arqv in fotos:
filename, file_extension = os.path.splitext(arqv.name)
filename = fs.save(
str(request.session['usuario_id']) + "_" + str(pet.id) +
file_extension, arqv)
foto = Foto()
foto.pet_id = pet.id
foto.arquivo = filename
foto.save()
except Exception:
e = sys.exc_info()
print("erro!")
print(e)
ficha = set(request.POST.getlist('chavevalor'))
ficha_texto = ''
for cada_campo in ficha:
ficha_texto += cada_campo + '; '
pets = conectar_mongo().pets
id_mongo = ObjectId(request.session['pet_mongo_id'])
conectar_mongo().pets.update_one({"_id": id_mongo}, {
"$set": {
'nome': request.POST['nome'],
'descricao': request.POST['descricao'],
'ficha': [],
'ficha_texto': ficha_texto
}
})
for cada_campo in ficha:
ChaveValor = cada_campo.split(":")
pets.update({'_id': id_mongo},
{'$push': {
'ficha': {
ChaveValor[0]: ChaveValor[1]
}
}})
return redirect('pets_index')
def editar(request, anuncio_id):
pets = Pet.objects.filter(dono_id=request.session['usuario_id'])
anuncio = AnuncioDoacao.objects.get(id=anuncio_id)
doc = conectar_mongo().anuncios.find_one(
{"_id": ObjectId(anuncio.id_mongo)})
return render(request, 'anuncios/editar.html', {
'pets': pets,
'anuncio': anuncio,
'descricao': doc['descricao']
})
def editar_requisito(request, requisito_id):
requisito = Requisito.objects.get(id=requisito_id)
doc = conectar_mongo().requisitos.find_one(
{"_id": ObjectId(requisito.id_mongo)})
return render(
request, 'requisitos/editar.html', {
'anuncio_id': requisito.anuncio_id,
'requisito': requisito,
'descricao': doc['descricao']
})
def index(request):
if (request.session['tipo'] == "pf"):
usuario = PF.objects.get(id=request.session["usuario_id"])
else:
usuario = PJ.objects.get(id=request.session["usuario_id"])
doc = conectar_mongo().usuarios.find_one(
{"_id": ObjectId(request.session['usuario_mongo_id'])})
if doc:
descricao = doc['descricao']
else:
descricao = ''
posts = Post.objects.all().order_by('-data_hora')[0:20]
for post in posts:
try:
post.autor = Usuario.objects.get(id=post.usuario_id).nome
except Exception:
post.autor = Usuario.objects.get(id=post.usuario_id).email
marcados = MarcadoNoPost.objects.filter(post_id=post.id)
post.marcados = []
for marcado in marcados:
pessoa = Usuario.objects.get(id=marcado.usuario_id)
aux = Tageados(pessoa.nome, pessoa.id)
post.marcados += [aux]
try:
texto_mongo = conectar_mongo().posts.find_one(
{"id_postgres": post.id})
if texto_mongo:
post.texto = texto_mongo['texto']
except Exception:
pass
return render(request, 'index.html', {
"usuario": usuario,
"descricao": descricao,
"posts": posts
})
def editar(request, pet_id):
pet = Pet.objects.get(id=pet_id)
mongo_pet = conectar_mongo().pets.find_one({"_id": ObjectId(pet.id_mongo)})
pet.descricao = mongo_pet["descricao"]
request.session['pet_mongo_id'] = pet.id_mongo
request.session['pet_id'] = pet.id
fotos = Foto.objects.filter(pet_id=pet.id)
return render(request, 'editar_pet.html', {
"pet": pet,
"fotos": fotos,
'ficha': mongo_pet["ficha"]
})
def criar(request):
novo_usuario = preencher(request)
novo_usuario.save()
db = conectar_mongo()
sitedb = db.usuarios
resultado = sitedb.insert_one({
'id_postgres': novo_usuario.id,
'nome': novo_usuario.nome,
'descricao': request.POST['descricao']
})
novo_usuario.id_mongo = str(resultado.inserted_id)
novo_usuario.save()
set_session(request, novo_usuario)
return redirect('index')
def criar(request):
if not dono_pet(request, 'pet_id'):
return erro_autorizacao('detectada possível manipulação do ID do Pet')
novo_anuncio = preencher_anuncio(AnuncioDoacao(), request)
novo_anuncio.save()
resultado = conectar_mongo().anuncios.insert_one({
'id_postgres':
novo_anuncio.id,
'descricao':
request.POST['descricao']
})
novo_anuncio.id_mongo = str(resultado.inserted_id)
novo_anuncio.save()
return redirect('requisito_index', novo_anuncio.id)
def atualizar(request):
# print(request.POST)
existente = Post.objects.get(id=request.POST['post_id'])
existente.titulo = request.POST['titulo']
conectar_mongo().posts.update_one(
{"_id": ObjectId(existente.id_mongo)},
{"$set": {
'texto': request.POST['texto']
}})
try:
myFile = request.FILES['arquivo']
fs = FileSystemStorage()
filename, file_extension = os.path.splitext(myFile.name)
filename = fs.save(
str(request.session['usuario_id']) + file_extension, myFile)
fs.delete(existente.arquivo)
existente.arquivo = filename
if (request.POST['fileType'] == 'vid'):
existente.video = True
except Exception:
pass
existente.save()
marcados = request.POST.getlist('marcados')
MarcadoNoPost.objects.filter(post_id=existente.id).delete()
for marcado in marcados:
email = marcado.split('(')[1]
email = email[:len(email) - 1]
# print(email)
usuario = Usuario.objects.get(email=email)
marcadoNoPost = MarcadoNoPost()
marcadoNoPost.usuario_id = usuario.id
marcadoNoPost.post_id = existente.id
marcadoNoPost.save()
return redirect('perfil')
def perfil(request, pet_id):
pet = Pet.objects.get(id=pet_id)
dono = Usuario.objects.get(id=pet.dono_id)
mongo_pet = conectar_mongo().pets.find_one({"_id": ObjectId(pet.id_mongo)})
pet.descricao = mongo_pet["descricao"]
fotos = Foto.objects.filter(pet_id=pet.id)
for chave, valor in mongo_pet["ficha"][0].items():
print(chave)
print(valor)
return render(request, 'perfil_pet.html', {
"pet": pet,
"dono": dono,
"fotos": fotos,
"ficha": mongo_pet["ficha"]
})
def editar(request):
if (request.session['tipo'] == "pf"):
usuario = PF.objects.get(id=request.session["usuario_id"])
else:
usuario = PJ.objects.get(id=request.session["usuario_id"])
doc = conectar_mongo().usuarios.find_one(
{"_id": ObjectId(request.session['usuario_mongo_id'])})
if doc:
descricao = doc['descricao']
else:
descricao = ''
return render(request, 'editar.html', {
"usuario": usuario,
"descricao": descricao
})
def criar(request):
novo_pet = preencher(request)
novo_pet.save()
ficha = set(request.POST.getlist('chavevalor'))
try:
fotos = request.FILES.getlist('arquivo')
fs = FileSystemStorage()
for arqv in fotos:
filename, file_extension = os.path.splitext(arqv.name)
filename = fs.save(
str(request.session['usuario_id']) + "_" + str(novo_pet.id) +
file_extension, arqv)
foto = Foto()
foto.pet_id = novo_pet.id
foto.arquivo = filename
foto.save()
except Exception:
e = sys.exc_info()
print("erro!")
print(e)
ficha_texto = ''
for cada_campo in ficha:
ficha_texto += cada_campo + '; '
pets = conectar_mongo().pets
resultado = pets.insert_one({
'id_postgres': novo_pet.id,
'nome': novo_pet.nome,
'descricao': request.POST['descricao'],
'ficha': [],
'ficha_texto': ficha_texto
})
for cada_campo in ficha:
ChaveValor = cada_campo.split(":")
pets.update({'_id': resultado.inserted_id},
{'$push': {
'ficha': {
ChaveValor[0]: ChaveValor[1]
}
}})
novo_pet.id_mongo = str(resultado.inserted_id)
novo_pet.save()
return redirect('pets_index')
def editarId(request, post_id):
post = Post.objects.get(id=post_id)
if post.usuario_id != request.session['usuario_id']:
return erro_autorizacao(
'Você não tem permissão para editar este post!')
post.texto = conectar_mongo().posts.find_one({"id_postgres":
post.id})['texto']
marcados = MarcadoNoPost.objects.filter(post_id=post.id)
post.marcados = []
for marcado in marcados:
pessoa = Usuario.objects.get(id=marcado.usuario_id)
aux = Tageados(pessoa.nome + " (" + pessoa.email + ")", pessoa.id)
post.marcados += [aux]
#print(post.marcados)
return render(request, 'editar_post.html', {'post': post})
def criar_requisito(request):
if not dono_anuncio2(request, 'anuncio_id'):
return erro_autorizacao(
'detectada possível manipulação do ID do Anúncio de Doação')
novo_req = preencher_requisito(Requisito(), request)
novo_req.anuncio_id = request.POST['anuncio_id']
novo_req.save()
resultado = conectar_mongo().requisitos.insert_one({
'id_postgres':
novo_req.id,
'id_anuncio_postgres':
novo_req.anuncio_id,
'titulo':
request.POST['titulo'],
'descricao':
request.POST['descricao']
})
novo_req.id_mongo = str(resultado.inserted_id)
novo_req.save()
# status de requisito para todos os processos são inseridos automaticamente via trigger
return redirect('requisito_index', novo_req.anuncio_id)
def visualizar(request, anuncio_id):
anuncio = AnuncioDoacao.objects.get(id=anuncio_id)
mongo = conectar_mongo()
doc = mongo.anuncios.find_one({"_id": ObjectId(anuncio.id_mongo)})
requisitos = Requisito.objects.filter(anuncio_id=anuncio_id)
reqs_mongo = mongo.requisitos.find({'id_anuncio_postgres': anuncio_id})
descricoes_reqs = {}
for r in reqs_mongo:
descricoes_reqs[r['id_postgres']] = r['descricao']
status_requisitos = StatusRequisito.objects.filter(
anuncio_id=anuncio_id, candidato_id=request.session['usuario_id'])
status = {}
for s in status_requisitos:
status[s.titulo] = s.status
return render(
request, 'anuncios/visualizar.html', {
'anuncio': anuncio,
'descricao': doc['descricao'],
'requisitos': requisitos,
'descricoes_reqs': descricoes_reqs,
'status': status
})
def busca(request):
busca_dic = {"$text": {"$search": request.GET['q']}}
mongo = conectar_mongo()
busca_pets = mongo.pets.find(busca_dic)
ids_pets = []
for p in busca_pets:
ids_pets.append(p['id_postgres'])
busca_anuncios = mongo.anuncios.find(busca_dic)
ids_anuncios = []
for a in busca_anuncios:
ids_anuncios.append(a['id_postgres'])
busca_requisitos = mongo.requisitos.find(busca_dic)
for r in busca_requisitos:
ids_anuncios.append(r['id_anuncio_postgres'])
anuncios = AnuncioDoacao.objects.filter(
Q(pet_id__in=ids_pets) | Q(id__in=ids_anuncios),
data_termino__gte=datetime.date(
datetime.now())).exclude(status='Finalizado')
return render(request, 'anuncios/resultados_busca.html',
{'anuncios': anuncios})
