def post(self, accountId):
data = request.get_json()
print(json.dumps(data, indent=4, sort_keys=True))
# Verifying required data is available to proccess request
if not data or not data.get("appDetails") or not data.get(
"accountDetails") or not data.get("carDetails"):
return res.badRequestError("Missing data to process request.")
dataAppDetails = data.get("appDetails")
dataAppVersionDetails = dataAppDetails["appversionDetails"]
dataAccountDetails = data.get("accountDetails")
dataCarDetails = data.get("carDetails")
if not dataAppDetails or not dataAppVersionDetails or not dataAccountDetails or not dataCarDetails:
return res.badRequestError("Missing data to process request.")
# Finding requested app package in server
appReqDownloadPath = os.path.join(
app.config["UPLOAD_FOLDER"],
os.path.join(dataAppDetails["appname"],
dataAppVersionDetails["version"]))
if os.path.exists(appReqDownloadPath) == False:
print("wrong path")
return res.badRequestError("App executable files not found.")
# Saves customer download request
apprequestDetails = {
"requesttype": 3,
"appversion": dataAppVersionDetails["id"],
"customer": accountId,
"car": dataCarDetails["id"]
}
customerAppRequest, error = apprequest_schema.load(apprequestDetails)
if error:
return res.internalServiceError(error)
customerAppRequest.status = 5 # sets status as download request
db.session.add(customerAppRequest)
db.session.commit()
# Connect to client vehicle device
remoteAppDirectory = os.path.join(app.config["PI_REMOTE_DIR"],
dataAppDetails["appname"])
error, sshI = ssh.SSHconnect(app.config["PI_IP"], 22)
if error < 0:
return res.internalServiceError(sshI)
# Download and Install app in remote device
ssh.createAppDirectory(sshI, remoteAppDirectory)
ssh.sendFile(sshI, appReqDownloadPath,
os.path.join(remoteAppDirectory, "App.zip"))
ssh.installApp(sshI, remoteAppDirectory, "helloworld.py")
print(sshI)
return res.postSuccess("App installation successful.")
def get(self, accountId):
queryDeveloperApp = ApplicationDeveloper.query.filter_by(
accountid=accountId).all()
if not queryDeveloperApp:
return res.resourceMissing(
"No apps for developer with account {} found.".format(
accountId))
developerapps, error = applicationdevelopers_schema.dump(
queryDeveloperApp)
if error:
return res.internalServiceError(error)
allapps = []
for developerapp in developerapps:
queryApplication = Application.query.filter(
Application.id == developerapp["appid"]).filter(
or_(
Application.active == True,
and_(Application.active == False,
Application.runningversion == 0))).first()
if queryApplication:
queryAppVersion = ApplicationVersion.query.filter(
ApplicationVersion.app == queryApplication.id).first()
developerapp["appDetails"] = application_schema.dump(
queryApplication).data
if queryAppVersion:
developerapp["appDetails"][
"appversionDetails"] = applicationversion_schema.dump(
queryAppVersion).data
allapps.append(developerapp)
return res.getSuccess(data=allapps)
def post(self, accountId):
data = request.get_json()
# Verifying data required for endpoint was given
if not data or not data.get("vinNumber"):
return res.badRequestError("Missing data to process request.")
# Verifying car given exists in database
queryCar = Car.query.filter_by(vin=data.get("vinNumber")).first()
if not queryCar:
return res.resourceMissing("Car {} does not exist.".format(
data.get("vinNumber")))
# Verifying car given is NOT registered under the given customer
queryCarUser = CarUser.query.filter_by(car=queryCar.id,
account=accountId).first()
if queryCarUser:
return res.resourceExistsError(
"Car already registered under customer {}.".format(accountId))
# Creata the link from user to the registered car in the database
newCarUserDetails = {"car": queryCar.id, "account": accountId}
newCarUser, error = caruser_schema.load(newCarUserDetails)
if error:
return res.internalServiceError(error)
db.session.add(newCarUser)
db.session.commit()
return res.postSuccess("Car {} registered under customer {}.".format(
data.get("vinNumber"), accountId))
def put(self):
#print(request.files)
data = request.form
print(data)
if not data or not data["requestId"] or not data["status"] or not data[
"appDetail"]:
return res.badRequestError("Missing data to process request.")
# Validate app path exists
appDetail = data["appDetail"]
appDetail = appDetail.replace('-', '/')
logStoragePath = os.path.join(app.config['UPLOAD_FOLDER'], appDetail)
if os.path.exists(logStoragePath) == False:
return res.internalServiceError(
"No directory found for {}.".format(appDetail))
queryAppRequest = AppRequest.query.filter_by(
id=data["requestId"]).first()
if not queryAppRequest:
return res.badRequestError("Request {} does not exist.".format(
data["requestId"]))
# Call application service to update application version status
if (int(data.get("status")) == 2):
status = 4
else:
status = 3
AppServiceReq = requests.put(
app.config['APPLICATION_SERVICE'] +
"{}/appversion".format(queryAppRequest.appversion),
json={
"status": status
}).json()
if ("success" not in AppServiceReq["status"]):
return res.internalServiceError(
"Error in application service. Is it running?")
# Saves log file
saved, msg = ServUtil.saveLoginServer(app, request.files["logfile"],
logStoragePath)
if not saved:
return res.internalServiceError(msg)
queryAppRequest.status = data["status"]
db.session.commit()
return res.putSuccess(
data=apprequest_schema.dump(queryAppRequest).data)
def get(self, developerId):
query = AppRequest.query.filter_by(developer=developerId).all()
if not query:
return res.getSuccess(data=None)
developerrequests, error = apprequests_schema.dump(query)
if error:
return res.internalServiceError(error)
return res.getSuccess(
"Requests made by developer {} retrieved".format(developerId),
developerrequests)
def get(self, appversionId):
queryRequests = AppRequest.query.filter_by(
appversion=appversionId).all()
if not queryRequests:
return res.getSuccess(data=None)
apprequests, error = apprequests_schema.dump(queryRequests)
if error:
return res.internalServiceError(error)
return res.getSuccess(
"Requests for app {} retrieved".format(appversionId), apprequests)
def get(self):
queryApps = Application.query.filter_by(active=True).all()
print(queryApps)
if not queryApps:
return res.resourceMissing("No apps in AppStore yet. Brah!")
apps, error = applications_schema.dump(queryApps)
if error:
return res.internalServiceError(error)
for a in apps:
queryAppVersion = ApplicationVersion.query.filter_by(
id=a["runningversion"]).first()
a["appversionDetails"] = applicationversion_schema.dump(
queryAppVersion).data
return res.getSuccess(data=apps)
def get(self, appversionId):
queryAppVersion = ApplicationVersion.query.filter_by(
id=appversionId).first()
if not queryAppVersion:
return res.resourceMissing(
"No version record {} exists.".format(appversionId))
appVersion, error = applicationversion_schema.dump(queryAppVersion)
if error:
return res.internalServiceError(error)
queryApp = Application.query.filter_by(id=queryAppVersion.app).first()
if not queryApp:
return res.resourceMissing("App {} does not exist.".format(
queryAppVersion.app))
appVersion["appDetails"] = application_schema.dump(queryApp).data
return res.getSuccess(data=appVersion)
def post(self):
data = request.get_json()
if not data or not data.get("firstname") or not data.get("lastname") or not data.get("username") or not data.get("password"):
return res.badRequestError("Missing information to process account creation.")
# check username is unique
query = Account.query.filter_by(username=data.get("username")).first()
if query:
return res.resourceExistsError("Username {} already taken.".format(data.get("username")))
newAccountDetails = {"firstname": data.get("firstname"), "lastname": data.get("lastname"), "username": data.get("username"), "password": data.get("password") }
newAccount, error = account_schema.load(newAccountDetails)
if error:
return res.internalServiceError(error)
db.session.add(newAccount)
db.session.commit()
return res.postSuccess("Account succesfully created for username {}.".format(newAccount.username), account_schema.dump(newAccount).data)
def get(self, accountId):
appRequestServ = requests.get(app.config['APPREQUEST_SERVICE'] +
"customer/{}".format(accountId)).json()
print(json.dumps(appRequestServ))
if "success" not in appRequestServ["status"]:
return res.internalServiceError("Sorry :(")
allRequests = appRequestServ["data"]
applications = []
for req in allRequests:
queryAppVersion = ApplicationVersion.query.filter_by(
id=req["appversion"]).first()
queryApp = Application.query.filter_by(
id=queryAppVersion.app).first()
thisapp = application_schema.dump(queryApp).data
thisapp["appversionDetails"] = applicationversion_schema.dump(
queryAppVersion).data
applications.append(thisapp)
return res.getSuccess(data=applications)
def post(self):
data = request.get_json()
print(request.files)
print(data)
if not data or not data.get("accountId") or not data.get(
"author") or not data.get("appName"):
return res.badRequestError("Missing data to process request")
# Checks if app name already exists
query = Application.query.filter_by(
appname=data.get('appName')).first()
if query is not None:
return res.resourceExistsError("App name {} already taken".format(
data.get('appName')))
# Validates and saves app data given
appDetails = {
"appname": data.get('appName'),
"author": data.get("author"),
"description": data.get('appDescription')
}
newApp, error = application_schema.load(appDetails)
if error:
return res.badRequestError(error)
db.session.add(newApp)
db.session.commit()
# Create app directory
ServUtil.createAppDir(
os.path.join(app.config["UPLOAD_FOLDER"], newApp.appname))
# Add permission to developer over created application
linked, msg = ServUtil.addDevelopertoApp(
db, {
"appid": newApp.id,
"accountid": data.get("accountId")
})
if not linked:
return res.internalServiceError(msg)
return res.postSuccess(
"Succesfully created application {}.".format(newApp.appname),
application_schema.dump(newApp).data)
def get(self, caruserId):
queryCarUser = CarUser.query.filter_by(id=caruserId).first()
# Verifies car and customer registration exists
if not queryCarUser:
return res.resourceMissing("No data found for car registration.")
queryCar = Car.query.filter_by(id=queryCarUser.car).first()
# Verifies car type data is available on database
# (if fails this is an internal error, because data from model was deleted from database)
if not queryCar:
return res.resourceMissing("No data found for car type {}.".format(
queryCarUser.car))
caruser, error = caruser_schema.dump(queryCarUser)
if error:
return res.internalServiceError(error)
caruser["cardetails"] = car_schema.dump(queryCar).data
return res.getSuccess(
"Succesfully retrieved data for customer car registered.", caruser)
def post(self):
data = request.get_json()
#print(data)
if not data or not data.get("versionNumber") or not data.get(
"checksum") or not data.get("accountId") or not data.get(
"appversionId") or not data.get(
"requestType") or not data.get("appName"):
return res.badRequestError("Missing data to create app request")
requestDetails = {
"developer": data.get("accountId"),
"appversion": data.get("appversionId"),
"requesttype": data.get("requestType")
}
appRequest, error = apprequest_schema.load(requestDetails)
print(appRequest)
if error:
return res.internalServiceError(error)
db.session.add(appRequest)
db.session.commit()
kabascript = "/nfs/2017/d/dmontoya/42/fordappstore/infrastructure/containers/raspbian/kabascriptest.sh" # using test kaba for nows
# sh run.sh App.zip ya-ya b7709364cb0e7a86416f17fa3ff35b903077e8fa9e94c7e580ad7d57d5a6d509 1
appName = data.get("appName")
appName = appName.replace(' ', '\ ')
appZipPath = os.path.join(app.config["UPLOAD_FOLDER"], appName,
data.get("versionNumber"), "App.zip")
appandversion = "{}-{}".format(data.get("appName"),
data.get("versionNumber"))
print(data.get("checksum"))
print(kabascript)
print(appandversion)
print(appZipPath)
print(str(appRequest.id))
subprocess.call([
"sh", kabascript, appZipPath, appandversion,
data.get("checksum"),
str(appRequest.id)
])
return res.postSuccess("Request succesfully created.",
apprequest_schema.dump(appRequest).data)
def get(self, accountId):
queryCarUser = CarUser.query.filter_by(account=accountId).all()
if not queryCarUser:
return res.resourceMissing(
"No cars registered under account {}.".format(accountId))
usercars, error = carusers_schema.dump(queryCarUser)
if error:
return res.internalServiceError(error)
customerCars = []
for usercar in usercars:
car = Car.query.filter_by(id=usercar["car"]).first()
if not car:
return res.resourceMissing("No data found for car {}.".format(
usercar["car"]))
usercar["carDetails"] = car_schema.dump(car).data
queryCarModel = CarModel.query.filter_by(id=car.carmodel).first()
if queryCarModel:
usercar["carDetails"][
"carmodelDetails"] = carmodel_schema.dump(
queryCarModel).data
customerCars.append(usercar)
return res.getSuccess(
"Cars registered under account {}.".format(accountId),
customerCars)
def post(self, appId):
data = request.form
print(data)
print(request.files)
# Verifies data required was sent in request
if not data or not data.get("appName") or not data.get(
"versionNumber") or not data.get("checksum") or not data.get(
"versionDescription"):
return res.badRequestError("Missing data to process request.")
# Verifies app version file was sent in request
if 'file' not in request.files:
return res.badRequestError("Missing app file.")
file = request.files['file']
if "icon" not in request.files:
return res.badRequestError("Send me an icon.")
icon = request.files['icon']
iconPath = os.path.join(app.config["UPLOAD_FOLDER"],
data.get("appName"), "Icon")
print(iconPath)
saved, msg = ServUtil.saveIcon(icon, iconPath)
if not saved:
return res.internalServiceError(msg)
checksum = ServUtil.checksum_sha256(file)
if data.get("checksum") == checksum:
print("good checksum")
else:
return res.badRequestError("File corrupted.")
file.seek(0)
# Verifies app exists
queryApp = Application.query.filter_by(id=appId).first()
if not queryApp:
return res.resourceMissing("App {} not found.".format(appId))
queryAppVersion = ApplicationVersion.query.filter_by(
app=appId, version=data.get("versionNumber")).first()
if queryAppVersion:
return res.resourceExistsError(
"Duplicate {} v.{} has already been submitted for review.".
format(queryApp.appname, queryAppVersion.version))
# Validates data and creates application version
appVersionDetails = {
"app": appId,
"version": data.get("versionNumber"),
"description": data.get("versionDescription")
}
newappVersion, error = applicationversion_schema.load(
appVersionDetails)
if error:
return res.internalServiceError(error)
db.session.add(newappVersion)
db.session.commit()
# Saves version files
saved, msg = ServUtil.saveinAppVersion(app, file, data)
if not saved:
return res.internalServiceError(message=msg)
return res.postSuccess(
"{} v.{} successfully created !".format(queryApp.appname,
newappVersion.version),
applicationversion_schema.dump(newappVersion).data)
