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 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 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 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 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 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 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 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 getBalance(self, user_id):
ret = {}
user = self.getUser(user_id)
if user is None:
ret['errors'] = []
ret['errors'].append("Invalid User")
return apiDecorate(ret, 400, "Invalid User")
ret['balance'] = user.balance
return apiDecorate(ret, 200, "success")
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 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 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 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")
def getBatch(batch_id):
ret = {}
session = dbConn().get_session(dbConn().get_engine())
batch = session.query(
models.batch).filter(models.batch.id == batch_id).first()
if (batch is None):
ret['errors'] = []
ret['errors'].append("Invalid batch id")
return apiDecorate(ret, 400, "Invalid batch id")
experiment = session.query(models.experiments).filter(
models.experiments.resource_id == batch.experiment_id).first()
dataset = session.query(models.dataset).filter(
models.dataset.id == experiment.dataset_id).first()
#k.key = "e_"+randName+"/"+str(batchCount)+".json"
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)
k = Key(bucket)
k.key = "e_" + batch.experiment_id + "/" + str(
batch.local_resource_id) + ".json"
fileJson = k.get_contents_as_string()
fileArr = json.loads(fileJson)
ret['description'] = experiment.description
if (dataset.isMedia == 1):
filesArr = []
for item in fileArr:
itemKey = dataset.resource_id + "/" + str(item)
itemK = Key(bucket)
itemK.key = itemKey
fileEntry = {}
fileEntry['name'] = item
fileEntry['link'] = itemK.generate_url(3600,
query_auth=True,
force_http=True)
filesArr.append(fileEntry)
ret['files'] = filesArr
else:
ret['data'] = fileArr
ret['count'] = batch.curAnnotation
return apiDecorate(ret, 200, "Success")
#print k.generate_url(3600, query_auth=True, force_http=True)
return fileJson
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 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 getDatasets(self, user_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())
datasets = session.query(
models.dataset).filter(models.dataset.user_id == user_id).all()
returnDict = []
for data in datasets:
returnData = {}
returnData['title'] = data.title
returnData['id'] = data.id
returnData['resource_name'] = data.resource_id
if (data.isPublic == True):
returnData['status'] = "Public"
else:
returnData['status'] = "Private"
returnDict.append(returnData)
ret['datasets'] = returnDict
return apiDecorate(ret, 200, "Success")
def getPastExperiments(user_id):
ret = {}
session = dbConn().get_session(dbConn().get_engine())
myBatches = session.query(
models.batch).filter(models.batch.user_id == user_id)
batches = myBatches.all()
listBatch = []
for curBatch in batches:
exp = session.query(
models.experiments).filter(models.experiments.resource_id ==
curBatch.experiment_id).first()
batchData = {}
batchData['description'] = exp.description
if (curBatch.rating is None):
batchData['rating'] = -1
else:
batchData['rating'] = curBatch.rating
listBatch.append(batchData)
ret['batches'] = listBatch
return apiDecorate(ret, 200, 'success')
def updateExperiment(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])
argArray = {}
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)
description = argArray.get("description")
notifTime = argArray.get("notifTime")
allocateTime = argArray.get("allocateTime")
maxTime = argArray.get("maxTime")
if (description == None or len(description) == 0):
return apiDecorate(ret, 400, "Description cant be empty")
if (maxTime is not None):
try:
if len(maxTime) == 0 or maxTime == 0:
maxTime = None
else:
maxTime = int(maxTime)
except:
return apiDecorate(ret, 400, "Max time is not integer")
if (notifTime is not None):
try:
if len(notifTime) == 0 or maxTime == 0:
notifTime = None
else:
notifTime = int(notifTime)
except:
return apiDecorate(ret, 400,
"Notification time is not integer")
if (allocateTime is not None):
try:
if len(allocateTime) == 0 or maxTime == 0:
allocateTime = None
else:
allocateTime = int(allocateTime)
except:
return apiDecorate(ret, 400, "Allocate time is not integer")
if (notifTime is not None and max is None):
return apiDecorate(
ret, 400,
"Allocation time needs to be specified if, notification time is specified"
)
if (notifTime is not None):
if notifTime < 0 or notifTime > maxTime:
return apiDecorate(ret, 400, "Notification time incorrect")
content = "Experiment (" + experiment.title + "), has been changed." + "\n New instruction are : " + description
experiment.description = description
experiment.notifTime = notifTime
experiment.allocateTime = allocateTime
experiment.maxTime = maxTime
session.commit()
session = dbConn().get_session(dbConn().get_engine())
batches = session.query(
models.batch).filter(models.batch.user_id != None).filter(
models.batch.experiment_id == experiment.resource_id).all()
if (len(batches) < 1):
return apiDecorate(ret, 200, "Success")
for batch in batches:
user = session.query(
models.User).filter(models.User.id == batch.user_id).first()
notification.sendMail("*****@*****.**", user.email,
"Experiment changed", "text/plain", content)
notification.sendText(user.phone, content)
return apiDecorate(ret, 200, "Success")
def createExperiment(user_id):
ret = {}
argArray = {}
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)
dataset_id = argArray.get("dataset_id")
if (dataset_id is None):
ret['errors'] = []
ret['errors'].append("Invalid dataset")
return apiDecorate(ret, 400, "Invalid dataset")
try:
dataset_id = int(dataset_id)
except:
ret['errors'] = []
ret['errors'].append("Invalid dataset")
return apiDecorate(ret, 400, "Invalid dataset")
# price, description, multiSelect=None
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")
dataset = session.query(
models.dataset).filter(models.dataset.id == dataset_id).first()
if (dataset is None):
ret['errors'] = []
ret['errors'].append("Invalid dataset")
return apiDecorate(ret, 400, "Invalid dataset")
price = argArray.get('price')
batchSize = argArray.get('batchSize')
description = argArray.get('description')
multiSelect = argArray.get('multiSelect')
datasetType = argArray.get('datasetType')
gender = argArray.get("gender")
country = argArray.get("country")
skill = argArray.get("skill")
'''dt = argArray.get("deadline")'''
maxTime = argArray.get("maxTime")
notifTime = argArray.get("notifTime")
allocateTime = argArray.get("allocateTime")
title = argArray.get("title")
if (maxTime is not None):
try:
if len(maxTime) == 0 or maxTime == 0:
maxTime = None
else:
maxTime = int(maxTime)
except:
return apiDecorate(ret, 400, "Max time is not integer")
if (notifTime is not None):
try:
if len(notifTime) == 0 or maxTime == 0:
notifTime = None
else:
notifTime = int(notifTime)
except:
return apiDecorate(ret, 400,
"Notification time is not integer")
if (allocateTime is not None):
try:
if len(allocateTime) == 0 or maxTime == 0:
allocateTime = None
else:
allocateTime = int(allocateTime)
except:
return apiDecorate(ret, 400, "Allocate time is not integer")
if (notifTime is not None and maxTime is None):
return apiDecorate(
ret, 400,
"Allocation time needs to be specified if, notification time is specified"
)
if (notifTime is not None):
if notifTime < 0 or notifTime > maxTime:
return apiDecorate(ret, 400, "Notification time incorrect")
'''
if(dt is not None):
#deadline = datetime.datetime.strptime(dt, '%Y/%m/%d')
deadline = datetime.strptime(dt, '%Y/%m/%d')
else:
deadline = None
'''
if (gender is not None and len(gender) < 1):
gender = None
if (country is not None and len(country) < 1):
country = None
if (skill is not None and len(skill) < 1):
skill = 0
else:
try:
skill = int(skill)
except:
skill = 0
if (multiSelect is None):
multiSelect = 1
if ((price is None or len(price) <= 0)
or (batchSize is None or len(batchSize) <= 0)
or (description is None or len(description) <= 0)
or (datasetType is None or len(datasetType) <= 0)
or (title is None or len(title) == 0)):
ret['errors'] = []
ret['errors'].append("Parameters not set")
return apiDecorate(ret, 400, "Parameters not set")
try:
batchSize = int(batchSize)
price = float(price)
datasetType = int(datasetType)
except:
ret['errors'] = []
ret['errors'].append("price/batchSize not integer")
return apiDecorate(ret, 400, "price/batchSize not integer")
if (price < 0):
ret['errors'] = []
ret['errors'].append("Price less than 0")
return apiDecorate(ret, 400, "Price less than 0")
totalCost = batchSize * price
if (user.balance < totalCost):
ret['errors'] = []
ret['errors'].append("Insufficient funds")
return apiDecorate(ret, 400, "Insufficient funds")
else:
user.balance -= totalCost
session.commit()
randNum = randint(1, 10000)
randNum2 = randint(1, 10000)
randString = ''.join(
random.choice('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ')
for i in range(randint(10, 20)))
timeStamp = datetime.now()
randName = str(randNum) + str(timeStamp.year) + str(
timeStamp.month) + randString + str(timeStamp.day) + str(
timeStamp.hour) + str(timeStamp.minute) + str(
timeStamp.second) + str(randNum2)
if (int(dataset.isMedia) != int(datasetType)):
print int(dataset.isMedia)
print datasetType
ret['errors'] = []
ret['errors'].append("Invalid dataset type and experiment type")
return apiDecorate(ret, 400,
"Invalid dataset type and experiment type")
batches = datasetHandler.makeBatches(dataset, batchSize)
if (batches is None):
ret['errors'] = []
ret['errors'].append("Batch problems")
return apiDecorate(ret, 400, "Batch problems")
experiment = models.experiments(user.id, title, randName, price,
len(batches), description, dataset.id,
gender, country, skill, maxTime,
notifTime, allocateTime)
session.add(experiment)
session.commit()
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)
batchCount = 0
for batch in batches:
batchJson = json.dumps(batch)
k = Key(bucket)
k.key = "e_" + randName + "/" + str(batchCount) + ".json"
sent = k.set_contents_from_string(batchJson,
cb=None,
md5=None,
reduced_redundancy=False)
batch = models.batch(randName, batchCount, len(batch))
batch.allocateTime = allocateTime or 0
batch.price = price
session.add(batch)
session.commit()
batchCount += 1
k = Key(bucket)
k.key = "e_" + randName + "/res.json"
arr = []
sent = k.set_contents_from_string(json.dumps(arr),
cb=None,
md5=None,
reduced_redundancy=False)
return apiDecorate(ret, 200, "Success")
def uploadFile(user_id, datasetType):
ret = {}
argArray = {}
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 = userHandler().getUser(user_id)
if user is None:
ret['errors'] = []
ret['errors'].append("User doesnt't exist/not logged in")
return apiDecorate(ret, 400, "User doesnt't exist/not logged in")
if 'file' not in request.files:
ret['errors'] = []
ret['errors'].append("File not supplied")
return apiDecorate(ret, 400, "File not supplied")
if (datasetType != 0 and datasetType != 1):
ret['errors'] = []
ret['errors'].append("Invalid Type")
return apiDecorate(ret, 400, "Invalid Type")
uploadedFile = request.files['file']
if not uploadedFile:
ret['errors'] = []
ret['errors'].append("File not supplied")
return apiDecorate(ret, 400, "File not supplied")
if not fileHandler.allowed_file(uploadedFile.filename):
ret['errors'] = []
ret['errors'].append("File not supported")
return apiDecorate(ret, 400, "File not supported")
filename = secure_filename(uploadedFile.filename)
randNum = randint(1, 10000)
randNum2 = randint(1, 10000)
randString = ''.join(
random.choice('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ')
for i in range(randint(10, 20)))
timeStamp = datetime.now()
randName_noext = str(randNum) + str(timeStamp.year) + str(
timeStamp.month) + randString + str(timeStamp.day) + str(
timeStamp.hour) + str(timeStamp.minute) + str(
timeStamp.second) + str(randNum2)
randName = randName_noext
storageLocation = os.path.join(fileHandler.UPLOAD_FOLDER, randName)
uploadedFile.save(storageLocation)
fileSize = os.stat(storageLocation).st_size
if (not zipfile.is_zipfile(storageLocation)):
ret['errors'] = []
ret['errors'].append("Invalid File, File not a valid zip file")
return apiDecorate(ret, 400, "Invalid File")
zipF = zipfile.ZipFile(storageLocation)
if (datasetType == 0):
fileArr = fileHandler.jsonFile(zipF)
else:
fileArr = fileHandler.imgFile(zipF)
if (fileArr is None):
ret['errors'] = []
ret['errors'].append(
"Zip file empty or contains invalid/incompatible files")
return apiDecorate(ret, 400, "Zip file empty")
botoConn = boto.connect_s3(fileHandler.DREAM_key,
fileHandler.DREAM_secretKey,
host="objects-us-west-1.dream.io")
bucket = botoConn.get_bucket(fileHandler.DREAM_Bucket, validate=False)
for file in fileArr:
k = Key(bucket)
k.key = randName + "/" + file['name']
sent = k.set_contents_from_string(file['fileByte'],
cb=None,
md5=None,
reduced_redundancy=False)
print len(file['fileByte'])
print sent
data = models.dataset(user_id=user_id,
isMedia=datasetType,
resource_id=randName)
data.title = argArray.get("dataset_title") or "No Title Given"
session = dbConn().get_session(dbConn().get_engine())
session.add(data)
session.commit()
return apiDecorate(ret, 200, "Verified")
def register(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)
firstName = argArray.get("firstname")
lastName = argArray.get("lastname")
email = argArray.get("email")
phone = argArray.get("phone")
password = argArray.get("password")
gender = argArray.get("gender")
country = argArray.get("country")
skill = argArray.get("skill")
user = models.User(first_name=firstName,
last_name=lastName,
password=password,
email=email,
phone=phone,
gender=gender,
country=country,
skill=skill)
if len(user.errors) > 0:
ret['errors'] = user.errors
return apiDecorate(ret, 400,
"Invalid and/or incomplete data specified")
return apiDecorate(ret)
session = dbConn().get_session(dbConn().get_engine())
checkUser = session.query(
models.User).filter(models.User.email == email).first()
if (checkUser is not None):
ret['errors'] = []
ret['errors'].append("User already exists")
return apiDecorate(ret, 400, "User already exists")
session.add(user)
session.commit()
## Generate email key
randNum = randint(1, 10000)
randNum2 = randint(1, 10000)
timeStamp = datetime.now()
emailKey = str(randNum) + str(timeStamp.year) + str(
timeStamp.month) + str(timeStamp.day) + str(timeStamp.hour) + str(
timeStamp.minute) + str(timeStamp.second) + "_" + str(randNum2)
contentText = "Go to the link to verify " + "http://datonate.com:5000/api/verify/email/" + emailKey
res = notification.sendMail(fromEmail="*****@*****.**",
toEmail=user.email,
subject="Confirm your account",
contentType="text/plain",
content=contentText)
print(res)
## Generate Phone key
randNum = randint(1, 10000)
randNum2 = randint(1, 10000)
timeStamp = datetime.now()
phoneKey = str(randNum) + str(timeStamp.year) + str(
timeStamp.month) + str(timeStamp.day) + str(timeStamp.hour) + str(
timeStamp.minute) + str(
timeStamp.second) + "__" + str(randNum2)
textContent = "Go to the link to verify " + "http://datonate.com:5000/api/verify/phone/" + phoneKey
message = notification.sendText(user.phone, textContent)
regUser = session.query(
models.User).filter(models.User.email == user.email).first()
userValidate = models.user_validate(regUser.id, emailKey, phoneKey)
session.add(userValidate)
session.commit()
return apiDecorate(ret, 200, "User Added")
def getExperiments(user_id):
ret = {}
argArray = {}
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)
sort = argArray.get("sort")
levelFilter = argArray.get("education")
if (levelFilter is not None and len(str(levelFilter)) < 0):
levelFilter = None
if (levelFilter is not None):
try:
levelFilter = int(levelFilter)
except:
levelFilter = None
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")
ret = {}
if (sort == "compensation"):
batches = session.query(models.batch.experiment_id).filter(
models.batch.user_id == None).order_by(
models.batch.price).group_by(models.batch.price).group_by(
models.batch.experiment_id).all()
if (sort == "time"):
batches = session.query(models.batch.experiment_id).filter(
models.batch.user_id == None).order_by(
models.batch.allocateTime).group_by(
models.batch.allocateTime).group_by(
models.batch.experiment_id).all()
else:
batches = session.query(models.batch.experiment_id).filter(
models.batch.user_id == None).distinct(
models.batch.experiment_id).all()
experiments = []
for batch in batches:
experiment = session.query(models.experiments).filter(
models.experiments.resource_id == batch[0]).first()
if ((experiment.gender != None
and experiment.gender != user.gender)
or (experiment.country != None
and experiment.country != user.country)
or (user.skill < experiment.skill) or
(levelFilter is not None and experiment.skill != levelFilter)
or (experiment.isPaused != 0)):
print "User skill " + str(
user.skill) + "experiment.skill " + str(
experiment.skill) + "\n"
continue
datas = session.query(models.dataset).filter(
models.dataset.id == experiment.dataset_id).first()
tempExperiment = {}
tempExperiment['id'] = experiment.id
tempExperiment['price'] = experiment.price
tempExperiment['description'] = experiment.description
tempExperiment['isMedia'] = datas.isMedia
tempExperiment['allocate'] = experiment.allocateTime or 0
experiments.append(tempExperiment)
ret['experiments'] = experiments
return apiDecorate(ret, 200, "Success")
