def root():
try:
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request)
logger.debug(utils.get_debug_all(request))
key = {'url': request.url}
tmp_dict = None
#data_dict = None
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
data = render_template(RENDER_ROOT)
rediscache.__setCache(key, data, 60)
else:
logger.info("Data found in redis, using it directly")
data = tmp_dict
return data, 200
except Exception as e:
import traceback
traceback.print_exc()
return "An error occured, check logDNA for more information", 200
def __getMatchById(match_id):
sqlRequest = """select date__c ,
match__c.participant_home__c participant_home_id,
match__c.participant_visitor__c participant_visitor_id,
match__c.sfid match_id,
match__c.gameactivity__c gameactivity__c,
match__c.question__c question__c,
participant__home.name participant_home_name,
participant__home.image__c participant_home_image,
participant__home.description__c participant_home_description,
participant__visitor.name participant_visitor_name,
participant__visitor.image__c participant_visitor_image,
participant__visitor.description__c participant_visitor_description
from salesforce.match__c,
salesforce.participant__c participant__home,
salesforce.participant__c participant__visitor
where match__c.sfid= %(match_id)s
and (participant__home.sfid = match__c.participant_home__c)
and (participant__visitor.sfid = match__c.participant_visitor__c)"""
key = {"sqlRequest": "__getMatchById", "match_id": match_id}
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache : heroku log data not known")
data = __execRequest(sqlRequest, {'match_id': match_id})
rediscache.__setCache(key, ujson.dumps(data), 60)
else:
logger.info("Data found in redis, using it directly")
data = ujson.loads(tmp_dict)
return data
def __getMatchsByGameActivityId(gameactivity__c):
sqlRequest = """select match__c.sfid matchid ,
match__c.date__c Date,
match__c.question__c Question,
participant__c_home.name as Participant_Home,
participant__c_visitor.name Participant_Visitor
from
salesforce.match__c match__c,
salesforce.participant__c participant__c_home ,
salesforce.participant__c participant__c_visitor
where match__c.gameactivity__c = %(gameactivity__c)s
and (participant__c_home.sfid = match__c.participant_home__c)
and (participant__c_visitor.sfid = match__c.participant_visitor__c)
order by
match__c.date__c DESC"""
key = {
"sqlRequest": "__getMatchsByGameActivityById",
"activityId": gameactivity__c
}
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache : heroku log data not known")
data = __execRequest(sqlRequest, {'gameactivity__c': gameactivity__c})
rediscache.__setCache(key, ujson.dumps(data), 60)
else:
logger.info("Data found in redis, using it directly")
data = ujson.loads(tmp_dict)
return data
def root_photo():
try:
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
logger.debug(utils.get_debug_all(request))
key = {'url': request.url}
tmp_dict = None
#data_dict = None
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
data = render_template(RENDER_ROOT_PHOTO,
FA_APIKEY=utils.FOLLOWANALYTICS_API_KEY,
userid=cookie,
PUSHER_KEY=notification.PUSHER_KEY)
#rediscache.__setCache(key, data, 60)
else:
logger.info("Data found in redis, using it directly")
data = tmp_dict
return utils.returnResponse(data, 200, cookie, cookie_exists)
except Exception as e:
import traceback
traceback.print_exc()
cookie, cookie_exists = utils.getCookie()
return utils.returnResponse(
"An error occured, check logDNA for more information", 200, cookie,
cookie_exists)
def getObjects():
try:
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request)
# output type
output = 'html'
if 'output' in request.args:
output = request.args['output'].lower()
# logs all attributes received
logger.debug(get_debug_all(request))
# gets object name
object_name = ''
if ('name' in request.args):
object_name = request.args['name']
else:
return "Error, must specify a object name with ?name=xxx", 404
key = {'url': request.url, 'output': output}
tmp_dict = None
data_dict = None
tmp_dict = rediscache.__getCache(key)
data = ""
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
data_dict = postgres.__getObjects(object_name)
if (output == 'html'):
logger.info(
"Treating request as a web request, output to Web page")
data = render_template(RENDER_TABLE_DATA,
columns=data_dict['columns'],
object_name=object_name,
entries=data_dict['data'])
else:
logger.info(
"Treating request as an API request, output to Json only")
data = ujson.dumps(data_dict)
if (postgres.HEROKU_LOGS_TABLE
not in request.url): # we don't want to cache these logs
rediscache.__setCache(key, data.encode('utf-8'), 300)
else:
logger.info("Data found in redis, using it directly")
#logger.info(tmp_dict)
if (output == 'html'):
#data_dict = ujson.loads(tmp_dict)
data = tmp_dict.decode('utf-8')
else:
#data = ujson.loads(tmp_dict)
data = tmp_dict
logger.info("returning data")
return data, 200
except Exception as e:
import traceback
traceback.print_exc()
return "An error occured, check logDNA for more information", 200
def votes_placevote():
try:
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request)
logger.debug(utils.get_debug_all(request))
key = {'url' : request.url}
tmp_dict = None
#data_dict = None
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
#gameactivity__c = request.args['gameactivity__c']
match_id = request.args['match_id']
resultMatch = postgres.__getMatchById(match_id)
if (resultMatch['data'][0]['question__c'] == None):
resultMatch['data'][0]['question__c'] = ""
data = render_template(RENDER_PLACE_BET,
entry = resultMatch['data'][0]
)
rediscache.__setCache(key, data, 60)
else:
logger.info("Data found in redis, using it directly")
data = tmp_dict
return data, 200
except Exception as e:
import traceback
traceback.print_exc()
return "An error occured, check logDNA for more information", 200
def homepage():
cookie, cookie_exists = utils.getCookie()
logger.debug(utils.get_debug_all(request))
key = {'cookie': cookie}
tmp_dict = None
#data_dict = None
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
logger.debug(utils.get_debug_all(request))
text = 'User is not authenticated, please log in ! <a href="%s">Authenticate with Salesforce</a>'
state = str(uuid4())
save_created_state(state)
params = {
"client_id": APP_CLIENT_ID,
"response_type": "code",
"state": state,
"redirect_uri": REDIRECT_URI_CODE,
"scope": "full refresh_token"
}
url = SF_AUTHORIZE_TOKEN_URL + urllib.parse.urlencode(params)
logger.info(url)
data = text % url
else:
data = tmp_dict
return utils.returnResponse(data, 200, cookie, cookie_exists)
def votes_placevote():
try:
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
logger.debug(utils.get_debug_all(request))
key = {'url': request.url}
tmp_dict = None
#data_dict = None
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
#gameactivity__c = request.args['gameactivity__c']
match_id = request.args['match_id']
resultMatch = postgres.__getMatchById(match_id)
if (resultMatch['data'][0]['question__c'] == None):
resultMatch['data'][0]['question__c'] = ""
data = render_template(RENDER_PLACE_BET,
entry=resultMatch['data'][0],
FA_APIKEY=utils.FOLLOWANALYTICS_API_KEY,
userid=cookie,
PUSHER_KEY=notification.PUSHER_KEY)
#rediscache.__setCache(key, data, 60)
else:
logger.info("Data found in redis, using it directly")
data = tmp_dict
return utils.returnResponse(data, 200, cookie, cookie_exists)
except Exception as e:
import traceback
traceback.print_exc()
return "An error occured, check logDNA for more information", 200
def is_valid_state(state):
val = rediscache.__getCache(state)
logger.info(val)
return val != None and val != '' and val == b'created'
#if __name__ == '__main__':
# app.run(debug=True, port=65010)
def __getImageAnalysis(tableName, objectName):
key = {"sqlRequest" : "__getImageAnalysis", "objectName" : objectName}
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache : heroku log data not known")
concat = SALESFORCE_SCHEMA + "." + tableName
data = __execRequest("select * from {} where name='{}' ".format(concat, objectName), {})
rediscache.__setCache(key, ujson.dumps(data), 120)
else:
logger.info("Data found in redis, using it directly")
data = ujson.loads(tmp_dict)
return data
def createTicket():
try:
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
logger.debug(utils.get_debug_all(request))
form = TicketForm(request.form)
hosts = postgres.__getSFUsers()
key = {'url' : MAIN_URL, 'cookie' : cookie}
tmp_dict = rediscache.__getCache(key)
data = ""
if (request.method=="GET"):
if ((tmp_dict != None) and (tmp_dict != '')):
#means user has already registered, forwarding him to the guest thanks
data = render_template(CREATETICKETS, registered=True, form=form, userid=cookie, PUSHER_KEY=notification.PUSHER_KEY, PUSHER_CLUSTER=notification.CLUSTER)
return utils.returnResponse(data, 200, cookie, cookie_exists)
else:
# means it has to register
return redirect("/",code=302)
elif request.method == 'POST':
if ((tmp_dict != None) and (tmp_dict != '')):
#means user has already registered, accepting this
Reason=request.form['Reason']
Subject=request.form['Subject']
Description=request.form['Description']
postgres.__insertCase(cookie, Subject, Description, "Self Service", Reason)
#postgres.__saveGuestEntry(Firstname, Lastname, Email, Company, PhoneNumber, Host, cookie, Picture)
data = render_template(GUESTTHANKS, registered=True, userid=cookie, PUSHER_KEY=notification.PUSHER_KEY, PUSHER_CLUSTER=notification.CLUSTER)
#rediscache.__setCache(key, data.encode('utf-8'), 3600)
return utils.returnResponse(data, 200, cookie, cookie_exists)
else:
# means user has not registered and is trying to post, ..
# so returning him the registration page first
return redirect("/",code=302)
else:
# trying to hack someting ?
return redirect("/",code=302)
data = render_template(CREATETICKETS, form=form, hosts=hosts['data'],userid=cookie,PUSHER_KEY=notification.PUSHER_KEY, PUSHER_CLUSTER=notification.CLUSTER)
return utils.returnResponse(data, 200, cookie, cookie_exists)
except Exception as e:
import traceback
traceback.print_exc()
cookie, cookie_exists = utils.getCookie()
return utils.returnResponse("An error occured, check logDNA for more information", 200, cookie, cookie_exists)
def __getTables():
key = {"sqlRequest": "__getTables"}
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache : heroku log data not known")
sqlRequest = "SELECT table_schema, table_name FROM information_schema.tables where table_schema like '%%alesforce' ORDER BY table_schema,table_name"
data = __execRequest(sqlRequest, {})
rediscache.__setCache(key, ujson.dumps(data), 30)
else:
logger.info("Data found in redis, using it directly")
data = ujson.loads(tmp_dict)
return data
def __getObjects(tableName):
key = {"sqlRequest": "__getObjects", "tableName": tableName}
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache : data not known")
concat = SALESFORCE_SCHEMA + "." + tableName
data = __execRequest("select * from {}".format(concat), {})
logger.info("Data Returned")
logger.info(data)
rediscache.__setCache(key, utils.jsonencode(data), 30)
else:
logger.info("Data found in redis, using it directly")
data = ujson.loads(tmp_dict)
return data
def __getSFUsers():
key = {"sqlRequest": "getSFUsers"}
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache : heroku log data not known")
sql = "select name, sfid from salesforce.user where CanAcceptGuest__c = 'True' order by name ASC"
data = __execRequest(sql, {})
rediscache.__setCache(key, utils.jsonencode(data), 60)
else:
logger.info("Data found in redis, using it directly")
data = ujson.loads(tmp_dict)
logger.debug(data)
return data
def bets_bygameactivity__c():
try:
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
logger.debug(utils.get_debug_all(request))
key = {'url': request.url}
tmp_dict = None
#data_dict = None
tmp_dict = rediscache.__getCache(key)
has_voted = False
if ('has_voted' in request.args):
has_voted = bool(request.args['has_voted'])
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
gameactivity__c = request.args['gameactivity__c']
resultActivityName = postgres.__getGameActivityById(
gameactivity__c)
result = postgres.__getMatchsByGameActivityId(gameactivity__c)
data = render_template(
RENDER_BETS_MATCHS,
columns=result['columns'],
entries=result['data'],
category_name=resultActivityName['data'][0]['activityname'],
category_id=gameactivity__c,
hasvoted=has_voted,
FA_APIKEY=utils.FOLLOWANALYTICS_API_KEY,
userid=cookie,
PUSHER_KEY=notification.PUSHER_KEY)
#rediscache.__setCache(key, data, 60)
else:
logger.info("Data found in redis, using it directly")
data = tmp_dict
return utils.returnResponse(data, 200, cookie, cookie_exists)
except Exception as e:
import traceback
traceback.print_exc()
cookie, cookie_exists = utils.getCookie()
return utils.returnResponse(
"An error occured, check logDNA for more information", 200, cookie,
cookie_exists)
def __checkHerokuLogsTable():
key = {'checkHerokuLogTables' : "True"}
tmp_dict = None
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache : heroku log data not known")
hasDatabase = False
if (MANUAL_ENGINE_POSTGRES != None):
sqlRequest = 'SELECT EXISTS( SELECT * FROM information_schema.tables WHERE table_schema = %(schema)s AND table_name = %(tablename)s ) '
result = MANUAL_ENGINE_POSTGRES.execute(sqlRequest, {'schema' : SALESFORCE_SCHEMA, 'tablename' : HEROKU_LOGS_TABLE} )
for entry in result:
logger.info(entry['exists'])
hasDatabase = entry['exists']
if (hasDatabase == True):
rediscache.__setCache(key, "True", 3600)
return hasDatabase
else:
return True
def __getMatchs():
sqlRequest = """
select
salesforce.gameactivity__c.name ,
salesforce.gameactivity__c.sfid,
(select count(*) from salesforce.match__c where salesforce.match__c.gameactivity__c = salesforce.gameactivity__c.sfid) as nbMatchs
from salesforce.gameactivity__c
where salesforce.gameactivity__c.active__c = True
"""
key = {"sqlRequest": "__getMatchs"}
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache : heroku log data not known")
data = __execRequest(sqlRequest, None)
rediscache.__setCache(key, ujson.dumps(data), 60)
else:
logger.info("Data found in redis, using it directly")
data = ujson.loads(tmp_dict)
return data
def __getGameActivityById(gameactivity__c):
key = {"sqlRequest" : "__getGameActivityById", "activityId" : gameactivity__c}
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache : heroku log data not known")
sqlRequestActivityName = """
select gameactivity__c.name ActivityName
from
salesforce.gameactivity__c
where
gameactivity__c.sfid = %(gameactivity__c)s """
data = __execRequest(sqlRequestActivityName, {'gameactivity__c':gameactivity__c})
rediscache.__setCache(key, ujson.dumps(data), 60)
else:
logger.info("Data found in redis, using it directly")
data = ujson.loads(tmp_dict)
return data
def contact():
try:
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
logger.debug(utils.get_debug_all(request))
if ('phone' not in request.args):
return utils.returnResponse("Please provide a phone number", 403,
cookie, cookie_exists)
entry_phone = request.args['phone']
if (entry_phone == '' or entry_phone == None):
return utils.returnResponse("Please provide a phone number", 403,
cookie, cookie_exists)
key = {'url': request.url}
tmp_dict = None
#data_dict = None
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
data_dict = postgres.__execRequest(
'select name, mobilephone, phone, email, sfid from salesforce.contact where phone = %(phone)s or mobilephone=%(phone)s',
{'phone': entry_phone})
logger.info(data_dict)
rediscache.__setCache(key, data_dict, 60)
data = ujson.dumps(data_dict)
else:
logger.info("Data found in redis, using it directly")
data = tmp_dict
return utils.returnResponse(data, 200, cookie, cookie_exists)
except Exception as e:
import traceback
traceback.print_exc()
cookie, cookie_exists = utils.getCookie()
return utils.returnResponse(
"An error occured, check logDNA for more information", 403, cookie,
cookie_exists)
def FACE_API_CALLBACK(ch, method, properties, body):
try:
# transforms body into dict
body_dict = ujson.loads(body)
logger.info(body_dict)
logger.info(" [x] Received id=%r" % (body_dict['id']))
# gets the id of the image to retrieve in Redis
image_id = body_dict['id']
if (body_dict['UPLOAD_IN_REDIS'] == True):
image_binary_data = rediscache.__getCache(image_id)
# write binary data into a file
logger.debug("Writing file to disk")
localfilename = '%s/%s' % (PATH_TO_TEST_IMAGES_DIR,
"/rab_" + image_id + ".jpg")
remotefilename = image_id + ".jpg"
file = open(localfilename, "wb")
file.write(image_binary_data)
file.close()
# sends data to AWS
logger.debug("Starting AWS Upload")
awsFilename = aws.uploadData(localfilename, remotefilename)
logger.debug("uploaded file to amazon : {}".format(awsFilename))
# deletes from redis
rediscache.__delCache(image_id)
# deletes local file
os.remove(localfilename)
else:
awsFilename = body_dict['remote_url']
# now detection !!
logger.debug("Starting Face API")
result, code = faceapi.face_http(awsFilename)
logger.debug("Face API Result : {}".format(result))
if (code != 200):
logger.error("Can't treat entry.")
return
else:
img_width = body_dict['image_width']
img_height = body_dict["image_height"]
# now treats each result
for entry in result:
try:
personid = uuid.uuid4().__str__()
data = {
'MediaId__c':
image_id,
'image__c':
awsFilename,
'UserAgent__c':
body_dict['user-agent'],
'URL__c':
body_dict['url'],
'Name':
personid,
'PersonId__c':
personid,
'Gender__c':
entry['faceAttributes']['gender'],
'Age__c':
int(entry['faceAttributes']['age']),
'Smile_value__c':
entry['faceAttributes']['smile'],
'eyemakeup__c':
entry['faceAttributes']['makeup']['eyeMakeup'],
'lipmakeup__c':
entry['faceAttributes']['makeup']['lipMakeup'],
'Emotion_Value__c':
0.000
}
# now let's treat things in the right order ..
floatToBool(entry['faceAttributes'], 'smile', data,
'Smile__c', 0.5)
stringToBool(entry['faceAttributes'], 'glasses', data,
'Glasses__c', ["ReadingGlasses"])
floatToBool(entry['faceAttributes']['hair'], 'bald', data,
'Bald__c', 0.5)
# face square
data['ImageWidth__c'] = img_width
data['ImageHeight__c'] = img_height
data['FaceTop__c'] = int(
(entry['faceRectangle']['top'] / img_height) * 100)
data['FaceLeft__c'] = int(
(entry['faceRectangle']['left'] / img_width) * 100)
data['FaceWidth__c'] = int(
(entry['faceRectangle']['width'] / img_width) * 100)
data['FaceHeight__c'] = int(
(entry['faceRectangle']['height'] / img_height) * 100)
if (entry['faceAttributes']['hair']['bald'] > 0.49):
data['Hair__c'] = "bald"
data['Haircolor__c'] = ''
if ('hairColor' in entry['faceAttributes']['hair']):
if (len(entry['faceAttributes']['hair']['hairColor'])
>= 1):
data['Haircolor__c'] = entry['faceAttributes'][
'hair']['hairColor'][0]['color']
data['Hair__c'] = entry['faceAttributes']['hair'][
'hairColor'][0]['color']
else:
data['Hair__c'] = "bald"
else:
data['Hair__c'] = "bald"
FacialHair = "None"
if (entry['faceAttributes']['facialHair']['moustache'] >
0.49):
FacialHair = 'moustache'
if (entry['faceAttributes']['facialHair']['beard'] > 0.49):
if (FacialHair != "None"):
FacialHair += ' or beard'
else:
FacialHair += 'beard'
data['FacialHair__c'] = FacialHair
data['Emotion__c'] = "neutral"
floatToBool(entry['faceAttributes']['facialHair'],
'moustache', data, 'Moustache__c', 0.5)
floatToBool(entry['faceAttributes']['facialHair'], 'beard',
data, 'Beard__c', 0.5)
floatToBool(entry['faceAttributes']['emotion'], 'anger',
data, 'Anger__c', 0.01)
floatToBool(entry['faceAttributes']['emotion'], 'contempt',
data, 'Contempt__c', 0.01)
floatToBool(entry['faceAttributes']['emotion'], 'disgust',
data, 'Disgust__c', 0.01)
floatToBool(entry['faceAttributes']['emotion'], 'fear',
data, 'Fear__c', 0.01)
floatToBool(entry['faceAttributes']['emotion'],
'happiness', data, 'Happiness__c', 0.01)
floatToBool(entry['faceAttributes']['emotion'], 'neutral',
data, 'Neutral__c', 0.01)
floatToBool(entry['faceAttributes']['emotion'], 'sadness',
data, 'Sadness__c', 0.01)
floatToBool(entry['faceAttributes']['emotion'], 'surprise',
data, 'Surprise__c', 0.01)
data['Emotion_Value__c'] = 0.0
data['Emotion__c'] = 'neutral'
floatToString(entry['faceAttributes']['emotion'], 'anger',
data['Emotion_Value__c'], data, 'Emotion__c',
'Emotion_Value__c')
floatToString(entry['faceAttributes']['emotion'],
'contempt', data['Emotion_Value__c'], data,
'Emotion__c', 'Emotion_Value__c')
floatToString(entry['faceAttributes']['emotion'],
'disgust', data['Emotion_Value__c'], data,
'Emotion__c', 'Emotion_Value__c')
floatToString(entry['faceAttributes']['emotion'], 'fear',
data['Emotion_Value__c'], data, 'Emotion__c',
'Emotion_Value__c')
floatToString(entry['faceAttributes']['emotion'],
'happiness', data['Emotion_Value__c'], data,
'Emotion__c', 'Emotion_Value__c')
floatToString(entry['faceAttributes']['emotion'],
'neutral', data['Emotion_Value__c'], data,
'Emotion__c', 'Emotion_Value__c')
floatToString(entry['faceAttributes']['emotion'],
'sadness', data['Emotion_Value__c'], data,
'Emotion__c', 'Emotion_Value__c')
floatToString(entry['faceAttributes']['emotion'],
'surprise', data['Emotion_Value__c'], data,
'Emotion__c', 'Emotion_Value__c')
data['Description__c'] = ujson.dumps(entry)
logger.debug(data)
postgres.__saveImageAnalysisEntry(data)
except Exception as e:
import traceback
traceback.print_exc()
logger.error("Error treating entry, going to the next")
logger.info(" [x] Finished id=%r" % (body_dict['id']))
except Exception as e:
import traceback
traceback.print_exc()
def singleguestbadgemanagement():
try:
logger.debug(utils.get_debug_all(request))
cookie, cookie_exists = utils.getCookie()
#data_dict = None
key_fromCanvas = {'cookie': cookie, 'fromCanvas': True}
tmp_dict_fromCanvas = rediscache.__getCache(key_fromCanvas)
if ((tmp_dict_fromCanvas == None) or (tmp_dict_fromCanvas == '')):
logger.info("Data not found in cache")
logger.debug(utils.get_debug_all(request))
text = 'User is not coming from canvas app !'
return utils.returnResponse(text, 200, cookie, cookie_exists)
else:
struct_json = ujson.loads(tmp_dict_fromCanvas)
guest_id = request.args['guest_id']
# gest the record id
if request.method == 'POST':
logger.info("post detected")
actionform = request.form['action']
actiontype = actionform.split('.')[0]
actionvalue = actionform.split('.')[1]
sqlUpdate = "update public.badge set badge_status=%(status)s where id=%(id)s"
postgres.__execRequestWithNoResult(sqlUpdate, {
'status': actiontype,
'id': actionvalue
})
# now updates the guest status
# sf_getProducts(struct_json['client']['instanceUrl'] , struct_json['client']['oauthToken'])
#def sf_updateBadge(sfurl, sftoken, guest, status)
logger.info('actionType={}'.format(actiontype))
sfinstanceurl = struct_json['client']['instanceUrl']
sftoken = struct_json['client']['oauthToken']
host_id = sf.sf_getGuestHost(sfinstanceurl, sftoken, guest_id)
if (actiontype == 'INACTIVE'):
sf.sf_updateBadge(sfinstanceurl, sftoken, guest_id,
'SECURITY RISK')
elif (actiontype == 'ACTIVE'):
sf.sf_updateBadge(sfinstanceurl, sftoken, guest_id,
'BADGE ISSUED')
sf.sf_ChatterPost(sfinstanceurl, sftoken, guest_id, host_id,
actiontype)
sqlRequest = "select Id, guest_id, guest_firstname, guest_lastname, badge_status, creation_date from public.badge where guest_id = %(guest_id)s order by creation_date"
sqlResult = postgres.__execRequest(sqlRequest,
{'guest_id': guest_id})
data = render_template(CANVAS_FILE,
request_json=ujson.dumps(struct_json),
columns=sqlResult['columns'],
entries=sqlResult['data'])
return utils.returnResponse(data, 200, cookie, cookie_exists)
except Exception as e:
import traceback
traceback.print_exc()
cookie, cookie_exists = utils.getCookie()
return utils.returnResponse(
"An error occured, check logDNA for more information", 200, cookie,
cookie_exists)
def badgesmanagement():
try:
logger.debug(utils.get_debug_all(request))
cookie, cookie_exists = utils.getCookie()
key = {'cookie': cookie}
tmp_dict = None
#data_dict = None
key_fromCanvas = {'cookie': cookie, 'fromCanvas': True}
tmp_dict = rediscache.__getCache(key)
tmp_dict_fromCanvas = rediscache.__getCache(key_fromCanvas)
if (tmp_dict != None):
pprint.pprint(ujson.loads(tmp_dict))
logger.debug("############")
if (tmp_dict_fromCanvas != None):
pprint.pprint(ujson.loads(tmp_dict_fromCanvas))
if (((tmp_dict == None) or (tmp_dict == '')) and
((tmp_dict_fromCanvas == None) or (tmp_dict_fromCanvas == ''))):
logger.info("Data not found in cache")
logger.debug(utils.get_debug_all(request))
text = 'User is not authenticated, please log in ! <a href="%s">Authenticate with Salesforce</a>'
state = str(uuid4())
save_created_state(state)
params = {
"client_id": APP_CLIENT_ID,
"response_type": "code",
"state": state,
"redirect_uri": REDIRECT_URI_CODE,
"scope": "full refresh_token"
}
url = SF_AUTHORIZE_TOKEN_URL + urllib.parse.urlencode(params)
logger.info(url)
data = text % url
return utils.returnResponse(data, 200, cookie, cookie_exists)
else:
if request.method == 'POST':
struct_json = ujson.loads(tmp_dict)
logger.info("post detected")
actionform = request.form['action']
actiontype = actionform.split('.')[0]
actionvalue = actionform.split('.')[1]
sqlUpdate = "update public.badge set badge_status=%(status)s where id=%(id)s"
postgres.__execRequestWithNoResult(sqlUpdate, {
'status': actiontype,
'id': actionvalue
})
logger.info('actionType={}'.format(actiontype))
sfinstanceurl = struct_json['instance_url']
sftoken = struct_json['access_token']
guest_id = postgres.getBadgeById(
actionvalue)['data'][0]['guest_id']
host_id = sf.sf_getGuestHost(sfinstanceurl, sftoken, guest_id)
if (actiontype == 'INACTIVE'):
sf.sf_updateBadge(sfinstanceurl, sftoken, guest_id,
'SECURITY RISK')
elif (actiontype == 'ACTIVE'):
sf.sf_updateBadge(sfinstanceurl, sftoken, guest_id,
'BADGE ISSUED')
sf.sf_ChatterPost(sfinstanceurl, sftoken, guest_id, host_id,
actiontype)
logger.info(tmp_dict)
sqlRequest = "select Id, guest_firstname, guest_lastname, badge_status, creation_date from public.badge order by creation_date"
sqlResult = postgres.__execRequest(sqlRequest, None)
data = render_template(BADGE_FILE,
columns=sqlResult['columns'],
entries=sqlResult['data'])
return utils.returnResponse(data, 200, cookie, cookie_exists)
except Exception as e:
import traceback
traceback.print_exc()
cookie, cookie_exists = utils.getCookie()
return utils.returnResponse(
"An error occured, check logDNA for more information", 200, cookie,
cookie_exists)
def bet_vote():
try:
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request)
logger.debug(utils.get_debug_all(request))
# trick
# ?matchid={{ entry.match_id }}&gameactivity__c={{ entry.gameactivity__c }}&vote_winner={{ entry.participant_home_id}}
is_vote_through_get = False
if ('matchid' in request.args and
'vote_winner' in request.args and
'gameactivity__c' in request.args):
is_vote_through_get = True
if (request.method == 'POST' or is_vote_through_get == True):
matchid = request.args['matchid']
gameactivity__c=request.args['gameactivity__c']
if (is_vote_through_get):
winner = request.args['vote_winner']
else:
winner = request.form['vote_winner']
useragent = request.headers['User-Agent']
externalid = uuid.uuid4().__str__()
createddate = datetime.now()
sqlRequest = """
insert into salesforce.bet__c (winner__c,
useragent__c,
name,
externalid__c,
match__c,
createddate) values
( %(winner)s, %(useragent)s, %(externalid)s, %(externalid)s, %(matchid)s, %(createddate)s ) """
postgres.MANUAL_ENGINE_POSTGRES.execute(sqlRequest,
{
'winner' : winner,
'useragent' : useragent,
'createddate':createddate,
'externalid' : externalid,
'matchid':matchid} )
logger.info('##### vote taken into account ####')
return redirect('/matchs?gameactivity__c='+gameactivity__c+"&has_voted=True")
else:
key = {'url' : request.url}
tmp_dict = None
data_dict = None
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
sqlRequest = """
select
salesforce.gameactivity__c.name ,
salesforce.gameactivity__c.sfid,
(select count(*) from salesforce.match__c where salesforce.match__c.gameactivity__c = salesforce.gameactivity__c.sfid) as nbMatchs
from salesforce.gameactivity__c
"""
data_dict = postgres.__execRequest(sqlRequest, None)
data = render_template(RENDER_BETS_MAIN,
columns=data_dict['columns'],
entries = data_dict['data'])
rediscache.__setCache(key, data, 60)
else:
logger.info("Data found in redis, using it directly")
data = tmp_dict
return data, 200
except Exception as e:
import traceback
traceback.print_exc()
return "An error occured, check logDNA for more information", 200
def guest():
try:
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
logger.debug(utils.get_debug_all(request))
form = ReusableForm(request.form)
hosts = postgres.__getSFUsers()
key = {'url' : MAIN_URL, 'cookie' : cookie}
tmp_dict = rediscache.__getCache(key)
data = ""
if request.method == 'GET':
if ((tmp_dict != None) and (tmp_dict != '')):
#means user has already registered, forwarding him to the guest thanks
data = render_template(GUESTTHANKS, registered=True, userid=cookie, PUSHER_KEY=notification.PUSHER_KEY, PUSHER_CLUSTER=notification.CLUSTER)
return utils.returnResponse(data, 200, cookie, cookie_exists)
else:
# needs to register
data = render_template(GUESTFILE, form=form, hosts=hosts['data'],userid=cookie,PUSHER_KEY=notification.PUSHER_KEY, PUSHER_CLUSTER=notification.CLUSTER)
return utils.returnResponse(data, 200, cookie, cookie_exists)
elif request.method == 'POST':
if ((tmp_dict != None) and (tmp_dict != '')):
#user has gone through the registration process already, need to redirect him to the guest thanks page
data = render_template(GUESTTHANKS, registered=True, userid=cookie, PUSHER_KEY=notification.PUSHER_KEY, PUSHER_CLUSTER=notification.CLUSTER)
return utils.returnResponse(data, 200, cookie, cookie_exists)
else:
#user has not registerd yet, it's the case now
Firstname=request.form['Firstname']
Lastname=request.form['Lastname']
Email=request.form['Email']
Company=request.form['Company']
PhoneNumber=request.form['PhoneNumber']
Host=request.form['Host']
Picture="https://3.bp.blogspot.com/-KIngJEZr94Q/Wsxoh-8kwuI/AAAAAAAAQyM/YlDJM1eBvzoDAUV79-0v_Us-amsjlFpkgCLcBGAs/s1600/aaa.jpg"
if ("fileToUpload" in request.files):
Picture, rabbitData =aws.AWS_upload(request.files['fileToUpload'], request)
rabbitData['cookie'] = cookie
rabbitData['UPLOAD_IN_REDIS'] = False
rabbitData['remote_url'] = Picture
logger.info(rabbitData)
rabbitmq.sendMessage(ujson.dumps(rabbitData), rabbitmq.CLOUDAMQP_QUEUE)
postgres.__saveGuestEntry(Firstname, Lastname, Email, Company, PhoneNumber, Host, cookie, Picture)
data = render_template(GUESTTHANKS, registered=False, userid=cookie, PUSHER_KEY=notification.PUSHER_KEY, PUSHER_CLUSTER=notification.CLUSTER)
rediscache.__setCache(key, ujson.dumps({"Status":"Logged In"}), 3600)
return utils.returnResponse(data, 200, cookie, cookie_exists)
else:
#redirecting the user
return redirect("/",code=302)
if form.validate():
# Save the comment here.
flash('Hello ' + Firstname)
else:
flash('All the form fields are required. ')
data = render_template(GUESTFILE, form=form, hosts=hosts['data'],userid=cookie,PUSHER_KEY=notification.PUSHER_KEY, PUSHER_CLUSTER=notification.CLUSTER)
return utils.returnResponse(data, 200, cookie, cookie_exists)
except Exception as e:
import traceback
traceback.print_exc()
cookie, cookie_exists = utils.getCookie()
return utils.returnResponse("An error occured, check logDNA for more information", 200, cookie, cookie_exists)
def photos_display():
try:
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
# output type
output = 'html'
if 'output' in request.args:
output = request.args['output'].lower()
# logs all attributes received
logger.debug(utils.get_debug_all(request))
# gets object name
object_name = 'ImageAnalysis__c'
key = {'url': request.url, 'output': output}
tmp_dict = None
data_dict = None
tmp_dict = rediscache.__getCache(key)
data = ""
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
data_dict = postgres.__getObjects(object_name)
if (output == 'html'):
logger.info(
"Treating request as a web request, output to Web page")
if ('image__c' in data_dict['columns']):
data = render_template(
RENDER_PHOTOS_DISPLAY,
columns=data_dict['columns'],
object_name=object_name,
entries=data_dict['data'],
FA_APIKEY=utils.FOLLOWANALYTICS_API_KEY,
userid=cookie,
PUSHER_KEY=notification.PUSHER_KEY)
else:
logger.info(
"Treating request as an API request, output to Json only")
data = ujson.dumps(data_dict)
#if (postgres.HEROKU_LOGS_TABLE not in request.url): # we don't want to cache these logs
# rediscache.__setCache(key, data.encode('utf-8'), 60)
else:
logger.info("Data found in redis, using it directly")
#logger.info(tmp_dict)
if (output == 'html'):
#data_dict = ujson.loads(tmp_dict)
data = tmp_dict.decode('utf-8')
else:
#data = ujson.loads(tmp_dict)
data = tmp_dict
logger.info("returning data")
return utils.returnResponse(data, 200, cookie, cookie_exists)
except Exception as e:
import traceback
traceback.print_exc()
cookie, cookie_exists = utils.getCookie()
return utils.returnResponse(
"An error occured, check logDNA for more information", 200, cookie,
cookie_exists)
def image():
try:
logger.debug(utils.get_debug_all(request))
i = request.files['fileToUpload'] # get the image
imageid = uuid.uuid4().__str__()
f = ('%s.jpeg' % (imageid))
i.save('%s/%s' % (PATH_TO_TEST_IMAGES_DIR, f))
completeFilename = '%s/%s' % (PATH_TO_TEST_IMAGES_DIR, f)
try:
filepath = completeFilename
image = Image.open(filepath)
img_width = image.size[0]
img_height = image.size[1]
for orientation in ExifTags.TAGS.keys():
if ExifTags.TAGS[orientation] == 'Orientation':
break
exif = dict(image._getexif().items())
logger.debug(exif[orientation])
if exif[orientation] == 3:
image = image.rotate(180, expand=True)
image.save(
filepath,
quality=50,
subsampling=0,
)
elif exif[orientation] == 6:
image = image.rotate(270, expand=True)
image.save(
filepath,
quality=50,
subsampling=0,
)
elif exif[orientation] == 8:
image = image.rotate(90, expand=True)
image.save(
filepath,
quality=50,
subsampling=0,
)
img_width = image.size[0]
img_height = image.size[1]
image.close()
except Exception as e:
import traceback
traceback.print_exc()
# ok the entry is correct let's add it in our db
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
# now upload
logger.debug(completeFilename)
#prepare rabbitmq data
rabbitdata = {
'id': imageid,
'user-agent': request.headers['User-Agent'],
'url': request.url,
'image_width': img_width,
"image_height": img_height,
'cookie': cookie
}
if (UPLOAD_IN_REDIS == True):
# Save the image into redis
file = open(completeFilename, "rb")
data = file.read()
file.close()
rediscache.__setCache(imageid, data, 3600)
os.remove(completeFilename)
logger.info("File saved in Redis")
rabbitdata['UPLOAD_IN_REDIS'] = True
else:
# saves into AWS
rabbitdata['UPLOAD_IN_REDIS'] = False
remotefilename = imageid + ".jpg"
awsFilename = aws.uploadData(completeFilename, remotefilename)
os.remove(completeFilename)
logger.info("File saved in AWS")
rabbitdata['remote_url'] = awsFilename
# Sends data to RabbitMQ
logger.debug(rabbitdata)
rabbitmq.sendMessage(ujson.dumps(rabbitdata), rabbitmq.CLOUDAMQP_QUEUE)
#awsFilename = aws.uploadData(completeFilename, f)
key = {
'url': request.url,
'status_upload': 'Thanks for participating',
'error_upload': None
}
tmp_dict = None
#data_dict = None
tmp_dict = rediscache.__getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
data = render_template(RENDER_ROOT_PHOTO,
status_upload="Thanks for participating",
error_upload=None,
FA_APIKEY=utils.FOLLOWANALYTICS_API_KEY,
userid=cookie,
PUSHER_KEY=notification.PUSHER_KEY)
#rediscache.__setCache(key, data, 60)
else:
logger.info("Data found in redis, using it directly")
data = tmp_dict
return utils.returnResponse(data, 200, cookie, cookie_exists)
except Exception as e:
import traceback
cookie, cookie_exists = utils.getCookie()
data = render_template(
RENDER_ROOT_PHOTO,
status_upload=None,
error_upload=
"An error occured while saving your file, please try again",
FA_APIKEY=utils.FOLLOWANALYTICS_API_KEY,
userid=cookie,
PUSHER_KEY=notification.PUSHER_KEY)
return utils.returnResponse(data, 200, cookie, cookie_exists)
