def post(self):
self.session = get_current_session()
# testOrder = 0: memory first
# memOrder = 0: ask about outcomes given drug first
# TO = 0, MO = 0: E|C, C|E, Causal
# TO = 0, MO = 1: C|E, E|C, Causal
# TO = 1, MO = 0: Causal, E|C, C|E
# TO = 1, MO = 1: Causal, C|E, E|C
if (int(self.session['testOrder']) == 0) & (int(
self.session['memOrder']) == 0):
judgmentOrder = 0 # E|C, C|E, Causal
elif (int(self.session['testOrder']) == 0) & (int(
self.session['memOrder']) == 1):
judgmentOrder = 1 # C|E, E|C, Causal
elif (int(self.session['testOrder']) == 1) & (int(
self.session['memOrder']) == 0):
judgmentOrder = 2 # Causal, E|C, C|E
elif (int(self.session['testOrder']) == 1) & (int(
self.session['memOrder']) == 1):
judgmentOrder = 3 # Causal, C|E, E|C
else:
judgmentOrder = 100
usernum = self.session['usernum']
scenario = self.session['scenario']
condition = str(self.request.get('condition')) # good or bad
leftDrugName = str(self.request.get('leftDrugName'))
rightDrugName = str(self.request.get('rightDrugName'))
leftDrugRarity = str(self.request.get('leftDrugRarity'))
rightDrugRarity = str(self.request.get('rightDrugRarity'))
leftDrugColor = str(self.request.get('leftDrugColor'))
rightDrugColor = str(self.request.get('rightDrugColor'))
leftNumberBad = int(self.request.get('leftNumberBad'))
rightNumberBad = int(self.request.get('rightNumberBad'))
goodOutcomesLeft = int(self.request.get('goodOutcomesLeft'))
goodOutcomesRight = int(self.request.get('goodOutcomesRight'))
badOutcomesLeft = int(self.request.get('badOutcomesLeft'))
badOutcomesRight = int(self.request.get('badOutcomesRight'))
logging.info("usernum: " + str(usernum))
logging.info('account: ' + str(self.session['account']))
logging.info("condition: " + str(condition))
logging.info("leftDrugName: " + str(leftDrugName))
logging.info("rightDrugName: " + str(rightDrugName))
logging.info("leftDrugRarity: " + str(leftDrugRarity))
logging.info("rightDrugRarity: " + str(rightDrugRarity))
logging.info("leftDrugColor: " + str(leftDrugColor))
logging.info("rightDrugColor: " + str(rightDrugColor))
logging.info("leftNumberBad: " + str(leftNumberBad))
logging.info("rightNumberBad: " + str(rightNumberBad))
logging.info("goodOutcomesLeft: " + str(goodOutcomesLeft))
logging.info("goodOutcomesRight: " + str(goodOutcomesRight))
logging.info("badOutcomesLeft: " + str(badOutcomesLeft))
logging.info("badOutcomesRight: " + str(badOutcomesRight))
logging.info("memOrder: " + str(self.session['memOrder']))
logging.info("testOrder: " + str(self.session['testOrder']))
logging.info("judgmentOrder: " + str(judgmentOrder))
judgmentOrder = judgmentOrder
que = db.Query(FinalJudgmentData).filter(
'usernum =',
self.session['usernum']).filter('scenario =', scenario)
results = que.fetch(limit=1000)
# make all of the data items into 3-value arrays, then make a loop to put them in the datastore
if (len(results) == 0):
logging.info('NEW ENTRY')
newajaxmessage = FinalJudgmentData(
# user properties
user=self.session['userkey'],
usernum=usernum,
account=self.session['account'],
# scenario properties
scenario=scenario,
condition=condition,
# drug properties
leftDrugName=leftDrugName,
rightDrugName=rightDrugName,
leftDrugRarity=leftDrugRarity, # DO THESE
rightDrugRarity=rightDrugRarity,
leftDrugColor=leftDrugColor,
rightDrugColor=rightDrugColor,
leftNumberBad=leftNumberBad,
rightNumberBad=rightNumberBad,
goodOutcomesLeft=goodOutcomesLeft,
goodOutcomesRight=goodOutcomesRight,
badOutcomesLeft=badOutcomesLeft,
badOutcomesRight=badOutcomesRight,
# causalJudgment = causalJudgment, Not this handler
judgmentOrder=judgmentOrder)
newajaxmessage.put()
self.response.out.write(json.dumps(({
'blah': 'blah'
}))) # not sure what this does?
else:
logging.info('UPDATING CURRENT')
obj = que.get()
# user properties
obj.user = self.session['userkey']
obj.usernum = usernum
obj.account = self.session['account']
# scenario properties
obj.scenario = scenario
obj.condition = condition
# drug properties
obj.leftDrugName = leftDrugName
obj.rightDrugName = rightDrugName
obj.leftDrugRarity = leftDrugRarity # DO THESE
obj.rightDrugRarity = rightDrugRarity
obj.leftDrugColor = leftDrugColor
obj.rightDrugColor = rightDrugColor
obj.leftNumberBad = leftNumberBad
obj.rightNumberBad = rightNumberBad
obj.goodOutcomesLeft = goodOutcomesLeft
obj.goodOutcomesRight = goodOutcomesRight
obj.badOutcomesLeft = badOutcomesLeft
obj.badOutcomesRight = badOutcomesRight
# causalJudgment = causalJudgment, Not this handler
obj.judgmentOrder = judgmentOrder
obj.put()
self.response.out.write(json.dumps(({'blah': 'blah'}))) # ?
def get_gamepage(self, game, no_refresh=False):
key = self.get_gamepage_memkey(game)
gamepage = memcache.get(key)
if gamepage is None and not no_refresh:
# Not in memcache, so construct the gamepage and store it in
# memcache.
# Gamepage is a list of dictionaries. These dictionaries have up
# to 5 keys, 'category', 'bk_runner', 'bk_time', 'bk_video' and
# 'infolist'.
gamepage = []
# Grab the game model
game_model = self.get_game_model(util.get_code(game))
if game_model is None:
logging.error("Could not create " + key + " due to no " +
"game model")
return None
if game_model == self.OVER_QUOTA_ERROR:
return self.OVER_QUOTA_ERROR
gameinfolist = json.loads(game_model.info)
try:
# Use a projection query to get all of the unique
# username, category pairs
q = db.Query(runs.Runs,
projection=('username', 'category'),
distinct=True)
q.ancestor(runs.key())
q.filter('game =', game)
q.order('category')
cur_category = None
for run in q.run(limit=1000):
if run.category != cur_category:
# New category
d = dict(category=run.category,
category_code=util.get_code(run.category),
infolist=[])
gamepage.append(d)
cur_category = run.category
# Check for a best known time for this category
for gameinfo in gameinfolist:
if gameinfo['category'] == run.category:
d['bk_runner'] = gameinfo.get('bk_runner')
d['bk_time'] = util.seconds_to_timestr(
gameinfo.get('bk_seconds'))
d['bk_date'] = util.datestr_to_date(
gameinfo.get('bk_datestr'))[0]
d['bk_video'] = gameinfo.get('bk_video')
break
# Add the info to the gamepage
info = self.get_runinfo(run.username, game, run.category)
if info == self.OVER_QUOTA_ERROR:
return self.OVER_QUOTA_ERROR
d['infolist'].append(info)
except apiproxy_errors.OverQuotaError, msg:
logging.error(msg)
return self.OVER_QUOTA_ERROR
# For each category, sort the runlist by seconds, breaking ties
# by date
for runlist in gamepage:
runlist['infolist'].sort(
key=lambda x: util.get_valid_date(x['pb_date']))
runlist['infolist'].sort(key=itemgetter('pb_seconds'))
# Sort the categories by number of runners
gamepage.sort(key=lambda x: len(x['infolist']), reverse=True)
if memcache.set(key, gamepage):
logging.debug("Set " + key + " in memcache")
else:
logging.warning("Failed to set " + key + " in memcache")
class XHR(webapp.RequestHandler):
#==========================================================================
def get(self):
logging.info("self.request.path: " + self.request.path)
if self.request.path == "/dump":
session = self.getSession()
userData = {}
offline_data_placeholder = ""
user = db.Query(User).filter('username ='******'users'] = {
'catchAllUser': {
'__masterkey_test_value__': 'masterkey',
's': '112233445566778899aabbccddeeff00112233445566778899aabbccddeeff00',
'v': '112233445566778899aabbccddeeff00112233445566778899aabbccddeeff00'
}
}
records = {}
for currentRecord in db.Query(Record).ancestor(user):
versions = {}
for currentVersion in db.Query(RecordVersion).ancestor(currentRecord):
versions[currentVersion.reference] ={
'header': currentVersion.header,
'data': currentVersion.data,
'version': currentVersion.version,
'creationDate': str(currentVersion.creation_date),
'updateDate': str(currentVersion.update_date),
'accessDate': str(currentVersion.access_date)
}
records[currentRecord.reference] = {
'data': currentRecord.data,
'version': currentRecord.version,
'creationDate': str(currentRecord.creation_date),
'updateDate': str(currentRecord.update_date),
'accessDate': str(currentRecord.access_date),
'currentVersion': currentVersion.reference,
'versions': versions
}
userData['users'][user.username] = {
's': user.srp_s,
'v': user.srp_v,
'version': user.auth_version,
'maxNumberOfRecords': '100',
'userDetails': user.header,
'statistics': user.statistics,
'userDetailsVersion': user.version,
'records': records
}
offline_data_placeholder = offline_data_placeholder + "_clipperz_dump_data_ = " + simplejson.dumps(userData, indent=4) + "\n"
offline_data_placeholder = offline_data_placeholder + "Clipperz.PM.Proxy.defaultProxy = new Clipperz.PM.Proxy.Offline();" + "\n"
offline_data_placeholder = offline_data_placeholder + "Clipperz.Crypto.PRNG.defaultRandomGenerator().fastEntropyAccumulationForTestingPurpose();" + "\n"
path = os.path.join(os.path.dirname(__file__), 'static/dump.html')
self.response.headers.add_header('Content-Type', 'text/html')
self.response.headers.add_header('Content-Disposition', 'attachment', filename='Clipperz.html')
self.response.out.write(template.render(path, {'offline_data_placeholder': offline_data_placeholder}))
#==========================================================================
def post(self):
method = self.request.get('method')
parameters = simplejson.loads(self.request.get('parameters'))
session = self.getSession()
result = {};
#----------------------------------------------------------------------
if method == 'registration':
message = parameters['message'];
if message == 'completeRegistration':
user = User()
user.updateCredentials(parameters['credentials'])
user.update(parameters['user'])
user.put()
result['lock'] = user.lock
result['result'] = "done"
#----------------------------------------------------------------------
elif method == 'handshake':
srp_g = 2L
srp_n = long("0x%s" % "115b8b692e0e045692cf280b436735c77a5a9e8a9e7ed56c965f87db5b2a2ece3", 16)
message = parameters['message'];
#------------------------------------------------------------------
if message == 'connect':
session.C = parameters['parameters']['C']
session.A = parameters['parameters']['A']
user = db.Query(User).filter('username ='******'keyValue =', optId).get()
if oneTimePassword.parent().username != user.username:
oneTimePassword.reset('DISABLED').put()
raise Exception, "User missmatch between the current session and 'One Time Password' user"
elif oneTimePassword.status != 'REQUESTED':
oneTimePassword.reset('DISABLED').put()
raise Exception, "Tring to use an 'One Time Password' in the wrong state"
oneTimePassword.reset("USED").put()
result['oneTimePassword'] = oneTimePassword.reference
except Exception, detail:
logging.error("connect.optId: " + str(detail))
session.s = user.srp_s
session.v = user.srp_v
else:
session.s = "112233445566778899aabbccddeeff00112233445566778899aabbccddeeff00"
session.v = "112233445566778899aabbccddeeff00112233445566778899aabbccddeeff00"
session.b = randomSeed()
session.B = hex(long("0x%s" % session.v, 16) + pow(srp_g, long("0x%s" %session.b, 16), srp_n))[2:-1]
result['s'] = session.s
result['B'] = session.B
#------------------------------------------------------------------
elif message == 'credentialCheck':
B = long("0x%s" % session.B, 16)
b = long("0x%s" % session.b, 16)
A = long("0x%s" % session.A, 16)
v = long("0x%s" % session.v, 16)
u = long("0x%s" % clipperzHash(str(B)), 16)
n = srp_n
S = pow((A * pow(v, u, n)), b, n)
K = clipperzHash(str(S))
M1 = clipperzHash(str(A) + str(B) + K)
if M1 == parameters['parameters']['M1']:
session.K = K
M2 = clipperzHash(str(A) + M1 + K)
result['M2'] = M2
result["connectionId"] = ""
result["loginInfo"] = {}
result["loginInfo"]["latest"] = {}
result["loginInfo"]["current"] = {}
result["offlineCopyNeeded"] = "false";
result["lock"] = "----";
else:
result['error'] = "?"
#------------------------------------------------------------------
elif message == 'oneTimePassword':
oneTimePassword = db.Query(OneTimePassword).filter("keyValue =", parameters["parameters"]["oneTimePasswordKey"]).get()
if oneTimePassword != None:
if oneTimePassword.status == 'ACTIVE':
if oneTimePassword.keyChecksum == parameters['parameters']['oneTimePasswordKeyChecksum']:
#session.userId = str(oneTimePassword.parent().username)
session.otpId = str(oneTimePassword.keyValue)
result['data'] = oneTimePassword.data
result['version'] = oneTimePassword.version
oneTimePassword.reset('REQUESTED').put()
else:
oneTimePassword.reset('DISABLED').put()
raise Exception, "The requested One Time Password has been disabled, due to a wrong keyChecksum"
else:
raise Exception, "The requested One Time Password was not active"
else:
raise Exception, "The requested One Time Password has not been found"
#----------------------------------------------------------------------
elif method == 'message':
if parameters['srpSharedSecret'] == session.K:
message = parameters['message']
if message == 'getUserDetails':
# {"message":"getUserDetails", "srpSharedSecret":"f18e5cf7c3a83b67d4db9444af813ee48c13daf4f8f6635397d593e52ba89a08", "parameters":{}}
user = db.Query(User).filter('username ='******'header'] = user.header;
result['statistics'] = user.statistics;
result['version'] = user.version;
elif message == "addNewRecords":
user = db.Query(User).filter('username ='******'username ='******'parameters']['user'])
for recordParameter in parameters['parameters']['records']:
record = Record(parent=user)
record.put()
recordVersion = RecordVersion(parent=record)
recordVersion.put()
recordVersion.update(recordParameter)
record.put()
recordVersion.put()
user.put();
result['lock'] = user.lock
result['result'] = 'done'
"""
elif message == 'getRecordDetail':
record = db.Query(Record).ancestor(db.Query(User).filter('username ='******'reference =', parameters["parameters"]["reference"]).get()
recordVersion = db.Query(RecordVersion).ancestor(record).get()
result['currentVersion'] = {}
result['currentVersion']['reference'] = recordVersion.reference
result['currentVersion']['data'] = recordVersion.data
result['currentVersion']['header'] = recordVersion.header
result['currentVersion']['version'] = recordVersion.version
result['currentVersion']['creationDate'] = str(recordVersion.creation_date)
result['currentVersion']['updateDate'] = str(recordVersion.update_date)
result['currentVersion']['accessDate'] = str(recordVersion.access_date)
result['reference'] = record.reference
result['data'] = record.data
result['version'] = record.version
result['creationDate'] = str(record.creation_date)
result['updateDate'] = str(record.update_date)
result['accessDate'] = str(record.access_date)
result['oldestUsedEncryptedVersion'] = "---"
elif message == 'updateData':
user = db.Query(User).filter('username ='******'parameters']['user'])
for recordParameter in parameters['parameters']['records']:
logging.info('reference =' + recordParameter['record']['reference'])
record = db.Query(Record).ancestor(user).filter('reference =', recordParameter['record']['reference']).get()
recordVersion = db.Query(RecordVersion).ancestor(record).get()
recordVersion.update(recordParameter)
recordVersion.put()
recordVersion.parent().put()
user.put();
result['lock'] = user.lock
result['result'] = 'done'
elif message == 'deleteRecords':
user = db.Query(User).filter('username ='******'parameters']['user'])
for recordReference in parameters['parameters']['recordReferences']:
record = db.Query(Record).ancestor(user).filter('reference =', recordReference).get()
#recordVersion = db.Query(RecordVersion).ancestor(record).get()
db.delete(db.Query(RecordVersion).ancestor(record))
record.delete()
user.put()
result['lock'] = user.lock
result['result'] = 'done'
elif message == 'deleteUser':
user = db.Query(User).filter('username ='******'addNewOneTimePassword':
user = db.Query(User).filter('username ='******'parameters']['user'])
oneTimePassword = OneTimePassword(parent=user)
oneTimePassword.update(parameters['parameters']['oneTimePassword'], "ACTIVE")
oneTimePassword.put()
user.put()
result['lock'] = user.lock
result['result'] = 'done'
elif message == 'updateOneTimePasswords':
user = db.Query(User).filter('username ='******'parameters']['user'])
validOtpReferences = parameters['parameters']['oneTimePasswords']
for currentOtp in db.Query(OneTimePassword).ancestor(user):
if currentOtp.reference in validOtpReferences:
pass
else:
currentOtp.delete()
user.put()
result['result'] = user.lock
elif message == 'getOneTimePasswordsDetails':
pass
elif message == 'getLoginHistory':
result["result"] = []
elif message == 'upgradeUserCredentials':
user = db.Query(User).filter('username ='******'parameters']['credentials'])
user.update(parameters['parameters']['user'])
for oneTimePasswordReference in parameters['parameters']['oneTimePasswords']:
oneTimePassword = db.Query(OneTimePassword).ancestor(user).filter("reference =", oneTimePasswordReference).get()
if oneTimePassword != None:
oneTimePassword.data = parameters['parameters']['oneTimePasswords'][oneTimePasswordReference]
oneTimePassword.put()
user.put()
result['lock'] = user.lock
result['result'] = 'done'
"""
$user = new user();
$user->Get($_SESSION["userId"]);
$otp = new onetimepassword();
updateUserCredentials($parameters["parameters"]["credentials"], $user);
updateUserData($parameters["parameters"]["user"], $user);
$otpList = $parameters["parameters"]["oneTimePasswords"];
foreach($otpList as $otpReference=>$otpData) {
$otpList = $otp->GetList(array(array("reference", "=", $otpReference)));
$currentOtp = $otpList[0];
$currentOtp->data = $otpData;
$currentOtp->Save();
}
$user->Save();
$result["lock"] = $user->lock;
$result["result"] = "done";
"""
#=============================================================
"""
java.util.Map result;
try {
java.util.Map credentials;
if (someParameters.get("credentials") != null) {
credentials = (java.util.Map)someParameters.get("credentials");
} else {
credentials = someParameters;
}
aUser.setUsername((java.lang.String)credentials.get("C"));
aUser.setSrpS((java.lang.String)credentials.get("s"));
aUser.setSrpV((java.lang.String)credentials.get("v"));
aUser.setVersion((java.lang.String)credentials.get("version"));
if (someParameters.get("user") != null) {
com.clipperz.dataModel.EncoderHelper.updateWithMap(aUser, (java.util.Map)someParameters.get("user"));
}
if (someParameters.get("oneTimePasswords") != null) {
java.util.Map updatedOneTimePasswords;
java.util.List usersOneTimePasswords;
int i,c;
updatedOneTimePasswords = (java.util.Map)someParameters.get("oneTimePasswords");
usersOneTimePasswords = com.clipperz.dataModel.OneTimePassword.oneTimePasswordsForUser(this.user());
c = usersOneTimePasswords.size();
for (i=0; i<c; i++) {
com.clipperz.dataModel.OneTimePassword currentOneTimePassword;
currentOneTimePassword = (com.clipperz.dataModel.OneTimePassword)usersOneTimePasswords.get(i);
if (updatedOneTimePasswords.get(currentOneTimePassword.getReference()) != null) {
currentOneTimePassword.setData((java.lang.String)updatedOneTimePasswords.get(currentOneTimePassword.getReference()));
}
}
}
result = new java.util.Hashtable();
this.dataContext().commitChanges();
result.put("lock", this.user().getNewLock());
result.put("result", "done");
} catch(java.lang.Exception exception) {
this.dataContext().rollbackChanges();
logger.error(exception);
throw exception;
}
return result;
"""
elif message == 'echo':
result['result'] = parameters;
else:
result['error'] = "Wrong shared secret!"
def get(self):
query = db.Query(models.SearchWave)
waves = query.fetch(limit=40)
self.PickOneWave(waves)
self.PickOneWave(waves)
self.PickOneWave(waves)
def get(self):
que = db.Query(ChatMessage).order('-created')
chat_list = que.fetch(limit=10)
doRender(self, 'chatscreen.htm')
def get(self):
waveId = self.request.get('waveId').replace('%2B', '+')
query = db.Query(models.WaveExport)
query.filter('id =', waveId)
result = query.get()
if result is None:
template_values = {
'title': 'Wave Not Found',
'body': 'Please check the ID',
'id': waveId
}
else:
participants = result.participants
canDisplayWave = False
if '*****@*****.**' in participants:
canDisplayWave = True
else:
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
sandboxEmail = user.email().replace('@gmail.com',
'@wavesandbox.com')
previewEmail = user.email().replace('@gmail.com',
'@googlewave.com')
if sandboxEmail or previewEmail in participants:
canDisplayWave = True
id_domain = waveId.split('!')[0]
if id_domain == 'googlewave.com':
dir = 'wave/'
else:
dir = 'a/' + id_domain + '/'
if canDisplayWave:
template_values = {
'title':
result.title,
'html':
result.html,
'text':
result.text,
'id':
waveId,
'dir':
dir,
'url':
'https://wave.google.com/' + dir +
'#minimized:nav,minimized:contact,minimized:search,restored:wave:'
+ waveId.replace('+', '%252B')
}
else:
template_values = {
'title': 'Wave Access Denied',
'body': 'This Wave is not public, and ' + sandboxEmail +
' is not a participant.',
'id': waveId
}
format = self.request.get('format')
if format and format == 'text':
filename = 'export.text'
self.response.headers['Content-Type'] = "text/plain"
else:
filename = 'export.html'
self.response.headers['Content-Type'] = "text/html"
path = os.path.join(os.path.dirname(__file__), filename)
self.response.out.write(template.render(path, template_values))
def Query(cls):
# TODO(termie): I don't like that this module is called "models" here,
# I'd prefer to be accessing it by "db"
return models.Query(cls)
def get_user_sprints(user):
if not user: return []
memberships = db.Query(SprintTeamMember).filter('user =', user)
return [m.sprint for m in memberships]
def get_published():
published = db.Query(Sprint).filter('published =', True)
return list(published)
def get(self):
query = db.Query(db_models.ApplicationAuthor)
query.filter('user = '******'author': author}
self.generate('edit_profile.html', template_values)
def find(sprint):
query = db.Query(Burndown)
query.filter('sprint =', sprint)
return query.get()
def get(self):
query = db.Query(db_models.ApplicationAuthor)
query.filter('latlng !=', None)
authors = query.fetch(500)
template_values = {'authors': authors}
self.generate('authorsmap.html', template_values)
def post(self):
self.session = get_current_session()
# message=str(self.request.get('message'))
usernum = self.session['usernum']
scenario = self.session['scenario']
causalJudgment = int(self.request.get('judgmentInput'))
usernum = self.session['usernum']
scenario = self.session['scenario']
logging.info("usernum: " + str(usernum))
logging.info('account: ' + str(self.session['account']))
logging.info('scenario: ' + str(scenario))
# how to check if there are example rows in the datastore
que = db.Query(FinalJudgmentData).filter(
'usernum =',
self.session['usernum']).filter('scenario =', scenario)
results = que.fetch(limit=1000)
# make all of the data items into 3-value arrays, then make a loop to put them in the datastore
if (len(results) == 0):
logging.info('NEW ENTRY')
newajaxmessage = FinalJudgmentData(
# user properties
user=self.session['userkey'],
usernum=usernum,
account=self.session['account'],
# scenario properties
scenario=scenario,
# condition = self.session['conditions'][self.session['scenario']],
# drug properties
# leftDrugName = drugA_Name,
# rightDrugName = drugB_Name,
# leftDrugRarity = leftDrugRarity, # DO THESE
# rightDrugRarity = rightDrugRarity,
# leftDrugColor = leftDrugColor,
# rightDrugColor = rightDrugColor,
# leftNumberBad = leftNumberBad, Not this handler
# rightNumberBad = rightNumberBad, Not this handler
# goodOutcomesLeft = goodOutcomesLeft,
# goodOutcomesRight = goodOutcomesRight,
# badOutcomesLeft = badOutcomesLeft,
# badOutcomesRight = badOutcomesRight,
causalJudgment=causalJudgment)
# judgmentOrder = judgmentOrder);
newajaxmessage.put()
self.response.out.write(json.dumps(({
'blah': 'blah'
}))) # not sure what this does?
else:
logging.info('UPDATING CURRENT')
obj = que.get()
# user properties
obj.user = self.session['userkey']
obj.usernum = usernum
obj.account = self.session['account']
# scenario properties
obj.scenario = scenario
# obj.condition = self.session['conditions'][self.session['scenario']]
# drug properties
# obj.leftDrugName = drugA_Name
# obj.rightDrugName = drugB_Name
# obj.leftDrugRarity = leftDrugRarity # DO THESE
# obj.rightDrugRarity = rightDrugRarity
# obj.leftDrugColor = leftDrugColor
# obj.rightDrugColor = rightDrugColor
# leftNumberBad = leftNumberBad, Not this handler
# rightNumberBad = rightNumberBad, Not this handler
# goodOutcomesLeft = goodOutcomesLeft,
# goodOutcomesRight = goodOutcomesRight,
# badOutcomesLeft = badOutcomesLeft,
# badOutcomesRight = badOutcomesRight,
obj.causalJudgment = causalJudgment
# obj.judgmentOrder = judgmentOrder
obj.put()
self.response.out.write(json.dumps(({'blah': 'blah'}))) # ?
def get(self):
# I don't even think I need this handler...
que = db.Query(FinalJudgmentData)
que.order("usernum").order("scenario").order("judgmentNumber")
d = que.fetch(limit=10000)
doRender(self, 'ajaxCausalTest.htm', {'d': d})
def get_all_posts(offset=0, limit=None):
q = db.Query(Post)
return q.order('-created_time').run(offset=offset, limit=limit)
def get_all_sprints(): all_sprints = db.Query(Sprint) return list(all_sprints)
def get_all_slugs():
q = db.Query(Post)
return [p.slug for p in q]
def user_has_access(self, user):
if not user: return False
query = db.Query(SprintTeamMember)
query.filter('sprint =', self)
query.filter('user =', user)
return query.get()
def validate_user(username):
result = db.Query(WikiUser).filter("username =", username).fetch(limit=1)
return result
def updateForSprint(burndown, sprint):
data = []
taskHelper = {}
lastBelow = 0
#calc initial values
bdi = BurndownDataItem()
bdi.date = datetime.datetime.now()
bdi.above = 0
bdi.below = 0
for task in sprint.task_set:
if task.color != 0xb7fa57:
taskHelper[task.key()] = task.us_time;
if not task.deleted and task.pos_quad in [1,4,7,2,5,8]:
bdi.above += safeFloatOrZero(task.us_time)
data.append(bdi)
bdi = bdi.copy()
# do the trace back analysis
hist = db.Query(SprintHistory).filter('sprint =', sprint).filter('action !=', 'move_xy')
histList = list(hist)
histList.sort(key=lambda item:item.time, reverse=True)
for item in histList:
delta = bdi.date - item.time
if delta.days>0:
bdi.date = item.time
data.insert(0, bdi)
bdi = bdi.copy()
lastBelow = bdi.below
if item.task.color == 0xb7fa57:
continue
if item.action == 'change_us_time':
x = taskHelper[item.task.key()]
y = item.value
y = y.replace(',','.')
if x != y:
taskHelper[item.task.key()] = y
if safeFloatOrZero(y)>safeFloatOrZero(x):
bdi.above += safeFloatOrZero(y)-safeFloatOrZero(x)
else:
bdi.below += safeFloatOrZero(x)-safeFloatOrZero(y)
if item.action == 'move_quad':
if int(item.value) in [3,6,9,10,11,12]:
bdi.above += safeFloatOrZero(taskHelper[item.task.key()])
if item.action == 'del_task':
bdi.above += safeFloatOrZero(taskHelper[item.task.key()])
# normalize data
for bdi in data:
bdi.above -= lastBelow
bdi.below -= lastBelow
# remove old burndown data
for bdData in burndown.burndowndata_set:
bdData.delete();
# fill new burndown data
for bdi in data:
worked = lastBelow-bdi.above
#added = -bdi.below
#left = bdi.above-bdi.below
added = bdi.below
left = bdi.above
bdData = BurndownData(burndown=burndown, date=bdi.date, worked_value=str(worked), added_value=str(added), left_value=str(left))
bdData.put()
burndown.initial_value = str(lastBelow)
burndown.version = sprint.get_version()
burndown.valid = True
burndown.put()
def count_datastore_sessions():
q = db.Query(SessionModel, keys_only=True, namespace='')
c = q.count()
return c
def load_newschunks(entries, feed_title, hitlist_general_dict,
hitlist_exclusive_dict):
for new_entry in entries:
if "shutterstock" in new_entry.link:
break
if "dribbble" in new_entry.link:
break
if "craigslist" in new_entry.link:
break
if "job" in new_entry.link:
break
cond1 = isinstance(new_entry.title, basestring)
cond2 = new_entry.title == ""
if cond1 and cond2:
continue
else:
new_title = new_entry.title
if "Stock Update" in new_title:
break
new_nc = NewsChunks(title=new_title,
feed_title=feed_title,
entry_data=pickle.dumps(new_entry))
for hitlistname in hitlist_general_dict:
for hit in hitlist_general_dict[hitlistname]:
if hit["title"].lower() in new_title.lower(
): # it's a regular hit!
new_nc.hitnames.append(hit["title"])
new_nc.weight += hit["weight"]
exclusive_hit_title = ""
exclusive_hit_weight = 0
for hitlistname in hitlist_exclusive_dict:
for hit in hitlist_exclusive_dict[hitlistname]:
if hit["title"].lower() in new_title.lower():
if hit["weight"] > exclusive_hit_weight: # it's an exclusive hit!
exclusive_hit_title = hit["title"]
exclusive_hit_weight = hit["weight"]
if exclusive_hit_weight > 0:
new_nc.hitnames.append(exclusive_hit_title)
new_nc.weight += exclusive_hit_weight
if new_nc.weight == 0:
continue
match_nc = None
q = db.Query(NewsChunks)
best_match_ratio = DUPLICATE_THRESHOLD
for nc in q:
existing_title = nc.title
# checks for duplicates with sequence matcher
ratio = difflib.SequenceMatcher(None, new_title,
existing_title).ratio()
if ratio > best_match_ratio:
if nc.weight >= new_nc.weight:
return
else:
best_match_ratio = ratio
match_nc = nc
if match_nc is None:
# unique nc
new_nc.put()
else:
# similar, but new_nc is heavier
match_nc.delete()
new_nc.put()
def updateModel(handler, jsonModel):
createModel = False
if "id" in jsonModel:
modelWrap = StochKitModelWrapper.get_by_id(jsonModel["id"])
userID = handler.user.user_id()
if userID != modelWrap.user_id:
raise "Error accessing model {0} with user id {1} (model owned by {2})".format(jsonModel["id"], userID, modelWrap.user_id)
else:
createModel = True
modelWrap = StochKitModelWrapper()
if 'isSpatial' not in jsonModel or 'spatial' not in jsonModel:
jsonModel['isSpatial'] = False
jsonModel['spatial'] = { 'subdomains' : [],
'mesh_wrapper_id' : None,
'species_diffusion_coefficients' : {} ,
'species_subdomain_assignments' : {} ,
'reactions_subdomain_assignments' : {},
'initial_conditions' : [] }
# This seems insane
if 'user_id' in jsonModel:
userID = jsonModel['user_id']
else:
userID = handler.user.user_id()
#if "name" not in jsonModel:
# raise Exception("Why is this code here?")
if 'isSpatial' in jsonModel:
modelWrap.isSpatial = jsonModel['isSpatial']
if 'spatial' in jsonModel:
modelWrap.spatial = jsonModel['spatial']
# Make sure we have access to a copy of the mesh (if it exists)
if "mesh_wrapper_id" in modelWrap.spatial and modelWrap.spatial["mesh_wrapper_id"]:
meshDbCurrent = mesheditor.MeshWrapper.get_by_id(modelWrap.spatial["mesh_wrapper_id"])
if createModel:
if meshDbCurrent.user_id != userID:
meshDb = mesheditor.MeshWrapper()
meshDb.user_id = userID
names = [x.name for x in db.Query(mesheditor.MeshWrapper).filter('user_id =', handler.user.user_id()).run()]
tmpName = meshDbCurrent.name
i = 0
while tmpName in names:
tmpName = meshDbCurrent.name + '_' + str(i)
i += 1
meshDb.name = tmpName
meshDb.description = meshDbCurrent.description
meshDb.meshFileId = meshDbCurrent.meshFileId
meshDb.subdomains = meshDbCurrent.subdomains
meshDb.uniqueSubdomains = meshDbCurrent.uniqueSubdomains
meshDb.undeletable = False#meshDbCurrent.undeletable
meshDb.ghost = False
meshDb.put()
modelWrap.spatial["mesh_wrapper_id"] = meshDb.key().id()
else:
meshDbCurrent.ghost = False
meshDbCurrent.put()
# This is maintained here!
modelWrap.subdomains = meshDbCurrent.uniqueSubdomains
if 'is_public' not in jsonModel:
jsonModel['is_public'] = False
modelWrap.user_id = userID
modelWrap.name = jsonModel["name"]
modelWrap.species = jsonModel["species"]
modelWrap.type = jsonModel["type"]
modelWrap.parameters = jsonModel["parameters"]
modelWrap.reactions = jsonModel["reactions"]
#modelWrap.spatial = jsonModel["spatial"]
#modelWrap.isSpatial = jsonModel["isSpatial"]
modelWrap.is_public = jsonModel["is_public"]
modelWrap.units = jsonModel["units"]
return modelWrap.put().id()
def get(self):
self.session = Session()
que = db.Query(User)
user_list = que.fetch(limit=100)
doRender(self, 'memberscreen.html',{'user_list': user_list})
def get(self):
que = db.Query(ChatMessage).order('-created')
chat_list = que.fetch(limit=100)
doRender(self, 'messages.htm', {'chat_list': chat_list})
def get(self):
self.session = Session()
que = db.Query(ChatMessage).order('-created');
chat_list = que.fetch(limit=10)
doRender(self,'chatscreen.html',{ 'chat_list': chat_list })
def __Dynamic_Read(self, request, response):
"""Implements _Dynamic_Read if called by _run_in_namespace."""
response.clear_offset()
if request.version_id_size() != 1:
raise apiproxy_errors.ApplicationError(
log_service_pb.LogServiceError.INVALID_REQUEST)
if (request.request_id_size() and
(request.has_start_time() or request.has_end_time() or
request.has_offset())):
raise apiproxy_errors.ApplicationError(
log_service_pb.LogServiceError.INVALID_REQUEST)
if request.request_id_size():
results = []
try:
results = db.get(request.request_id_list())
except datastore_errors.BadKeyError:
for request_id in request.request_id_list():
try:
results.append(db.get(request_id))
except datastore_errors.BadKeyError:
pass
for result in results:
if result.version_id != request.version_id(0):
continue
log = response.add_log()
app_logs = db.get(result.app_logs)
result.fill_in_log(request, log, app_logs)
return
query = db.Query(_LogRecord)
if request.has_offset():
query.filter('__key__ > ', db.Key(request.offset().request_id()))
if request.has_count():
limit = request.count()
else:
limit = LogServiceStub.__DEFAULT_READ_COUNT
versions = request.version_id_list()
index = 0
for result in query.run(limit=limit):
index += 1
start = result.start_time
if request.has_start_time():
if request.start_time() > start:
continue
if request.has_end_time():
if request.end_time() <= start:
continue
if not request.include_incomplete() and not result.finished:
continue
if result.version_id not in versions:
continue
app_logs = db.get(result.app_logs)
if request.has_minimum_log_level():
for app_log in app_logs:
if app_log.level >= request.minimum_log_level():
break
else:
continue
log = response.add_log()
result.fill_in_log(request, log, app_logs)
log.mutable_offset().set_request_id(str(result.key()))
if index == limit:
response.mutable_offset().set_request_id(str(result.key()))
def get_published_posts(offset=0, limit=None):
q = db.Query(Post)
return list(
q.filter('draft', False).order('-created_time').run(offset=offset,
limit=limit))
def post(self):
method = self.request.get('method')
parameters = simplejson.loads(self.request.get('parameters'))
session = self.getSession()
result = {};
#----------------------------------------------------------------------
if method == 'registration':
message = parameters['message'];
if message == 'completeRegistration':
user = User()
user.updateCredentials(parameters['credentials'])
user.update(parameters['user'])
user.put()
result['lock'] = user.lock
result['result'] = "done"
#----------------------------------------------------------------------
elif method == 'handshake':
srp_g = 2L
srp_n = long("0x%s" % "115b8b692e0e045692cf280b436735c77a5a9e8a9e7ed56c965f87db5b2a2ece3", 16)
message = parameters['message'];
#------------------------------------------------------------------
if message == 'connect':
session.C = parameters['parameters']['C']
session.A = parameters['parameters']['A']
user = db.Query(User).filter('username ='******'keyValue =', optId).get()
if oneTimePassword.parent().username != user.username:
oneTimePassword.reset('DISABLED').put()
raise Exception, "User missmatch between the current session and 'One Time Password' user"
elif oneTimePassword.status != 'REQUESTED':
oneTimePassword.reset('DISABLED').put()
raise Exception, "Tring to use an 'One Time Password' in the wrong state"
oneTimePassword.reset("USED").put()
result['oneTimePassword'] = oneTimePassword.reference
except Exception, detail:
logging.error("connect.optId: " + str(detail))
session.s = user.srp_s
session.v = user.srp_v
else:
session.s = "112233445566778899aabbccddeeff00112233445566778899aabbccddeeff00"
session.v = "112233445566778899aabbccddeeff00112233445566778899aabbccddeeff00"
session.b = randomSeed()
session.B = hex(long("0x%s" % session.v, 16) + pow(srp_g, long("0x%s" %session.b, 16), srp_n))[2:-1]
result['s'] = session.s
result['B'] = session.B
#------------------------------------------------------------------
elif message == 'credentialCheck':
B = long("0x%s" % session.B, 16)
b = long("0x%s" % session.b, 16)
A = long("0x%s" % session.A, 16)
v = long("0x%s" % session.v, 16)
u = long("0x%s" % clipperzHash(str(B)), 16)
n = srp_n
S = pow((A * pow(v, u, n)), b, n)
K = clipperzHash(str(S))
M1 = clipperzHash(str(A) + str(B) + K)
if M1 == parameters['parameters']['M1']:
session.K = K
M2 = clipperzHash(str(A) + M1 + K)
result['M2'] = M2
result["connectionId"] = ""
result["loginInfo"] = {}
result["loginInfo"]["latest"] = {}
result["loginInfo"]["current"] = {}
result["offlineCopyNeeded"] = "false";
result["lock"] = "----";
else:
result['error'] = "?"
#------------------------------------------------------------------
elif message == 'oneTimePassword':
oneTimePassword = db.Query(OneTimePassword).filter("keyValue =", parameters["parameters"]["oneTimePasswordKey"]).get()
if oneTimePassword != None:
if oneTimePassword.status == 'ACTIVE':
if oneTimePassword.keyChecksum == parameters['parameters']['oneTimePasswordKeyChecksum']:
#session.userId = str(oneTimePassword.parent().username)
session.otpId = str(oneTimePassword.keyValue)
result['data'] = oneTimePassword.data
result['version'] = oneTimePassword.version
oneTimePassword.reset('REQUESTED').put()
else:
oneTimePassword.reset('DISABLED').put()
raise Exception, "The requested One Time Password has been disabled, due to a wrong keyChecksum"
else:
raise Exception, "The requested One Time Password was not active"
else:
raise Exception, "The requested One Time Password has not been found"
def get(self):
que = db.Query(FinalJudgmentData)
que.order("usernum").order("scenario").order("judgmentNumber")
d = que.fetch(limit=10000)
doRender(self, 'ajaxTest.htm', {'d': d})
