def extractCredentials(self, request):
"""This method is called on every request to extract credentials.
In our case, that means looking for the values we store in the
session.
o Return a mapping of any derived credentials.
o Return an empty mapping to indicate that the plugin found no
appropriate credentials.
"""
# Get the session from Beaker.
session = ISession(request, None)
if session is None:
return None
# We have been authenticated and we have a session that has not yet
# expired:
if SessionKeys.userId in session:
return {
'src': self.getId(),
'userid': session[SessionKeys.userId],
'username': session[SessionKeys.userId],
}
return None
def __call__(self):
antworten = self.context.antworten
uid = self.context.UID()
yours = int(self.request.get(uid))
success = False
validated = []
for i in antworten:
index = antworten.index(i)
i['btnclass'] = 'btn btn-secondary btn-sm btn-block'
if i.get('bewertung') in ['richtig', 'success']:
i['btnclass'] = 'btn btn-success btn-sm btn-block'
if index == yours:
i['yours'] = True
if i.get('bewertung') in ['richtig', 'success']:
success = True
else:
i['btnclass'] = 'btn btn-danger btn-sm btn-block'
else:
i['yours'] = False
validated.append(i)
cookie = {'success': success, 'validated': validated}
session = ISession(self.request)
if uid not in session:
session[uid] = cookie
session.save()
url = "%s%s" % (self.context.absolute_url(), '#ergebnis')
return self.request.response.redirect(url)
def getSessionData(request):
"""
Liest das SessionCookie
"""
session = ISession(request)
mongo_objid = session.get('key', '')
client = MongoClient(mongoserver, mongoport)
db = client.hh_database
collection = db.hh_collection
if mongo_objid:
print 'lesen: ', mongo_objid
data = collection.find_one({"_id": mongo_objid})
else:
data = {
'hhlpan': False,
'taetigkeit': {},
'chemiesuche': {},
'cbsuche': {},
'mechaniksuche': {},
'schutzhandschuhe': [],
'hautschutz': [],
'hautreinigung': [],
'hautpflege': [],
'desinfektion': [],
'hautschutzplan': {}
}
return data
def get_validated(self):
validated = {}
uid = self.context.UID()
session = ISession(self.request)
if uid in session:
validated = session[uid]['validated']
return validated
def setCartCookie(cookie, request):
"""
Schreibt das Cookie in die Session
"""
session = ISession(request)
session['cart'] = cookie
session.save()
def checkpin(self, request):
check = False
uid = self.UID()
session = ISession(request)
if uid in session:
checkpin = session[uid]
check = self.compare_pin(checkpin)
return check
def resetCredentials(self, request, response):
"""This method is called if the user logs out.
Here, we simply destroy their session.
"""
session = ISession(request, None)
if session is None:
return
session.delete()
def _setAuthorizationCookie(self):
session = ISession(self.context.REQUEST)
authorization = IAuthorizationTool(self.context)
token = authorization.createAuthToken(self.request)
self.request.response.setCookie(ZAUTH_COOKIE,
token['id'],
path="/",
secure=session.secure,
http_only=True)
def checkchat(self, request):
check = False
uid = self.UID()
chatid = 'chat_%s' % uid
session = ISession(request)
if chatid in session:
checkmember = session[chatid]
chatmember = self.chatmember(checkmember)
if chatmember:
check = True
return check
def update(self):
''' Nothing
'''
# import pdb; pdb.set_trace()
logger.debug('Generating view for kollkoll')
kollkoll = Kollkoll()
pid = get_pid()
self.result = kollkoll.listCards(pid)
session = ISession(self.request, None)
session[SessionKeys.available_cards] = self.result
session.save()
def getSessionData(request):
"""
Liest das SessionCookie
"""
session = ISession(request)
mongo_objid = session.get('key', '')
client = get_mongo_client().client
db = client.mp_database
collection = db.mp_collection
if mongo_objid:
data = collection.find_one({"_id":mongo_objid})
else:
data = {}
return data
def delSessionData(request):
"""
Loescht das Cookie
"""
data = {'hhlpan':False,
'taetigkeit':{},
'chemiesuche':{},
'mechaniksuche':{},
'schutzhandschuhe':[],
'hautschutz':[],
'hautreinigung':[],
'hautpflege':[],
'desinfektion':[],
'hautschutzplan':{}}
insert = setSessionData(request, data)
session = ISession(request)
session.delete()
def setSessionData(request, data):
"""
Schreibt das Cookie in die Session
"""
session = ISession(request)
mongo_objid = session.get('key', '')
client = get_mongo_client().client
db = client.mp_database
collection = db.mp_collection
if mongo_objid:
insert = collection.replace_one({'_id':mongo_objid}, data, upsert=True)
session.save()
else:
insert = collection.insert_one(data).inserted_id
session['key'] = insert
session.save()
return insert
def getCartCookie(request):
"""
Liest das SessionCookie
"""
session = ISession(request)
cart_default = {} #leere Artikelliste
cookie = session.get('cart', cart_default)
delkeys = []
for i in cookie:
try:
if int(cookie[i]['menge']) <= 0:
delkeys.append(i)
except:
print i
for i in delkeys:
del cookie[i]
return cookie
def update(self):
''' Shows confirmation view before removing bank
'''
#import pdb; pdb.set_trace()
session = ISession(self.request, None)
self.card_id = self.request.get('id', None)
self.return_url = self.request.get('return_url', None)
available_cards = {}
for card in session[SessionKeys.available_cards]:
available_cards[card['id']] = card
self.bank = available_cards[self.card_id]
#import pdb; pdb.set_trace()
button_ok = self.request.form.get('form.button.Ok') or None
if button_ok:
utils = getToolByName(self, "plone_utils")
if self.card_id in [
x.get('id') for x in session[SessionKeys.available_cards]
]:
kollkoll = Kollkoll()
try:
result = kollkoll.removeCard(uid=get_pid(),
bid=self.card_id)
utils.addPortalMessage(
_('Din inlogging till ' + self.bank['name'] +
' togs bort'), 'info')
except Exception, ex:
utils.addPortalMessage(
_('Det uppstod ett fel i samband med att din inloggning skulle tas bort'
), 'error')
logger.exception('Exception occured: %s' % str(ex))
else:
utils.addPortalMessage(_('Bank med angivet id saknas'),
'error')
if self.return_url and self.return_url != 'None':
url = self.return_url
else:
url = self.context.absolute_url()
return self.request.response.redirect(url)
def handleApply(self, action):
data, errors = self.extractData()
if not errors:
checkmember = self.context.chatmember(data.get('chatpin'))
if not checkmember:
errormsg = u"Der eingegebene PIN ist leider nicht gültig"
ploneapi.portal.show_message(message=errormsg,
request=self.request,
type='error')
url = self.context.absolute_url() + '/chat-pin'
return self.request.response.redirect(url)
else:
session = ISession(self.request)
uid = self.context.UID()
chatid = "chat_%s" % uid
session[chatid] = checkmember
session.save()
url = self.context.absolute_url() + '/@@chatroom/'
return self.request.response.redirect(url)
def __call__(self):
data = {}
if not ploneapi.user.is_anonymous():
authuser = ploneapi.user.get_current()
data['user'] = {'name':authuser.getProperty('fullname'), 'pin':authuser.getProperty('email'), 'role':'teacher'}
else:
session = ISession(self.request)
chatid = 'chat_%s' % self.context.UID()
userdata = session.get(chatid)
userdata['role'] = 'trainee'
data['user'] = userdata
database = True
if not self.get_databases():
database = self.create_database()
data['database'] = database
data['teacher_folder_uid'] = self.context.aq_parent.UID()
data['classroom_uid'] = self.context.UID()
myauth = self.get_credentials()
data['dbuser'] = myauth[0]
data['dbpassword'] = myauth[1]
classlist = self.context.get_classlist()
data['classlist'] = classlist
payload = jsonlib.write(data)
return payload
def delSessionData(request):
"""
Loescht das Cookie
"""
session = ISession(request)
session.delete()
def update(self):
# Use collective.beaker for session managment
session = ISession(self.request, None)
self.sessionmanager = session
super(Wizard, self).update()
def _session(self):
""" Here's the core logic which looks up the Beaker session. """
session = ISession(self.REQUEST)
return BeakerSessionDataObject(session)
def __call__(self):
registry = getUtility(IRegistry)
TWITTER_CONSUMER_KEY = registry.get(
'cs.auth.twitter.controlpanel.ITwitterLoginSettings.twitter_consumer_key'
).encode()
TWITTER_CONSUMER_SECRET = registry.get(
'cs.auth.twitter.controlpanel.ITwitterLoginSettings.twitter_consumer_secret'
).encode()
session = ISession(self.request)
token = oauth.Token(
session[AuthorizationTokenKeys.oauth_token],
session[AuthorizationTokenKeys.oauth_token_secret],
)
consumer = oauth.Consumer(key=TWITTER_CONSUMER_KEY,
secret=TWITTER_CONSUMER_SECRET)
client = oauth.Client(consumer, token)
resp, content = client.request(TWITTER_ACCESS_TOKEN_URL, 'GET')
if resp.get('status', '999') != '200':
IStatusMessage(self.request).add(
_(u"Error authenticating with Twitter. Please try again."),
type="error")
self.request.response.redirect(self.context.absolute_url())
return u""
access_token = dict(parse_qsl(content))
# Save the data in the session so that the extraction plugin can
# authenticate the user to Plone
session = ISession(self.request)
session[SessionKeys.user_id] = str(access_token['user_id'])
session[SessionKeys.screen_name] = access_token['screen_name']
session[SessionKeys.oauth_token] = access_token['oauth_token']
session[SessionKeys.
oauth_token_secret] = access_token['oauth_token_secret']
api = Api(consumer_key=TWITTER_CONSUMER_KEY,
consumer_secret=TWITTER_CONSUMER_SECRET,
access_token_key=session[AuthorizationTokenKeys.oauth_token],
access_token_secret=session[
AuthorizationTokenKeys.oauth_token_secret])
us = api.GetUser(str(access_token['user_id']))
session[SessionKeys.name] = us.name
session[SessionKeys.profile_image_url] = us.profile_image_url
session[SessionKeys.description] = us.description
session[SessionKeys.location] = us.location
session.save()
# Add user data into our plugin storage:
acl = self.context.acl_users
acl_plugins = acl.plugins
ids = acl_plugins.listPluginIds(IExtractionPlugin)
for id in ids:
plugin = getattr(acl_plugins, id)
if ICSTwitterPlugin.providedBy(plugin):
if plugin._storage.get(session[SessionKeys.user_id],
None) is None:
user_data = {
'screen_name': session[SessionKeys.screen_name],
'fullname': session[SessionKeys.name],
'profile_image_url':
session[SessionKeys.profile_image_url],
'description': session[SessionKeys.description],
'location': session[SessionKeys.location]
}
plugin._storage[session[SessionKeys.user_id]] = user_data
IStatusMessage(self.request).add(_(u"Welcome. You are now logged in."),
type="info")
return_args = ''
if self.request.get('came_from', None) is not None:
return_args = {'came_from': self.request.get('came_from')}
return_args = '?' + urllib.urlencode(return_args)
self.request.response.redirect(self.context.absolute_url() +
'/logged_in' + return_args)
def handle_search(self):
data, errors = self.extractData()
if errors:
return
brains = ploneapi.content.find(portal_typ='Partner',
art=data.get('art'))
self.partners = []
adresse = "%s, Deutschland" % data.get('plz')
if data.get('strhnr'):
adresse = "%s, %s, Deutschland" % (data.get('strhnr'),
data.get('plz'))
location = geolocator.geocode(adresse, timeout=10)
geolocations = []
if location:
location = (location.latitude, location.longitude)
geolocation = {
"title": "Adresse Kunde",
"lon": location[1],
"lat": location[0],
"color": '#555555'
}
geolocations = [geolocation]
session = ISession(self.request)
for i in brains:
entry = {}
partner = (i.latitude, i.longitude)
distance = great_circle(location, partner).km
if data.get('umkreis') != 'alle':
if distance <= data.get('umkreis'):
obj = i.getObject()
entry['title'] = obj.title
entry['id'] = obj.UID()
entry['url'] = obj.absolute_url()
entry['plz'] = obj.plz
entry['ort'] = obj.ort
entry['kontakt'] = self.createKontaktinfos(obj)
entry['distance'] = distance
entry['printdistance'] = int(round(distance))
entry['zusatzinfos'] = obj.zusatzinfos
self.partners.append(entry)
geolocation = {
"title": obj.title,
"lon": i.longitude,
"lat": i.latitude,
"color": '#004994'
}
geolocations.append(geolocation)
else:
obj = i.getObject()
entry['title'] = obj.title
entry['id'] = obj.UID()
entry['url'] = obj.absolute_url()
entry['plz'] = obj.plz
entry['ort'] = obj.ort
entry['kontakt'] = self.createKontaktinfos(obj)
entry['distance'] = distance
entry['printdistance'] = int(round(distance))
entry['zusatzinfos'] = obj.zusatzinfos
self.partners.append(entry)
geolocation = {
"title": obj.title,
"lon": i.longitude,
"lat": i.latitude,
"color": '#004994'
}
geolocations.append(geolocation)
if self.partners:
self.partners = sorted(self.partners, key=itemgetter('distance'))
else:
self.message = u'Leider konnten für Ihre Angaben keine Netzwerkpartner gefunden werden. Bitte ändern Sie gegebenenfalls Ihre Angaben\
und versuchen es dann erneut.'
#ploneapi.portal.show_message(self.message, self.request, type="error")
#return self.response.redirect(self.formurl)
session['geodata'] = geolocations
session.save()
def __init__(self, context, request, wizard):
# Use collective.beaker for session managment
session = ISession(request, None)
self.sessionmanager = session
super(SocialNetworkStep, self).__init__(context, request, wizard)
def _getSessionData(self, id):
# For some reason Products.BeakerSessionDataManager doesn't support getSessionDataByKey
#sess = self.context.session_data_manager.getSessionDataByKey(sessionId)
session = ISession(self.context.REQUEST)
return session.get_by_id(id)
def __call__(self):
locations = []
session = ISession(self.request)
if session.get('geodata'):
locations = session.get('geodata')
return jsonlib.write(locations)
def __call__(self):
registry = getUtility(IRegistry)
TWITTER_CONSUMER_KEY = registry.get(
'cs.auth.twitter.controlpanel.ITwitterLoginSettings.twitter_consumer_key'
).encode()
TWITTER_CONSUMER_SECRET = registry.get(
'cs.auth.twitter.controlpanel.ITwitterLoginSettings.twitter_consumer_secret'
).encode()
# Create an Oauth Consumer
oauth_consumer = oauth.Consumer(key=TWITTER_CONSUMER_KEY,
secret=TWITTER_CONSUMER_SECRET)
oauth_client = oauth.Client(oauth_consumer)
# Set the callback URL. Be sure that callback urls are allowed in Twitter
# App configuration. Do not leave blank the field of the callback url
# when creating the app, otherwise this login method *will not work*.
return_args = ''
if self.request.get('came_from', None) is not None:
return_args = {'came_from': self.request.get('came_from')}
return_args = '?' + urllib.urlencode(return_args)
args = {
'oauth_callback':
self.context.absolute_url() + '/@@twitter-login-verify' +
return_args,
}
body = urllib.urlencode(args)
resp, content = oauth_client.request(TWITTER_REQUEST_TOKEN_URL,
'POST',
body=body)
if resp.get('status', '999') != '200':
IStatusMessage(self.request).add(_(
u"Error getting the authorization token from Twitter. Try again please"
),
type="error")
self.request.response.redirect(self.context.absolute_url())
return u""
else:
# The request was successful, so save the token in the session
# and redirect the user to Twitter
request_token = dict(parse_qsl(content))
session = ISession(self.request)
session[AuthorizationTokenKeys.
oauth_token] = request_token['oauth_token']
session[AuthorizationTokenKeys.
oauth_token_secret] = request_token['oauth_token_secret']
session[AuthorizationTokenKeys.
oauth_callback_confirmed] = request_token[
'oauth_callback_confirmed']
session.save()
args = {
'oauth_token': request_token['oauth_token'],
}
self.request.response.redirect("%s?%s" % (
TWITTER_AUTH_URL,
urllib.urlencode(args),
))
def update(self):
session = ISession(self.request)
del session['cart']
session.save()
def order(self):
data, errors = self.extractData()
if self.verif and len(errors) == 2:
errors = None
if errors:
return
sapapi = sapshopapi.getAPI()
checker = self.checkBestand()
if not checker:
url = ploneapi.portal.get().absolute_url() + '/checkorder'
message = u'Bei Ihrer Bestellung ist leider ein Fehler aufgetreten. Bitte beachten Sie die aktualisierten Mengen bei den rot markierten\
Artikeln.'
ploneapi.portal.show_message(message=message,
request=self.request,
type='error')
return
bestellung = sapapi.createOrder(self.userdata.get('email'),
self.artlist)
if bestellung.EX_RETURN == 0:
self.bestellnummer = bestellung.EX_VBELN
self.userdata['bestellnummer'] = self.bestellnummer
key = setSessionData(self.request, self.userdata)
mime_msg = MIMEMultipart('related')
mime_msg['Subject'] = u"Ihre Bestellung auf bgetem.de"
mime_msg['From'] = u"*****@*****.**"
mime_msg['To'] = self.userdata.get('email')
mime_msg.preamble = 'This is a multi-part message in MIME format.'
msgAlternative = MIMEMultipart('alternative')
mime_msg.attach(msgAlternative)
htmltext = createOrderMessage(self.userdata, self.verif, self.mnr,
self.artlist, self.gesamt_mem,
self.gesamt, self.bestellnummer)
msg_txt = MIMEText(htmltext, _subtype='html', _charset='utf-8')
msgAlternative.attach(msg_txt)
mail_host = ploneapi.portal.get_tool(name='MailHost')
mail_host.send(mime_msg.as_string())
#message = u'Vielen Dank, Ihre Bestellung ist bei uns eingegangen. Sie erhalten eine Bestätigung per E-Mail.'
#ploneapi.portal.show_message(message=message, request=self.request, type='info')
try:
carddata = getCartCookie(self.request)
for i in carddata:
artikel = ploneapi.content.find(UID=i)[0].getObject()
artikel._v_article = None
session = ISession(self.request)
del session['cart']
session.save()
except:
print u'Problem beim Delete Session'
url = ploneapi.portal.get().absolute_url(
) + '/medienportal/orderconfirm'
return self.response.redirect(url)
else:
message = u'Bei Ihrer Bestellung ist leider ein Fehler aufgetreten. Bitte versuchen Sie es später noch einmal. (%s)' % bestellung.EX_MESSAGE
ploneapi.portal.show_message(message=message,
request=self.request,
type='error')
return self.response.redirect(self.formurl)
def __call__(self):
registry = getUtility(IRegistry)
GOOGLEPLUS_CLIENT_ID = registry.get('cs.auth.googleplus.controlpanel.IGooglePlusLoginSettings.googleplus_client_id').encode()
GOOGLEPLUS_CLIENT_SECRET = registry.get('cs.auth.googleplus.controlpanel.IGooglePlusLoginSettings.googleplus_client_secret').encode()
verificationCode = self.request.form.get("code", None)
error = self.request.form.get("error", None)
errorReason = self.request.form.get("error_reason", None)
salt = hashlib.sha256().hexdigest()
session = ISession(self.request)
session[GOOGLEPLUS_AUTHENTICATION_SALT_KEY] = salt
args = {
'state': STATE,
'scope': PERMISSIONS,
'client_id': GOOGLEPLUS_CLIENT_ID,
'redirect_uri': "%s/%s" % (self.context.absolute_url(),
self.__name__),
'response_type': RESPONSE,
}
# Did we get an error back after a Google+ redirect?
if error is not None or errorReason is not None:
log.info(error)
log.info(errorReason)
IStatusMessage(self.request).add(_(
u"GOOGLEPLUS authentication denied"), type="error")
self.request.response.redirect(self.context.absolute_url())
return u""
# Check if this the status is the same...
return_salt = self.request.form.get('status', '')
session_salt = session.get(GOOGLEPLUS_AUTHENTICATION_SALT_KEY)
if return_salt and return_salt != session_salt:
IStatusMessage(self.request).add(_(
u"GooglePlus authentication denied"), type="error")
self.request.response.redirect(self.context.absolute_url())
log.info('%s != %s' % (
return_salt,
session.get(GOOGLEPLUS_AUTHENTICATION_SALT_KEY)))
return u""
# If there is no code, this is probably the first request, so redirect
# to Google+
if verificationCode is None:
self.request.response.redirect(
"%s?%s" % (GOOGLEPLUS_AUTH_URL, urllib.urlencode(args),)
)
return u""
# If we are on the return path form Google+,
# exchange the return code for a token
args = {
'code': verificationCode,
'client_id': GOOGLEPLUS_CLIENT_ID,
'client_secret': GOOGLEPLUS_CLIENT_SECRET,
'redirect_uri': "%s/%s" % (
self.context.absolute_url(),
self.__name__),
'grant_type': GRANT,
}
response = requests.post(GOOGLEPLUS_ACCESS_TOKEN_URL, data=args)
#Load the profile using the access token we just received
accessToken = response.json()["access_token"]
def unicode_to_utf8(data):
if isinstance(data, unicode):
return data.encode('utf-8')
else:
return data
def dict_unicode_to_utf8(data):
new_data = {}
for key, value in data.items():
new_data[unicode_to_utf8(key)] = unicode_to_utf8(value)
return new_data
profile = json.load(urllib.urlopen(
"%s?%s" % (
GOOGLEPLUS_PROFILE_URL,
urllib.urlencode({'access_token': accessToken}),)
), object_hook=dict_unicode_to_utf8)
userId = profile.get('id')
name = profile.get('name')
email = profile.get('email', '')
username = profile.get('name')
profile_image = profile.get('picture')
if not userId:
IStatusMessage(self.request).add(
_(u"Insufficient information in GooglePlus profile"),
type="error")
self.request.response.redirect(self.context.absolute_url())
return
# Save the data in the session so that the extraction plugin can
# authenticate the user to Plone
session[SessionKeys.accessToken] = accessToken
session[SessionKeys.userId] = userId
session[SessionKeys.userName] = username
session[SessionKeys.fullname] = name
session[SessionKeys.email] = email
session[SessionKeys.profile_image] = profile_image
session.save()
# Add user data into our plugin storage:
acl = self.context.acl_users
initial_login = acl.getUserById(userId) is None
acl_plugins = acl.plugins
ids = acl_plugins.listPluginIds(IExtractionPlugin)
for id in ids:
plugin = getattr(acl_plugins, id)
if ICSGooglePlusPlugin.providedBy(plugin):
user_data = plugin._storage.get(
session[SessionKeys.userId], {})
user_data['username'] = session[SessionKeys.userName]
user_data['fullname'] = session[SessionKeys.fullname]
user_data['email'] = session[SessionKeys.email]
plugin._storage[session[SessionKeys.userId]] = user_data
IStatusMessage(self.request).add(
pmf(u"Welcome! You are now logged in."),
type="info")
return_args = ''
if self.request.get('came_from', None) is not None:
return_args = {'came_from': self.request.get('came_from')}
return_args = '?' + urllib.urlencode(return_args)
user = acl.getUserById(userId)
if initial_login:
notify(GoogleUserRegisteredEvent(user, profile))
else:
notify(GoogleUserLoggedInEvent(user, profile))
self.request.response.redirect(
self.context.absolute_url() + '/logged_in' + return_args)
