def test_getExperimentsProgress():
session = db.dbConn().get_session(db.dbConn().get_engine())
test_user = session.query(
models.User).filter(models.User.email == test_email).first()
#session = db.dbConn().get_session(dbConn().get_engine())
experiment = session.query(models.experiments).filter(
models.experiments.user_id == test_user.id).first()
checkBatch = session.query(models.batch).filter(
models.batch.experiment_id == experiment.resource_id).all()
#assert False, len(checkBatch)
com = 0
for batch in checkBatch:
if (batch.curAnnotation == batch.totalAnnotation):
com = com + 1
jsonStr, suc = call_getExperimentProgress(test_user.id)
jsonArr = json.loads(jsonStr)
if (not suc):
assert False, "Could not return progress"
if (jsonArr['experiments'][0]['completed'] != com):
assert False, "Returns succes but fails to return correct progress"
def batchList(user_id):
ret = {}
session = dbConn().get_session(dbConn().get_engine())
user = session.query(
models.User).filter(models.User.id == user_id).first()
if (user is None):
ret['errors'] = []
ret['errors'].append("Invalid User")
return apiDecorate(ret, 400, "Invalid User")
batches = session.query(
models.batch).filter(models.batch.user_id == user.id).filter(
models.batch.isCompleted == False).all()
userBatches = []
for batch in batches:
userBatch = {}
userBatch['id'] = batch.id
experiment = session.query(models.experiments).filter(
models.experiments.resource_id == batch.experiment_id).first()
if (experiment.isPaused != 0):
continue
datas = session.query(models.dataset).filter(
models.dataset.id == experiment.dataset_id).first()
userBatch['description'] = experiment.description
userBatch['price'] = experiment.price
userBatch['isMedia'] = datas.isMedia
if (batch.deadline != None):
userBatch['due'] = str(batch.deadline)
else:
userBatch['due'] = "No Deadline"
userBatches.append(userBatch)
ret['batches'] = userBatches
return apiDecorate(ret, 200, "Success")
def verify_phone(self, key):
ret = {}
if key is None:
ret['errors'] = []
ret['errors'].append("Invalid and/or expired key supplied")
return apiDecorate(ret, 400, "Invalid and/or expired key supplied")
session = dbConn().get_session(dbConn().get_engine())
userValidate = session.query(models.user_validate).filter(
models.user_validate.phoneCode == key).first()
if (userValidate is None):
ret['errors'] = []
ret['errors'].append("Invalid and/or expired key supplied")
return apiDecorate(ret, 400, "Invalid and/or expired key supplied")
curUser = session.query(
models.User).filter(models.User.id == userValidate.id).first()
if (curUser is None):
ret['errors'] = []
ret['errors'].append("Server Error")
return apiDecorate(ret, 500, "Server Error")
curUser.isPhone = True
session.commit()
if (curUser.isEmail == True):
session.delete(userValidate)
session.commit()
return apiDecorate(ret, 200, "Verified")
def call_createExperiment(user):
session = db.dbConn().get_session(db.dbConn().get_engine())
checkUser = session.query(
models.User).filter(models.User.email == test_email).first()
checkUser.balance = 2000
session.commit()
session = db.dbConn().get_session(db.dbConn().get_engine())
checkSet = session.query(
models.dataset).filter(models.dataset.user_id == user).first()
temp = 0
if (checkSet.isMedia):
temp = 1
jsonString = urllib2.urlopen(
SERVER_ADDRESS + '/api/' + str(user) + '/create?dataset_id=' +
str(checkSet.id) + '&batchSize=1&user_id=' + str(user) +
'&price=1&description=IMAGE&isPhone=3126469650&datasetType=' +
str(temp) + '&title=FirstExperiment').read()
jsonArr = json.loads(jsonString)
#assert False, jsonArr['status']
if (jsonArr['status'] == 200):
return jsonString, True
else:
return jsonString, False
def test_allPublicDatasets():
session = db.dbConn().get_session(db.dbConn().get_engine())
datasets = session.query(
models.dataset).filter(models.dataset.isPublic == True).all()
jsonStr, suc = call_allPublicDatasets()
jsonArr = json.loads(jsonStr)
if (suc):
for s in jsonArr['datasets']:
session = db.dbConn().get_session(db.dbConn().get_engine())
temp = session.query(models.dataset).filter(
models.dataset.resource_id == s['resource_name']).first()
flag = False
for t in datasets:
x = t.resource_id + " " + temp.resource_id
#assert False, x
if (t.resource_id == temp.resource_id):
flag = True
if (flag == False):
assert False, "Gives success but fails to retrieve some/all of the datasets"
if (not suc):
assert False, "Failed to retrieve all public datasets"
def login(self):
ret = {}
if request.method == "GET":
argArray = request.args
elif request.method == "POST":
if (len(request.form) > 0):
argArray = request.form
else:
print request.get_data()
argArray = json.loads(request.data)
user = models.User(password=argArray.get("password"),
email=argArray.get("email"))
if not user.email or not user.password:
ret['errors'] = []
ret['errors'].append("Invalid and/or expired key supplied")
return apiDecorate(ret, 400, "Invalid and/or expired key supplied")
session = dbConn().get_session(dbConn().get_engine())
user = session.query(
models.User).filter(models.User.email == user.email).filter(
models.User.password == user.password).filter(
models.User.isEmail == 1).filter(
models.User.isPhone == 1).first()
if user is None:
ret['errors'] = []
ret['errors'].append(
"Incorect User/password combinator or the user is not registered"
)
return apiDecorate(ret, 400, "Invalid and/or expired key supplied")
ret['id'] = user.id
return apiDecorate(ret, 200, "Login Accepted")
def pay():
customer = stripe.Customer.create(email=request.form['stripeEmail'],
source=request.form['stripeToken'])
charge = stripe.Charge.create(customer=customer.id,
amount=99,
currency='usd',
description='The Product')
#print(customer.email)
#return redirect(url_for('thanks'))
if charge.paid:
print(customer.email)
session = dbConn().get_session(dbConn().get_engine())
s = str(customer.email)
curUser = session.query(
models.User).filter(models.User.email == s).first()
print(customer.email)
if (curUser is None):
return redirect(url_for('failure'))
else:
curUser.balance = curUser.balance + charge.amount
session.commit()
return redirect(url_for('thanks'))
else:
return redirect(url_for('failure'))
def copyPublicDataset(self, user_id, dataset_id):
ret = {}
user = self.getUser(user_id)
if user is None:
ret['errors'] = []
ret['errors'].append("Invalid User")
return apiDecorate(ret, 400, "Invalid User")
session = session = dbConn().get_session(dbConn().get_engine())
dataset = session.query(
models.dataset).filter(models.dataset.id == dataset_id).filter(
models.dataset.isPublic == True).first()
if dataset is None:
ret['errors'] = []
ret['errors'].append("Invalid dataset or dataset is not public")
return apiDecorate(ret, 400,
"Invalid dataset or dataset is not public")
#copyDataset = models.dataset(user.id, file_name=dataset.file_name, resource_id=dataset.resource_id)
copyDataset = models.dataset(user.id,
isMedia=dataset.isMedia,
resource_id=dataset.resource_id)
copyDataset.title = dataset.title
session.add(copyDataset)
session.commit()
copyDataset.isPublic = True
session.commit()
return apiDecorate(ret, 200, "Success")
def toggleDataset(self, user_id, dataset_id):
ret = {}
user = self.getUser(user_id)
if user is None:
ret['errors'] = []
ret['errors'].append("Invalid User")
return apiDecorate(ret, 400, "Invalid User")
session = session = dbConn().get_session(dbConn().get_engine())
dataset = session.query(
models.dataset).filter(models.dataset.user_id == user_id).filter(
models.dataset.id == dataset_id).first()
if dataset is None:
ret['errors'] = []
ret['errors'].append(
"Invalid dataset or user doesnt own the dataset")
return apiDecorate(
ret, 400, "Invalid dataset or user doesnt own the dataset")
if (dataset.isPublic == False):
dataset.isPublic = True
else:
dataset.isPublic = False
session.commit()
return apiDecorate(ret, 200, "Success")
def getBatchToRate(experiment_id):
ret = {}
session = dbConn().get_session(dbConn().get_engine())
experiment = session.query(models.experiments).filter(
models.experiments.id == experiment_id).first()
if experiment is None:
ret['errors'] = []
ret['errors'].append("Invalid experiment id")
return apiDecorate(ret, 400, "Invalid experiment id")
batches = session.query(models.batch).filter(
models.batch.experiment_id == experiment.resource_id).filter(
models.batch.rating == None).all()
finishedBatch = []
for batch in batches:
if (batch.isCompleted == False):
continue
botoConn = boto.connect_s3(datasetHandler.DREAM_key,
datasetHandler.DREAM_secretKey,
host="objects-us-west-1.dream.io")
bucket = botoConn.get_bucket(datasetHandler.DREAM_Bucket,
validate=False)
curBatch = {}
curBatch['id'] = batch.id
link = "e_" + experiment.resource_id + "/" + str(
batch.local_resource_id) + "_res.json"
itemk = Key(bucket)
itemk.key = link
print link
link = itemk.generate_url(3600, query_auth=True, force_http=True)
curBatch['link'] = link
print link
finishedBatch.append(curBatch)
ret['batches'] = finishedBatch
return apiDecorate(ret, 200, "success")
def rateBatch(batch_id, rating):
ret = {}
session = dbConn().get_session(dbConn().get_engine())
curBatch = session.query(
models.batch).filter(models.batch.id == batch_id).first()
if (curBatch is None):
ret['errors'] = []
ret['errors'].append("Invalid batch")
return apiDecorate(ret, 400, "Invalid batch")
if (curBatch.isCompleted == False):
ret['errors'] = []
ret['errors'].append("Batch not annotated")
return apiDecorate(ret, 400, "Batch not annotated")
if (curBatch.rating is not None):
ret['errors'] = []
ret['errors'].append("Batch already has rating")
return apiDecorate(ret, 400, "Batch already has rating")
if (rating > 5):
rating = 5
elif (rating < 0):
rating = 0
curBatch.rating = rating
session.commit()
return apiDecorate(ret, 200, "success")
def test_getBatchToRate():
session = db.dbConn().get_session(db.dbConn().get_engine())
test_user = session.query(
models.User).filter(models.User.email == test_email).first()
#session = db.dbConn().get_session(dbConn().get_engine())
experiment = session.query(models.experiments).filter(
models.experiments.user_id == test_user.id).first()
checkBatch = session.query(models.batch).filter(
models.batch.experiment_id == experiment.resource_id).first()
#checkBatch.isCompleted = True
session.commit()
session = db.dbConn().get_session(db.dbConn().get_engine())
test_user = session.query(
models.User).filter(models.User.email == test_email).first()
#session = db.dbConn().get_session(dbConn().get_engine())
experiment = session.query(models.experiments).filter(
models.experiments.user_id == test_user.id).first()
jsonStr, suc = call_getBatchToRate(experiment.id)
jsonArr = json.loads(jsonStr)
if (not suc):
assert False, "Does not return a batch to rate"
'''
t = str(checkBatch.isCompleted) + " " + str(experiment.resource_id) + " " + str(checkBatch.experiment_id) + " " + str(len(jsonArr['batches']))
assert False, t
'''
if (len(jsonArr['batches']) != 0):
assert False, "Returns wrong number of batches"
def getExperimentProgress(user_id):
ret = {}
session = dbConn().get_session(dbConn().get_engine())
experiments = session.query(models.experiments).filter(
models.experiments.user_id == user_id).all()
if (experiments is None):
return apiDecorate(ret, 400, "Invalid id")
ret['experiments'] = []
for experiment in experiments:
totalAnnotateCount = 0
curAnnotateCount = 0
print(experiment.resource_id)
batches = session.query(models.batch).filter(
models.batch.experiment_id == experiment.resource_id).all()
botoConn = boto.connect_s3(datasetHandler.DREAM_key,
datasetHandler.DREAM_secretKey,
host="objects-us-west-1.dream.io")
bucket = botoConn.get_bucket(datasetHandler.DREAM_Bucket,
validate=False)
dataArr = []
for batch in batches:
if (batch.isCompleted == True):
fileName = "e_" + experiment.resource_id + "/" + str(
batch.local_resource_id) + "_res.json"
k = Key(bucket)
k.key = fileName
fileJson = k.get_contents_as_string()
fileArr = json.loads(fileJson)
dataArr.append(fileArr)
totalAnnotateCount += batch.totalAnnotation
curAnnotateCount += batch.curAnnotation
fileApp = "e_" + experiment.resource_id + "/" + "res.json"
k = Key(bucket)
k.key = fileApp
print "key " + k.key
sent = k.set_contents_from_string(json.dumps(dataArr),
cb=None,
md5=None,
reduced_redundancy=False)
curExp = {}
curExp['total'] = totalAnnotateCount
curExp['completed'] = curAnnotateCount
curExp['experiment_id'] = experiment.id
curExp['price'] = experiment.price
curExp['description'] = experiment.description
curExp['link'] = k.generate_url(3600,
query_auth=True,
force_http=True)
if (experiment.isPaused != 0):
curExp['status'] = "Paused"
else:
curExp['status'] = "Resumed"
ret['experiments'].append(curExp)
return apiDecorate(ret, 200, "Success")
def submitBatchRowImage(batch_id):
ret = {}
if request.method == "GET":
argArray = request.args
elif request.method == "POST":
if (len(request.form) > 0):
argArray = request.form
else:
print request.get_data()
argArray = json.loads(request.data)
imageText = argArray.get('imageText') or ""
imageData = argArray.get('imageData') or ""
if (len(imageText) == 0 or len(imageData) == 0):
return apiDecorate(ret, 400, "Image data/text not present")
session = dbConn().get_session(dbConn().get_engine())
curBatch = session.query(
models.batch).filter(models.batch.id == batch_id).first()
if (curBatch is None):
return apiDecorate(ret, 400, 'Invalid batch id')
curExperiment = session.query(models.experiments).filter(
models.experiments.resource_id == curBatch.experiment_id).first()
curDataset = session.query(models.dataset).filter(
models.dataset.id == curExperiment.dataset_id).first()
if (curDataset.isMedia == False):
return apiDecorate(ret, 400, "Invalid submission route called")
if (curBatch.isCompleted == True):
print "eee"
return apiDecorate(ret, 400, "Batch finished annotating")
batchData = {}
batchData['text'] = imageText
batchData['data'] = imageData
botoConn = boto.connect_s3(datasetHandler.DREAM_key,
datasetHandler.DREAM_secretKey,
host="objects-us-west-1.dream.io")
fileApp = "e_" + curExperiment.resource_id + "/" + str(
curBatch.local_resource_id) + "_" + str(curBatch.curAnnotation)
bucket = botoConn.get_bucket(datasetHandler.DREAM_Bucket,
validate=False)
k = Key(bucket)
k.key = fileApp + ".json"
print "key " + k.key
sent = k.set_contents_from_string(json.dumps(batchData),
cb=None,
md5=None,
reduced_redundancy=False)
if ((curBatch.curAnnotation + 1) >= curBatch.totalAnnotation):
curBatch.isCompleted = True
curBatch.curAnnotation += 1
session.commit()
session = dbConn().get_session(dbConn().get_engine())
curBatch = session.query(
models.batch).filter(models.batch.id == batch_id).first()
if (curBatch.isCompleted == True):
datasetHandler.makeBatchData(batch_id)
return apiDecorate(ret, 200, "Success")
def getUserById(user_id):
session = dbConn().get_session(dbConn().get_engine())
retUser = session.query(
models.User).filter(models.User.id == user_id).first()
if (retUser is None):
return ""
ret = {}
ret['id'] = retUser.id
ret['name'] = retUser.first_name
return json.dumps(ret)
def getMoney(self, user_id, money):
ret = {}
session = dbConn().get_session(dbConn().get_engine())
user = session.query(
models.User).filter(models.User.id == user_id).first()
if user is None:
ret['errors'] = []
ret['errors'].append("Invalid User")
return apiDecorate(ret, 400, "Invalid User")
user.balance += money
session.commit()
return apiDecorate(ret, 200, "success")
def test_updateDataset():
session = db.dbConn().get_session(db.dbConn().get_engine())
test_user = session.query(
models.User).filter(models.User.email == test_email).first()
#session = db.dbConn().get_session(dbConn().get_engine())
experiment = session.query(models.experiments).filter(
models.experiments.user_id == test_user.id).first()
jsonStr, suc = call_updateExperiment(experiment.id)
if (not suc):
assert False, "Failed to update experiment"
def retDatasets(user_id):
ret = {}
user = userHandler().getUser(user_id)
session = dbConn().get_session(dbConn().get_engine())
allUserDatasets = session.query(
models.dataset).filter(models.dataset.user_id == user.id).all()
if (allUserDatasets is None):
ret['errors'] = []
ret['errors'].append("No files uploaded")
return apiDecorate(ret, 400, "User has not uploaded any files")
def makeBatchData(batch_id):
ret = {}
session = dbConn().get_session(dbConn().get_engine())
curBatch = session.query(
models.batch).filter(models.batch.id == batch_id).first()
curExp = session.query(models.experiments).filter(
models.experiments.resource_id == curBatch.experiment_id).first()
price = curExp.price
curUser = session.query(
models.User).filter(models.User.id == curBatch.user_id).first()
if (curUser is None):
return apiDecorate(ret, 400, "Not right user")
curUser.balance = curUser.balance + price
session.commit()
session = dbConn().get_session(dbConn().get_engine())
curBatch = session.query(
models.batch).filter(models.batch.id == batch_id).first()
curExperiment = session.query(models.experiments).filter(
models.experiments.resource_id == curBatch.experiment_id).first()
batches = session.query(models.batch).filter(
models.batch.experiment_id == curBatch.experiment_id).order_by(
models.batch.local_resource_id).all()
botoConn = boto.connect_s3(datasetHandler.DREAM_key,
datasetHandler.DREAM_secretKey,
host="objects-us-west-1.dream.io")
bucket = botoConn.get_bucket(datasetHandler.DREAM_Bucket,
validate=False)
dataArr = []
for i in range(0, curBatch.totalAnnotation):
k = Key(bucket)
fileApp = "e_" + curExperiment.resource_id + "/" + str(
curBatch.local_resource_id) + "_" + str(i) + ".json"
k.key = fileApp
fileJson = k.get_contents_as_string()
fileArr = json.loads(fileJson)
dataArr.append(fileArr)
fileApp = "e_" + curExperiment.resource_id + "/" + str(
curBatch.local_resource_id) + "_res"
k = Key(bucket)
k.key = fileApp + ".json"
print "key " + k.key
sent = k.set_contents_from_string(json.dumps(dataArr),
cb=None,
md5=None,
reduced_redundancy=False)
def test_user_delete():
session = db.dbConn().get_session(db.dbConn().get_engine())
delUser = session.query(
models.User).filter(models.User.email == test_email).first()
checkExp = session.query(models.experiments).filter(
models.experiments.user_id == delUser.id).first()
checkBatch = session.query(models.batch).filter(
models.batch.experiment_id == checkExp.resource_id).all()
for temp in checkBatch:
session.delete(temp)
session.commit()
session = db.dbConn().get_session(db.dbConn().get_engine())
checkExp = session.query(models.experiments).filter(
models.experiments.user_id == delUser.id).all()
for temp in checkExp:
session.delete(temp)
session.commit()
session = db.dbConn().get_session(db.dbConn().get_engine())
checkSet = session.query(
models.dataset).filter(models.dataset.user_id == delUser.id).all()
for temp in checkSet:
session.delete(temp)
session.commit()
session = db.dbConn().get_session(db.dbConn().get_engine())
delUser = session.query(
models.User).filter(models.User.email == test_email).first()
session.delete(delUser)
session.commit()
def getPublicDatasets(self):
ret = {}
session = session = dbConn().get_session(dbConn().get_engine())
datasets = session.query(
models.dataset).filter(models.dataset.isPublic == True).all()
returnDict = []
for data in datasets:
returnData = {}
#returnData['file_name'] = data.file_name
returnData['title'] = data.title
returnData['resource_name'] = data.resource_id
returnData['id'] = data.id
returnDict.append(returnData)
ret['datasets'] = returnDict
return apiDecorate(ret, 200, "Success")
def toggleExperiment(experiment_id):
ret = {}
session = dbConn().get_session(dbConn().get_engine())
experiment = session.query(models.experiments).filter(
models.experiments.id == experiment_id).first()
if (experiment is None):
ret['errors'] = []
ret['errors'].append("Invalid experiment id")
return apiDecorate(ret, 400, ret['errors'][0])
if (experiment.isPaused == 0):
experiment.isPaused = 1
else:
experiment.isPaused = 0
session.commit()
return apiDecorate(ret, 200, "success")
def test_getUserBalance():
session = db.dbConn().get_session(db.dbConn().get_engine())
test_user = session.query(
models.User).filter(models.User.email == test_email).first()
jsonStr, suc = call_getUserBalance(test_user.id)
jsonArr = json.loads(jsonStr)
if (not suc):
assert False, "Fails to return balance"
if (jsonArr['balance'] != test_user.balance):
assert False, "Returns success message but balance shown is not correct"
def getExperimentDetails(experiment_id):
ret = {}
session = dbConn().get_session(dbConn().get_engine())
experiment = session.query(models.experiments).filter(
models.experiments.id == experiment_id).first()
if experiment is None:
ret['errors'] = []
ret['errors'].append("Invalid experiment id")
return apiDecorate(ret, 400, ret['errors'][0])
ret['id'] = experiment_id
ret['description'] = experiment.description
ret['notifTime'] = experiment.notifTime
ret['allocateTime'] = experiment.allocateTime
ret['maxTime'] = experiment.maxTime
return apiDecorate(ret, 200, "success")
def test_createExperiment():
session = db.dbConn().get_session(db.dbConn().get_engine())
test_user = session.query(
models.User).filter(models.User.email == test_email).first()
jsonStr, suc = call_createExperiment(test_user.id)
if (not suc):
assert False, "Experiment could not be created"
session = db.dbConn().get_session(db.dbConn().get_engine())
test_exp = session.query(models.experiments).filter(
models.experiments.user_id == test_user.id).first()
if (test_exp is None):
assert False, "Gives success message but is not created in experiment table"
def call_upload_text(file):
session = db.dbConn().get_session(db.dbConn().get_engine())
checkUser = session.query(
models.User).filter(models.User.email == test_email).first()
temp = str(checkUser.id)
f = open(file, 'rb')
print(f)
r = requests.post('http://127.0.0.1:5000/api/' + temp + '/upload/0',
files={'file': f})
jsonArr = json.loads(str(r.text))
if (jsonArr['status'] == 200):
return r.text, True
else:
return r.text, False
def userBatchExtracter(batch_id):
session = dbConn().get_session(dbConn().get_engine())
curBatch = session.query(
models.batch).filter(models.batch.id == batch_id).first()
curBatch.isCompleted = True
curExp = session.query(models.experiments).filter(
models.experiment.resource_id == curBatch.experiment_id)
price = curExp.price
curUser = session.query(
models.User).filter(models.User.id == curBatch.user_id)
curUser.balance = curUser.balance + price
session.commit()
def test_getPastExperiments():
session = db.dbConn().get_session(db.dbConn().get_engine())
test_user = session.query(
models.User).filter(models.User.email == test_email).first()
session = db.dbConn().get_session(db.dbConn().get_engine())
test_batch = session.query(
models.batch).filter(models.batch.user_id == test_user.id).first()
jsonStr, suc = call_getPastExperiments(test_user.id)
if (not suc):
assert False, "Failed to return past experiments"
if (test_batch.isCompleted == False):
assert False, "Returned success but didn't provide all prior experiments"
def test_get_datasets():
session = db.dbConn().get_session(db.dbConn().get_engine())
test_user = session.query(
models.User).filter(models.User.email == test_email).first()
jsonStr, suc = call_getDatasets(test_user.id)
jsonArr = json.loads(jsonStr)
imageResourceName = jsonArr['datasets'][0]['resource_name']
textResource = jsonArr['datasets'][1]['resource_name']
session = db.dbConn().get_session(db.dbConn().get_engine())
imageDataset = session.query(models.dataset).filter(
models.dataset.resource_id == imageResourceName).first()
session = db.dbConn().get_session(db.dbConn().get_engine())
checkUser = session.query(
models.User).filter(models.User.id == imageDataset.user_id).first()
if (suc):
if (imageDataset is None):
assert False, "Doesn't return dataset despite returning success message"
if (checkUser is None):
assert False, "Returns success message but corresponding user is invalid"
if (not suc):
assert False, "Couldn't return any of existing datasets"
session = db.dbConn().get_session(db.dbConn().get_engine())
textDataset = session.query(models.dataset).filter(
models.dataset.resource_id == textResource).first()
session = db.dbConn().get_session(db.dbConn().get_engine())
checkUser = session.query(
models.User).filter(models.User.id == textDataset.user_id).first()
if (suc):
if (textDataset is None):
assert False, "Doesn't return dataset despite returning success message"
if (checkUser is None):
assert False, "Returns success message but corresponding user is invalid"
if (not suc):
assert False, "Couldn't return any of existing datasets"
def assignBatch(user_id, experiment_id):
ret = {}
session = dbConn().get_session(dbConn().get_engine())
user = session.query(
models.User).filter(models.User.id == user_id).first()
if (user is None):
ret['errors'] = []
ret['errors'].append("Invalid User")
return apiDecorate(ret, 400, "Invalid User")
experiment = session.query(models.experiments).filter(
models.experiments.id == experiment_id).first()
if (experiment is None):
ret['errors'] = []
ret['errors'].append("Invalid experiment")
return apiDecorate(ret, 400, "Invalid experiment")
hasBatch = session.query(models.batch).filter(
models.batch.experiment_id == experiment.resource_id).filter(
models.batch.user_id == user.id).first()
if (hasBatch is not None):
#ret['errors'] = []
#ret['errors'].append("User already has a batch")
ret['batch_id'] = hasBatch.id
return apiDecorate(ret, 200, "Success")
batch = session.query(models.batch).filter(
models.batch.experiment_id == experiment.resource_id).filter(
models.batch.user_id == None).first()
if (batch is None):
ret['errors'] = []
ret['errors'].append("No batch available")
return apiDecorate(ret, 400, "No batch available")
batch.user_id = user.id
ret['batch_id'] = batch.id
if (experiment.maxTime != None):
batch.deadline = datetime.now() + timedelta(
hours=experiment.maxTime)
if (experiment.notifTime != None):
batch.notifDeadline = datetime.now() + timedelta(
hours=(experiment.maxTime - experiment.notifTime))
session.commit()
return apiDecorate(ret, 200, "Success")
