def post(self, request):
user = request.user
message_id = int(unicode(request.data.get('message_id', 0)))
m_id = int(message_id)
try:
message = Message.objects.get(id=m_id)
message.is_seen = True
message.save()
messages = Message.objects.filter(receiver=user, is_seen=False)
total_unseen = len(messages)
message_read.send(sender=message.sender,
receiver=user,
message=message,
kwargs=None)
serializer = MessageSerializer(message, many=False)
return {"messages": serializer.data, "total_unseen": total_unseen}
except Exception, R:
log = Logger(log=str(R))
log.save()
return {'messages': {'message': 'error ' + str(R)}}
def post(self, request):
try:
query = request.data['q']
categories = Category.objects.filter(
Q(name__icontains=query) | Q(code__icontains=query))
services = Service.objects.filter(
Q(description__icontains=query) | Q(statement__icontains=query)
| Q(title__icontains=query) | Q(service__icontains=query))
posts = Post.objects.filter(
Q(title__icontains=query) | Q(body__icontains=query))
# res = chain(posts,categories)
all_results = list(posts)
serializer_categories = CategorySerializer(categories, many=True)
serializer_services = ServiceSerializer(services, many=True)
serializer_posts = GlobalSearchSerializer(posts, many=True)
return {
'posts': serializer_posts.data,
'services': serializer_services.data,
'categories': serializer_categories.data,
'q': query
}
except Exception, R:
log = Logger(log=str(R))
log.save()
return {'message': 'error ' + str(R)}
def msg_duplication_view(request):
"""
A view to activate or deactivate private message duplication
"""
data = JSONParser().parse(request)
user_id = data['user_id']
toggle = data['toggle']
if request.user.is_authenticated():
user = request.user
else:
try:
user = User.objects.get(id=int(user_id))
except Exception as e:
return Response({'resilt': 'error'})
try:
user_id = int(user_id)
messages_settings = MessagingSettings.objects.get(user=user)
messages_settings.duplicate_private = bool(toggle)
messages_settings.save()
serializer = MessagingSettingsSerializer(messages_settings, many=False)
except ObjectDoesNotExist:
messages_settings = MessagingSettings.objects.create(
user=user, duplicate_private=bool(toggle))
serializer = MessagingSettingsSerializer(messages_settings, many=False)
log = Logger(log='WE ARE RETURNING {}'.format(str(serializer.data)))
log.save()
return Response(serializer.data)
def post(request):
consult = ConsultTemplate.objects.get(id=1)
milestones = MileStone.objects.all()
advantage_links = AdvantageLink.objects.filter(advantage_id=1)
slides = Slide.objects.all()
faqs = FAQ.objects.all()
posts = Post.objects.all()
qquestions = QualifyQuestion.objects.all()
if request.user.is_authenticated():
logout = True
try:
user_id = request.user.id
username = request.user.username
first_name = request.user.first_name
last_name = request.user.last_name
profile_image_path = ''
except Exception, R:
log = Logger(log='WE GOT SOME ERROR' + str(R))
log.save()
user_id = -1
username = ''
first_name = ''
last_name = ''
profile_image_path = ''
def post(self, request):
user = request.user
post_id = request.data["post_id"]
title = request.data["title"]
body = request.data["body"]
category_id = request.data["category_id"]
link = request.data["link"]
try:
category = Category.objects.get(id=int(category_id))
post = Post.objects.get(id=int(post_id))
post.category=category
post.title=title
post.body=body
post.link=link
post.save()
posts = Post.objects.filter(author=user)
serializer = PostSerializer(posts,many=True)
return serializer.data
except Exception,R:
log = Logger(log=str(R))
log.save()
return {'message':'error '+str(R)}
def activate(request, activation_key):
milestones = MileStone.objects.all()
advantage_links = AdvantageLink.objects.filter(advantage_id=1)
slides = Slide.objects.all()
faqs = FAQ.objects.all()
posts = post = Post.objects.all()
qquestions = QualifyQuestion.objects.all()
if request.user.is_authenticated():
logout = True
try:
user_id = request.user.id
username = request.user.username
first_name = request.user.first_name
last_name = request.user.last_name
profile_image_path = ''
except Exception, R:
log = Logger(log='WE GOT SOME ERROR' + str(R))
log.save()
user_id = -1
username = ''
first_name = ''
last_name = ''
profile_image_path = ''
HttpResponseRedirect('/dashboard')
def delete_address_view(request):
"""
A view to delete a billing address
"""
data = JSONParser().parse(request)
address_id = data['address_id']
user_id = data['user_id']
if request.user.is_authenticated():
user = request.user
else:
try:
user = User.objects.get(id=int(user_id))
except Exception as e:
return Response({'result': 'error'})
try:
address = Address.objects.get(id=int(address_id))
address.delete()
except Exception as e:
pass
addresses = Address.objects.filter(user=user)
log = Logger(log='TOTAL ADDRESSES {}'.format(len(addresses)))
log.save()
serializer = AddressSerializer(addresses, many=True)
return Response(serializer.data)
def logout(request):
log_out(request)
milestones = MileStone.objects.all()
advantage_links = AdvantageLink.objects.filter(advantage_id=1)
slides = Slide.objects.all()
if request.user.is_authenticated():
logout = True
try:
user_id = request.user.id
username = request.user.username
first_name = request.user.first_name
last_name = request.user.last_name
profile_image_path = ''
except Exception as R:
log = Logger(log='WE GOT SOME ERROR' + str(R))
log.save()
user_id = -1
username = ''
first_name = ''
last_name = ''
profile_image_path = ''
else:
user_id = -1
logout = False
username = ''
first_name = ''
last_name = ''
profile_image_path = ''
return HttpResponseRedirect('/')
def reset_password_link(sender, instance, **kwargs):
try:
reset_key = utils.create_activation_key(instance)
link = settings.BASE_URL + '/reset/%s' % reset_key
user_profile = instance.profile
user_profile.password_recovery_key = reset_key
user_profile.save()
timeNow = datetime.now()
profile = ProfileMetaProp.objects.get(pk=1)
FROM = '<strong>Любовь и Ненависть'
USER = profile.user_name
PASSWORD = profile.password
PORT = profile.smtp_port
SERVER = profile.smtp_server
TO = instance.profile.email
SUBJECT = 'Восстановление доступа'
MESSAGE = MIMEMultipart('alternative')
MESSAGE['subject'] = SUBJECT
MESSAGE['To'] = TO
MESSAGE['From'] = "{}".format(FROM)
MESSAGE.preamble = """
Your mail reader does not support the report format.
Please visit us <a href="http://www.divorcesus.com">online</a>!"""
f = codecs.open("templates/activate_inline.html", 'r')
mess = str(f.read())
mess = str.replace(mess, '[greeting]', 'Приветствуем Вас на ЛХ,')
mess = str.replace(
mess, '[greeting_statement]',
'Нажмите на кнопку ниже для восстановления доступа.')
mess = str.replace(mess, '[greeting_link]', 'Восстановить Пароль')
mess = str.replace(mess, '[greeting_sent]',
'Это сообщение было послано на адрес')
mess = str.replace(mess, '[greeting_global_link]',
'Любовь и Ненависть')
mess = str.replace(mess, '[greeting_locale]',
'Москва, Российская Федерация')
mess = str.replace(mess, '[First Name]', instance.username)
mess = str.replace(mess, '[message]', 'Восстановление Доступа')
mess = str.replace(mess, '*****@*****.**',
instance.profile.email)
mess = str.replace(mess, '[link]', link)
HTML_BODY = MIMEText(mess.encode('utf-8'), 'html', 'utf-8')
MESSAGE.attach(HTML_BODY)
msg = MESSAGE.as_string()
server = smtplib.SMTP(SERVER + ':' + PORT)
server.ehlo()
server.starttls()
server.login(USER, PASSWORD)
server.sendmail(FROM, TO, msg)
server.quit()
except Exception as R:
log = Logger(log='Failed resetting {}'.format(str(R)))
log.save()
def google_profile(sender, instance, is_new, email, profile_picture):
log = Logger(log='IN GOOGLE PROFILE CREATION')
log.save()
profile = Profile.objects.get(id=instance.id)
new_account_created(instance=instance)
def message_read_handler(sender, receiver, message, **kwargs):
try:
notification = Notification.objects.get(message=message)
notification.is_received = True
notification.save()
except Exception as R:
log = Logger(log='WE ARE IN SIGNAL READ MESSAGE AND WE HAVE FAILED ' +
str(R))
log.save()
def post_comment_added_handler(sender, instance, **kwargs):
log = Logger(log="New comment posted -- time to check")
log.save()
try:
comment = Comment.objects.get(id=instance.id - 1)
if comment.body == instance.body:
comment.delete()
except ObjectDoesNotExist:
pass
def reset_default_billing(address_id, user_id):
try:
addresses = Address.objects.filter(user_id=user_id).exclude(
id=address_id)
for address in addresses:
address.is_default = False
address.save()
except Exception as e:
log = Logger(log='SOMETHING BROKE {}'.format(e))
log.save()
def topics(request, topic_id):
redirect = 'topics.html'
try:
has_private = request.user.profile.has_private
except Exception as e:
has_private = False
try:
lovers = Emotion.objects.filter(
attitude_id=1, topic_id=topic_id).order_by('-time_published')
except Exception as e:
lovers = []
try:
mehs = Emotion.objects.filter(
attitude_id=2, topic_id=topic_id).order_by('-time_published')
except Exception as e:
mehs = []
try:
haters = Emotion.objects.filter(
attitude_id=3, topic_id=topic_id).order_by('-time_published')
except Exception as e:
haters = []
try:
topic = Topic.objects.get(id=int(topic_id))
except Exception as e:
topic = None
log = Logger(log="TOPICS DID NOT READ {}".format(e))
log.save()
if request.user:
if request.user.is_authenticated:
username = request.user.username
else:
username = ''
else:
username = ''
return render(
request, redirect, {
'home': 'topics.html',
'lovers': lovers,
'topic': topic,
'mehs': mehs,
'has_private': has_private,
'haters': haters,
'username': username,
'user_id': request.user.id,
'user': request.user,
'current_page': 'topics',
'logout': False
})
def signin(request):
logout(request)
username = str(request.POST.get('login_username', ''))
password = str(request.POST.get('login_password', ''))
log = Logger(log="USER HERE IS {} {}".format(username, password))
log.save()
user = authenticate(username=username, password=password)
request.session.set_expiry(1086400) #sets the exp. value of the session
login(request, user, backend='custom.users.backends.LocalBackend') #the user is now logged in
return HttpResponseRedirect('/')
def get(self, request): # Get requests handler
try:
email = request.params.get('email', '')
log = Logger(log='WE ARE SENDING EMAIL - GET' + " " + email)
log.save()
return {'message': 'success', 's3_base_url': "blablabla"}
except Exception, R:
return {
'message': 'error',
'data': 'we failed reading s3 base url'
}
def post(self, request):
try:
email = request.data['email']
log = Logger(log='WE ARE SENDING EMAIL' + str(email))
log.save()
return {'message': 'success', 's3_base_url': "blablabla"}
except Exception as R:
return {
'message': 'error',
'data': 'we failed reading s3 base url'
}
def incoming_messages_view(request):
"""
A view that returns incoming messages
"""
try:
data = JSONParser().parse(request)
user_id = data['receiver_id'].encode('utf-8')
messages_list = Message.objects.filter(receiver_id=user_id)
serializer = MessageSerializer(messages_list, many=True)
except Exception as e:
log = Logger(log='WE F****D IT UP {}'.format(str(e)))
log.save()
return {}
return Response(serializer.data)
def post(request):
consult = ConsultTemplate.objects.get(id=1)
milestones = MileStone.objects.all()
advantage_links = AdvantageLink.objects.filter(advantage_id=1)
slides = Slide.objects.all()
faqs = FAQ.objects.all()
posts = Post.objects.all()
qquestions = QualifyQuestion.objects.all()
if request.user.is_authenticated():
logout = True
try:
user_id = request.user.id
username = request.user.username
first_name = request.user.first_name
last_name = request.user.last_name
profile_image_path = ''
except Exception as R:
log = Logger(log='WE GOT SOME ERROR' + str(R))
log.save()
user_id = -1
username = ''
first_name = ''
last_name = ''
profile_image_path = ''
else:
user_id = -1
logout = False
username = ''
first_name = ''
last_name = ''
profile_image_path = ''
return render(
request, 'index-0.html', {
'logout': logout,
'user_id': user_id,
'first': first_name,
'last': last_name,
'consult': consult,
'service': "blog",
'slides': slides,
'faqs': faqs,
'qualifying': qquestions,
'posts': posts,
'milestones': milestones,
'advantage_links': advantage_links,
'profile_image': profile_image_path
})
def changepassword(request):
oldpassword = str(request.data.get('oldpassword', ''))
newpassword = str(request.data.get('newpassword', ''))
user_id = request.data.get('user_id', '')
try:
usr = User.objects.get(id=int(user_id))
user = authenticate(username=usr.username, password=oldpassword)
except Exception as e:
log = Logger(log="USER COULD NOT BE FOUND {}".format(e))
log.save()
try:
user = User.objects.get(id=int(user_id))
vaid = False
if user.is_authenticated and user.is_superuser:
user = authenticate(username=user.username,
password=oldpassword)
if user:
valid = True
except Exception as e1:
valid = False
if not valid:
return Response(
{
"message": 'Старый пароль не найден!',
"code": 400,
"message_error": str(e),
"log_out": False,
"status": "unauthenticated",
"not_activated": False,
"reason": "invalid old password"
},
status=400)
user.set_password(newpassword)
user.save()
return Response(
{
"message": "success",
"status": "authenticated",
"code": 200,
"not_activated": False,
"user_id": user.id,
"username": user.username,
"log_out": True
},
status=200)
def get(self, request):
try:
message_id = int(unicode(request.params.get('message_id', 0)))
log = Logger(log="MESSAGE ID IN GET IS %d" % message_id)
log.save()
mode = int(unicode(request.params.get('mode', 0)))
message = Message.objects.get(id=message_id)
message.delete()
messages_list = Message.objects.filter(sender_id=request.user.id)
if mode == 1:
messages_list = Message.objects.filter(
sender_id=request.user.id)
else:
messages_list = Message.objects.filter(
receiver_id=request.user.id)
serializer = MessageSerializer(messages_list, many=True)
return {'messages': serializer.data}
except Exception as e:
log = Logger(
log="SOMETHING BAD HAS HAPPENED IN DELETE GET %s - %s" %
(e, request.params))
log.save()
return {
'messages': 'error',
'exception': 'message id is a mandatory'
}
def save_chat_color(request):
try:
user_id = request.data.get('user_id')
color = request.data.get('color')
user = User.objects.get(id=int(user_id))
user.profile.in_chat = True
user.profile.chat_color = color
user.profile.save()
except Exception as e:
log = Logger(log="DID NOT WORK - {}".format(e))
log.save()
return Response({'message':str(e), 'cause':str(e)})
return Response({'message':'success'})
def post(self, request):
user = request.user
try:
posts = Post.objects.filter(author=user)
serializer = PostSerializer(posts,many=True)
return serializer.data
except Exception,R:
log = Logger(log=str(R))
log.save()
return {'message':'error '+str(R)}
def get(self, request):
user = request.user
post_id = request.params.get("post_id","")
try:
post = Post.objects.get(id=int(post_id))
post.delete()
posts = Post.objects.filter(author=user)
serializer = PostSerializer(posts,many=True)
return serializer.data
except Exception,R:
log = Logger(log=str(R))
log.save()
return {'message':'error '+str(R)}
def simple_signin(request):
user_activity_objects = OnlineUserActivity.get_user_activities(timedelta(minutes=15))
onliners = (user for user in user_activity_objects)
try:
loves = Emotion.objects.filter(attitude_id=1)
mehs = Emotion.objects.filter(attitude_id=2)
hates = Emotion.objects.filter(attitude_id=3)
username = request.POST.get('uname')
password = request.POST.get('psw')
user = authenticate(username=username, password=password)
login(request, user, backend='custom.users.backends.LocalBackend') #the user is now logged in
if request.user.is_authenticated:
logout=True
user_id = user.id
username = user.username
is_authenticated = True
has_private = request.user.profile.has_private
else:
logout=False
user_id = -1
username = ''
is_authenticated = False
has_private = False
except Exception as e:
log = Logger(log="SOMETHING WENT WRONG {}".format(e))
log.save()
username = ''
logout = False
user_id = -1
user = request.user
is_authenticated = False
has_private = False
return render(request, 'index.html',{'home':'index.html',
'user': user,
'loves': loves,
'mehs': mehs,
'hates': hates,
'has_private': has_private,
'username': user.username,
'is_authenticated': is_authenticated,
'logout': logout,
'user_id': user.id})
def resend_password_link(request):
username = request.data.get('username', '')
email = request.data.get('email', '')
user = None
try:
user = User.objects.get(username=username, email=email)
except ObjectDoesNotExist:
return Response(
{
"message": "failure - username not found",
"status": "registered",
"code": 400,
"falure_code": 1,
"user_id": -1,
"email": email,
"username": username
},
status=400)
try:
user_send_reset_password_link.send(sender=user,
instance=user,
kwargs=None)
except Exception as e:
log = Logger(log="Could not send reset link {}".format(e))
log.save()
return Response(
{
"message": "failure - username not found",
"status": "registered",
"code": 400,
"falure_code": 1,
"user_id": -1,
"email": email,
"username": username
},
status=400)
return Response(
{
"message": "success",
"status": "registered",
"code": 200,
"user_id": 1,
"username": username
},
status=200)
def editprofile(request):
redirect = 'mylh_avatar.html'
username = request.POST.get('profile_username', '')
user_id = request.POST.get('profile_user_id', '')
session_username = request.POST.get('session_username', '')
first_name = request.POST.get('first_name', '')
last_name = request.POST.get('last_name', '')
email = request.POST.get('profile_email', '')
bio = request.POST.get('bio', '')
profile_image_path = None
if request.method == 'POST':
profile_image_path = None
avtr_file = request.FILES.get('avatar', None)
if avtr_file:
avatar = request.FILES['avatar']
fs = FileSystemStorage()
filename = fs.save(avatar.name, avatar)
uploaded_file_url = fs.url(filename)
profile_image_path = uploaded_file_url
else:
profile = request.user.profile
profile_image_path = profile.profile_image_path
try:
username_transliterated = cyrtranslit.to_latin(username, 'ru').lower()
user = request.user
user.username = username
user.first_name = first_name
user.last_name = last_name
user.email = email
user.profile.username = username
user.profile.first_name = first_name
user.profile.bio = bio
user.profile.email = email
user.profile.username_transliterated = username_transliterated
user.profile.profile_image_path = profile_image_path
user.save()
user.profile.save()
except Exception as e:
user = None
log = Logger(log="Failed to save user {}".format(e))
log.save()
return HttpResponseRedirect('/mylh/')
def about(request):
if request.user.is_authenticated():
logout = True
try:
user_id = request.user.id
username = request.user.username
first_name = request.user.first_name
last_name = request.user.last_name
profile_image_path = ''
except Exception, R:
log = Logger(log='WE GOT SOME ERROR' + str(R))
log.save()
user_id = -1
username = ''
first_name = ''
last_name = ''
profile_image_path = ''
def pricing(request):
if request.user.is_authenticated():
logout = True
try:
user_id = request.user.id
profile = User.objects.get(id=request.user.id)
username = request.user.username
first_name = request.user.first_name
last_name = request.user.last_name
profile_image_path = profile.profile_image_path
except Exception, R:
log = Logger(log='WE GOT SOME ERROR' + str(R))
log.save()
user_id = -1
username = ''
first_name = ''
last_name = ''
profile_image_path = ''
def message_sent_handler(sender, receiver, message, **kwargs):
try:
log = Logger(log='WE SENT A MESSAGE %d %d' % (sender.id, receiver.id))
log.save()
notification = Notification.objects.create(notification_type_id=1,
is_received=False,
is_sent=True,
message=message,
user=receiver)
except Exception as R:
log = Logger(log='WE ARE IN SIGNAL AND WE HAVE FAILED ' + str(R))
log.save()
