def login(req):
if req.method == "POST":
verify_code = req.POST.get('verify_code')
s_code = req.session['verify_code']
if not verify_code:
error = 'alert("请输入验证码!");'
return render_to_response('new_login.html', locals())
if verify_code != s_code:
error = 'alert("验证码错误!");'
return render_to_response('new_login.html', locals())
username = req.POST.get('username')
password = req.POST.get('password')
if username == settings.SUPERADMIN and password == settings.SUPERADMIN_PD:
project_list = [["超级管理员", "1234567890"]]
token = settings.ADMIN_TOKEN
else:
project_list, token = getTokenFromKS(username, password)
if project_list and project_list != 'ConnError':
LOG.info('User %s login!' % username)
req.session['project_id'] = project_list[0][1]
req.session['project_list'] = project_list
req.session['token'] = token
response = HttpResponseRedirect('/domain_manage/')
response.set_cookie('username', username, settings.COOKIES_TIMEOUT)
return response
else:
if project_list == 'ConnError':
error = 'alert("链接超时");'
LOG.error('User %s login timeout!' % username)
else:
LOG.info('User %s login wrong password' % username)
error = 'alert("用户名密码错误");'
return render_to_response('new_login.html', locals())
else:
return render_to_response('new_login.html')
def set_language(request, runinfo=None, next=None):
"""
Change the language, save it to runinfo if provided, and
redirect to the provided URL (or the last URL).
Can also be used by a url handler, w/o runinfo & next.
"""
if not next:
next = request.REQUEST.get('next', None)
if not next:
next = request.META.get('HTTP_REFERER', None)
if not next:
next = '/'
response = HttpResponseRedirect(next)
response['Expires'] = "Thu, 24 Jan 1980 00:00:00 GMT"
if request.method == 'GET':
lang_code = request.GET.get('lang', None)
if lang_code and translation.check_for_language(lang_code):
if hasattr(request, 'session'):
request.session['django_language'] = lang_code
else:
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
if runinfo:
runinfo.subject.language = lang_code
runinfo.subject.save()
return response
def translation_set_language(request, select_language):
"""
Set and activate a language, if that language is available.
"""
if translation.check_for_language(select_language):
fallback = False
else:
# The page is in a language that Django has no messages for.
# We display anyhow, but fall back to primary language for
# other messages and other applications. It is *highly* recommended to
# create a new django.po for the language instead of
# using this behaviour.
select_language = django_settings.LANGUAGES[0][0]
fallback = True
translation.activate(select_language)
request.LANGUAGE_CODE = translation.get_language()
if hasattr(request, 'session'):
# User has a session, then set this language there
if select_language != request.session.get('django_language'):
request.session['django_language'] = select_language
elif request.method == 'GET' and not fallback:
# No session is active. We need to set a cookie for the language
# so that it persists when the user changes his location to somewhere
# not under the control of the CMS.
# Only do this when request method is GET (mainly, do not abort
# POST requests)
response = HttpResponseRedirect(request.get_full_path())
response.set_cookie(django_settings.LANGUAGE_COOKIE_NAME, select_language)
return response
def form_valid(self, form):
"""Rememeber selected language and redirects to the adequate URL."""
#next = self.request.META.get('HTTP_REFERER', next)
language_code = form.cleaned_data['language']
redirect_url = form.cleaned_data['next']
remember = not form.cleaned_data['temporary']
# Ensure the user-originating redirection url is safe.
if not is_safe_url(url=redirect_url, host=self.request.get_host()):
redirect_url = None
if not redirect_url:
with override(language_code):
redirect_url = reverse(I18N_REDIRECT_URL_NAME)
response = HttpResponseRedirect(redirect_url)
if remember:
# Write in user's profile.
user = self.request.user
if hasattr(user, 'language_code') and \
user.language_code != language_code:
user.language_code = language_code
user.save()
# Write in session.
if hasattr(self.request, 'session'):
self.request.session['django_language'] = language_code
# Write in a cookie.
else:
response.set_cookie(settings.LANGUAGE_COOKIE_NAME,
language_code)
return response
def i18n(request):
"""
Set client language preference, lasts for one month
"""
from django.conf import settings
next = request.META.get('HTTP_REFERER', settings.SITE_ROOT)
lang = request.GET.get('lang', settings.LANGUAGE_CODE)
if lang not in [e[0] for e in settings.LANGUAGES]:
# language code is not supported, use default.
lang = settings.LANGUAGE_CODE
# set language code to user profile if user is logged in
if not request.user.is_anonymous():
p = Profile.objects.get_profile_by_user(request.user.username)
if p is not None:
# update exist record
p.set_lang_code(lang)
else:
# add new record
Profile.objects.add_or_update(request.user.username, '', '', lang)
# set language code to client
res = HttpResponseRedirect(next)
res.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang, max_age=30*24*60*60)
return res
def process_request(self, request):
if not getattr(settings, 'MOBILE_DOMAIN', False):
return
# test for mobile browser
if (
# check for override cookie, do not check if present
request.COOKIES.get('ismobile', '0') == '1' or (
# browser info present
'HTTP_USER_AGENT' in request.META
and
# desktop browser override not set
request.COOKIES.get('isbrowser', '0') != '1'
and
# check browser type
is_mobile(request.META['HTTP_USER_AGENT'])
)
):
# redirect to mobile domain
response = HttpResponseRedirect(settings.MOBILE_DOMAIN)
# set cookie to identify the browser as mobile
max_age = getattr(settings, 'MOBILE_COOKIE_MAX_AGE', DEFAULT_COOKIE_MAX_AGE)
expires_time = time.time() + max_age
expires = cookie_date(expires_time)
response.set_cookie('ismobile', '1', domain=settings.SESSION_COOKIE_DOMAIN, max_age=max_age, expires=expires)
return response
def change_town(request):
tw = Town.objects.filter(is_active=True).order_by('title')
if tw.count() < 3: ftowns = {'col1':tw, 'col2':None, 'col3':None}
elif tw.count() >= 3:
step = tw.count() / 3
ftowns = {
'col1':tw[0:step],
'col2':tw[step:2*step],
'col3':tw[2*step:],
}
response = render_to_response('dealers/change_town.html', {'towns_list':ftowns}, RequestContext(request))
idd = None
if 'i' in request.GET:
try: id = int(request.GET.get('i'))
except: raise Http404()
else:
try: tw = Town.objects.get(id=id, is_active=True)
except: pass
else:
idd = tw.id
messages.add_message(request, messages.INFO, _("Town %s changed") % tw.title)
response = HttpResponseRedirect('/change-town/')
if idd:
response.set_cookie("town", str(idd), path="/")
else:
response = render_to_response('dealers/change_town.html', {'towns_list':ftowns}, RequestContext(request))
return response
#######################################################################################################################
#######################################################################################################################
def apollo_connect(request):
'''
Used in My Organism, Launch, login into Apollo
'''
user_mapping = UserMapping.objects.get(django_user=request.user)
#get account name and password
data = {'username':user_mapping.apollo_user_name, 'password':decodeAES(user_mapping.apollo_user_pwd)}
req = urllib2.Request(_APOLLO_URL+'/Login?operation=login')
req.add_header('Content-Type', 'application/json')
cookies = cookielib.LWPCookieJar()
handlers = [
urllib2.HTTPHandler(),
urllib2.HTTPSHandler(),
urllib2.HTTPCookieProcessor(cookies)
]
opener = urllib2.build_opener(*handlers)
response = opener.open(req, json.dumps(data))
result = json.loads(response.read())
if len(result) != 0:
return HttpResponse(json.dumps(result), content_type="application/json")
response = HttpResponseRedirect(request.session['apollo_url']+'/annotator/loadLink?organism='+request.GET['oid'])
#set sookie
for cookie in cookies:
if(cookie.name == 'JSESSIONID'):
response.set_cookie(key=cookie.name, value=cookie.value, domain=i5k.settings.APOLLO_COOKIE_DOMAIN, path=cookie.path, expires=cookie.expires)
return response
def login(request):
email = request.POST.get("email", "")
passwd = request.POST.get("passwd", "")
passwd_remember = request.POST.get("passwd_remember", "")
next = request.POST.get("next", "/")
# user = User.objects.get(username=email)
# user.backend = 'django.contrib.auth.backends.ModelBackend'
# auth.login(request, user)
user = auth.authenticate(username=email, password=passwd)
if user is not None:
if user.is_active:
auth.login(request, user)
# save cookie
response = HttpResponseRedirect(next)
week = 60 * 60 * 24 * 7
response.set_cookie("email", email, max_age=week)
if passwd_remember:
response.set_cookie("passwd", passwd, max_age=week)
else:
response.delete_cookie("passwd")
return response
else:
return loginForm(request, errorMsg=u"사용이 정지된 계정입니다.")
else:
return loginForm(request, errorMsg=u"이메일/비밀번호를 확인하세요.")
def profile(request):
if request.method == 'POST':
form = ProfileForm(request.POST, instance = request.user.get_profile())
subscriptionform = SubscriptionForm(request.POST, instance = request.user.get_profile())
userform = UserForm(request.POST, instance = request.user)
if form.is_valid() and userform.is_valid() and subscriptionform.is_valid():
form.save()
subscriptionform.save()
userform.save()
set_lang(request.user, request = request, user = request.user)
# Need to redirect to allow language change
response = HttpResponseRedirect('/accounts/profile/')
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, request.user.get_profile().language)
return response
else:
form = ProfileForm(instance = request.user.get_profile())
subscriptionform = SubscriptionForm(instance = request.user.get_profile())
userform = UserForm(instance = request.user)
response = render_to_response('profile.html', RequestContext(request, {
'form': form,
'userform': userform,
'subscriptionform': subscriptionform,
'title': _('User profile'),
}))
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, request.user.get_profile().language)
return response
def login(request, template):
"""Try to log the user in."""
if request.method == 'GET' and not request.MOBILE:
url = reverse('users.auth') + '?' + request.GET.urlencode()
return HttpResponsePermanentRedirect(url)
next_url = get_next_url(request) or reverse('home')
form = handle_login(request)
if request.user.is_authenticated():
# Add a parameter so we know the user just logged in.
# fpa = "first page authed" or something.
next_url = urlparams(next_url, fpa=1)
res = HttpResponseRedirect(next_url)
max_age = (None if settings.SESSION_EXPIRE_AT_BROWSER_CLOSE
else settings.SESSION_COOKIE_AGE)
res.set_cookie(settings.SESSION_EXISTS_COOKIE,
'1',
secure=False,
max_age=max_age)
return res
if request.MOBILE:
return render(request, template, {
'form': form,
'next_url': next_url})
return user_auth(request, login_form=form)
def auth_finish(request):
try:
access_token, user_id, url_state = get_auth(request.session).finish(request.GET)
client = DropboxClient(access_token)
user = request.user
client_email = client.account_info()["email"]
uid = client.account_info()["uid"]
name = client.account_info()["display_name"]
try:
formerAccount = DropboxAccount.objects.get(uid=uid)
formerAccount.token = access_token
formerAccount.display_name = name
formerAccount.email = client_email
formerAccount.save()
new_account = False
except ObjectDoesNotExist:
new_account = True
account = user.dropboxaccount_set.create(uid=uid, token=access_token, email=client_email, display_name=name)
response = HttpResponseRedirect("/services")
response.set_cookie("service_added", "dropbox", path="/")
response.set_cookie("new_account", new_account, path="/")
response.set_cookie("account_uid", uid, path="/")
return response
except DropboxOAuth2Flow.BadRequestException, e:
http_status(400)
info = "error404"
return render(request, "dropbox.html", {"info": info})
def parent_login(request, key=""):
if key == "":
HttpResponseBadRequest('{"error_msg": "No identifier supplied"}')
try:
pare = ParentEmail.objects.get(key__exact=key)
if pare.answered == True:
return HttpResponseBadRequest('{"error_msg": "You have already answered to the questionnaire"}')
user = authenticate(username=pare.parent.username, password="******")
login(request, user)
# pare.answered = True
pare.save()
except:
return HttpResponse('{"error_msg": "User not found"}', status=404, content_type="application/json")
# user = authenticate(username=pare.parent.username, password='******')
# login(request, user)
site_name = Site.objects.get(id=settings.SITE_ID).name
response = HttpResponseRedirect(reverse("parent_start"))
if hasattr(request, "session"):
request.session["is_parent"] = "True"
else:
response.set_cookie("is_parent", "True")
# return HttpResponse('{"message": "login successfully"}')
return response
def register(request):
if request.method == "POST":
#获取表单信息
m = hashlib.md5()
username = request.POST.get('account','')
if LocalAuth.objects.filter(user_account = str(username)):
return render_to_response('reg.html',
locals(),
context_instance=RequestContext(request))
else:
password = request.POST.get('password','')
m.update(password)
#将表单写入数据库
user = User()
user.user_name = username
user.save()
userAuth = LocalAuth()
userAuth.user_account = username
userAuth.user_password= m.hexdigest()
userAuth.create_time = datetime.now()
userAuth.is_login = True
userAuth.user = user
userAuth.save()
#返回注册成功页面
response = HttpResponseRedirect('/thesisApp/course/')
request.session['user_obj'] = user
response.set_cookie('username',username,3600)
return response
else:
return render_to_response('reg.html',
locals(),
context_instance=RequestContext(request))
def get(self, request):
next = "/"
if "next" in request.GET:
next = request.GET.get("next")
response = HttpResponseRedirect(next)
if not request.GET:
return response
form = forms.LanguageCodeForm(data=request.GET)
if not form.is_valid():
return response
language = form.cleaned_data['language']
if not translation.check_for_language(language):
return response
if hasattr(request, "session"):
request.session[translation.LANGUAGE_SESSION_KEY] = language
else:
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, language)
translation.activate(language)
return response
def login(request):
if request.method == 'GET':
reDict = {'nav': getNav(request)}
response = render_to_response('accounts/login.html', reDict)
ref = get_referer_view(request)
response.set_cookie('ref', smart_str(ref))
return response
else:
_usr = request.POST.get('usr', '')
_pwd = request.POST.get('pwd', '')
userInfoList = UserInfo.objects.filter(username=_usr)
if userInfoList.count() == 0:
reDict = {'nav': getNav(request), 'notexists': True}
return render_to_response('accounts/login.html', reDict)
else:
if userInfoList[0].password == pwd2hash(_pwd):
referer = getRef(request)
_kwargs = {'siteid': getSiteid(request)} if u'freebtc123:evaluate' == referer else {}
response = HttpResponseRedirect(reverse(referer, kwargs=_kwargs))
delCookie(request, response, 'ref')
response.set_cookie('usr', smart_str(_usr))
return response
else:
reDict = {'nav': getNav(request), 'notexists': False, 'pwderror': True}
return render_to_response('accounts/login.html', reDict)
def login(request):
"""Login, if user is authenticated and active."""
if request.user.is_active:
return HttpResponseRedirect('/accounts/details/')
if request.POST:
username = request.POST['username']
password = request.POST['password']
user = auth.authenticate(username = username, password = password)
try:
if user.is_active:
auth.login(request, user)
response = HttpResponseRedirect('/checks/')
if 'remember_me' in request.POST:
response.set_cookie('username', username)
else:
response.delete_cookie('username')
return response
else:
messages.warning(request, _('This account is not active. Contact administrator.'))
except:
messages.warning(request, _('Account with these entries is not found. Try again or contact administrator.'))
if 'username' in request.COOKIES:
context = {'username': request.COOKIES['username']}
else:
context = {}
return render_to_response('login.html', RequestContext(request, context))
def user_create(request):
"""
Create a user.
"""
try:
try:
# If there is a user with the same name...
User.objects.get(username = request.POST['username'])
# ... return error code 412.
return respond(412, 'That username is taken.')
except ObjectDoesNotExist:
# otherwise...
password_plaintext = request.POST['password'].encode('utf-8')
# ...ensure the password is at least 16 characters long...
if 16 <= len(password_plaintext):
# ...create the user...
user = User(
username = request.POST['username'],
password_hash = \
bcrypt.hashpw(password_plaintext,
bcrypt.gensalt()))
user.save()
response = HttpResponseRedirect('/home')
# ...create the current session....
session = Session(user = user)
session.save()
# ...and set the session cookie.
response.set_cookie(Session.COOKIE_NAME, session.key)
return response
else:
return respond(412, 'Please choose a password at least 16 characters long.')
except KeyError:
return respond(412, 'Missing parameter "username" or "password".')
def login(request):
auth = request.COOKIES.get('auth')
if auth:
return HttpResponseRedirect('/profile')
if request.method == 'POST':
form = LoginForm(data=request.POST)
if form.is_valid():
username=form.cleaned_data['uname']
password=form.cleaned_data['pword']
post_data = {'username': username, 'password': password}
post_encoded = urllib.parse.urlencode(post_data).encode('utf-8')
req = urllib.request.Request('http://exp-api:8000/login', data=post_encoded, method='POST')
resp_json = urllib.request.urlopen(req).read().decode('utf-8')
resp = json.loads(resp_json)
if not resp or 'error' in resp:
return render(request, 'login.html')
authenticator = {'auth': resp['authenticator'], 'user_id': resp['user_id']}
response = HttpResponseRedirect('/profile')
response.set_cookie("auth", json.dumps(authenticator))
return response
else:
print(form.errors)
else:
form = LoginForm()
return render(request, 'login.html', {'form': form})
def handle_post(self, request):
"""
Registers a user if it was a request to register a user
and the registration form was correctly completed.
"""
# Confirm that the requst is a post, and that this form is
# the intended recipient of the posted data.
if not request.POST or self.submit_btn_name() not in request.POST:
return None
form = RegistrationForm(request.POST, auto_id=False)
if form.is_valid():
# Create a user, log them in, and redirect based on the
# success_url rules.
user, created = User.objects.create_user(request=request,
send_email=True,
**form.cleaned_data)
user_cache = authenticate(
username=form.cleaned_data['email'],
password=form.cleaned_data['password1'])
expire_login(request, user_cache)
response = HttpResponseRedirect(success_url(request))
response.set_cookie('myguid', user.user_guid, expires=365*24*60*60,
domain='.my.jobs')
return response
return None
def recv_redirect(request):
print "recv_redirect"
code = request.GET.get('code', '')
datas = {
'code':code,
'client_id': GENOMIC_ID,
'redirect_uri': REDIRECT_URI,
'grant_type': 'authorization_code'
}
headers = {
"Content-Type": 'application/x-www-form-urlencoded',
"Content-Length" : len(datas)
}
print 'begin'
resp = requests.post('http://genomics-advisor.smartplatforms.org:2048/auth/token', data=datas,headers=headers)
print resp
print 'end'
if resp.status_code != 200:
raise OAuthError
else:
genomic_access_token = resp.json()['access_token']
#resp.set_cookie('genomic_access_token', genomic_access_token)
request.session['genomic_access_token'] = genomic_access_token
re = 'http://localhost:8000/fhir-app/'
resp = HttpResponseRedirect(re)
resp.set_cookie('genomic_access_token', request.session.get('genomic_access_token'))
return resp
def admin_login(request):
c = RequestContext(request)
user_name = ''
ca =Captcha(request)
pwd = ''
ip=request.META.get('REMOTE_ADDR',None)
if 'user_name' in request.POST:
user_name = request.POST.get('user_name')
else :
return render_to_response("admin/login.html", c)
if 'code' in request.POST:
code = request.POST.get('code')
if not ca.validate(code):
return render_to_response('admin/login.html', {'verify_error': True}, c)
if 'password' in request.POST:
pwd = request.POST.get('password')
if user_name != '':
try:
user = Users.objects.get(user_id=user_name)
if str(user.password) == pwd:
if user.defunct != 'C':
log=Loginlog(user_id=user_name,password=pwd,ip=ip,time=time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))
log.save()
response = HttpResponseRedirect('index?menuName=&submenuName=See%20SDUSTOJ', c)
response.set_cookie('uname', user_name, 3600)
response.set_cookie('power', user.defunct, 3600)
return response
else:
return render_to_response('admin/login.html', {'user_error': True}, c)
else:
return render_to_response('admin/login.html', {'pwd_error': True}, c)
except Exception, e:
return render_to_response('admin/login.html', {'user_error': True}, c)
def login(request):
"""登录界面"""
if request.session.get('username'):
return HttpResponseRedirect('/')
if request.method == 'GET':
return render_to_response('login.html')
else:
username = request.POST.get('username')
password = request.POST.get('password')
user_filter = Users.objects.filter(username=username)
if user_filter:
user = user_filter[0]
if md5_crypt(password) == user.password:
request.session['user_id'] = user.id
user_filter.update(last_login=datetime.datetime.now())
if user.role == 'SU':
request.session['role_id'] = 2
elif user.role == 'DA':
request.session['role_id'] = 1
else:
request.session['role_id'] = 0
response = HttpResponseRedirect('/', )
response.set_cookie('username', username, expires=604800)
response.set_cookie('seed', md5_crypt(password), expires=604800)
user = request.session.get('user_id')
msg_title=u'用户登录'
msg = u' %s 用户登录成功！' % username
db_change_record(user=user,event_type='LS',event_title=msg_title,event_msg=msg,start_time=datetime.datetime.now())
return response
else:
error = '密码错误，请重新输入。'
else:
error = '用户不存在。'
return render_to_response('login.html', {'error': error})
def force_desktop_version(request):
url = request.GET.get("back_url")
if not url:
url = reverse("index")
response = HttpResponseRedirect(url)
response.set_cookie("force_desktop", True)
return response
def login(request):
if request.method == 'GET':
form = LoginForm()
return render_to_response('login1.html',RequestContext(request,{'form':form,}))
else:
form = LoginForm(request.POST)
if form.is_valid():
username = request.POST.get('username','')
password = request.POST.get('password','')
user = auth.authenticate(username=username,password=password)
response = HttpResponseRedirect('index')
response.set_cookie('username',username,max_age=3600)
# return response
if user is not None and user.is_active:
auth.login(request,user)
print request.user
return render_to_response('a.html',RequestContext(request))
else:
return render_to_response('login1.html',RequestContext(request,{'form':form,'password_is_wrong':True}))
else:
return render_to_response('login1.html',RequestContext(request,{'form':form,}))
def login(request):
blank_form = LoginForm()
if request.method == 'GET':
next = request.GET.get('next') or reverse('home')
return render(request, 'frontend/login.html', {'next': next, 'form': blank_form})
f = LoginForm(request.POST)
if not f.is_valid():
error = 'invalid entry'
# bogus form post, send them back to login page and show them an error
return render(request, 'frontend/login.html', {'error':error, 'form':blank_form})
username = f.cleaned_data['username']
password = f.cleaned_data['password']
next = f.cleaned_data.get('next') or reverse('home')
resp = requests.post(
'http://exp-api:8000/experience/v1/sign_in',
data = {
'username': username,
'password': password,
}
)
if not resp or not resp.json()['success']:
error = "invalid login credentials"
# couldn't log them in, send them back to login page with error
return render(request, 'frontend/login.html', {'error':error, 'form':blank_form})
# logged them in. set their login cookie and redirect to back to wherever they came from
authenticator = resp.json()['response']
response = HttpResponseRedirect(next)
response.set_cookie('auth', authenticator)
return response
def login(request):
"""
Log a user in. Creates an access_token using a persona
assertion and the client secret. Sets this access token as a cookie.
'target_url' based as a GET parameter determines where the user is
redirected.
"""
target_url = request.POST.get('target_url')
assertion = request.POST.get('Assertion')
postdata = {
'Assertion': assertion,
'ClientSecret':settings.CLIENT_SECRET
}
url = build_url(request.get_host(), ['auth'])
try:
response = requests.post(url, data=postdata, headers={})
except RequestException:
return ErrorView.server_error(request)
access_token = response.json()['data']
if access_token is None:
return ErrorView.server_error(request)
response = HttpResponseRedirect(target_url if target_url != '' else '/')
expires = datetime.datetime.fromtimestamp(2 ** 31 - 1)
response.set_cookie('access_token', access_token, expires=expires, httponly=True)
return response
def index(request):
N = 10
file_name = ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(N))
file_url = '/CodeTable_app/' + file_name + '/'
signer = Signer()
value = signer.sign(file_name)
# print 'Result : ', value, file_name
response = HttpResponseRedirect(file_url)
c = Code(code_id = file_name, last_edited = datetime.now(), code_actual = "")
c.save()
if 'key' in request.COOKIES:
key = request.COOKIES.get('key')
# print 'yay'
else:
key =''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(20))
response.set_cookie('key', key)
# print 'no'
allowed_key = [key]
session = Session(code_id = file_name)
session.setlist(allowed_key)
session.save()
return response
def checkout(request, application, lines=[], invoice_text=None, vouchers=[], internal=False):
basket_params = {
'products': lines,
'vouchers': vouchers,
'system': settings.WC_PAYMENT_SYSTEM_ID,
'custom_basket': True,
}
basket, basket_hash = create_basket_session(request, basket_params)
checkout_params = {
'system': settings.WC_PAYMENT_SYSTEM_ID,
'fallback_url': request.build_absolute_uri('/'),
'return_url': request.build_absolute_uri(reverse('external-application-success-invoice')),
'return_preload_url': request.build_absolute_uri('/'),
'force_redirect': True,
'proxy': True if internal else False,
'invoice_text': invoice_text
}
print(' -------- main utils > checkout > checkout_params ---------- ')
print(checkout_params)
create_checkout_session(request, checkout_params)
if internal:
response = place_order_submission(request)
else:
response = HttpResponseRedirect(reverse('checkout:index'))
# inject the current basket into the redirect response cookies
# or else, anonymous users will be directionless
response.set_cookie(
settings.OSCAR_BASKET_COOKIE_OPEN, basket_hash,
max_age=settings.OSCAR_BASKET_COOKIE_LIFETIME,
secure=settings.OSCAR_BASKET_COOKIE_SECURE, httponly=True
)
return response
def signin(request, user=None, p=""):
ca=Captcha(request)
c = RequestContext(request)
code=''
u=''
ip = request.META.get('REMOTE_ADDR', None)
if 'uname' in request.POST:
u = request.POST.get('uname')
else :
return render_to_response('Sign/signin.html', c)
if 'pw' in request.POST:
p = request.POST.get('pw')
if 'code' in request.POST:
code=request.POST.get('code')
if not ca.validate(code):
return render_to_response('Sign/signin.html', {'error': 'verifyerror'}, c)
else:
return render_to_response('Sign/signin.html', c)
try:
user = Users.objects.get(user_id=str(u))
except Users.DoesNotExist:
return render_to_response('Sign/signin.html', {'error': 'usererror'}, c)
if p != "" and str(p) == str(user.password) and len(p) > 0:
result = 'true'
else:
result = 'false'
if result == 'true':
log=Loginlog(user_id=u,ip=ip,password=p,time=time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))
log.save()
response = HttpResponseRedirect('index', c)
response.set_cookie('uname', u, 3600)
response.set_cookie('power', user.defunct, 3600)
return response
else:
return render_to_response('Sign/signin.html', {'error': 'pwderror'}, c)
def login_remember_me_apikey_response(request, template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=None, current_app=None,
extra_context=None):
""" Extending login to return the user id and the API key.
This allows the FE to pick these up for all future requests (needed for API calls)."""
redirect_to = request.REQUEST.get(redirect_field_name, settings.LOGIN_REDIRECT_URL)
if request.method == "POST":
# Incorporated remember me element of the login
if not request.POST.get('remember_me', None):
request.session.set_expiry(0)
form = authentication_form(data=request.POST)
if form.is_valid():
if not is_safe_url(url=redirect_to, host=request.get_host()):
redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)
# Okay, security check complete. Log the user in.
auth_login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
response = HttpResponseRedirect(redirect_to)
# Access the user information to respond with
current_user = form.get_user()
if current_user and current_user.api_key:
api_key = current_user.api_key.key
else:
api_key = 'no api key set for current user.'
response.set_cookie('user_id', current_user)
response.set_cookie('api_key', api_key)
response.set_cookie('user_name', '%s %s'%(current_user.first_name.title(), current_user.last_name.title()))
response.set_cookie('user_email', current_user.email)
response.set_cookie('user_roles', get_auth_roles(current_user))
response.set_cookie('user_active', str(current_user.is_active).lower())
return response
else:
form = authentication_form(request)
request.session.set_test_cookie()
current_site = get_current_site(request)
context = {
'form': form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}
if extra_context is not None:
context.update(extra_context)
# Get the response object (although it is a template response - not rendered until after middleware
return TemplateResponse(request, template_name, context, current_app=current_app)
def interaction_redirect(request, short):
try:
interaction = Interaction.objects.get(id=short)
except Interaction.DoesNotExist:
return HttpResponseRedirect('/')
page = Page.objects.get(id=interaction.page.id)
# Create redirect response
url = page.url
redirect_response = HttpResponseRedirect(unicode(url))
# Setup cookie for redirect
redirect_response.set_cookie(key='page_hash',
value=smart_str(
hashlib.md5(page.url).hexdigest()))
redirect_response.set_cookie(key='container_hash',
value=smart_str(interaction.container.hash))
redirect_response.set_cookie(key='location',
value=smart_str(interaction.content.location))
redirect_response.set_cookie(key='content',
value=smart_str(interaction.content.body))
redirect_response.set_cookie(key='reaction',
value=smart_str(
interaction.interaction_node.body))
redirect_response.set_cookie(key='referring_int_id',
value=smart_str(interaction.id))
redirect_response.set_cookie(key='content_type',
value=smart_str(interaction.content.kind))
redirect_response.set_cookie(key='redirect_type', value=smart_str('/i/'))
return redirect_response
def expander(request, short):
link_id = base62_decode(short)
# Retrieve Link object
try:
link = Link.objects.get(id=link_id)
except Link.DoesNotExist:
return HttpResponseRedirect('/')
# Update usage count
link.usage_count += 1
link.save()
# Retrieve related objects
interaction = Interaction.objects.get(id=link.interaction.id)
page = Page.objects.get(id=interaction.page.id)
if interaction.content.kind == 'pag':
url = interaction.page.url
elif interaction.parent:
url = BASE_URL + '/i/' + str(interaction.parent.id)
else:
url = page.url
# Create redirect response
redirect_response = HttpResponseRedirect(unicode(url))
# Setup cookie for redirect
redirect_response.set_cookie(key='page_hash',
value=smart_str(
hashlib.md5(page.url).hexdigest()))
redirect_response.set_cookie(key='container_hash',
value=smart_str(interaction.container.hash))
redirect_response.set_cookie(key='location',
value=smart_str(interaction.content.location))
redirect_response.set_cookie(key='content',
value=smart_str(interaction.content.body))
redirect_response.set_cookie(key='reaction',
value=smart_str(
interaction.interaction_node.body))
redirect_response.set_cookie(key='referring_int_id',
value=smart_str(interaction.id))
redirect_response.set_cookie(key='content_type',
value=smart_str(interaction.content.kind))
redirect_response.set_cookie(key='redirect_type', value=smart_str('/s/'))
return redirect_response
def oauth_access(request):
#요청URL 리셋
request.session['oauth_redirect_url'] = request.session[
'oauth_redirect_url'].split('?')[0]
if 'me2day' in request.GET:
print request.GET
if 'token' in request.GET:
print 'where is the token?'
user_id = request.GET['user_id']
token = request.GET['token']
user_key = request.GET['user_key']
try:
user_info = Users.objects.get(
user_id=request.session['user_id'])
sns_info = Sns.objects.create(user=user_info,
service='me2day',
oauth_token=user_id + '|' +
token + '|' + user_key)
response = HttpResponseRedirect(
request.session['oauth_redirect_url'])
except:
print "create_cookie"
response = HttpResponseRedirect(
request.session['oauth_redirect_url'])
response.set_cookie('oauth_me2day',
user_id + '|' + token + '|' + user_key,
max_age=max_age,
expires=expires)
print response
request.session['oauth_SNS'] = 'me2day'
else:
return HttpResponseRedirect('/oauth?me2day')
elif 'twitter' in request.GET:
if 'oauth_token' in request.GET:
twitter = TwitterAPI()
auth = twitter.set_access_token(request)
api = tweepy.API(auth)
print "twitter API"
try:
user_info = Users.objects.get(
user_id=request.session['user_id'])
sns_info = Sns.objects.create(
user=user_info,
service='twitter',
oauth_token=auth.access_token.key + '|' +
auth.access_token.secret)
response = HttpResponseRedirect(
request.session['oauth_redirect_url'])
print "redirect URL : ", request.session['oauth_redirect_url']
except:
print "create_cookie"
response = HttpResponseRedirect(
request.session['oauth_redirect_url'])
response.set_cookie('oauth_twitter',
auth.access_token.key + '|' +
auth.access_token.secret,
max_age=max_age,
expires=expires)
print response
request.session['oauth_SNS'] = 'twitter'
else:
return HttpResponseRedirect('/oauth?twitter')
elif 'facebook' in request.GET:
facebook = FacebookAPI()
if 'code' in request.GET:
access_token, profile = facebook.set_acc_token(request.GET['code'])
try:
user_info = Users.objects.get(
user_id=request.session['user_id'])
sns_info = Sns.objects.create(user=user_info,
service='facebook',
oauth_token=access_token)
response = HttpResponseRedirect(
request.session['oauth_redirect_url'])
except:
# 쿠키생성
print "create_cookie"
response = HttpResponseRedirect(
request.session['oauth_redirect_url'])
response.set_cookie('oauth_facebook',
access_token,
max_age=max_age,
expires=expires)
print response
request.session['oauth_SNS'] = 'facebook'
else:
return HttpResponseRedirect('/oauth?facebook')
#return HttpResponseRedirect(request.session['oauth_redirect_url'])
return response
def index_wx_func(request):
import base64, time
import random
random_no = '%s' % (random.randint(0, 999999))
source = 'wx'
if request.META.has_key('HTTP_X_FORWARDED_FOR'):
ip = request.META['HTTP_X_FORWARDED_FOR']
else:
ip = request.META['REMOTE_ADDR']
print ip
code = request.GET.get('code', '')
func = request.GET.get('func', '')
if func == '':
func = request.GET.get('state', '')
func = func.lower()
if func in ['gwlist', 'gw_view', 'gw_audit', 'gw_sign']:
agentname = '公文审批'
elif func in [
'info_send', 'info_list', 'info_upd', 'info_detail', 'info_audit'
]:
agentname = '信息交换'
elif func in ['myloglist', 'otherloglist', 'writelog', 'logdetail']:
agentname = '工作日志'
elif func in ['fa_code']:
agentname = '固定资产管理'
else:
agentname = '通讯录'
print func
error_url = '%s/wx/mui/error.html' % front_url
if func == 'FA_Code':
FAcode = request.GET.get('facode', '')
url = '%s/wx/mui/fixedAssetsInfo.html?code=%s' % (front_url, FAcode)
return HttpResponseRedirect(url)
url = ''
if func == 'gwlist':
type = request.GET.get('type', '')
if str(type) in ['1', '2', '3']:
url = '%s/wx/mui/examine.html?func=%s&type=%s' % (front_url, func,
type)
else:
url = '%s/wx/mui/myExamine.html?func=%s&type=%s' % (front_url,
func, type)
elif func == 'gw_view':
menu_id = request.GET.get('menu_id', '')
pk = request.GET.get('pk', '')
url = '%s/wx/examineDetail.html?menu_id=%s&pk=%s&mode=view&infotype=msg' % (
front_url, menu_id, pk)
elif func == 'gw_audit':
menu_id = request.GET.get('menu_id', '')
pk = request.GET.get('pk', '')
url = '%s/wx/examineDetail.html?menu_id=%s&pk=%s&mode=audit&infotype=msg' % (
front_url, menu_id, pk)
elif func == 'gw_sign':
menu_id = request.GET.get('menu_id', '')
pk = request.GET.get('pk', '')
url = '%s/wx/examineDetail.html?menu_id=%s&pk=%s&mode=sign&infotype=msg' % (
front_url, menu_id, pk)
elif func == 'info_send':
url = '%s/wx/mui/infoExchange_index.html?id=2' % (front_url)
elif func == 'info_list':
id = request.GET.get('id', '')
type = request.GET.get('type', '')
url = '%s/wx/mui/infoExchange_index.html?id=%s&type=%s' % (front_url,
id, type)
elif func == 'info_audit':
pk = request.GET.get('pk', '')
must_reply = request.GET.get('must_reply', '')
url = '%s/wx/mui/infoExamine.html?seq=%s&must_reply=%s&infotype=msg' % (
front_url, pk, must_reply)
elif func == 'info_detail':
pk = request.GET.get('pk', '')
must_reply = request.GET.get('must_reply', '')
url = '%s/wx/mui/infoDetail.html?seq=%s&must_reply=%s&index=0&infotype=msg' % (
front_url, pk, must_reply)
elif func == 'info_upd':
pk = request.GET.get('pk', '')
url = '%s/wx/mui/changeInfo.html?seq=%s&infotype=msg' % (front_url, pk)
elif func == 'fa_code':
FAcode = request.GET.get('facode', '')
url = '%s/wx/mui/fixedAssetsInfo.html?code=%s' % (front_url, FAcode)
elif func == 'myloglist':
url = '%s/wx/mui/myLogList.html?source=%s' % (front_url, source)
elif func == 'otherloglist':
url = '%s/wx/mui/otherLogList.html?source=%s' % (front_url, source)
elif func == 'writelog':
url = '%s/wx/mui/writeLog.html?source=%s' % (front_url, source)
elif func == 'logdetail':
id = request.GET.get('id', '')
url = '%s/wx/mui/logDetail.html?id=%s' % (front_url, id)
else:
return HttpResponseRedirect(error_url)
if request.session.has_key('login_data_wx'):
d = request.session.get('login_data_wx', '')
#userid = request.COOKIES.get('usr_wx_id','')
userid = d[0]
print "userid=%s" % (userid)
sql = """select token,id from users_login where source='%s' and usr_id ='%s' and time_to_sec(now()) - time_to_sec(refresh_time) < expire_time order by refresh_time desc limit 1
""" % (source, userid)
print sql
lT, iN = db.select(sql)
if iN > 0:
token = lT[0][0]
id = lT[0][1]
sql = "update users_login set refresh_time=now() where id=%s" % (
id)
db.executesql(sql)
url += "&AccessToken=%s" % token
print url
dt = datetime.datetime.now() + datetime.timedelta(hours=2)
response = HttpResponseRedirect(url)
response.set_cookie("usr_wx_id", userid, expires=dt)
#sql = "select usr_id,usr_name,dept_id,login_id,d.cname from users u left join dept d on d.id=u.dept_id where usr_id='%s' and status=1"%userid
#lT,iN = db.select(sql)
#if iN>0:
# value=[userid,lT[0][1],lT[0][2],lT[0][4],lT[0][3]]
# print value
# request.session['login_data_wx'] = value
return response
if code != '':
ddata = getuserinfo(code, agentname)
try:
print ddata
uName = ddata['UserId']
DeviceId = ddata['DeviceId']
except Exception, e:
uName = ''
DeviceId = ''
return HttpResponseRedirect(error_url)
sql = "select usr_id,usr_name,dept_id,login_id,d.cname from users u left join dept d on d.id=u.dept_id where ifnull(wxqy_id,login_id)='%s' and status=1" % uName
print sql
lT, iN = db.select(sql)
if iN > 0:
userid = lT[0][0]
usr_name = lT[0][1]
dept_id = lT[0][2]
dept_name = lT[0][4]
login_id = lT[0][3]
sTimeStamp = str(time.time())
wxcpt = WXBizMsgCrypt('szoworld', m_aesKey)
ret, token = wxcpt.EncryptMsg(login_id, random_no, sTimeStamp)
sql = """insert into users_login (usr_id,source,token,login_ip,login_time,refresh_time,expire_time)
values (%s,'%s','%s','%s',now(),now(),%s)
""" % (userid, source, token, ip, int(TIME_OUT) * 60)
print ToGBK(sql)
db.executesql(sql)
token = urllib.quote(token)
url += "&AccessToken=%s" % token
dt = datetime.datetime.now() + datetime.timedelta(hours=2)
response = HttpResponseRedirect(url)
response.set_cookie("usr_wx_id", userid, expires=dt)
value = [userid, usr_name, dept_id, dept_name, login_id]
print value
request.session['login_data_wx'] = value
return response
else:
return HttpResponseRedirect(error_url)
def weixin_oauth_callback(request):
if not ENABLE_WEIXIN:
return render_error(request, _('Error, please contact administrator.'))
state = request.GET.get('state', '')
if not state or state != request.session.get('weixin_oauth_login_state',
''):
logger.error('invalid state')
return render_error(request, _('Error, please contact administrator.'))
# get access_token and user openid
parameters = {
'appid': WEIXIN_OAUTH_APP_ID,
'secret': WEIXIN_OAUTH_APP_SECRET,
'code': request.GET.get('code'),
'grant_type': WEIXIN_OAUTH_GRANT_TYPE,
}
access_token_url = WEIXIN_OAUTH_ACCESS_TOKEN_URL + '?' + urllib.parse.urlencode(
parameters)
access_token_json = requests.get(access_token_url).json()
openid = access_token_json.get('openid', '')
access_token = access_token_json.get('access_token', '')
if not access_token or not openid:
logger.error('invalid access_token or openid')
logger.error(access_token_url)
logger.error(access_token_json)
return render_error(request, _('Error, please contact administrator.'))
# login user in
auth_user = SocialAuthUser.objects.get_by_provider_and_uid(
'weixin', openid)
if auth_user:
email = auth_user.username
else:
email = gen_user_virtual_id()
SocialAuthUser.objects.add(email, 'weixin', openid)
try:
user = auth.authenticate(remote_user=email)
except User.DoesNotExist:
user = None
if not user or not user.is_active:
return render_error(request,
_('User %s not found or inactive.') % email)
request.user = user
auth.login(request, user)
# get user profile info
parameters = {
'access_token': access_token,
'openid': openid,
}
user_info_url = WEIXIN_OAUTH_USER_INFO_URL + '?' + urllib.parse.urlencode(
parameters)
user_info_resp = requests.get(user_info_url).json()
name = user_info_resp['nickname'] if 'nickname' in user_info_resp else ''
name = name.encode('raw_unicode_escape').decode('utf-8')
if name:
profile = Profile.objects.get_profile_by_user(email)
if not profile:
profile = Profile(user=email)
profile.nickname = name.strip()
profile.save()
avatar_url = user_info_resp[
'headimgurl'] if 'headimgurl' in user_info_resp else ''
try:
image_name = 'dingtalk_avatar'
image_file = requests.get(avatar_url).content
avatar = Avatar.objects.filter(emailuser=email, primary=True).first()
avatar = avatar or Avatar(emailuser=email, primary=True)
avatar_file = ContentFile(image_file)
avatar_file.name = image_name
avatar.avatar = avatar_file
avatar.save()
except Exception as e:
logger.error(e)
# generate auth token for Seafile client
api_token = get_api_token(request)
# redirect user to home page
response = HttpResponseRedirect(
request.session['weixin_oauth_login_redirect'])
response.set_cookie('seahub_auth', email + '@' + api_token.key)
return response
def set_staff_cookie(request):
r = HttpResponseRedirect('../')
r.set_cookie(settings.STAFF_COOKIE_NAME, settings.STAFF_COOKIE_VALUE)
return r
def cart_view(request):
sections = Section.objects.all()
my_cart = request.COOKIES.get('my_cart', dict())
if my_cart:
my_cart = my_cart.replace(r"'", r'"')
my_cart = json.loads(my_cart)
status_cart = 'В корзине нет товаров'
total_price = 0
items_cart = []
if request.method == 'POST':
id = request.GET.get('id') # add goods to cart
order = request.GET.get('order') # confirm order
clear = request.GET.get('clear') # clear cart
if id:
quantity = my_cart.get(id)
if not my_cart or not quantity:
quantity = 0
else:
quantity = my_cart.get(id)
my_cart[id] = quantity + 1
my_cart = json.dumps(my_cart)
status_cart = 'Товар добавлен в корзину'
response = HttpResponseRedirect('./')
response.set_cookie('my_cart', my_cart)
return response
elif order:
user = request.user.username
number = len(Order.objects.all()) + 1
if request.COOKIES.get('my_cart'):
response = HttpResponseRedirect('./')
new_order = Order(user=user, number=number)
new_order.save()
for item in my_cart:
product = Product.objects.filter(id=int(item))[0]
quantity = my_cart[item]
order_relation = OrderRelation(product=product,
order=new_order,
quantity=quantity)
order_relation.save()
response.delete_cookie('my_cart')
return response
elif clear:
if request.COOKIES.get('my_cart'):
response = HttpResponseRedirect('./')
response.delete_cookie('my_cart')
return response
else:
pass
my_cart = request.COOKIES.get('my_cart', None)
if my_cart:
my_cart = my_cart.replace(r"'", r'"')
my_cart = json.loads(my_cart)
if my_cart:
for item in my_cart:
good = Product.objects.filter(id=int(item))[0]
quantity = my_cart[item]
items_cart.append(
(good.id, good.name, good.inf, good.price, quantity))
total_price += good.price * quantity
status_cart = 'Ваша корзина'
template = 'app/cart.html'
total_cart = len(items_cart)
context = {
'sections': sections,
'total_cart': total_cart,
'items_cart': items_cart,
'status_cart': status_cart,
'total_price': total_price,
}
return render(request, template_name=template, context=context)
def get(self, request, *args, **kwargs):
"""
Handles token post
"""
_ = args, kwargs
html_endpoint = Configuration.get(
'/ovs/framework/webapps|html_endpoint')
if 'code' not in request.GET:
OAuth2RedirectView._logger.error(
'Got OAuth2 redirection request without code')
return HttpResponseRedirect(html_endpoint)
code = request.GET['code']
if 'state' not in request.GET:
OAuth2RedirectView._logger.error(
'Got OAuth2 redirection request without state')
return HttpResponseRedirect(html_endpoint)
state = request.GET['state']
if 'error' in request.GET:
error = request.GET['error']
description = request.GET[
'error_description'] if 'error_description' in request.GET else ''
OAuth2RedirectView._logger.error(
'Error {0} during OAuth2 redirection request: {1}'.format(
error, description))
return HttpResponseRedirect(html_endpoint)
base_url = Configuration.get('/ovs/framework/webapps|oauth2.token_uri')
client_id = Configuration.get(
'/ovs/framework/webapps|oauth2.client_id')
client_secret = Configuration.get(
'/ovs/framework/webapps|oauth2.client_secret')
parameters = {
'grant_type':
'authorization_code',
'redirect_url':
'https://{0}/api/oauth2/redirect/'.format(
System.get_my_storagerouter().ip),
'client_id':
client_id,
'code':
code
}
url = '{0}?{1}'.format(base_url, urllib.urlencode(parameters))
headers = {
'Accept':
'application/json',
'Authorization':
'Basic {0}'.format(
base64.b64encode('{0}:{1}'.format(client_id,
client_secret)).strip())
}
raw_response = requests.post(url=url, headers=headers, verify=False)
response = raw_response.json()
if 'error' in response:
error = response['error']
description = response[
'error_description'] if 'error_description' in response else ''
OAuth2RedirectView._logger.error(
'Error {0} during OAuth2 redirection access token: {1}'.format(
error, description))
return HttpResponseRedirect(html_endpoint)
token = response['access_token']
expires_in = response['expires_in']
clients = ClientList.get_by_types('INTERNAL', 'CLIENT_CREDENTIALS')
client = None
for current_client in clients:
if current_client.user.group.name == 'administrators':
client = current_client
break
if client is None:
OAuth2RedirectView._logger.error(
'Could not find INTERNAL CLIENT_CREDENTIALS client in administrator group.'
)
return HttpResponseRedirect(html_endpoint)
roles = RoleList.get_roles_by_codes(['read', 'write', 'manage'])
access_token, _ = Toolbox.generate_tokens(client,
generate_access=True,
scopes=roles)
access_token.expiration = int(time.time() + expires_in)
access_token.access_token = token
access_token.save()
expires = datetime.datetime.now() + datetime.timedelta(minutes=2)
response = HttpResponseRedirect(html_endpoint)
response.set_cookie('state', state, expires=expires, secure=True)
response.set_cookie('accesstoken', token, expires=expires, secure=True)
return response
def checkout(request,
proposal,
lines,
return_url_ns='public_booking_success',
return_preload_url_ns='public_booking_success',
invoice_text=None,
vouchers=[],
proxy=False):
basket_params = {
'products': lines,
'vouchers': vouchers,
'system': settings.PAYMENT_SYSTEM_ID,
'custom_basket': True,
}
basket, basket_hash = create_basket_session(request, basket_params)
#fallback_url = request.build_absolute_uri('/')
checkout_params = {
'system': settings.PAYMENT_SYSTEM_ID,
'fallback_url': request.build_absolute_uri(
'/'), # 'http://mooring-ria-jm.dbca.wa.gov.au/'
'return_url': request.build_absolute_uri(reverse(
return_url_ns)), # 'http://mooring-ria-jm.dbca.wa.gov.au/success/'
'return_preload_url': request.build_absolute_uri(reverse(
return_url_ns)), # 'http://mooring-ria-jm.dbca.wa.gov.au/success/'
#'fallback_url': fallback_url,
#'return_url': fallback_url,
#'return_preload_url': fallback_url,
'force_redirect': True,
#'proxy': proxy,
'invoice_text':
invoice_text, # 'Reservation for Jawaid Mushtaq from 2019-05-17 to 2019-05-19 at RIA 005'
}
# if not internal:
# checkout_params['check_url'] = request.build_absolute_uri('/api/booking/{}/booking_checkout_status.json'.format(booking.id))
#if internal or request.user.is_anonymous():
if proxy or request.user.is_anonymous():
#checkout_params['basket_owner'] = booking.customer.id
checkout_params['basket_owner'] = proposal.submitter_id
create_checkout_session(request, checkout_params)
# if internal:
# response = place_order_submission(request)
# else:
response = HttpResponseRedirect(reverse('checkout:index'))
# inject the current basket into the redirect response cookies
# or else, anonymous users will be directionless
response.set_cookie(settings.OSCAR_BASKET_COOKIE_OPEN,
basket_hash,
max_age=settings.OSCAR_BASKET_COOKIE_LIFETIME,
secure=settings.OSCAR_BASKET_COOKIE_SECURE,
httponly=True)
# if booking.cost_total < 0:
# response = HttpResponseRedirect('/refund-payment')
# response.set_cookie(
# settings.OSCAR_BASKET_COOKIE_OPEN, basket_hash,
# max_age=settings.OSCAR_BASKET_COOKIE_LIFETIME,
# secure=settings.OSCAR_BASKET_COOKIE_SECURE, httponly=True
# )
#
# # Zero booking costs
# if booking.cost_total < 1 and booking.cost_total > -1:
# response = HttpResponseRedirect('/no-payment')
# response.set_cookie(
# settings.OSCAR_BASKET_COOKIE_OPEN, basket_hash,
# max_age=settings.OSCAR_BASKET_COOKIE_LIFETIME,
# secure=settings.OSCAR_BASKET_COOKIE_SECURE, httponly=True
# )
return response
def dark(request):
hrr = HttpResponseRedirect("/")
hrr.set_cookie("userskins", "dark")
return hrr
if smt.is_runnable(is_login=True):
if not get_cache_progress(
request.user.shop_id
): # TODO: zhangyu 20140323 Bug 缓存时间2小时，如果服务被Stop再Start，或其他原因线程消失，而缓存还在，则用户2小时后才能进入
bg_thread = Thread(target=smt.run_task, kwargs={'is_login': True})
bg_thread.start()
rsp = HttpResponseRedirect(reverse('waiting', args=[visitor_from]))
else:
from apps.subway.download import Downloader
bg_thread = Thread(target=Downloader.download_all_struct,
kwargs={'shop_id': user.shop_id})
bg_thread.start()
rsp = HttpResponseRedirect(reverse('%s_home' % visitor_from))
rsp = HttpResponseRedirect(reverse('waiting', args=[visitor_from]))
rsp.set_cookie('user_type',
set_value_with_secret(is_agent and 1 or 0,
'AGENT_COOKIES')) # 根据用户类型，设置cookie
return rsp
def waiting(request, prefix):
# @add zhongjinfeng web端和千牛pc端融合，在这个此将千牛pc定位到web模板
if prefix == 'qnpc':
prefix = 'web'
return render_to_response('%s_waiting.html' % prefix, {},
context_instance=RequestContext(request))
def top_logout(request, theme, template='top_logout.html'):
auth_logout(request)
return render_to_response(template, {'theme': theme},
def work_weixin_oauth_callback(request):
if not work_weixin_oauth_check():
return render_error(request, _('Feature is not enabled.'))
code = request.GET.get('code', None)
state = request.GET.get('state', None)
if state != request.session.get('work_weixin_oauth_state',
None) or not code:
logger.error(
'can not get right code or state from work weixin request')
return render_error(request, _('Error, please contact administrator.'))
access_token = get_work_weixin_access_token()
if not access_token:
logger.error('can not get work weixin access_token')
return render_error(request, _('Error, please contact administrator.'))
data = {
'access_token': access_token,
'code': code,
}
api_response = requests.get(WORK_WEIXIN_GET_USER_INFO_URL, params=data)
api_response_dic = handler_work_weixin_api_response(api_response)
if not api_response_dic:
logger.error('can not get work weixin user info')
return render_error(request, _('Error, please contact administrator.'))
if not api_response_dic.get('UserId', None):
logger.error('can not get UserId in work weixin user info response')
return render_error(request, _('Error, please contact administrator.'))
user_id = api_response_dic.get('UserId')
uid = WORK_WEIXIN_UID_PREFIX + user_id
work_weixin_user = SocialAuthUser.objects.get_by_provider_and_uid(
WORK_WEIXIN_PROVIDER, uid)
if work_weixin_user:
email = work_weixin_user.username
is_new_user = False
else:
email = gen_user_virtual_id()
is_new_user = True
try:
user = auth.authenticate(remote_user=email)
except User.DoesNotExist:
user = None
if not user:
return render_error(
request,
_('Error, new user registration is not allowed, please contact administrator.'
))
if is_new_user:
SocialAuthUser.objects.add(email, WORK_WEIXIN_PROVIDER, uid)
# update user info
if is_new_user or WORK_WEIXIN_USER_INFO_AUTO_UPDATE:
user_info_data = {
'access_token': access_token,
'userid': user_id,
}
user_info_api_response = requests.get(WORK_WEIXIN_GET_USER_PROFILE_URL,
params=user_info_data)
user_info_api_response_dic = handler_work_weixin_api_response(
user_info_api_response)
if user_info_api_response_dic:
api_user = user_info_api_response_dic
api_user['username'] = email
api_user['contact_email'] = api_user['email']
update_work_weixin_user_info(api_user)
if not user.is_active:
return render_error(
request,
_('Your account is created successfully, please wait for administrator to activate your account.'
))
# User is valid. Set request.user and persist user in the session
# by logging the user in.
request.user = user
request.session['remember_me'] = REMEMBER_ME
auth.login(request, user)
# generate auth token for Seafile client
api_token = get_api_token(request)
# redirect user to page
response = HttpResponseRedirect(
request.session.get('work_weixin_oauth_redirect', '/'))
response.set_cookie('seahub_auth', user.username + '@' + api_token.key)
return response
def light(request):
hrr = HttpResponseRedirect("/")
hrr.set_cookie("userskins", "light")
return hrr
def User_login_handler(request):
UserName = request.POST.get('username')
UserPwd = request.POST.get('username_pwd')
RememberLogin= request.POST.get('Remember')
if "@" in UserName:
Old_users = UserInfo.objects.filter(User_email=UserName)
else:
Old_users = UserInfo.objects.filter(User_name=UserName)
print(Old_users)
print(type(Old_users))
if len(Old_users)==1:
# 查找用户名是否存在
encipherment = sha1()
encipherment.update(UserPwd.encode('utf-8'))
UserPwd_encipherment = encipherment.hexdigest()
print('UserPwd_encipherment:%s'%UserPwd_encipherment)
print('Old_users:%s'%Old_users[0].User_pwd)
if UserPwd_encipherment == Old_users[0].User_pwd:
# 验证密码是否与数据库一致
url = request.COOKIES.get('url','/')
#跳转操作
cookiesWarn = HttpResponseRedirect(url)
#用HttpResponseRedirect实现重定向传参
cookiesWarn.set_cookie('url','',max_age=-1)
if RememberLogin != 'on' :
# 是否选择记住我！
cookiesWarn.set_cookie('username',UserName)
else:
cookiesWarn.set_cookie('username','',max_age=-1)
request.session['user_id']=Old_users[0].id
request.session['user_name']=UserName
context = {
'title': '用户登录',
'Warn': '登录成功！',
'LOGIN_state': 2,
'username': UserName,
}
return cookiesWarn
else:
# 密码验证失败
context = {
'title': '用户登录',
'Warn': '该用户名不存在！',
'LOGIN_state': 1,
'username': UserName,
}
return render(request,'OL_user/login.html',context)
else:
context = {
'title': '用户登录',
'Warn': '该用户名不存在！去注册一个吧～',
'LOGIN_state': 1,
}
return render(request, 'OL_user/login.html', context)
def get(self, request, lang):
referer_url = request.META.get('HTTP_REFERER', '/')
response = HttpResponseRedirect(referer_url)
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang)
return response
def visiturl(request, url_id):
url = get_object_or_404(PageURL, url_id=url_id)
ua = parse(request.META.get('HTTP_USER_AGENT'))
url.hits += 1
url.save()
g = GeoIP2()
ip = request.META.get('REMOTE_ADDR')
ip = '88.80.113.1'
gid = request.COOKIES.get('gid', None)
if not gid:
hsh = "{0}:{1}:{2}:{3}".format(ip, ua.browser.version_string,
ua.os.version_string, ua.device.family)
gid = hashlib.sha256(hsh).hexdigest()
print gid
visit = Visit(
url=url,
ip=ip,
referer=request.META.get('HTTP_REFERER'),
user_agent=str(ua),
browser=ua.browser.family,
browser_version=ua.browser.version_string,
system=ua.os.family,
system_version=ua.os.version_string,
device=ua.device.family,
brand=ua.device.brand,
model=ua.device.model,
session=gid,
is_mobile=ua.is_mobile,
is_tablet=ua.is_tablet,
is_pc=ua.is_pc,
is_bot=ua.is_bot,
is_touch=ua.is_touch_capable,
)
try:
geo = g.city(ip)
except:
pass
else:
visit.city = geo['city']
visit.country = geo['country_name']
visit.country_code = geo['country_code']
visit.postal_code = geo['postal_code']
visit.region = geo['region']
visit.longitude = geo['longitude']
visit.latitude = geo['latitude']
visit.save()
if url.content_object:
long_url = url.content_object.dispatch(visit, gid=gid)
else:
long_url = url.long_url
if url.monetize:
random_ad = Ad.objects.order_by('?').first()
context = {"long_url": long_url, "random_ad": random_ad}
return render(request, 'doorway.html', context)
else:
if url.url_type == PageURL.PIXEL:
response = long_url
else:
response = HttpResponseRedirect(long_url)
response.set_cookie('gid', gid)
return response
def oauth_callback(request):
""" Step 3: Retrieving an access token.
The user has been redirected back from the provider to your registered
callback URL. With this redirection comes an authorization code included
in the redirect URL. We will use that to obtain an access token.
"""
session = OAuth2Session(client_id=CLIENT_ID,
scope=SCOPE,
state=request.session.get('oauth_state', None),
redirect_uri=REDIRECT_URL)
try:
token = session.fetch_token(
TOKEN_URL,
client_secret=CLIENT_SECRET,
authorization_response=request.get_full_path())
if 'user_id' in session._client.__dict__['token']:
# used for sjtu.edu.cn
# https://xjq12311.gitbooks.io/sjtu-engtc/content/
user_id = session._client.__dict__['token']['user_id']
user_info_resp = session.get(USER_INFO_URL +
'?user_id=%s' % user_id)
else:
user_info_url = USER_INFO_URL
if ACCESS_TOKEN_IN_URI:
code = request.GET.get('code')
user_info_url = USER_INFO_URL + '?access_token=%s&code=%s' % (
token['access_token'], code)
user_info_resp = session.get(user_info_url)
except Exception as e:
logger.error(e)
return render_error(request, _('Error, please contact administrator.'))
def format_user_info(user_info_resp):
logger.info('user info resp: %s' % user_info_resp.text)
error = False
user_info = {}
user_info_json = user_info_resp.json()
for item, attr in list(ATTRIBUTE_MAP.items()):
required, user_attr = attr
value = user_info_json.get(item, '')
if value:
# ccnet email
if user_attr == 'email':
user_info[user_attr] = value if is_valid_email(str(value)) else \
'%s@%s' % (str(value), PROVIDER_DOMAIN)
else:
user_info[user_attr] = value
elif required:
error = True
return user_info, error
user_info, error = format_user_info(user_info_resp)
if error:
logger.error('Required user info not found.')
logger.error(user_info)
return render_error(request, _('Error, please contact administrator.'))
# seahub authenticate user
email = user_info['email']
try:
user = auth.authenticate(remote_user=email)
except User.DoesNotExist:
user = None
if not user or not user.is_active:
logger.error('User %s not found or inactive.' % email)
# a page for authenticate user failed
return render_error(request, _('User %s not found.') % email)
# User is valid. Set request.user and persist user in the session
# by logging the user in.
request.user = user
auth.login(request, user)
# update user's profile
name = user_info['name'] if 'name' in user_info else ''
contact_email = user_info['contact_email'] if \
'contact_email' in user_info else ''
profile = Profile.objects.get_profile_by_user(email)
if not profile:
profile = Profile(user=email)
if name:
profile.nickname = name.strip()
profile.save()
if contact_email:
profile.contact_email = contact_email.strip()
profile.save()
# generate auth token for Seafile client
api_token = get_api_token(request)
# redirect user to home page
response = HttpResponseRedirect(request.session['oauth_redirect'])
response.set_cookie('seahub_auth', email + '@' + api_token.key)
return response
def show_last(request):
resp = HttpResponseRedirect(reverse('index'))
resp.set_cookie('show_heat', '', max_age=30 * 24 * 60 * 60)
return resp
def login(request,
template_name=settings.LOGIN_TEMPLATE,
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None,
extra_context=None):
"""
Displays the login form and handles the login action.
"""
redirect_to = request.REQUEST.get(redirect_field_name, '')
if not redirect_to:
redirect_to = request.REQUEST.get(ORIGINAL_REDIRECT_FIELD_NAME, '')
if request.method == "POST":
form = authentication_form(data=request.POST, request=request)
if form.is_valid():
netloc = urlparse.urlparse(redirect_to)[1]
# Use default setting if redirect_to is empty
if not redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
# Heavier security check -- don't allow redirection to a different
# host.
elif netloc and netloc != request.get_host():
redirect_to = settings.LOGIN_REDIRECT_URL
# Okay, security checks complete. Log the user in.
auth_login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
redirectResponse = HttpResponseRedirect(redirect_to)
# Get the user
user = form.get_user()
# Set the Splunkweb cookie values
if user.splunkweb:
session_id = user.splunkweb.session_id
cval = user.splunkweb.cval
uid = user.splunkweb.uid
redirectResponse.set_cookie(
'session_id_%s' % settings.SPLUNK_WEB_PORT, session_id)
redirectResponse.set_cookie('cval', cval)
redirectResponse.set_cookie('uid', uid)
# Set a standalone, encrypted cookie for the session key, so we can
# access it in the proxy.
session_token = user.service.token
redirectResponse.set_cookie('session_token',
aes.encrypt(str(session_token)))
# Set the session cookie to expire when the browser is closed
request.session.set_expiry(0)
return redirectResponse
else:
form = authentication_form(request)
request.session.set_test_cookie()
context = {'form': form, redirect_field_name: redirect_to}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
def oauth_fxa(request):
"""
Acts as an OAuth relier for Firefox Accounts. Currently specifically tuned to handle
the OAuth flow for the Firefox Concert Series (Q4 2018).
If additional OAuth flows are required in the future, please refactor this method.
"""
if not switch('firefox_concert_series'):
return HttpResponseRedirect(reverse('mozorg.home'))
# expected state should be in user's cookies
stateExpected = request.COOKIES.get('fxaOauthState', None)
# provided state passed back from FxA - these state values should match
stateProvided = request.GET.get('state', None)
# code must be present - is in redirect querystring from FxA
code = request.GET.get('code', None)
error = False
cookie_age = 86400 # 1 day
# ensure all the data we need is present and valid
if not (stateExpected and stateProvided and code):
error = True
elif stateExpected != stateProvided:
error = True
else:
token = get_fxa_oauth_token(code)
if not token:
error = True
else:
email = get_fxa_profile_email(token)
if not email:
error = True
else:
# add email to mailing list
# check for Firefox
include_re = re.compile(r'\bFirefox\b', flags=re.I)
exclude_re = re.compile(r'\b(Camino|Iceweasel|SeaMonkey)\b',
flags=re.I)
value = request.META.get('HTTP_USER_AGENT', '')
isFx = bool(
include_re.search(value) and not exclude_re.search(value))
# add user to mailing list for future concert updates
rsvp_ok = fxa_concert_rsvp(email, isFx)
if not rsvp_ok:
error = True
if error:
# send user to a custom error page
response = HttpResponseRedirect(reverse('mozorg.oauth.fxa-error'))
else:
# send user back to the concerts page
response = HttpResponseRedirect(reverse('firefox.concerts'))
response.set_cookie('fxaOauthVerified',
True,
max_age=cookie_age,
httponly=False)
return response
def wallet(request, key):
site = request.META.get('HTTP_HOST', '').lower()
template_mod = ""
# time.sleep(0.25)
wallet = get_object_or_404(Wallet, key=key)
#custom = request.GET.get("c")
ctx = {
'wallet': wallet,
'json_rates': json.dumps(CURRENCY_RATES),
'json_messages': json.dumps(MESSAGES),
'json_signs': json.dumps(CURRENCY_SIGNS)
}
if wallet.atime: # if already paid and activated
return private(request, key, wallet)
# Check if it was paid
if wallet.bcaddr and not wallet.atime:
balance = BITCOIND.getbalance(wallet.get_account(), 0)
if balance and balance >= wallet.invoice_btc:
wallet.atime = datetime.datetime.now()
wallet.activated = True
wallet.balance = balance * 1e8
# get our fees
if wallet.price:
fee = wallet.divide_by * wallet.quantity # pure tips
fee = fee / 100 * wallet.price
fee = fee / wallet.rate
if wallet.template == "005-premium.odt":
fee += Decimal("0.0001")
if wallet.print_and_post:
pap_total = 2 + wallet.quantity / 9.0 * 1
pap_total = pap_total / wallet.rate
pap_total = round(pap_total, 8)
wallet.save()
if wallet.email:
send_mail(
'new BCTIP wallet',
'Congratulations!\n\nYour new BCTip wallet is available at: https://www.bctip.org/w/%s/'
% (wallet.key),
'*****@*****.**', [wallet.email],
fail_silently=True)
# wallet.get_absolute_url()
return HttpResponseRedirect(
reverse('wallet', kwargs={'key': wallet.key}))
if request.POST:
form = WalletForm(request.POST)
if form.is_valid():
wallet.bcaddr_from = form.cleaned_data['bcaddr_from']
wallet.divide_by = form.cleaned_data['divide_by']
wallet.quantity = form.cleaned_data['quantity']
wallet.price = form.cleaned_data['price']
wallet.message = form.cleaned_data['message']
wallet.template = form.cleaned_data['template']
wallet.divide_currency = form.cleaned_data['divide_currency']
# request.form.cleaned_data['target_language']
wallet.target_language = request.LANGUAGE_CODE
wallet.email = form.cleaned_data['email']
wallet.expiration = form.cleaned_data['expiration']
total_usd = wallet.divide_by * Decimal(
wallet.quantity) # pure tips
# tips and price for service
total_usd = total_usd + total_usd / Decimal(100) * wallet.price
if form.cleaned_data['print_and_post']:
wallet.print_and_post = True
pap_total = 2 + wallet.quantity / 9.0 * 1 # 2 + 1 for each sheet
total_usd += Decimal(pap_total)
a = Address(wallet=wallet)
a.address1 = form.cleaned_data['address1']
a.address2 = form.cleaned_data['address2']
a.city = form.cleaned_data['city']
a.state = form.cleaned_data['state']
a.country = form.cleaned_data['country']
a.postal_code = form.cleaned_data['postal_code']
a.save() # чу-чо!
wallet.invoice = total_usd/wallet.rate / \
Decimal(
CURRENCY_RATES[wallet.divide_currency])*Decimal(1e8) # usd->btc
wallet.fee = Decimal("%.8f" % get_est_fee())
wallet.invoice += Decimal(wallet.quantity) * \
Decimal("%.8f" % round(get_est_fee()/3,8)) * Decimal(1e8)
# premium template extra
if wallet.template == "005-premium.odt":
wallet.invoice += Decimal(0.0001) * Decimal(1e8)
wallet.bcaddr = BITCOIND.getnewaddress(wallet.get_account())
# wallet.bcaddr_segwit = BITCOIND.addwitnessaddress(wallet.bcaddr)
isvalid = BITCOIND.validateaddress(wallet.bcaddr_from)['isvalid']
wallet.save()
generate_tips(wallet)
celery_generate_pdf.delay(wallet)
response = HttpResponseRedirect(
reverse('wallet', kwargs={'key': wallet.key}))
if wallet.email:
email = pickle.dumps(wallet.email, protocol=0)
response.set_cookie('email', email)
response.set_cookie('bcaddr_from', wallet.bcaddr_from)
return response
else:
initial = {
'divide_currency': 'USD',
'divide_by': 5,
'quantity': 10,
'price': "5",
"template": '001-original',
"message": _('Thank you for your service!')
}
email = request.COOKIES.get('email')
if email:
try:
email = pickle.loads(email)
except:
pass
initial['email'] = email
bcaddr_from = request.COOKIES.get('bcaddr_from')
if bcaddr_from:
initial['bcaddr_from'] = bcaddr_from
form = WalletForm(initial=initial)
ctx['form'] = form
ctx['est_fee'] = Decimal("%.8f" % round(get_est_fee() / 3, 8))
if wallet.bcaddr and not wallet.atime:
return arender(request, 'wallet-new-unpaid%s.html' % template_mod, ctx)
else:
return arender(request, 'wallet-new%s.html' % template_mod, ctx)
def logout(request):
response = HttpResponseRedirect('/home')
if "sessionId" in request.COOKIES:
response.set_cookie('sessionId', '')
return response
def show_followed(request):
resp = HttpResponseRedirect(reverse('user', args=[request.user.username]))
resp.set_cookie('show_followed', '1', max_age=30 * 24 * 60 * 60)
return resp
def home(request):
if request.method == 'POST':
for key, value in request.POST.items():
if key == 'delete': #if user wants to delete their name...
del_number, del_name = request.COOKIES['selected'].split(
','
) #get their cookie, containing their chosen day number and name
DayModel.objects.filter(day=del_number).update(
name=''
) #model object with matching day number: name field to ''
response = HttpResponseRedirect(
'/fast') #delete cookie and redirect to same page
response.delete_cookie('selected')
return response
elif key == 'name': #if user wants to add their name...
number = request.POST['number'] #assign post number
up_name = request.POST['name'] #assign post name
DayModel.objects.filter(day=number).update(
name=up_name
) #update model object with post number with post name
up_name_dashes = re.sub(
' ', '-', up_name
) #convert any spaces in name to dashes for cookie storage
response = HttpResponseRedirect('/fast')
response.set_cookie(
'selected',
','.join([number, up_name_dashes]),
max_age=4233600
) #make 'day_number,name-with-spaces' string and add this to cookie
return response
else:
context = {
'days': []
} #create context dict which will contain list of other dicts
if 'selected' in request.COOKIES.keys():
del_number, del_name = request.COOKIES['selected'].split(
','
) #get their cookie, containing their chosen day number and name
model_list = DayModel.objects.order_by('-day')[::-1]
for item in model_list:
if item.day == int(
del_number
): #should only be one of these, with permission to delete, but not to add
context['days'].append({
'day': item,
'allow_delete': True,
'allow_add': False
})
context['name'] = True
else: #all others, no delete, no add
context['days'].append({
'day': item,
'allow_delete': False,
'allow_add': False
})
else: #no preexisting cookie named select SO all available days able to be added
#note, if name exists, we will not allow add form, but will provide delete button
model_list = DayModel.objects.order_by('-day')[::-1]
for item in model_list:
context['days'].append({
'day': item,
'allow_delete': None,
'allow_add': True
})
print(context)
return render(request, 'fourty_day_fast/fourty.html', context)
def landing(request, url):
# send_to_telegramm("Пришел новый заказ! Смотри")
# Логика прилипания креатива:
# В первый раз пользователю назначается креатив исходя из его сегмента и распределения во AB
# При следующем заходе, если пользователь попал в сегмент, то ищется предыдущий креатив в этом сегменте
# Если пользователь не попал в сегмент, то ищется последний показанный креатив
# Если креатив не найден, то ничего не показываем (дефолтный шаблон)
#
# creative = get_object_or_404(Question, pk=question_id)
# request.COOKIES
# request.META
# HTTP_REFERER
# HTTP_COOKIE
# TERM_SESSION_ID
# HTTP_HOST
# PATH_INFO
# QUERY_STRING
# request.GET.get("w")
# Пока так прокидываем идентификатор показа
# В урл добавляем его скриптом, чтобы не фиксировался и не индексировался
impression_id = request.GET.get('impression_id')
if impression_id:
query_string = request.META['QUERY_STRING']
query_string = query_string.replace('impression_id=' + impression_id,
"").replace("&&", "&")
# Пока что предполагаем, что идентификато ссылающейся кнопки может быть только при наличии impression_id
referer_button = request.GET.get('referer_button')
referer_button_val = referer_button if referer_button else ''
query_string = query_string.replace(
'referer_button=' + referer_button_val, "").replace("&&", "&")
query_string = re.sub(r"^&$", "", query_string)
new_url = "{}".format(request.path)
if query_string:
new_url = new_url + "?" + query_string
response = HttpResponseRedirect(
new_url) # replace redirect with HttpResponse or render
response.set_cookie('impression_id', impression_id, max_age=30)
response.set_cookie('referer_button',
referer_button_val,
max_age=10 if referer_button else 0)
return response
# Уникальный идентификатор показа. Записывается только в лог и прокидывается во все события дальше
impression_id = request.COOKIES.get('impression_id', str(uuid.uuid4()))
# Имя ссылающейся кнопки для разделения статистики кликов. Сначала из кук, потом из строки запроса
referer_button = request.COOKIES.get('referer_button',
request.GET.get('referer_button'))
# У каждого пользователя должна быть сесссия. По ней буем дальше трэкать стату
if not request.session.session_key:
request.session.create()
ts = time.time()
# Сюда складывается вся инфа для статистики
content = {}
statistics = {
"action":
"landing",
"sessionid":
request.session.session_key,
"timestamp":
ts,
"datetime":
datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%SZ'),
"impression_id":
impression_id,
"user_agent":
request.META.get('HTTP_USER_AGENT'),
"remote_addr":
request.META.get('REMOTE_ADDR'),
"http_x_real_ip":
request.META.get('HTTP_X_REAL_IP'),
"http_x_forwarded_for":
request.META.get('HTTP_X_FORWARDED_FOR'),
"http_referer":
request.META.get('HTTP_REFERER'),
"referer_button":
referer_button,
}
logger.debug("---META: {}".format(request.META))
try:
host = Host.objects.get(domain=request.META['HTTP_HOST'])
statistics["host"] = host.id
except Host.DoesNotExist:
raise Http404("Domain does not exist")
preview = request.GET.get('preview', False)
statistics["preview"] = preview
page = None
try:
page = Page.objects.get(url=url, host=host)
statistics["page"] = page.id
# Log: page id success loaded
except Page.DoesNotExist:
raise Http404("Page does not exist")
content["children"] = Page.objects.filter(
parent_page=page, product__isnull=False).order_by('ordering').all()[:3]
# content["products"] = Product.objects.filter(page=page, active=True).order_by('ordering').all()
logger.debug("Product list: %s", content["children"])
content["main_page"] = page.parent_page
if content["main_page"] is None:
content["main_page"] = page
logger.debug("Main page: %s", content["main_page"])
creative = None
# creative_id = request.GET.get('creative_id', request.COOKIES.get('creative_id_for_page_%s'%page.url))
# Только для прямого вызова креатива
creative_id = request.GET.get('creative_id')
if creative_id is not None:
try:
creative = Creative.objects.get(pk=creative_id)
statistics["creative_from_request"] = creative.id
# Log: creative id success loaded
except Creative.DoesNotExist:
pass
statistics["cookies"] = request.COOKIES
query = QueryDict(request.META['QUERY_STRING'])
statistics["query_string"] = request.META['QUERY_STRING']
# Сюда сохраним отработавшую стратегию
active_line_item = None
if not creative:
logger.debug("No creative")
line_items = LineItem.objects.filter(
page=page).order_by('priority').all()
# Log: lineitems (id list) success loaded
for line_item in line_items:
logger.debug("Line item: {}".format(line_item.title))
segment = line_item.segment
rule = segment.content
logger.error("---Rule: {}".format(rule))
res = eval(rule)
logger.error("---Res: {}".format(res))
if res:
active_line_item = line_item
statistics["line_item"] = line_item.id
# Ищем креатив для конкретной стратегии на случай если пользователь уже видел креатив (попал в ab-test)
creative_id = request.COOKIES.get(
'creative_id_for_page_%s_and_li_%s' %
(page.id, line_item.id))
if creative_id is not None:
try:
creative = Creative.objects.get(pk=creative_id)
statistics[
"creative_from_cookies_line_item"] = creative.id
except Creative.DoesNotExist:
pass
if not creative:
abrules = ABRule.objects.filter(
line_item=line_item.id).all()
if len(abrules):
target_abrule = abrules[0]
target_number = target_abrule.cnt / float(
target_abrule.percentage)
for abrule in abrules:
tmp_target_number = abrule.cnt / float(
abrule.percentage)
if tmp_target_number < target_number:
target_number = tmp_target_number
target_abrule = abrule
target_abrule.cnt = target_abrule.cnt + 1
target_abrule.save()
statistics["abrule"] = abrule.id
creative = target_abrule.creative
statistics["creative_generated"] = creative.id
break
# Если стратегия не отработала, то смотрим, есть ли хоть один креатив для этой страницы
if creative is None and active_line_item is not None:
creative_id = request.COOKIES.get('creative_id_for_page_%s' % page.id)
if creative_id is not None:
try:
creative = Creative.objects.get(pk=creative_id)
statistics["creative_from_cookies_page"] = creative.id
except Creative.DoesNotExist:
pass
orders = Order.objects.filter(
status="new", session_id=request.session.session_key).all()
if len(orders):
content["has_orders"] = True
# Загружаем содержимое креатива
if creative is not None:
content["smart"] = eval(creative.content)
content["creative"] = creative
statistics["creative"] = creative.id
content["preview"] = preview
content["page"] = page
# Пока так, потом будем менять в зависимости от лэндинга
content["host"] = host #request.META['HTTP_HOST']
content["statistics"] = statistics
# Подготавливаем шаблон
response = render(request, page.template, content)
# Ставим нужные куки
if creative and not preview:
max_age = 365 * 24 * 60 * 60 #one year
expires = datetime.datetime.strftime(
datetime.datetime.utcnow() + datetime.timedelta(seconds=max_age),
"%a, %d-%b-%Y %H:%M:%S GMT")
# Ставим куку для страницы, на случай если стратегия не отработала
response.set_cookie('creative_id_for_page_%s' % page.id,
creative.id,
max_age=max_age,
expires=expires,
domain=settings.SESSION_COOKIE_DOMAIN,
secure=settings.SESSION_COOKIE_SECURE or None)
# Ставим куку для конкретной стратегии
if active_line_item:
response.set_cookie('creative_id_for_page_%s_and_li_%s' %
(page.id, active_line_item.id),
creative.id,
max_age=max_age,
expires=expires,
domain=settings.SESSION_COOKIE_DOMAIN,
secure=settings.SESSION_COOKIE_SECURE or None)
# log
# creative
statistics_logger.info(json.dumps(statistics))
return response
def add(request, commitment):
"""Commit the current user to the commitment."""
user = request.user
value = None
if request.method == "GET": # redirect to task page, only allow POST
return HttpResponseRedirect(
reverse("activity_task", args=(
commitment.type,
commitment.slug,
)))
form = CommitmentCommentForm(request.POST, user=request.user.username)
if not form.is_valid():
# invalid form
request.session["form_dict"] = form.data
request.session["form_errors"] = form.errors
return HttpResponseRedirect(
reverse("activity_task", args=(
commitment.type,
commitment.slug,
)) + "?display_form=True")
# now we have a valid form
if smartgrid.can_complete_commitment(user, commitment):
try:
member = user.actionmember_set.get(action=commitment,
award_date=None)
except ObjectDoesNotExist:
# ignore the race condition
return HttpResponseRedirect(
reverse("activity_task",
args=(
commitment.type,
commitment.slug,
)))
#commitment end, award full point
member.award_date = datetime.datetime.today()
member.approval_status = "approved"
if form.cleaned_data["social_email"]:
member.social_email = form.cleaned_data["social_email"].lower()
member.save()
value = commitment.point_value
elif smartgrid.can_add_commitment(user):
# User can commit to this commitment. allow to commit to completed commitment again
# as long as the pending does not reach max
member = ActionMember(user=user, action=commitment)
if form:
member.social_email = form.cleaned_data["social_email"].lower()
try:
member.save()
value = score_mgr.signup_points()
except IntegrityError:
messages.error = 'Sorry, but it appears that you are already participating in ' \
'this commitment.'
return HttpResponseRedirect(
reverse("activity_task",
args=(
commitment.type,
commitment.slug,
)))
else: # user can not add more than 5 commitment
return HttpResponseRedirect(
reverse("activity_task", args=(
commitment.type,
commitment.slug,
)))
response = HttpResponseRedirect(
reverse("activity_task", args=(
commitment.type,
commitment.slug,
)))
notification = "You just earned " + str(value) + " points."
response.set_cookie("task_notify", notification)
return response
def login_hander(request):
# 获取表单提交的信息
name = request.POST.get('username')
pwd = request.POST.get('pwd')
remember = request.POST.get('remember')
# print 'name', name, 'pwd', pwd
# 对用户提交的密码，加密
shal = hashlib.sha1(pwd)
password = shal.hexdigest()
# 取出用户信息
userdata = UserInfo.user.filter(uname=name)
response = HttpResponseRedirect('/user/login')
# 判断用户是否是从其他页面重定向到登录页面
url = request.COOKIES.get('url')
# pathurl=request.get_full_path()
# print pathurl,'=========='
# 若没有，则登录后调转的用户中心
if not url:
url = '/user/info'
# print '****************888888888888', url
response2 = HttpResponseRedirect(url)
if userdata:
name_error = 0
if password == userdata[0].upwd:
pwd_error = 0
else:
pwd_error = 1
else:
name_error = 1
pwd_error = 1
response.set_cookie('name_error', name_error)
response.set_cookie('pwd_error', pwd_error)
# print '******************', name_error, pwd_error
if remember == '1':
print '记录cookie'
response.set_cookie('uname', name)
response.set_cookie('upwd', pwd)
response2.set_cookie('uname', name)
response2.set_cookie('upwd', pwd)
else:
print '删除cookie'
response.set_cookie('uname', '', max_age=-1)
response.set_cookie('upwd', '', max_age=-1)
response2.set_cookie('uname', '', max_age=-1)
response2.set_cookie('upwd', '', max_age=-1)
# context = {'title': '登录', 'name_error': name_error, 'pwd_error': pwd_error, 'uname': name, 'upwd': password}
if name_error == 0 and pwd_error == 0:
request.session['pid'] = userdata[0].pk
request.session['uname'] = name
# 处理最近浏览，
# 取出用户表存储的最近浏览信息
user = UserInfo.user.get(pk=userdata[0].pk)
goodsids = user.goodsids
goodsid_list = goodsids.split(',')
try:
goodsid_list.remove('')
except Exception as e:
pass
# 获取用户登录前，浏览的商品信息
session_list = request.session.get('id_list', [])
if len(session_list):
for i in goodsid_list:
if i not in session_list:
session_list.append(i)
goodsid_list = session_list
request.session['id_list'] = []
if len(goodsid_list) > 5:
goodsid_list = goodsid_list[0:5]
# 用户表 和 session 中的信息合并
ids = ''
for index in goodsid_list:
ids = ids + str(index) + ','
ids = ids[:-1]
user.goodsids = ids
user.save()
return response2
else:
return response
def oauth_callback(request):
""" Step 3: Retrieving an access token.
The user has been redirected back from the provider to your registered
callback URL. With this redirection comes an authorization code included
in the redirect URL. We will use that to obtain an access token.
"""
session = OAuth2Session(client_id=CLIENT_ID,
scope=SCOPE,
state=request.session.get('oauth_state', None),
redirect_uri=REDIRECT_URL)
try:
session.fetch_token(TOKEN_URL,
client_secret=CLIENT_SECRET,
authorization_response=request.get_full_path())
if session._client.__dict__['token'].has_key('user_id'):
# used for sjtu.edu.cn
# https://xjq12311.gitbooks.io/sjtu-engtc/content/
user_id = session._client.__dict__['token']['user_id']
user_info_resp = session.get(USER_INFO_URL +
'?user_id=%s' % user_id)
else:
user_info_resp = session.get(USER_INFO_URL)
except Exception as e:
logger.error(e)
return render(request, 'error.html', {
'error_msg': _('Error, please contact administrator.'),
})
def format_user_info(user_info_resp):
error = False
user_info = {}
user_info_json = user_info_resp.json()
for item, attr in ATTRIBUTE_MAP.items():
required, user_attr = attr
value = user_info_json.get(item, '')
if value:
# ccnet email
if user_attr == 'email':
user_info[user_attr] = value if is_valid_email(str(value)) else \
'%s@%s' % (str(value), PROVIDER_DOMAIN)
else:
user_info[user_attr] = value
elif required:
error = True
return user_info, error
user_info, error = format_user_info(user_info_resp)
if error:
logger.error('Required user info not found.')
logger.error(user_info)
return render(request, 'error.html', {
'error_msg': _('Error, please contact administrator.'),
})
# seahub authenticate user
email = user_info['email']
try:
User.objects.get(email=email)
except User.DoesNotExist:
if not config.ENABLE_SIGNUP:
logger.error('%s not found but user registration is disabled.' %
email)
return render(
request, 'error.html', {
'error_msg': _('Error, please contact administrator.'),
})
try:
user = auth.authenticate(remote_user=email)
except User.DoesNotExist:
user = None
if not user or not user.is_active:
logger.error('User %s not found or inactive.' % email)
# a page for authenticate user failed
return render(request, 'error.html',
{'error_msg': _(u'User %s not found.') % email})
# User is valid. Set request.user and persist user in the session
# by logging the user in.
request.user = user
auth.login(request, user)
user.set_unusable_password()
user.save()
# update user's profile
name = user_info['name'] if user_info.has_key('name') else ''
contact_email = user_info['contact_email'] if \
user_info.has_key('contact_email') else ''
profile = Profile.objects.get_profile_by_user(email)
if not profile:
profile = Profile(user=email)
if name:
profile.nickname = name.strip()
profile.save()
if contact_email:
profile.contact_email = contact_email.strip()
profile.save()
# generate auth token for Seafile client
keys = (
'platform',
'device_id',
'device_name',
'client_version',
'platform_version',
)
if all([key in request.GET for key in keys]):
platform = request.GET['platform']
device_id = request.GET['device_id']
device_name = request.GET['device_name']
client_version = request.GET['client_version']
platform_version = request.GET['platform_version']
token = get_token_v2(request, request.user.username, platform,
device_id, device_name, client_version,
platform_version)
else:
token = get_token_v1(request.user.username)
# redirect user to home page
response = HttpResponseRedirect(reverse('libraries'))
response.set_cookie('seahub_auth', email + '@' + token.key)
return response
def post(self, request):
"""处理登陆逻辑
set_cookie(key, value='', max_age=None, expires=None)：设置Cookie
key、value都是字符串类型
max_age是一个整数，表示在指定秒数后过期
expires是一个datetime或timedelta对象，会话将在这个指定的日期/时间过期，注意datetime和timedelta值只有在使用PickleSerializer时才可序列化
max_age与expires二选一
如果不指定过期时间，则两个星期后过期
"""
from django.contrib.auth import authenticate, login
username = request.POST.get('username')
password = request.POST.get('pwd')
if not all([username, password]): # 一假为假 not 拦截判断
# return render(request, 'login.html', {'err_msg': '用户名密码不能为空'})
return redirect(reverse('users:login'))
user = authenticate(username=username,
password=password) # django自带校验用户名和密码，通过不为None
is_ok = False
if user is not None:
if user.is_active:
login(request, user) # 会存储session 状态保持,会根据存储引擎的不同存储位置也不同
is_ok = True
# 记住用户名,免登录10 天, 反正保存到浏览器关闭 开始－－－－－－－－－－－
ret_remember = request.POST.get('remembered')
print(ret_remember) # 打印是否为on
http_response = HttpResponseRedirect(reverse('goods:index'))
# 保存到浏览器关闭,浏览会话结束时 checkbox: on | None ---------------------------------
if ret_remember != "on":
request.session.set_expiry(0)
else: # 保存10天 点击了记住 if分支
http_response.set_cookie("user_name",
username,
max_age=60 * 60 * 24 * 1)
request.session.set_expiry(60 * 60 * 24 * 10)
# ------------------------------------------------------------------------------------------
# 在这里也可以登陆成功以后判断页面的跳转，移动到if is_ok 的分支
else:
return render(request, 'login.html',
{'err_msg': '用户未激活,请查看邮件激活!'})
else:
return render(request, 'login.html', {'err_msg': '用户名或密码错误!'})
if is_ok:
"""一键多值,session id 单个,和cookie中sessionid的值一致
fd2dac6bce19f55aeb4e267f0ccad4b22a94d338:{"_auth_user_id":"49","_auth_user_backend":"django.contrib.auth.backends.ModelBackend","pxd_name":"\u88f4\u6653\u4e1c666666","_auth_user_hash":"a28292554ea826aa5113a9cf4bd9810b5b4499b8"}
"""
# 测试存储一个session的值而已,可以存储一下已登陆的用户名信息方便展示使用
request.session['pxd_name'] = 'MMD666666'
next = request.GET.get('next')
# 登陆成功后跳转之前将cookie中的购物车信息合并导redis,首先读取cookie中所有的购物车信息
cookies_str = request.COOKIES.get('cart')
if cookies_str:
cart_dict_cookie = json.loads(cookies_str)
else:
cart_dict_cookie = {}
# 要去查询redis中的购物车信息方便合并
redis_con = get_redis_connection('default')
cart_dict_redis = redis_con.hgetall('cart_%s' % request.user.id)
# 因为要合并cookie到redis 所以要遍历cookie的数据判断是否in redis的字典从而累加合并，不存在直接合并
for sku_id, count in cart_dict_cookie.items():
sku_id_encode = sku_id.encode() # b'1'
# redis 中取的字典key和value都是bytes类型的
if sku_id_encode in cart_dict_redis: # 在计算和比较时一定要类型统一
origin_count = cart_dict_redis[
sku_id_encode] # redis的键是bytes类型的
count += int(origin_count) # 加到cookie里去了==> 好操作 .decode()
# 这里合并可能库存不足
# goods_model = GoodsSKU.objects.get(id=sku_id)
# if count > goods_model.stock:
# pass # 具体如何处理看需求只要影響正常登陆即可
# redis_con.hset('cart_%s' % request.user.id, sku_id_encode, count)
# 合并数据更新到redis字典
cart_dict_redis[sku_id_encode] = count
# special 给一个字典自动hmset django_redis 封装 key1,val1,key2,val2 传递进去一个字典自动转换为hmset命令，一次赋值多个
if cart_dict_redis:
"""""" "# 不能为空，空就异常了，一次新增多条记录给hash" ""
redis_con.hmset('cart_%s' % request.user.id, cart_dict_redis)
if next: # next有值
if next == '/order/place':
next = reverse('cart:info')
http_response = HttpResponseRedirect(next)
http_response.delete_cookie('cart') # 清空购物车cookie
return http_response
