def majAddress():
try:
if (request.method =='POST'):
logger.error(utils.get_debug_all(request))
# gets inseeid
Siren__c = request.args.get('Siren__c')
# gets new city
city = request.args.get('city')
if (city == '' or city == None):
return utils.returnResponse("Please provide a city", 403, None, None)
#check if siren__c exits
if (postgres.__checkAccountBySiren(Siren__c) == False):
return utils.returnResponse("Please provide a Siren", 403, None, None)
# check if city exist
# updates
postgres.__updateCityInAccountBySiren(city, Siren__c)
return "ok"
elif (request.method == 'GET'):
logger.error(utils.get_debug_all(request))
cookie, cookie_exists = utils.getCookie()
# gets inseeid
Siren__c = request.args.get('Siren__c')
data = postgres.__getAccountBySiren(Siren__c)
kafka_utils.sendToKafka_EDF(ujson.dumps(data))
return utils.returnResponse(ujson.dumps(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 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 badges():
try:
if (request.method == 'POST'):
logger.error(utils.get_debug_all(request))
# gets all the data required to save the badge object
guest_id = request.args.get('guest_id')
guest_firstname = request.args.get('guest_firstname')
guest_lastname = request.args.get('guest_lastname')
guest_company = request.args.get('guest_company')
host_firstname = request.args.get('host_firstname')
host_lastname = request.args.get('host_lastname')
picture_url = request.args.get('picture_url')
# id is auto generated
uid = uuid.uuid4().__str__()
badge_status = 'ACTIVE'
badge_url = APPURL + uid
# status is set to default -> INACTIVE (status are inactive / active )
# url will be calculated
# gets new city
if (guest_id == '' or guest_id == None):
return utils.returnResponse("Please provide a guest_id", 403,
None, None)
# check if siren__c exits
postgres.__insertBadge(uid, guest_id, guest_firstname,
guest_lastname, guest_company,
host_firstname, host_lastname, badge_status,
badge_url, picture_url)
# generates now the data
#data = render_template(BADGE_DATA, GuestFirstname=guest_firstname,
#GuestLastname = guest_lastname, GuestCompany=guest_company, HostFirstname=host_firstname, HostLastname=host_lastname,
#ProfilePicture=picture_url, QRCode="")
return "{'Result':'Ok'}"
elif (request.method == 'GET'):
logger.error(utils.get_debug_all(request))
cookie, cookie_exists = utils.getCookie()
sqlRequest = sqlRequest = "select * from public.badge"
attributes = None
if ('badge_id' in request.args):
sqlRequest += " where id = %(badge_id)s"
attributes = {"badge_id": request.args.get('badge_id')}
data = postgres.__execRequest(sqlRequest, attributes)
return utils.returnResponse(ujson.dumps(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 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 tables():
try:
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request)
logger.debug(utils.get_debug_all(request))
rediscache.__display_RedisContent()
"""
key = {'url' : request.url}
tmp_dict = None
data_dict = None
tmp_dict = __getCache(key)
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
data_dict = __getTables()
__setCache(key, ujson.dumps(data_dict), 300)
else:
logger.info("Data found in redis, using it directly")
data_dict = ujson.loads(tmp_dict)
"""
data_dict = postgres.__getTables()
return render_template(RENDER_TABLES, entries=data_dict['data'])
except Exception as e:
import traceback
traceback.print_exc()
return "An error occured, check logDNA for more information", 200
def tables():
try:
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
logger.debug(utils.get_debug_all(request))
#rediscache.__display_RedisContent()
data_dict = postgres.__getTables()
output = 'html'
if 'output' in request.args:
output = request.args['output'].lower()
if (output == 'html'):
data = render_template(RENDER_TABLES,
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)
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 genericGetPost(uri, isAdmin):
try:
logs.logger.debug(utils.get_debug_all(request))
# check method type
properClass = functionLoader[uri]['class']
properClassName = functionLoader[uri]['classname']
return functionLoader[uri][request.method](properClass,
properClassName, uri,
isAdmin)
"""
if request.method == 'GET':
if ('GET' in functionLoader[uri]):
return functionLoader[uri]['GET'](properClass, properClassName, uri, isAdmin)
return __GET__Generic(properClass, properClassName, uri, isAdmin)
else:
if ('POST' in functionLoader[uri]):
return functionLoader[uri]['POST'](properClass, properClassName, uri, isAdmin)
return __POST__Generic(properClass, properClassName, uri, isAdmin)
"""
except werkzeug.exceptions.NotFound as e:
traceback.print_exc()
return utils.returnResponse("Requested resource does not exist", 404)
except Exception as e:
traceback.print_exc()
return utils.returnResponse(
"The server encountered an error while processing your request",
500)
def subscribtionStatus():
try:
logs.logger.debug(utils.get_debug_all(request))
#gets attributes
received_request = request.json
if (received_request == None):
received_request = []
received_args = request.args
if ('Device-Serial-Number' not in received_request
and 'Device-Serial-Number' not in received_args):
return utils.returnResponse(
"Error, missing Device-Serial-Number data", 404)
# gets the value of the attribute, priority is given to request.body
DeviceSN = ""
if ('Device-Serial-Number' in received_request):
DeviceSN = received_request['Device-Serial-Number']
else: #must be in the request.args
DeviceSN = received_args['Device-Serial-Number']
# calls the functions with the proper param
data = postgres.subscriptionStatus(DeviceSN)
if (
len(data) >= 1
): #only sends the first entry within the array .. should have only one ..
return utils.returnResponse(data[0], 200)
# nothing was found sending back an empty result
return utils.returnResponse({}, 200)
except Exception as e:
import traceback
traceback.print_exc()
return utils.returnResponse("An Error Occured.", 200)
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 form():
try:
cookie, cookie_exists = utils.getCookie()
logger.debug(utils.get_debug_all(request))
form = ReusableForm(request.form)
print(form.errors)
if request.method == 'POST':
name=request.form['name']
formvalue=request.form['formvalue']
email=request.form['email']
postgres.__saveLeadEntry(name, email, formvalue)
data = render_template('form.html', form=form, registered=True)
return utils.returnResponse(data, 200, cookie, cookie_exists)
print(form)
if form.validate():
# Save the comment here.
flash('Hello ' + name)
else:
flash('All the form fields are required. ')
data = render_template('form.html', form=form)
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:
cookie, cookie_exists = utils.getCookie()
logger.debug(utils.get_debug_all(request))
if (not checkAuthorization(request)):
return utils.returnResponse("Unauthorized access", 401, cookie,
cookie_exists)
# gets object name
describe = False
if ('describe' in request.args):
describe = True
object_name = ''
if ('name' in request.args):
object_name = request.args['name']
else:
return "Error, must specify a object name with ?name=xxx", 404
data_dict = None
data_dict = postgres.__getObjectsDescribe(object_name, describe)
data = ujson.dumps(data_dict) #{'columns':data_dict['columns']})
return utils.returnResponse(data, 200, cookie, cookie_exists)
except Exception as e:
import traceback
traceback.print_exc()
cookie = utils.getCookie()
return utils.returnResponse(
"An error occured, check logs for more information", 200, cookie,
cookie_exists)
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 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 photo_display():
try:
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
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'
name = request.args['name']
key = {'url': request.url, 'output': output}
tmp_dict = None
data_dict = None
if ((tmp_dict == None) or (tmp_dict == '')):
logger.info("Data not found in cache")
data_dict = postgres.__getImageAnalysis(object_name, 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_PHOTO_DISPLAY,
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'), 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 data, 200
except Exception as e:
import traceback
traceback.print_exc()
return "An error occured, check logDNA for more information", 200
def error():
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request)
logger.debug(utils.get_debug_all(request))
logger.error("Generating Error")
error_code = 500
if ('error_code' in request.args):
error_code = int(request.args['error_code'])
return "Error !!!!!!", error_code
def error():
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
logger.debug(utils.get_debug_all(request))
logger.error("Generating Error")
error_code = 500
if ('error_code' in request.args):
error_code = int(request.args['error_code'])
return utils.returnResponse("Error !! ", error_code, cookie, cookie_exists)
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 root_photo():
try:
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request)
logger.debug(utils.get_debug_all(request))
data = render_template(RENDER_ROOT_PHOTO,
imageid=uuid.uuid4().__str__())
return data, 200
except Exception as e:
import traceback
traceback.print_exc()
return "An error occured, check logDNA for more information", 200
def canvas_main():
try:
logger.debug(utils.get_debug_all(request))
cookie, cookie_exists = utils.getCookie()
logger.info("CookieExists={} - Cookie ={}".format(
cookie_exists, cookie))
key = {'cookie': cookie, 'fromCanvas': True}
tmp_dict = None
if ('signed_request' not in request.form):
return utils.returnResponse(
"This application is only accessible through Salesforce Canvas App technology. Please access it through Salesforce",
200, cookie, cookie_exists)
consumer_secret = os.getenv("APP_CLIENT_SECRET", "ChangeMe")
signed_request = request.form['signed_request']
sr = signedrequest.SignedRequest(consumer_secret, signed_request)
request_json = sr.verifyAndDecode()
struct_json = ujson.loads(request_json)
rediscache.__setCache(key, ujson.dumps(struct_json), 180)
# test for chatter api
#sf_getProducts(struct_json['client']['instanceUrl'] , struct_json['client']['oauthToken'])
pprint.pprint(struct_json)
if ('record' in struct_json['context']['environment']['parameters']):
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':
struct_json['context']['environment']['parameters']
['record']
})
else:
sqlRequest = "select Id, guest_id,guest_firstname, guest_lastname, badge_status, creation_date from public.badge order by creation_date"
sqlResult = postgres.__execRequest(sqlRequest, {})
data = render_template(CANVAS_FILE,
request_json=ujson.dumps(struct_json),
columns=sqlResult['columns'],
entries=sqlResult['data'])
#return render_template()
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, please check LogDNA",
200, cookie, cookie_exists)
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 customerPassions():
try:
logs.logger.debug(utils.get_debug_all(request))
#gets attributes
received_request = request.json
if (received_request == None):
received_request = []
received_args = request.args
if ('Customer-Number' not in received_request
and 'Customer-Number' not in received_args):
return utils.returnResponse("Error, missing Customer-Number data",
404)
if ('Current-Decade' not in received_request
and 'Current-Decade' not in received_args):
return utils.returnResponse("Error, missing Current-Decade data",
404)
# gets the value of the attribute, priority is given to request.body
CustomerNumber = ""
if ('Customer-Number' in received_request):
CustomerNumber = received_request['Customer-Number']
else: #must be in the request.args
CustomerNumber = received_args['Customer-Number']
currentDecade = ""
if ('Current-Decade' in received_request):
currentDecade = received_request['Current-Decade']
else: #must be in the request.args
currentDecade = received_args['Current-Decade']
# calls the functions with the proper param
data = postgres.customerPassion(CustomerNumber, currentDecade)
#ok now rework the structure as this one is different
# waiting for some data
if (
len(data) >= 1
): #only sends the first entry within the array .. should have only one ..
return utils.returnResponse(data, 200)
# nothing was found sending back an empty result
return utils.returnResponse({}, 200)
except Exception as e:
import traceback
traceback.print_exc()
return utils.returnResponse("An Error Occured.", 200)
def sfconnectedapp():
logger.error(utils.get_debug_all(request))
error = request.args.get('error', '')
if error:
return "Error: " + error
state = request.args.get('state', '')
if not is_valid_state(state):
# Uh-oh, this request wasn't started by us!
abort(403)
code = request.args.get('code')
print(code)
data = {
'client_id': APP_CLIENT_ID,
'client_secret': APP_CLIENT_SECRET,
"redirect_uri": REDIRECT_URI_CODE,
"code": code,
'grant_type': 'authorization_code'
}
headers = {'content-type': 'application/x-www-form-urlencoded'}
req = requests.post(SF_REQUEST_TOKEN_URL, data=data, headers=headers)
response = req.json()
logger.error(response)
#result = requests.post(url=url, data=data)
access_token = response['access_token']
instance_url = response['instance_url']
url = instance_url + API_URL
headers = {
'Authorization': "Bearer " + access_token,
"X-Prettylogger.debug": "1"
}
result = requests.get(url, headers=headers)
logger.info("Result Code : {}".format(result.status_code))
logger.info("Header : {}".format(result.headers))
logger.info("Content : {}".format(result.json()))
#now stores everything in redis
rediscache.__delCache(state)
cookie, cookie_exists = utils.getCookie()
key = {'cookie': cookie}
rediscache.__setCache(key, ujson.dumps(response), 3600)
return "got a code! %s" % response
def tables():
try:
cookie, cookie_exists = utils.getCookie()
logger.debug(utils.get_debug_all(request))
if (not checkAuthorization(request)):
return utils.returnResponse("Unauthorized access", 401, cookie,
cookie_exists)
data_dict = postgres.__getTables()
data = ujson.dumps(data_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 logs for more information", 200, cookie,
cookie_exists)
def tables():
try:
cookie, cookie_exists = utils.getCookie()
logger.debug(utils.get_debug_all(request))
if (not checkAuthorization(request)):
return utils.returnResponse("Unauthorized access", 401, cookie,
cookie_exists)
#Postgres part
data_dict = postgres.__getTables()
data = ujson.dumps(data_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(
"The server encountered an error while processing your request",
500, cookie, cookie_exists)
def image():
try:
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request)
logger.debug(utils.get_debug_all(request))
imageid = request.args['id']
i = request.files['fileToUpload'] # get the image
f = ('%s.jpeg' % (imageid))
i.save('%s/%s' % (PATH_TO_TEST_IMAGES_DIR, f))
completeFilename = '%s/%s' % (PATH_TO_TEST_IMAGES_DIR, f)
# now upload
logger.debug(completeFilename)
awsFilename = aws.uploadData(completeFilename, f)
return "File received, thanks for sharing! : You can review it here : " + awsFilename, 200
except Exception as e:
import traceback
traceback.print_exc()
return "An error occured, check logDNA for more information", 200
def genericGetPutDelById(uri, isAdmin, id_):
try:
logs.logger.debug(utils.get_debug_all(request))
# use the end of the route to know which class the call is meant for
properClass = functionLoader[uri]['class']
properClassName = functionLoader[uri]['classname']
logs.logger.debug("properclass={}".format(properClassName))
return functionLoader[uri][request.method](properClass,
properClassName, uri,
isAdmin, id_)
except werkzeug.exceptions.NotFound as e:
traceback.print_exc()
return utils.returnResponse("Requested resource does not exist", 404)
except Exception as e:
traceback.print_exc()
return utils.returnResponse(
"The server encountered an error while processing your request",
500)
def login():
logs.logger.debug(utils.get_debug_all(request))
if current_user.is_authenticated:
return utils.returnResponse(jsonify({"Error" : "You are already authenticated, logout first"}), 404)
hasAuthorizationHeader, decodedHeader = utils.checkAuthorization(request)
if (not hasAuthorizationHeader ):
return utils.returnResponse("Unauthorized access", 401)
#U/P are given in the authorization header
decodedHeaderSplitted=decodedHeader.decode('utf-8').split(':')
user = User.query.filter_by(username=decodedHeaderSplitted[0]).first()
if user is None or not user.check_password(decodedHeaderSplitted[1]):
return utils.returnResponse(jsonify({"Error" : "incorrect login or password"}), 404)
login_user(user)
return utils.returnResponse(jsonify("Welcome to the matrix neo"), 200)
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 tables():
try:
cookie, cookie_exists = utils.getCookie()
if (postgres.__checkHerokuLogsTable()):
postgres.__saveLogEntry(request, cookie)
logger.debug(utils.get_debug_all(request))
#rediscache.__display_RedisContent()
data_dict = postgres.__getTables()
data = render_template(RENDER_TABLES,
entries=data_dict['data'],
FA_APIKEY=utils.FOLLOWANALYTICS_API_KEY,
userid=cookie,
PUSHER_KEY=notification.PUSHER_KEY)
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 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)