def detail(request, post_id):
"""
:param request:
:param post_id:
:return:
"""
post = get_object_or_404(Post, pk=post_id)
parents = post.item.all()
content = ContentType.objects.get_for_model(Comment)
subs = Comment.objects.filter(content_type=content).filter(is_active=1).filter(parent=post_id)
if request.method == "POST":
form = CommentForm(request.POST)
if form.is_valid():
text = form.cleaned_data["text"]
email = form.cleaned_data["email"]
c_type = request.POST.get("c_type")
obj_id = request.POST.get("replyfor")
if c_type == "Comment":
c_model = Comment
if c_type == "Post":
c_model = Post
con_type = ContentType.objects.get_for_model(c_model)
new_comment = Comment(email=email,
text=text,
content_type=con_type,
parent=post_id,
object_id=obj_id,
pubdate=datetime.now(),
is_active=0)
new_comment.save()
if request.user.is_authenticated():
new_comment.is_active = 1
new_comment.user = request.user
new_comment.save()
else:
if email_check(email):
return redirect('/')
else:
act_code = produce_val()
send_act_code.delay(act_code,
new_comment.email)
new_activation = Activation(conf_code=act_code,
comment=new_comment,
exp_date=datetime.now(), )
new_activation.save()
form = CommentForm()
else:
form = CommentForm()
return render(request, 'blog/deneme.html', {'parents': parents,
'subs': subs, 'post': post,
'r_user': request.user,
'form': form, })
def save(self):
username = self.cleaned_data['username']
password = self.cleaned_data['password']
email = self.cleaned_data['email']
user = User.objects.create_user(username = username, email = email, password = password)
user.save()
person = Person(user = user, verified = True, email = email, name = username)
person.save()
self.person = person
activate = Activation(key = str(uuid.uuid4()), person = person)
activate.save()
self.activate = activate
self.success = True
return (self.person, self.activate)
def forgot_process():
"""Sends email to reset password after submit"""
email = request.form['email']
user_in_db = db.session.query(User).filter(User.email==email).first()
if not user_in_db:
flash("User not registered")
return redirect("/register")
if not user_in_db.is_activated:
flash("You need to activate your account first")
return redirect("/login")
reset_pass_number = randint(10**8, 10**12)
number_in_db = db.session.query(Activation).filter(Activation.activation_number==reset_pass_number).first()
while number_in_db:
reset_pass_number = randint(10**8, 10**12)
new_activation = Activation(activation_number=reset_pass_number, user_id=user_in_db.user_id)
db.session.add(new_activation)
db.session.commit()
send_email(email, reset_pass_number, 'forgot_pass')
flash("Please check your email to reset your password")
return redirect("/login")
def load_activations():
"""Records of activation numbers by users"""
for i in range(1,1001): #load_users() loads 10 users
activation_number = randint(10**8, 10**12)
user_id = i
activation = Activation(activation_number=activation_number, user_id=user_id)
db.session.add(activation)
db.session.commit()
def account_registration(request):
assert_post_parameters(request, ['displayName', 'password', 'emailAddress'])
emailAddress = request.POST['emailAddress']
password = request.POST['password']
if check_username_sanity(request.POST['displayName']):
displayName = request.POST['displayName']
else:
raise InvalidUsername(request.POST['displayName'])
try:
validate_email(emailAddress)
except ValidationError:
raise InvalidEmailAddress(emailAddress)
# validate username
if not check_username_sanity(displayName):
raise InvalidUsername(displayName)
# Check for already existing Username
if User.objects.filter(username__iexact=displayName).count():
raise UsernameNotAvailable(displayName)
# Check for already existing Mail
if User.objects.filter(email__iexact=emailAddress).count():
raise EmailAddressNotAvailiable(emailAddress)
user = create_user(displayName,
description="",
mail=emailAddress,
password=password,
groups=['texters', 'voters', 'bloggers'])
user.is_active = False
user.save()
activation = Activation.create(user)
try:
send_mail(settings.REGISTRATION_TITLE,
settings.REGISTRATION_BODY + ' ' + settings.FINDECO_BASE_URL +
'/#activate/' + str(activation.key),
settings.EMAIL_HOST_USER,
[emailAddress],
fail_silently=False)
except SMTPException:
# This means we can't send mails, so we can't create users
user.delete()
activation.delete()
raise
return json_response({'accountRegistrationResponse': {}})
def register_process():
"""Adding registered user to database."""
# Get form variables
name = request.form["name"].title()
lastname = request.form["lastname"].title()
country = request.form["sel-country"].title()
city = request.form["city"].title() #calculate city_id
email = request.form["email"] #Unique
password = argon2.hash(request.form["password"]) #hashed password
picture = "http://i.imgur.com/Jckb780t.jpeg" #default
#already registered?
user_in_db = db.session.query(User).filter(User.email==email).first()
if user_in_db:
flash("%s, already exists." % email)
return redirect("/register")
else:
#not registered yet, city info already exists? If not, add
country_code = search_country_code(country)
city_in_db = db.session.query(City).filter(City.name==city).first()
if not city_in_db:
new_city = City(name=city, country_code=country_code)
db.session.add(new_city)
db.session.commit()
city_id = db.session.query(City).filter(City.name==city).first().city_id
new_user = User(name=name, lastname=lastname, city_id=city_id, email=email, password=password, picture=picture) #is_activaded false
db.session.add(new_user)
db.session.commit()
# flash("%s %s, your registration was completed. Please, check your email to activate your account" % (name, lastname))
activation_number = randint(10**8, 10**12)
new_activation = Activation(activation_number=activation_number, user_id=new_user.user_id)
db.session.add(new_activation)
db.session.commit()
send_email(email, activation_number, 'activation')
#return redirect("/login")
return redirect("/activation_confirmation/%s" % new_user.user_id)
