def recommended_peripheral_items(request):
if request.method == 'GET':
form = UserForm(request.GET, request.FILES)
if form.is_valid():
id_user = form.cleaned_data['id']
user = get_object_or_404(User, pk=id_user)
shelf = shelve.open("dataRS.dat")
prefs = shelf['Prefs']
sim_items = shelf['SimItems']
items = []
if int(id_user) not in prefs:
return render(request, 'recommendationItems.html', {
'user': user,
'items': items
})
shelf.close()
getHybridRecommendation(prefs, int(id_user), sim_items)
rankings = getRecommendedItems(prefs, sim_items, int(id_user))
recommended = rankings[:
20] # Change number of similar items recommended
peripherals = []
scores = []
for re in recommended:
peripherals.append(Peripheral.objects.get(pk=re[1]))
scores.append(re[0])
items = zip(peripherals, scores)
return render(request, 'recommendationItems.html', {
'user': user,
'items': items
})
form = UserForm()
return render(request, 'searchUser.html', {'form': form})
def registerPage(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileInfoForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'profile_pic' in request.FILES:
print('found it')
profile.profile_pic = request.FILES['profile_pic']
profile.save()
registered = True
return HttpResponseRedirect('masuk')#reverse(''))# ('index'))
else:
print(user_form.errors,profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileInfoForm()
return render(request,
template_name= 'main/register.html', # 'dappx/registration.html',
context={'user_form':user_form, 'profile_form':profile_form, 'registered':registered})
def register(request):
context_dict = {}
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(request.POST, request.FILES)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'profile_picture' in request.FILES:
profile.profile_picture = request.FILES['profile_picture']
profile.save()
registered = True
else:
user_form = UserForm()
profile_form = UserProfileForm()
context_dict['user_form'] = user_form
context_dict['profile_form'] = profile_form
context_dict['registered'] = registered
return render(request, 'main/register.html', context_dict)
def recomendarJugadoresItem(request):
items = None
idUsuario = None
usuario = None
form = UserForm()
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
idUsuario = form.cleaned_data['id']
shelf = shelve.open("dataRS.dat")
Prefs = shelf['Prefs']
SimItems = shelf['SimItems']
shelf.close()
try:
usuario = Usuario.objects.get(id=int(idUsuario))
except:
return redirect('/error')
rankings = getRecommendedItems(Prefs, SimItems, int(idUsuario))
recommended = rankings[:3]
jugadores = []
scores = []
for re in recommended:
jugadores.append(Jugador.objects.get(pk=re[1]))
scores.append(re[0])
items = zip(jugadores, scores)
return render(request, 'searchRecommendJugadores.html', {
'user': usuario,
'items': items,
'form': form
})
def update_profile(request):
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST, instance=request.user.profile)
# image_form=ImageUploadForm(request.POST)
if user_form.is_valid() and profile_form.is_valid() and image_form.is_valid():
user_form.save()
profile_form.save()
# m = ExampleModel.objects.get(pk=course_id)
# m.model_pic = image_form.cleaned_data['image']
# m.save()
# messages.success(request, _('Your profile was successfully updated!'))
return redirect('home')
# else:
# messages.error(request, _('Please correct the error below.'))
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
# image_form=ImageUploadForm()
return render(request, 'profile.html', {
'user_form': user_form,
'profile_form': profile_form,
# 'image_form': image_form
})
# def upload_pic(request):
# if request.method == 'POST':
# form = ImageUploadForm(request.POST, request.FILES)
# if form.is_valid():
# m = ExampleModel.objects.get(pk=course_id)
# m.model_pic = form.cleaned_data['image']
# m.save()
# return HttpResponse('image upload success')
# return HttpResponseForbidden('allowed only via POST')
def register(request):
registered = False
if request.method == "POST":
user_form = UserForm(data=request.POST)
# Student_form=StudentInfoForm(data=request.POST)
if user_form.is_valid():
# and Student_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
registered = True
login(request, user)
print(user.username)
render(request, 'main/registration.html',
{'user': user, 'registered': registered})
else:
print(user_form.errors)
else:
user_form = UserForm()
return render(request, 'main/registration.html', {'user_form': user_form, 'registered': registered})
def validar_usuario(request):
'''Metodo ajax que valida el formulario de registro de un usuario retorna true o false '''
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
res = True
else:
res = False
context = {
'form': form
}
html = render_to_string('admin/usuarios/crear.html', context, request=request)
return JsonResponse({'html_form': html, 'res': res})
elif request.method == 'GET':
form = UserForm(request.GET)
if form.is_valid():
res = True
else:
res = False
context = {
'form': form
}
html = render_to_string('catalog/equipos/editar.html', context, request=request)
return JsonResponse({'html_form': html, 'res': res})
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(request.POST)
profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
registered = True
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileForm()
context_dict={}
context_dict['user_form'] = user_form
context_dict['profile_form'] = profile_form
context_dict['registered'] = registered
response = render(request, 'main/signup.html', context_dict)
return response
def signup(request):
if request.method == "POST":
user_form = UserForm(request.POST)
user_data_form = UserDataForm(request.POST)
if user_form.is_valid() and user_data_form.is_valid():
new_user = User.objects.create_user(
user_form.cleaned_data['username'],
user_form.cleaned_data['email'],
user_form.cleaned_data['password'])
new_user.first_name = user_form.cleaned_data['first_name']
new_user.last_name = user_form.cleaned_data['last_name']
new_user.save()
new_user_data = user_data_form.save(commit=False)
new_user_data.user = new_user
new_user_data.save()
user = authenticate(username=user_form.cleaned_data['username'],
password=user_form.cleaned_data['password'])
if user is not None:
login(request, user)
else:
print('invalid login')
return redirect('index')
else:
user_form = UserForm()
user_data_form = UserDataForm()
return render(
request, 'registration/signup.html', {
"user_form": user_form,
"user_data_form": user_data_form,
'parts': my_models.Part.objects.all(),
})
def recommendedFilms2(request):
if request.method == 'GET':
form = UserForm(request.GET, request.FILES)
if form.is_valid():
nombre = form.cleaned_data['name']
generos = Genre.objects.all()
diccionario = {}
for g in generos:
diccionario[g] = 0
usuario = User.objects.get(name=nombre)
id = usuario.idUser
puntuaciones = Rating.objects.filter(user=usuario)
peliculas = []
for p in puntuaciones:
print Film.objects.get(movieTitle=p.film)
pelicula = Film.objects.get(movieTitle=p.film)
peliculas.append(pelicula)
generos_p = pelicula.genres.all()
#intentar recorrer los generos de la pelicula
for ge in generos_p:
diccionario[ge] += 1
#ordenar de menor a mayor
l = diccionario.items()
l.sort(key=lambda x: x[1])
#coger los dos generos del diccionario que mas valor tengan
tamano = len(l)
lista = l[tamano - 2:]
g1 = lista[0][0]
g2 = lista[1][0]
lista = [g1.genreName, g2.genreName]
pelis = Film.objects.filter(genres=g1)
pelis1 = pelis.filter(genres=g2)
items = list(pelis1)
for pe in peliculas:
if pe in items:
items.remove(pe)
synopsis = []
final = []
for i in items:
ix = open_dir(dirindex)
with ix.searcher() as searcher:
query = QueryParser("sinopsis",
ix.schema).parse(unicode(i.movieTitle))
results = searcher.search(query)
for r in results:
synopsis.append(r['sinopsis'].encode('utf-8'))
for i in range(len(items) - 1):
final.append("Title: " + items[i].movieTitle +
" ----- Synopsis: " +
synopsis[i].decode('utf-8'))
return render_to_response('recommendationItemsByUser.html', {
'user': usuario,
'final': final
},
context_instance=RequestContext(request))
form = UserForm()
return render_to_response('search_user.html', {'form': form},
context_instance=RequestContext(request))
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save(
commit=False) # don't save it in the database yet
user.set_password(
user.password
) # set_password function ensures hashing before saving
user.is_active = False
user.save()
profile = profile_form.save(
commit=False) # don't save it in the database yet
profile.user = user # sets the one to one relationship
profile.activationCode = randint(1000, 9999)
if 'profilePicture' in request.FILES:
profile.profilePicture = request.FILES['profilePicture']
registered = True
profile.save()
# emailing the user using a html template. if the template doesn't work, a txt file gets used as an alternative
subject = 'Welcome! - Intelligent Q&A Forums'
email_to = [user.email]
with open(settings.BASE_DIR +
"/main/templates/main/authentication/sign_up_email.txt"
) as temp:
sign_up_email = temp.read()
email = EmailMultiAlternatives(subject=subject,
body=sign_up_email,
from_email=settings.EMAIL_HOST_USER,
to=email_to)
html = get_template(
"main/authentication/sign_up_email.html").render({
'user':
user,
'activationCode':
profile.activationCode
})
email.attach_alternative(html, "text/html")
email.send()
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(
request, 'main/authentication/registration.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
def search(request):
if request.method == 'GET':
form = UserForm(request.GET, request.FILES)
if form.is_valid():
id_user = form.cleaned_data['id']
user = get_object_or_404(User, pk=id_user)
return render(request, 'ratedPeripherals.html', {'user': user})
form = UserForm()
return render(request, 'searchUser.html', {'form': form})
def search(request):
if request.method == 'GET':
form = UserForm(request.GET, request.FILES)
if form.is_valid():
idUser = form.cleaned_data['id']
user = get_object_or_404(UserInformation, pk=idUser)
return render(request, 'ratedFilms.html', {'usuario': user})
form = UserForm()
return render(request, 'search_user.html', {'form': form})
def user_page(request):
if request.method == 'POST':
form = UserForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return render(request, 'thanks_page.html')
else:
form = UserForm()
return render(request, 'main_page.html', {'form': form})
def apartadoA(request):
if request.method=='GET':
form = UserForm(request.GET, request.FILES)
if form.is_valid():
idUsuario = form.cleaned_data['id']
user = get_object_or_404(Usuario, pk=idUsuario)
return render(request,'ratedBooks.html', {'usuario':user})
form=UserForm()
return render(request,'search_user.html', {'form':form })
def search(request):
if request.method == 'GET':
form = UserForm(request.GET, request.FILES)
if form.is_valid():
idUser = form.cleaned_data['id']
rating = Rating.objects.filter(user=idUser)
libros = Book.objects.all()
return render(request, 'ratedBooks.html', {'idUser': idUser, 'puntuaciones': rating, 'libros': libros})
form = UserForm()
return render(request, 'search_user.html', {'form': form})
def entrenarDatos(request):
if request.method == 'GET':
form = UserForm(request.GET, request.FILES)
if form.is_valid():
guardarEntrenamiento(str(form.cleaned_data['id']))
else:
form = UserForm()
return render_to_response('entrenarDatos.html', {'form': form},
context_instance=RequestContext(request))
def post(self, request):
form = UserForm(request.POST)
if form.is_valid():
form.save()
form = UserForm()
args = {
'users': self.model.objects.all().order_by('-id'),
'user_form': form,
}
return render(request, self.template_name, args)
def res_new(request):
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
form.save()
return redirect('restaurants')
else:
form = UserForm()
context = {'form': form}
return render(request, 'new.html', context)
def puntuacionesUsuarios(request):
if request.method == 'GET':
form = UserForm(request.GET, request.FILES)
if form.is_valid():
idUser = form.cleaned_data['id']
rating = Rating.objects.filter(user=idUser)
animes = Anime.objects.all()
return render(request, 'ratedAnimes.html', {'idUser': idUser, 'puntuaciones': rating, 'animes': animes})
form = UserForm()
return render(request, 'search_user.html', {'form': form})
def searchByUser(request):
if request.method == 'GET':
form = UserForm(request.GET, request.FILES)
if form.is_valid():
nombre = form.cleaned_data['name']
usuario = get_object_or_404(User, name=nombre)
print usuario
return render_to_response('ratedFilms.html', {'usuario': usuario},
context_instance=RequestContext(request))
else:
form = UserForm()
return render_to_response('search_user.html', {'form': form},
context_instance=RequestContext(request))
def post(self, request):
if 'submitExamples' in request.POST:
e_form = ExamplesForm(request.POST)
if e_form.is_valid():
file1 = e_form.cleaned_data['file1']
file2 = e_form.cleaned_data['file2']
self.generate_img('examples', file1, file2, find_files=True)
return HttpResponseRedirect(reverse_lazy('main:home'))
return self.render_to_response({
'e_form': e_form,
'u_form': UserForm
})
elif 'submitUser' in request.POST:
u_form = UserForm(request.POST, request.FILES)
if u_form.is_valid():
file1 = u_form.cleaned_data['file1']
file2 = u_form.cleaned_data['file2']
try:
self.generate_img('user', file1, file2)
return HttpResponseRedirect(reverse_lazy('main:home'))
except (IndexError, ValueError):
u_form.add_error(None, 'Can\'t parse SVG image')
return self.render_to_response({
'e_form': ExamplesForm,
'u_form': u_form
})
return HttpResponseNotFound()
def update_user(request):
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST, request.FILES, instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
messages.success(request, ('Your profile was sucessfull updated!'))
else:
messages.error(request, ('Please correct the error(s) below:'))
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
return render(request, 'main/update_user.html', {
'user_form': user_form,
'profile_form': profile_form
})
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
if user_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
registered = True
else:
print(user_form.errors)
else:
user_form = UserForm()
return render(request, 'main/registeration.html', {
'user_form': user_form,
'registered': registered
})
def person(request, category_slug=None):
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
# profile_form = ProfileForm(request.POST, instance=request.user.userprofile)
if user_form.is_valid():
# if user_form.is_valid() and profile_form.is_valid():
user_form.save()
# profile_form.save()
messages.success(request, ('Ваш профиль был успешно обновлен!'))
return HttpResponseRedirect('/personal-page')
else:
messages.success(request, ('Пожалуйста исправьте ошибки!'))
else:
user_form = UserForm(instance=request.user)
# profile_form = ProfileForm(instance=request.user.userprofile)
u = User.objects.get(username=request.user)
listZakaz = Reception.objects.filter(person_id = request.user)
# phone = u.userprofile.phone
# imagePerson = u.userprofile.avatar
# usl = MasterUsl.objects.filter(master=self.kwargs['master_id']);
if request.method == "POST":
formsPass = PasswordChangeForm(request.user, request.POST)
if formsPass.is_valid():
user = formsPass.save()
update_session_auth_hash(request, user)
messages.success(request, 'Ваш пароль успешно изменен')
return HttpResponseRedirect('/')
else:
messages.error(request, 'Пожалуйста исправьте ошибки')
else:
formsPass = PasswordChangeForm(request.user)
return render(request, 'pages/personal-page.html', {
# 'phone': phone,
# 'imagePerson': imagePerson,
'formsPass': formsPass,
'user_form': user_form,
# 'profile_form': profile_form,
'listZakaz': listZakaz,
})
def entrenarDatos(request):
if request.method == 'GET':
form = UserForm(request.GET, request.FILES)
if form.is_valid():
entrenamientoDatos(str(form.cleaned_data['id']))
conn = sqlite3.connect('carnaval.db')
cursor = conn.execute("SELECT distinct NOTICIA FROM ENTRENAMIENTO")
res = []
for registro in cursor:
res.append(registro[0])
return render_to_response('entreno.html', {'noticiasssss': res},
context_instance=RequestContext(request))
else:
form = UserForm()
return render_to_response('entrenarDatos.html', {'form': form},
context_instance=RequestContext(request))
def test_clean_username_exception(self):
User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
form = UserForm()
with self.assertRaises(ValidationError):
form.clean_username()
def test_user_create_form_valid(self):
form = UserForm(
data={
'first_name': 'Osama',
'last_name': 'Aboukoura',
'username': '******',
'email': '*****@*****.**',
'password': '******'
})
self.assertTrue(form.is_valid())
def recommendedFilms(request):
if request.method=='GET':
form = UserForm(request.GET, request.FILES)
if form.is_valid():
idUser = form.cleaned_data['id']
user = get_object_or_404(UserInformation, pk=idUser)
shelf = shelve.open("dataRS.dat")
Prefs = shelf['Prefs']
SimItems = shelf['SimItems']
shelf.close()
rankings = getRecommendedItems(Prefs, SimItems, int(idUser))
recommended = rankings[:2]
items = []
for re in recommended:
item = Film.objects.get(pk=re[1])
items.append(item)
return render(request,'recommendationItems.html', {'user': user, 'items': items})
form = UserForm()
return render(request,'search_user.html', {'form': form})
def profile(request):
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(request.POST,
request.FILES,
instance=request.user.profile)
if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
return redirect('home')
else:
messages.error(request, 'invalid sign up')
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)
return render(request, 'profile.html', {
'user_form': user_form,
'profile_form': profile_form
})
