def hubMembersView(request, data_type, data_value):
try:
logged_in_user = get_current_user(request)
if data_type == "id":
hubid = data_value
hub = get_hub_by_id(request, hubid, logged_in_user)
if hub == None:
return assembleHubErrorResponse(request,
"Sorry that Hub was not found")
memberNames = hub.get_hub_member_names(request)
members = [
get_user_by_name(request, userName) for userName in memberNames
]
members = [username for username in members if username != False]
details = render_to_response("partial_hub_profile_members.html", {
"current_user": logged_in_user,
"members": members,
"request": request,
"payload": {
"hub": hub
},
"logged_in_user": logged_in_user.user_id
},
context_instance=RequestContext(request))
return assembleHubResponse(
request,
logged_in_user,
hub,
details,
hideMiniSpraycan=(not logged_in_user.is_logged_in))
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def search(request, user_name=''):
try:
thereturn = loginscreen(request)
loggedin, user, loggedin_user, follow, data = getUserVariables(
request, user_name)
if loggedin:
user_name = user['user_name']
if not request.POST:
thereturn = render_to_response(
'partial_user_searchhub.html',
locals(),
context_instance=RequestContext(request))
elif 'query' in request.POST and len(request.POST['query']) > 0:
response = ttagGetHubsByName(request.POST['query'])
if response['result'] == 'OK':
response['data']['hubs'] = processRawHubs(
response['data']['hubs'], request)
from webapp.views.user import getUserHubs
response['data']['joinedhubs'] = getUserHubs(
user['user_name'])
thereturn = render_to_response(
'partial_userhub_searchresults.html',
locals(),
context_instance=RequestContext(request))
return thereturn
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def privacyView(request):
try :
loggedin, data = ttagServiceAuth(request)
return render_to_response('privacy.html', locals(), context_instance=RequestContext(request))
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def signupActivate(request):
try :
showPopup = True
return render_to_response('activate.html' if not request.is_ajax() else 'partial_activate.html', locals(), context_instance=RequestContext(request))
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def notifyOfWallPost(request, original_user_id, poster_user_id):
"""Send an email notification to tell a user that someone has posted on their wall"""
try:
orig_user = get_user_by_id(request, original_user_id)
post_user = get_user_by_id(request, poster_user_id)
to = orig_user.email
subject, from_email = post_user.full_name + ' posted on your TTAGIT wall', email.FROM_ADDRESS
templContext = {
"S3TATIC_URL": paths.S3TATIC_URL,
"host": paths.HTTPS + request.get_host(),
"orig_user": orig_user,
"post_user": post_user
}
text_content = mark_safe(
render_to_response("email_wallpost.txt", templContext).content)
html_content = mark_safe(
render_to_response("email_wallpost.html", templContext).content)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
# msg.send()
return HttpResponse("You should receive an email!")
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def ttagRemove(request, ttag_id):
try:
thereturn = loginscreen(request)
authed, user = ttagServiceAuth(request)
if authed:
if request.method == 'POST':
response = ttagPost(
'/user-data/remove-ttag', {
'ttag_id': ttag_id,
'user_id': user['_id'],
'access_token': request.COOKIES['access_token']
})
location = request.POST['location']
if request.is_ajax():
thereturn = HttpResponse(
mark_safe(
'<article class="deleted">Ttag deleted</article>'))
else:
thereturn = HttpResponseRedirect(location)
else:
location = request.META[
'HTTP_REFERER'] if 'location' not in request.GET else request.GET[
'location']
user_name = user['user_name']
thereturn = render_to_response(
'partial_ttag_confirmdelete.html',
locals(),
context_instance=RequestContext(request))
return thereturn
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def ttagRemove(request, ttag_id):
try:
thereturn = loginscreen(request)
authed, user = ttagServiceAuth(request)
if authed:
if request.method == "POST":
response = ttagPost(
"/user-data/remove-ttag",
{"ttag_id": ttag_id, "user_id": user["_id"], "access_token": request.COOKIES["access_token"]},
)
location = request.POST["location"]
if request.is_ajax():
thereturn = HttpResponse(mark_safe('<article class="deleted">Ttag deleted</article>'))
else:
thereturn = HttpResponseRedirect(location)
else:
location = request.META["HTTP_REFERER"] if "location" not in request.GET else request.GET["location"]
user_name = user["user_name"]
thereturn = render_to_response(
"partial_ttag_confirmdelete.html", locals(), context_instance=RequestContext(request)
)
return thereturn
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def join(request):
try :
thereturn = HttpResponse(mark_safe('<p>Sorry, we were not able to handle your request</p>'))
showPopup = True
if request.method == 'GET' :
loggedin, data = ttagServiceAuth(request)
if request.is_ajax() :
thereturn = render_to_response('partial_newsletter_joinform.html',locals(),context_instance=RequestContext(request))
else :
thereturn = render_to_response('newsletter_joinform.html',locals(),context_instance=RequestContext(request))
else :
form = Newsletter(request.POST)
if form.is_valid() :
news = ttagPost('/socialnetwork/save-email',{'email':form.clean_Email(),'ip_address':request.META['REMOTE_ADDR']})
# send email notification
from webapp.views.email import notifyOfNewsletterSuscribe
notifyOfNewsletterSuscribe(request, form.clean_Email())
if request.is_ajax() :
thereturn = render_to_response('partial_newsletter_joinform.html',locals(),context_instance=RequestContext(request))
else :
thereturn = render_to_response('newsletter_joinform.html',locals(),context_instance=RequestContext(request))
elif request.is_ajax() :
thereturn = render_to_response('partial_newsletter_joinform.html',locals(),context_instance=RequestContext(request))
else :
thereturn = render_to_response('newsletter_joinform.html',locals(),context_instance=RequestContext(request))
return thereturn
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def ttagShow(request, ttag_id, useHTML, appendCode=""):
try:
loggedin, data = ttagServiceAuth(request)
thereturn = custompopup(request, '<p>Could not complete request</p>')
response = ttagPost("/find/ttag", {'ttag_id': ttag_id})
if 'result' in response and response['result'] == 'OK':
if loggedin:
loggedin_user = data['_id']
from webapp.views.user import getUserFollowers
response['data']['followers'] = getUserFollowers(loggedin_user)
servertime = datetime.datetime.fromtimestamp(
int(response['time']) / 1000)
context = {
'pagetitle': 'ttagit - Flagged Ttag',
'request': request,
'ttag': response['data']['ttag'],
'servertime': servertime,
'appendCode': appendCode
}
thereturn = render_to_response(
'ttag_show.html',
context,
context_instance=RequestContext(request))
return thereturn
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def settingsView(request, popup=False):
"""Show the user settings dashboard page"""
try :
thereturn = loginscreen(request)
from webapp.views.user import getUserVariables
loggedin, user, loggedin_user, follow, data = getUserVariables(request, '')
if loggedin:
if request.method != "POST":
formdata = {'gender':'','google_map_address':'','pro_description':''}
for key in data :
formdata[key] = data[key]
else :
formdata = request.POST
form = SettingsForm(formdata)
response = ttagRequestCount(data['_id'])
if popup != False :
showPopup = True
popupPartial = "partial_"+popup+"_popup.html"
pagetitle = "ttagit - User Settings Page"
location = "Settings"
if request.is_ajax() :
from website.localsettings.paths import S3TATIC_URL
userpanel = render_to_response("partial_home_settings.html",locals(),context_instance=RequestContext(request))
userdetails = render_to_response("partial_user_details.html",locals(),context_instance=RequestContext(request))
head = render_to_response("djview_head_resources.html",{'headScripts':mark_safe('<script type="text/javascript" src="'+S3TATIC_URL+'scripts/passwordstrength.js"></script><script type="text/javascript" src="'+S3TATIC_URL+'scripts/settings.js"></script>')},context_instance=RequestContext(request))
jsonReturn = simplejson.dumps({"context":mark_safe(userdetails.content),"results":mark_safe(userpanel.content),'head':mark_safe(head.content)})
thereturn = HttpResponse(mark_safe(jsonReturn))
else :
thereturn = render_to_response('home_settings.html', locals(), context_instance=RequestContext(request))
return thereturn
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def forgotPasswordMail(request):
try:
if ('reset_token' in request.session) and ('reset_email'
in request.session):
reset_token = request.session['reset_token']
subject = 'Ttagit.com forgotten password email verification.'
email_message = 'Verify your email address by following this link:\n https://' + request.get_host(
) + '/fpverify/' + reset_token
localprint(request, email_message)
to_address = request.session['reset_email']
showPopup = True
send_mail(subject,
email_message,
FROM_ADDRESS, [to_address],
fail_silently=True)
return render_to_response(
'forgot_checkemail.html'
if not request.is_ajax() else 'partial_forgot_checkemail.html',
locals(),
context_instance=RequestContext(request))
else:
## cannot send email without reset_token and reset_email
return HttpResponse(
'Cannot send email without reset_token and reset_email')
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def resetFormPost(request):
try:
showPopup = True
if (request.method == 'POST') and ('reset_token' in request.session):
form = PasswordResetForm(request.POST) # bound form
if form.is_valid():
reset_token = request.session['reset_token']
service_response = ttagServiceFPChange(reset_token,
form.getNew_Password())
json_obj = simplejson.loads(service_response.read())
if json_obj['result'] == 'OK':
##inform user password was changed
return custompopup(
request,
"Your password has been changed. You can close this dialog and sign in with your new password."
)
else:
##inform user pass was not changed
return custompopup(
request,
'There was a problem, password was not changed.')
else:
form = PasswordResetForm() # unbound form
return render_to_response('resetform.html' if not request.is_ajax()
else 'partial_resetform.html',
locals(),
context_instance=RequestContext(request))
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def userWallView(request, user_name, to_time=INFINITE_TIME):
try :
from webapp.views.spraycan import url
hideMiniSpraycan = True
loggedin, user, loggedin_user, follow, data = getUserVariables(request, user_name)
if '_id' in data :
partial = 'partial_spraycan_ttags.html' if request.is_ajax() and to_time != INFINITE_TIME else 'partial_user_profile_wall.html'
spraycanURL = '/'.join(['','user',data['_id'],'wall'])
request.wall_owner_id = data['_id']
request.is_wallowner = ( loggedin_user == data['_id'] )
userdetails = mark_safe(url(request=request, location=spraycanURL, location_type='wall', partial=partial, thetemplate='base_ajax.html', user_name=user_name, to_time=to_time).content)
else :
userdetails = mark_safe(render_to_response('partial_user_notfound.html',locals(),context_instance=RequestContext(request)).content)
if request.is_ajax() :
if userdetails[0:1] == '{' or to_time != INFINITE_TIME :
thereturn = HttpResponse(userdetails)
else :
usercontext = mark_safe(render_to_response('partial_user_details.html',locals(),context_instance=RequestContext(request)).content)
trueJsonReturn = simplejson.dumps({'context':usercontext,'results':userdetails})
thereturn = render_to_response('ajax_ttag_create.html',{'jsonReturn':trueJsonReturn})
else :
thereturn = userProfileView(request=request, view_type='tags', user_name=user_name, userdetails=userdetails, hideMiniSpraycan=True)
return thereturn
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def ttagLink(request, ttag_id):
try:
response = ttagPost("/find/ttag", {"ttag_id": ttag_id})
theReturn = custompopup(request, "<p>Sorry, we failed to find that ttag!</p>")
if "result" in response and response["result"] == "OK":
ttag = response["data"]["ttag"]
if ttag["location_type"] == "wall":
theReturn = HttpResponseRedirect(ttag["location"])
elif ttag["location_type"] == "URL":
theReturn = HttpResponseRedirect(
paths.HTTPS
+ request.get_host()
+ reverse("spraycan-url")
+ "?location="
+ urlquote_plus(ttag["location"])
)
elif ttag["location_type"] == "HUB":
hubid = ttag["location"].split("#")[0]
theReturn = HttpResponseRedirect(
paths.HTTPS + request.get_host() + reverse("hub-wall", args=("id/", hubid))
)
return theReturn
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def hubMembersView(request, data_type, data_value):
try :
logged_in_user = get_current_user(request)
if data_type == "id" :
hubid = data_value
hub = get_hub_by_id(request, hubid, logged_in_user)
if hub == None:
return assembleHubErrorResponse(request, "Sorry that Hub was not found")
memberNames = hub.get_hub_member_names(request)
members = [get_user_by_name(request, userName) for userName in memberNames]
members = [username for username in members if username != False]
details = render_to_response("partial_hub_profile_members.html",
{
"current_user": logged_in_user,
"members": members,
"request": request,
"payload": {"hub": hub},
"logged_in_user": logged_in_user.user_id
},
context_instance=RequestContext(request))
return assembleHubResponse(request, logged_in_user, hub, details,
hideMiniSpraycan = (not logged_in_user.is_logged_in))
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def genericSocialActivate(sn_method,
sn_id,
access_token,
request,
state='homepage'):
try:
activation_result = ttagActivateSocialAccount(sn_method, sn_id,
access_token)
response = None
if activation_result['result'] == 'OK':
response = render_to_response(
'lb_signin.html', {'state': state},
context_instance=RequestContext(request))
else:
form = SignInForm({'user': '******', 'password': '******'})
form._errors = ErrorDict()
errors = ErrorList()
errors = form._errors.setdefault(NON_FIELD_ERRORS, errors)
form._errors['password'] = form.error_class(
[str(activation_result['msg'])])
response = viewHelp(request,
'standalone_homepage.html',
'extension',
'about_extension.html',
'TTAGIT Help - Google Browser Extension',
signinform=form)
return response
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def hubWallSpraycan(request, data_type, data_value):
try:
thereturn = assembleHubErrorResponse(
request, 'You are not authorized to view this area of the website')
logged_in_user = get_logged_in_user(request)
if data_type == "id":
hubid = data_value
hub = get_hub_by_id(request, hubid, logged_in_user)
if hub == None:
return HttpResponse("Sorry that Hub was not found")
if logged_in_user:
if request.is_ajax():
from django.core.urlresolvers import reverse
location = hub.hub_id + '#' + hub.default_topic_id
data = logged_in_user
thereturn = render_to_response(
'partial_hub_minispraycan.html',
locals(),
context_instance=RequestContext(request))
else:
thereturn = hubWallView(request, data_type, data_value)
return thereturn
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def notifyOfReply(request, original_user_id, replier_user_id, original_tag_id,
reply_tag_id):
"""Send an email notification to tell a user that someone has replied to their tag"""
try:
orig_user = get_user_by_id(request, original_user_id)
repl_user = get_user_by_id(request, replier_user_id)
to = orig_user.email
subject, from_email = repl_user.full_name + ' replied to you on TTAGIT', email.FROM_ADDRESS
templContext = {
"S3TATIC_URL": paths.S3TATIC_URL,
"host": paths.HTTPS + request.get_host(),
"orig_user": orig_user,
"repl_user": repl_user,
"original_tag_id": original_tag_id
}
text_content = mark_safe(
render_to_response("email_replied.txt", templContext).content)
html_content = mark_safe(
render_to_response("email_replied.html", templContext).content)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
# msg.send()
return HttpResponse("You should receive an email!")
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def forgotPasswordForm(request):
try :
form = PasswordForgotForm()
captcha_error = ''
email_error = ''
RECAPTCHA_PUB_KEY = keys.RECAPTCHA_PUB_KEY
RECAPTCHA_PRIVATE_KEY = keys.RECAPTCHA_PRIVATE_KEY
if request.method == 'POST' :
form = PasswordForgotForm(request.POST)
response = captcha.submit(
request.POST.get('recaptcha_challenge_field'),
request.POST.get('recaptcha_response_field'),
RECAPTCHA_PRIVATE_KEY,
request.META['REMOTE_ADDR'],)
captcha_error = response.error_code
if ( form.is_valid() and response.is_valid ) :
service_response = ttagServiceFPValidate(form.getEmail())
if service_response['result'] == 'OK' :
request.session['reset_token'] = service_response['reset_password_token']
request.session['reset_email'] = form.getEmail()
request.session.modified = True
if request.is_ajax() :
return forgotPasswordMail(request)
return HttpResponseRedirect(paths.HTTPS+request.get_host()+'/fpmail/')
else :
email_error = "Sorry, that email wasn't found"
showPopup = True
return render_to_response('partial_forgotform.html' if request.is_ajax() else 'forgotform.html', locals(), context_instance=RequestContext(request))
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def homepage(request):
try:
if request.is_ajax():
import simplejson
return HttpResponse(
simplejson.dumps({
'headerOuter':
mark_safe(
render_to_response(
'partial_user_dashboard.html',
locals(),
context_instance=RequestContext(request)).content),
'homepageMain':
mark_safe(
render_to_response(
'partial_standalone_apps.html',
locals(),
context_instance=RequestContext(request)).content)
}))
else:
return render_to_response('standalone_apps.html',
locals(),
context_instance=RequestContext(request))
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def userDelete(request):
try :
response = loginscreen(request)
loggedin, data = ttagServiceAuth(request)
if loggedin :
access_token = request.COOKIES['access_token']
if request.method == 'GET' :
pagetitle = 'TTAGIT - User Account Delete Request Confirmation'
showPopup = True
response = render_to_response('user_confirmdelete.html' if not request.is_ajax() else 'partial_user_confirmdelete.html', locals(), context_instance=RequestContext(request))
else :
json_obj = ttagServiceAccountDelete(access_token)
if json_obj['result'] == 'OK' :
response = custompopup(request,'<p>Your Acccount was deleted</p>', reverse('index-page'))
request.COOKIES['access_token'] = ''
else :
response = custompopup(request,'<p>Your Account was not deleted</p>')
return response
# only during development!!!
# elif 'user_name' in request.GET :
# ttagPost('/delete-user',{'user_name':request.GET['user_name']})
# response = HttpResponse('Your Account was deleted')
# elif 'email' in request.GET :
# ttagPost('/delete-user',{'email':request.GET['email']})
# response = HttpResponse('Your Account was deleted')
return response
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def signinError(request, errorField, errorMessage):
try:
signinform = SignInForm({'user': '******', 'password': '******'})
errorInit = signinform.is_valid()
signinform._errors[errorField] = signinform.error_class([errorMessage])
if request.is_ajax():
import simplejson
return HttpResponse(
simplejson.dumps({
'headerOuter':
mark_safe(
render_to_response(
'partial_user_dashboard.html',
locals(),
context_instance=RequestContext(request)).content),
'homepageMain':
mark_safe(
render_to_response(
'partial_standalone_signin.html',
locals(),
context_instance=RequestContext(request)).content)
}))
else:
return render_to_response('standalone_signin.html',
locals(),
context_instance=RequestContext(request))
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def actionJoin(request, data_type, data_value, quit=False):
try:
thereturn = loginscreen(request)
user = get_logged_in_user(request)
loggedin = user and user.is_current_user
thereturn = loginscreen(request)
if loggedin:
user_id = user["_id"]
hub_id = data_value
hub = get_hub_by_id(request, hub_id, user)
access_token = request.COOKIES['access_token']
if data_type == "id":
if quit:
response = ttagQuitJoinedHub(user_id, access_token, hub_id)
else:
response = ttagJoinHub(user_id, access_token, hub_id)
else:
return custompopup(request, '<p>Hub not found</p>')
if response["result"] == "OK":
if not request.is_ajax():
return HttpResponseRedirect(request.META['HTTP_REFERER'])
else:
hub.joined = True if not quit else False
return render_to_response(
'partial_hub_join.html',
locals(),
context_instance=RequestContext(request))
else:
return HttpResponse(response["msg"])
else:
return thereturn
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def listCreated(request, user_name):
try :
thereturn = custompopup(request,'<p>Sorry, we were unable to display this page.</p>')
loggedin, user, loggedin_user, follow, data = getUserVariables(request, user_name)
logged_in_user = get_logged_in_user(request)
request_user = get_user_by_name(request, user_name)
if request_user != False :
hubs = get_hubs_by_user(request, request_user)
if len(hubs) == 0 :
if loggedin and user_name == user['user_name'] :
thereturn = render_to_response('partial_user_nocreatedhubsmyself.html',locals(),context_instance=RequestContext(request))
else :
thereturn = render_to_response('partial_user_nocreatedhubs.html',locals(),context_instance=RequestContext(request))
else :
response = {'data': {'hubs': hubs }}
if loggedin :
from webapp.views.user import getUserHubs
response['data']['joinedhubs'] = getUserHubs(user['user_name'])
if user_name == user['user_name'] :
response['data']['createdhubs'] = [hub.hub_id for hub in response['data']['hubs']]
thereturn = render_to_response('partial_user_createdhubs.html',locals(),context_instance=RequestContext(request))
return thereturn
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def indexView(request):
"""Get the TTAGIT index page template for a user who is not logged in"""
try:
hideLogo = True
if request.is_ajax():
import simplejson
return HttpResponse(
simplejson.dumps({
'headerOuter':
mark_safe(
render_to_response(
'partial_user_dashboard.html',
locals(),
context_instance=RequestContext(request)).content),
'homepageMain':
mark_safe(
render_to_response(
'partial_standalone_homepage.html',
locals(),
context_instance=RequestContext(request)).content)
}))
return render_to_response('standalone_homepage.html',
locals(),
context_instance=RequestContext(request))
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def urlOlder(request, to_time):
try :
partial = 'partial_spraycan_ttags.html' if request.is_ajax() else 'spraycan.html'
return url(request=request, partial=partial, to_time=to_time)
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def create(request, user_name=''):
try:
thereturn = loginscreen(request)
loggedin, user, loggedin_user, follow, data = getUserVariables(
request, user_name)
if loggedin:
user_name = user['user_name']
if not request.POST:
thereturn = render_to_response(
'partial_user_createhub.html',
locals(),
context_instance=RequestContext(request))
else:
if 'hub_name' in request.POST and 'hub_desc' in request.POST:
hub_name = request.POST["hub_name"]
hub_desc = request.POST["hub_desc"]
response = ttagCreateHub(loggedin_user,
request.COOKIES['access_token'],
hub_name, hub_desc, "", "",
"true", "0")
if request.is_ajax():
thereturn = render_to_response(
'partial_user_hubcreated.html',
locals(),
context_instance=RequestContext(request))
else:
from django.core.urlresolvers import reverse
thereturn = HttpResponseRedirect(
reverse('userhub-created', args=(user_name)))
return thereturn
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def hubWallView(request, data_type, data_value, to_time=INFINITE_TIME):
try :
logged_in_user, hub, details = getHubDetails(request, data_type, data_value, to_time)
return assembleHubResponse(request, logged_in_user, hub, details, hideMiniSpraycan=True)
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def actionJoin(request, data_type, data_value, quit=False):
try :
thereturn = loginscreen(request)
user = get_logged_in_user(request)
loggedin = user and user.is_current_user
thereturn = loginscreen(request)
if loggedin:
user_id = user["_id"]
hub_id = data_value
hub = get_hub_by_id(request, hub_id, user)
access_token= request.COOKIES['access_token']
if data_type == "id":
if quit:
response = ttagQuitJoinedHub(user_id, access_token, hub_id)
else:
response = ttagJoinHub(user_id, access_token, hub_id)
else:
return custompopup(request,'<p>Hub not found</p>')
if response["result"] == "OK":
if not request.is_ajax() :
return HttpResponseRedirect(request.META['HTTP_REFERER'])
else :
hub.joined = True if not quit else False
return render_to_response('partial_hub_join.html',locals(),context_instance=RequestContext(request))
else:
return HttpResponse(response["msg"])
else:
return thereturn
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def view(request):
try :
thereturn = HttpResponse('You are not authorized to view this area of the website')
loggedin, data = ttagServiceAuth(request)
if loggedin :
usertemplate = 'base_marketing.html'
follow = -1
hidebadges = True
hidefooter = True
hideproinfo = True
user_id = data["_id"]
angularapp = "ttagitMarketing"
paypal_dict = {
"business":settings.PAYPAL_RECEIVER_EMAIL,
"custom":user_id,
"item_number": request.COOKIES['access_token'],
"item_name":"Ttagit Ad Credits",
"notify_url": paths.HTTPS+request.get_host() + "/3f2cf0fe3d994fb8dfe6d8f9g2h5",
"return_url": paths.HTTPS+request.get_host() + reverse('marketing-thankyou'),
"cancel_return": paths.HTTPS+request.get_host()+ reverse('marketing'),
}
form = PayPalPaymentsForm(initial=paypal_dict)
formaction = conf.POSTBACK_ENDPOINT if not debug.DEBUG else conf.SANDBOX_POSTBACK_ENDPOINT
thereturn = render_to_response('marketing_details.html',locals(),context_instance=RequestContext(request))
return thereturn
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def delete(request, data_type, data_value):
try :
thereturn = loginscreen(request)
loggedin, user, loggedin_user, follow, data = getUserVariables(request, '')
if loggedin :
user_name = user['user_name']
if data_type == 'id' :
hub_id = data_value
respHub = ttagGetHubByHubId(hub_id)
#print respHub
if respHub['result'] == 'OK' and respHub['data']['hub']['user']['user_id'] == loggedin_user :
if not request.POST :
hub = respHub['data']['hub']
thereturn = render_to_response('partial_userhub_confirmdelete.html',locals(),context_instance=RequestContext(request))
else :
if 'hub_id' in locals() :
response = ttagDeleteHub(loggedin_user, request.COOKIES['access_token'], hub_id)
if request.is_ajax() :
thereturn = HttpResponse(mark_safe('<article class="deleted">Hub deleted</article>'))
else :
thereturn = HttpResponseRedirect(request.META['HTTP_REFERER'])
return thereturn
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def userSettingsView(request):
try :
authed, data = ttagServiceAuth(request)
if authed:
if request.method != "POST":
formdata = {'gender':'','google_map_address':'','pro_description':''}
for key in data :
formdata[key] = data[key]
else :
formdata = request.POST
form = SettingsForm(formdata)
context = dict()
context['form'] = form
context['data'] = data
#localprint(request, data)
context['loggedin'] = True
context['loggedin_user'] = data['_id']
context['request'] = request
context['pagetitle'] = "ttagit - User Settings Page"
return render_to_response('user_settings_details.html', context, context_instance=RequestContext(request))
else:
## user is not logged in
return HttpResponseRedirect(paths.HTTPS+request.get_host()+'/index/')
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def userFavorite(request):
try :
authed, user = ttagServiceAuth(request)
thereturn = loginscreen(request)
if authed and 'favorite_id' in request.POST :
thereturn = custompopup(request,'<p>Could not complete request</p>')
form = Favorite(request.POST)
if form.is_valid() :
access_token = request.COOKIES['access_token']
faves = ttagRequestLists(user['_id'])
id = ''
if faves['data']['favorites'] :
for item in faves['data']['favorites'] :
if 'favorite_id' in item and item['favorite_id'] == form.getFavorite_Id() and item['favorite_type'] == form.getFavorite_Type() :
id = item['_id']
break;
postData = {'access_token': access_token, 'user_id': user['_id'], 'type': form.getFavorite_Type()}
postURL = "/action/favorite"
if len(id) == 0 :
postData['favorite_id'] = form.getFavorite_Id()
postData['values'] = {'title': form.getFavorite_Title(), 'category': form.getFavorite_Category(), 'description': form.getFavorite_Description()}
else :
postData['id'] = id
postURL = "/action/unfavorite"
response = ttagPost(postURL,postData)
if request.is_ajax() :
thereturn = render_to_response("follow_ajax.html",{'request': request, 'response': response, 'id': id}, context_instance=RequestContext(request))
else :
thereturn = HttpResponseRedirect(request.META['HTTP_REFERER'])
else :
thereturn = custompopup(request,'<p>'+str(form.errors)+'</p>')
return thereturn
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def googleAuthCallback(request):
try :
state = request.GET.get('state')
localprint(request, state)
code= str(request.GET.get('code'))
exchangeToken_url = 'https://accounts.google.com/o/oauth2/token'
data = {'code':code, 'client_id':GOOGLE_CLIENT_ID, 'client_secret':GOOGLE_CLIENT_SECRET, 'redirect_uri':GOOGLE_CALLBACK_URL, 'grant_type':'authorization_code'}
headers = {'Content-Type':'application/x-www-form-urlencoded'}
h = httplib2.Http(ca_certs=certifi.where())
resp, content = h.request(exchangeToken_url, 'POST', headers=headers, body=urlencode(data))
exchange_token_obj = simplejson.loads(content)
localprint(request, exchange_token_obj)
response = None
if(exchange_token_obj.has_key('access_token')):
access_token = exchange_token_obj['access_token']
request.session['google_access_token'] = access_token
profile_url = 'https://www.googleapis.com/oauth2/v1/userinfo?access_token=' + access_token
h2 = httplib2.Http(ca_certs=certifi.where())
user_info_resp, user_info_content = h2.request(profile_url, 'GET')
user_info_obj = simplejson.loads(user_info_content)
localprint(request, user_info_obj)
if user_info_resp.status == 200:
if state == 'userpage':
response = genericSocialActivate('googleplus', user_info_obj['id'], request.COOKIES['access_token'], request, state) #access token has to be change to the right access_token
elif state == 'homepage' or state == 'signin':
response = genericSocialLogin('googleplus', user_info_obj['id'], user_info_obj['email'], request, access_token, state)
else:
response = signinError(request,'password', u"Sorry, the Google sign-in failed.")
return response
#return response
else:
return HttpResponse("<script>window.close();</script>")
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def twitterAuthCredential(request, state):
try:
consumer = oauth.Consumer(
key=TWITTER_CONSUMER_KEY,
secret=TWITTER_CONSUMER_SECRET) #@UndefinedVariable
request_token_url = 'https://twitter.com/oauth/request_token'
client = oauth.Client(consumer) #@UndefinedVariable
client.ca_certs = certifi.where()
resp, content = client.request(request_token_url, 'GET')
content_dict = content.split('&')
request.session['tw_oauth_token_secret'] = content_dict[1].split(
'=')[1]
request.session['twitter_request_state'] = state
request.session.modified = True
localprint(request,
'token_secret=' + request.session['tw_oauth_token_secret'])
oauth_token = content_dict[0].split('=')[1]
localprint(request, content)
twitter_oauth_url = 'https://api.twitter.com/oauth/authenticate?oauth_token=' + oauth_token
#return HttpResponse('<script type="text/javascript>document.location.href="'+twitter_oauth_url+'";</script>')
return HttpResponseRedirect(twitter_oauth_url)
#webbrowser.open(twitter_oauth_url, new=1, autoraise=True)
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def toggleSignin(request, data_type, data_value, user_state="USER"):
try :
thereturn = HttpResponse(mark_safe('<p>You are not authorized to access this area</p>'))
logged_in_user = get_logged_in_user(request)
if data_type == "id" :
hubid = data_value
hub = get_hub_by_id(request, hubid, logged_in_user)
if hub == None:
thereturn = assembleHubErrorResponse(request, "Sorry that Hub was not found")
elif hub.creater_id != logged_in_user.user_id :
thereturn = assembleHubErrorResponse(request, "Sorry, you don't have permission to edit this Hub's settings")
else :
updated = logged_in_user.updateState(request, user_state, hubid if user_state == 'HUB' else logged_in_user.user_id)
if updated == True and not request.is_ajax() :
thereturn = HttpResponseRedirect(request.META['HTTP_REFERER'])
elif updated == True :
loggedin = logged_in_user.is_logged_in
request.logged_in_user = logged_in_user
data = logged_in_user
jsonReturn = simplejson.dumps({
'headerOuter': mark_safe(render_to_response('partial_user_dashboard.html',locals(),context_instance=RequestContext(request)).content),
'spraycanForm': mark_safe(render_to_response('partial_spraycan_form.html',locals(),context_instance=RequestContext(request)).content)
})
thereturn = render_to_response('ajax_ttag_create.html',locals(),context_instance=RequestContext(request))
else :
thereturn = assembleHubErrorResponse(request, updated)
return thereturn
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def facebookAuthCallBack(request):
try:
if request.GET.get('code') != None:
state = str(request.GET.get('state'))
localprint(request, "fb call back session state are equal")
code = str(request.GET.get('code'))
client_id = FACEBOOK_APP_ID
client_secret = FACEBOOK_APP_SECRET
redirect_uri = FACEBOOK_APP_CALLBACK_URL
exchangeToken_url = 'https://graph.facebook.com/oauth/access_token'
#exchangeToken_url = 'https://graph.facebook.com/oauth/access_token?'+'&client_id='+client_id+'&redirect_uri='+redirect_uri+'&client_secret='+client_secret+'&code='+code
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
data = {
'client_id': client_id,
'client_secret': client_secret,
'redirect_uri': redirect_uri,
'code': code
}
h = httplib2.Http(ca_certs=certifi.where())
resp, content = h.request(exchangeToken_url,
'POST',
headers=headers,
body=urlencode(data))
#Extracting access_token from the content string
localprint(request, content)
fb_access_token = content.split('&')[0].split('=')[1]
fb_profile_url = 'https://graph.facebook.com/me?access_token=' + fb_access_token
h2 = httplib2.Http(ca_certs=certifi.where())
user_info_resp, user_info_content = h2.request(
fb_profile_url, 'GET')
user_info_obj = simplejson.loads(user_info_content)
localprint(request,
'fb user account email: ' + user_info_obj['email'])
response = None
if user_info_resp.status == 200:
if state == 'userpage':
postToFacebookWall(fb_access_token,
'Connected to Ttagit.com', request)
response = genericSocialActivate(
'facebook', user_info_obj['id'],
request.COOKIES['access_token'], request, state)
elif state == 'homepage' or state == 'signin':
response = genericSocialLogin('facebook',
user_info_obj['id'],
user_info_obj['email'],
request, fb_access_token,
state)
else:
response = signinError(request, 'password',
u"Sorry, the Facebook sign-in failed.")
return response
elif request.GET.get('request_ids') != None and request.GET.get(
'app_request_type') != None:
return redirect(paths.HTTPS + request.get_host())
else:
return HttpResponse("<script>window.close();</script>")
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def thankyou(request):
try :
from paypal.standard.pdt.views import pdt
loggedin, data = ttagServiceAuth(request)
return pdt(request, template='marketing_thankyou.html', context=locals())
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def urlOlder(request, to_time):
try:
partial = 'partial_spraycan_ttags.html' if request.is_ajax(
) else 'spraycan.html'
return url(request=request, partial=partial, to_time=to_time)
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def thankyouView(request):
try:
return HttpResponse(
'Thanks for contacting us! If applicable, someone will reply to you via your email address. In the meantime, please feel free to surf the rest of website.'
)
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def redo(request):
try:
return render_to_response('composite.html',
locals(),
context_instance=RequestContext(request))
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def inviteTwitterFriends(request):
try :
list = getFollowerCustomizedInfo("alabamama2012")
c = {"twitter_contact_list":list}
return render_to_response('test_twitter_contacts.html', c, context_instance=RequestContext(request))
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def firsttimeView(request):
try:
return render_to_response('home_firsttime.html',
locals(),
context_instance=RequestContext(request))
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def privacyView(request):
try:
loggedin, data = ttagServiceAuth(request)
return render_to_response('privacy.html',
locals(),
context_instance=RequestContext(request))
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def click(request,banner_id,owner_id):
try :
response = ttagPost('/user-ads/clicked',{'banner_id':banner_id,'owner_id':owner_id})
#print response
if response['result'] == 'OK' :
return HttpResponseRedirect(response['data']['ads']['ads_url'])
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def inviteGoogleFriends(request):
try :
access_token = request.session['google_access_token']
temp_list = getGoogleContactUrllib(access_token)
c = {'google_contact_list': temp_list}
return render_to_response('test_contacts.html', c, context_instance=RequestContext(request))
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def signupError(request, errorField, errorMessage):
try :
form = SignUpForm(request.POST)
errorInit = form.is_valid()
form._errors[errorField] = form.error_class([errorMessage])
return viewHelp(request, 'standalone_homepage.html', 'extension', 'about_extension.html', 'TTAGIT Help - Google Browser Extension', signupform=form)
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def userFavorite(request):
try:
authed, user = ttagServiceAuth(request)
thereturn = loginscreen(request)
if authed and 'favorite_id' in request.POST:
thereturn = custompopup(request,
'<p>Could not complete request</p>')
form = Favorite(request.POST)
if form.is_valid():
access_token = request.COOKIES['access_token']
faves = ttagRequestLists(user['_id'])
id = ''
if faves['data']['favorites']:
for item in faves['data']['favorites']:
if 'favorite_id' in item and item[
'favorite_id'] == form.getFavorite_Id(
) and item[
'favorite_type'] == form.getFavorite_Type(
):
id = item['_id']
break
postData = {
'access_token': access_token,
'user_id': user['_id'],
'type': form.getFavorite_Type()
}
postURL = "/action/favorite"
if len(id) == 0:
postData['favorite_id'] = form.getFavorite_Id()
postData['values'] = {
'title': form.getFavorite_Title(),
'category': form.getFavorite_Category(),
'description': form.getFavorite_Description()
}
else:
postData['id'] = id
postURL = "/action/unfavorite"
response = ttagPost(postURL, postData)
if request.is_ajax():
thereturn = render_to_response(
"follow_ajax.html", {
'request': request,
'response': response,
'id': id
},
context_instance=RequestContext(request))
else:
thereturn = HttpResponseRedirect(
request.META['HTTP_REFERER'])
else:
thereturn = custompopup(request,
'<p>' + str(form.errors) + '</p>')
return thereturn
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def userFollow(request, user_name):
try:
authed, user = ttagServiceAuth(request)
thereturn = loginscreen(request)
if authed:
thereturn = custompopup(request,
'<p>Could not complete request</p>')
access_token = request.COOKIES['access_token']
location = request.META[
'HTTP_REFERER'] if 'location' not in request.POST else request.POST[
'location']
followers = ttagRequestFollowers(user['_id'])
found = False
follower_id = 0
if 'data' in followers and 'users' in followers[
'data'] and followers['data']['users'] != None:
for follower in followers['data']['users']:
if follower['user_name'] == str(user_name):
found = True
follower_id = follower['user_id']
break
if found:
response = ttagPost(
"/follow/delete", {
'access_token': access_token,
'user_id': user['_id'],
'follower_id': follower_id,
'followee_id': user['_id']
})
else:
f_user = ttagRequestUserProfile(user_name)
follower_id = f_user['data']['_id']
response = ttagPost(
"/follow/create", {
'access_token': access_token,
'user_id': user['_id'],
'follower_id': follower_id,
'followee_id': user['_id']
})
if response["result"] == "OK":
from webapp.views.email import notifyOfUserFollowing
# send reply notification
notifyOfUserFollowing(request, follower_id, user["_id"])
response['found'] = found
# localprint(request, response)
if request.is_ajax():
thereturn = render_to_response(
'partial_user_follow.html',
locals(),
context_instance=RequestContext(request))
else:
thereturn = HttpResponseRedirect(location)
return thereturn
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def signupActivate(request):
try:
showPopup = True
return render_to_response('activate.html' if not request.is_ajax() else
'partial_activate.html',
locals(),
context_instance=RequestContext(request))
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def inviteTwitterFriends(request):
try:
list = getFollowerCustomizedInfo("alabamama2012")
c = {"twitter_contact_list": list}
return render_to_response('test_twitter_contacts.html',
c,
context_instance=RequestContext(request))
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def thankyou(request):
try:
from paypal.standard.pdt.views import pdt
loggedin, data = ttagServiceAuth(request)
return pdt(request,
template='marketing_thankyou.html',
context=locals())
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def hubWallViewOlder(request, data_type, data_value, to_time):
try :
logged_in_user, hub, details = getHubDetails(request, data_type, data_value, to_time)
if request.is_ajax() :
return details
else :
return assembleHubResponse(request, logged_in_user, hub, details, hideMiniSpraycan=True)
except:
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def postToFacebookWall(fb_access_token, message, request):
try :
headers = {'Content-Type':'application/x-www-form-urlencoded'}
fb_post_wall_url = 'https://graph.facebook.com/me/feed?access_token=' + fb_access_token
data = {'message':message}
h = httplib2.Http(ca_certs=certifi.where())
resp, content = h.request(fb_post_wall_url, 'POST', headers=headers, body=urlencode(data))
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def userAvatarUpload(request, isAndroid=False):
try :
authed, data = ttagServiceAuth(request)
if authed and request.method == 'POST' :
aToken = request.COOKIES['access_token']
formdata = {'gender':'','google_map_address':'','pro_description':''}
if len(str(request.POST.get('avatar_src',""))) > 0 and len(str(request.POST.get('avatar_name',""))) > 0 and len(str(request.POST.get('avatar_type',""))) > 0 :
files = {}
from django.core.files.uploadedfile import SimpleUploadedFile
import base64
files['avatar_upload'] = SimpleUploadedFile(request.POST['avatar_name'],base64.b64decode(mark_safe(request.POST['avatar_src'])),request.POST['avatar_type'])
else :
files = request.FILES
for key in data :
formdata[key] = data[key]
upload = UploadFileForm(request.POST, files)
statusmsg = "User Avatar update successful!"
print request.POST
if 'avatar_upload' not in request.POST and 'avatar_src' not in request.POST and len(str(request.POST.get('avatar_url',''))) > 0 :
upload = SettingsAvatarForm(request.POST)
if upload.is_valid() :
avatar_url = upload.clean_AvatarURL()
if not upload.is_valid() :
statusmsg = ''.join(["User Avatar update failed: ",upload.errors.as_text().replace('\r','').replace('\n','')])
svcResp = {'result':'ERROR','msg':statusmsg}
else :
from website.settings import MEDIA_URL
if 'avatar_delete' in request.POST or 'avatar_upload' in request.POST :
avatar_url = ''
if 'avatar_upload' in files :
avatar_url = ''.join([MEDIA_URL,handleUploadedAvatar(files['avatar_upload'], data['user_name'], aToken)])
if 'avatar_url' in locals() and avatar_url != data['avatar_url'] :
svcResp = ttagServiceAvatarChange(aToken,avatar_url)
if svcResp.get('result',"OK") == 'OK' :
svcResp['data'], data['avatar_url'] = {'filename':avatar_url}, avatar_url
else :
statusmsg = ''.join(["User Avatar update failed: ",svcResp['msg']])
svcResp['msg'] = statusmsg
else :
svcResp = {'result':'OK','msg':'Nothing changed'}
svcResp = mark_safe(simplejson.dumps(svcResp))
form = SettingsForm(formdata)
context = {'request':request,'loggedin':True,'data':data,'form':form,'settings_message':statusmsg, 'location':'Settings', 'svcResp':svcResp}
ajax_page = 'user_avataruploaded.html' if not isAndroid else 'android_avataruploaded.html'
page = ajax_page if ( request.is_ajax() or isAndroid ) else 'home_settings.html'
thereturn = render_to_response(page,context,context_instance=RequestContext(request))
if request.is_ajax() and not isAndroid and 'avatar_url' in locals() and len(str(avatar_url)) > 0 :
jsonReturn = simplejson.dumps({'userAvatar':mark_safe('<img data-dj-view="userAvatar" src="'+avatar_url+'" alt="" />'),'userAvatarForm':mark_safe(thereturn.content)})
thereturn = render_to_response('ajax_ttag_create.html',locals(),context_instance=RequestContext(request))
return thereturn
else :
return loginscreen(request)
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def uploadBackground(request, data_type, data_value):
try :
logged_in_user = get_logged_in_user(request)
if data_type == "id" :
hubid = data_value
hub = get_hub_by_id(request, hubid, logged_in_user)
if hub == None:
return assembleHubErrorResponse(request, "Sorry that Hub was not found")
elif hub.creater_id != logged_in_user.user_id :
return assembleHubErrorResponse(request, "Sorry, you don't have permission to edit this Hub's settings")
if len(str(request.POST.get('background_src',""))) > 0 and len(str(request.POST.get('background_name',""))) > 0 and len(str(request.POST.get('background_type',""))) > 0 :
files = {}
from django.core.files.uploadedfile import SimpleUploadedFile
import base64
files['background_upload'] = SimpleUploadedFile(request.POST['background_name'],base64.b64decode(mark_safe(request.POST['background_src'])),request.POST['background_type'])
else :
files = request.FILES
if request.method == 'POST' :
aToken = request.COOKIES['access_token']
upload = UploadBackgroundForm(request.POST, files)
statusmsg = "User Background update successful!"
if not upload.is_valid() :
statusmsg = ''.join(["User Background update failed: ",upload.errors.as_text().replace('\r','').replace('\n','')])
return assembleHubErrorResponse(request, statusmsg)
else :
from website.settings import MEDIA_URL
if 'background_delete' in request.POST or 'background_upload' in request.POST :
background_url = ''
if 'background_upload' in files :
background_url = ''.join([MEDIA_URL,handleUploadedAvatar(files['background_upload'], hub.hub_id, aToken, '', "400x197")])
if 'background_url' in locals() and background_url != hub.hub_image :
hub.hub_image = background_url
saved = saveHub(hub, logged_in_user, request)
if saved == True :
if not request.is_ajax :
details = render_to_response("partial_hub_settings.html",
{
"current_user": logged_in_user,
"payload": {"hub": hub},
"backgroundmessage": "Background Image uploaded successfully"
}
,context_instance=RequestContext(request))
return assembleHubResponse(request, logged_in_user, hub, details)
else :
payload = {'hub':hub}
jsonReturn = simplejson.dumps({'hubBackground':mark_safe('<img data-dj-view="hubBackground" src="'+background_url+'" alt="" />'),'hubBackgroundForm':mark_safe(render_to_response('partial_hubsettings_background.html',locals(),context_instance=RequestContext(request)).content)})
return render_to_response('ajax_ttag_create.html',locals(),context_instance=RequestContext(request))
else :
statusmsg = ''.join(["User Avatar update failed: ",saved])
return assembleHubErrorResponse(request, statusmsg)
else :
return assembleHubErrorResponse(request, 'You are not authorized to access this area')
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
def inviteGoogleFriends(request):
try:
access_token = request.session['google_access_token']
temp_list = getGoogleContactUrllib(access_token)
c = {'google_contact_list': temp_list}
return render_to_response('test_contacts.html',
c,
context_instance=RequestContext(request))
except:
logger = logging.getLogger(__name__)
return errorscreen(request, logger, sys)
def userProfileView(request, user_name='', view_type='', page='', time='', userdetails='', pagetitle='ttagit - User Profile Page', pagetemplate='user_profile.html', partial=None, hideMiniSpraycan=False):
try :
authed, data = ttagServiceAuth(request)
follow = -1
loggedin_user = '' if not authed else data['_id']
if user_name != '' :
if request.COOKIES.has_key('access_token'):
response = ttagRequestUserProfileWithAccessToken(user_name,request.COOKIES['access_token'])
else:
response = ttagRequestUserProfile(user_name)
if 'data' in response and response['data']['is_activated'] and not response['data']['is_deleted'] :
data = response['data']
if 'follow' in response :
follow = response['follow']
if loggedin_user == data['_id'] :
follow = -1
else :
return HttpResponseRedirect(reverse('home-page'))
elif data != None and 'user_name' in data :
user_name = data['user_name']
if not data or data == None :
return HttpResponseRedirect(reverse('home-page'))
response = ttagRequestCount(data['_id'])
if 'counts' in response :
counts = response['counts']
servertime = response['time']
counts['tags'] = counts['ttags']
counts['following'] = counts['followees']
else :
counts = {'tags':0,'replies':0,'followers':0,'following':0}
import time
servertime = int(time.mktime(datetime.datetime.now().timetuple())*1000)
if view_type not in ['tags','replies','following','followers','finds','favorites'] :
view_type = 'tags'
if partial is not None :
return render_to_response(partial,locals(),context_instance=RequestContext(request))
if not page or page == '' :
page = 1
page = int(page)
if not time or time == '' :
time = 0
time = int(time)
more = True if counts[view_type] > PROFILE_ITEM_ROWS * page and time == 0 else False
if userdetails == '' :
userdetails = getUserDetails(request, data, user_name, data['_id'], loggedin_user, view_type, page, time, more)
if request.is_ajax() :
return HttpResponse(userdetails)
context = {'view_type': view_type, 'data': data, 'counts': counts, 'pagetitle': pagetitle, 'request': request, 'loggedin': False, 'details': userdetails, 'page': page, 'servertime': servertime,'follow':follow, 'showfollow': True, 'hideMiniSpraycan': hideMiniSpraycan}
if authed :
context['loggedin'] = True
return render_to_response(pagetemplate, context, context_instance=RequestContext(request))
except :
logger=logging.getLogger(__name__)
return errorscreen(request,logger, sys)
