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 get(self, requestId):
queryAppRequest = AppRequest.query.filter_by(id=requestId).first()
if not queryAppRequest:
return res.resourceMissing(
"No data found for app request #{}.".format(requestId))
return res.getSuccess(
data=apprequest_schema.dump(queryAppRequest).data)
def get(self):
queryAppRequests = AppRequest.query.filter(
AppRequest.customer == 0).filter(AppRequest.status == 1
or AppRequest.status == 2).all()
if not queryAppRequests:
return res.resourceMissing("No app requests penging found.")
return res.getSuccess(apprequests_schema.dump(queryAppRequests).data)
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 delete(self, accountId):
queryAccount = Account.query.filter_by(id=accountId).first()
if not queryAccount:
return res.resourceMissing("No account with id {} was found.".format(accountId))
queryAccount.active = False
db.session.commit()
return res.deleteSuccess("Account {} with username {} deleted.".format(accountId, queryAccount.username))
def put(self, appversionId):
data = request.get_json()
#print (data)
#print(data["status"])
print(data.get("status"))
# Validates request data
if not data or not data["status"]:
return res.badRequestError("Missing data to proccess request.")
if (int(data.get("status")) < 1 or int(data.get("status")) > 5):
return res.badRequestError("Invalid status code {}.".format(
data["status"]))
print("passed error")
# Verifies app version exists
queryAppVersion = ApplicationVersion.query.filter_by(
id=appversionId).first()
if not queryAppVersion:
return res.resourceMissing(
"No version record {} exists.".format(appversionId))
queryAppVersion.status = data.get("status")
queryAppVersion.approved = True
print(queryAppVersion.status)
db.session.commit()
return res.putSuccess("Update version {} status to {}.".format(
appversionId, data.get("status")))
def put(self, appversionId):
print(appversionId)
queryAppVersion = ApplicationVersion.query.filter_by(
id=appversionId).first()
queryApp = Application.query.filter_by(id=queryAppVersion.app).first()
# Ensures app exists in database
if not queryAppVersion:
return res.resourceMissing(
"No record with {} found for any app version.".format(
appversionId))
if queryApp.runningversion > queryAppVersion.id:
return res.badRequestError("Running version > than this version.")
# Ensures app is approved
if queryAppVersion.status is not 4:
print("awaiting to be approved")
return res.resourceExistsError(
"App v.{} is still awaiting to be approved.".format(
queryAppVersion.version))
queryApp.runningversion = queryAppVersion.id
queryAppVersion.status = 2
queryApp.active = True
db.session.commit()
return res.putSuccess(
"{} v.{} launched. Now available in MakitiAppStore !".format(
queryApp.appname, queryAppVersion.version))
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 get(self, accountId):
queryCustomerApps = AppRequest.query.filter_by(
customer=accountId).all()
if not queryCustomerApps:
return res.resourceMissing(
"No apps downloaded by customer {}.".format(accountId))
return res.getSuccess(
data=apprequests_schema.dump(queryCustomerApps).data)
def get(self, appId):
queryApp = Application.query.filter_by(id=appId).first()
# Checks application exists
if not queryApp:
return res.resourceMissing("No application found")
return res.getSuccess(data=application_schema.dump(queryApp).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 delete(self, appId):
queryApp = Application.query.filter_by(id=appId).first()
# Checks application exists in database
if not queryApp:
return res.resourceMissing("No application found.")
queryApp.active = False
db.session.commit()
return res.deleteSuccess(
"{} succesfully removed from Makiti App Store".format(
queryApp.appname),
application_schema.dump(queryApp).data)
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 post(self):
# Verifying request body is not empty
data = request.get_json()
if not data or not data.get("username") or not data.get("password"):
return res.badRequestError("Missing information to login user.")
# Verifies user exists in database
query = Account.query.filter_by(username=data.get("username")).first()
if not query:
return res.badRequestError("Incorrect login information.")
if query.active == False:
return res.badRequestError("This account is deactivated.")
if query.password != data.get("password"):
return res.resourceMissing("Incorrect password for user {}.".format(query.username))
return res.postSuccess(data=account_schema.dump(query).data)
def get(self, appId):
data = request.get_json()
if not data:
return res.badRequestError("Missing data to process request.")
queryApp = Application.query.filter_by(id=appId).first()
if not queryApp:
return res.badRequestError("App {} does not exist.".format(appId))
queryAppVersions = ApplicationVersion.query.filter_by(app=appId).all()
if not queryAppVersions:
return res.resourceMissing("No versions found for app {}.".format(
queryApp.appname))
return res.getSuccess(
data=applicationversions_schema.dump(queryAppVersions).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 get(self, appId):
print("innnnnnnnnnnnnn")
# png_output = StringIO()
# data = png_output.getvalue().encode('base64')
# data_url = 'data:image/png;base64,{}'.format(urllib.parse.quote(data.rstrip('\n')))
queryApp = Application.query.filter_by(id=appId).first()
if not queryApp:
return res.resourceMissing("App {} does not exist.")
iconPath = os.path.join(app.config["UPLOAD_FOLDER"], queryApp.appname,
"Icon")
print(iconPath)
onlyfiles = [f for f in listdir(iconPath) if isfile(join(iconPath, f))]
if len(onlyfiles) == 0:
return res.badRequestError("No icons for app {}.".format(appId))
iconfilePath = os.path.join(iconPath, onlyfiles[0])
print(iconfilePath)
with open(iconfilePath, "rb") as imageFile:
stri = base64.b64encode(imageFile.read())
return res.getSuccess(data=json.dumps(stri.decode('utf-8')))
def put(self, appId):
data = request.get_json()
if not data:
return res.badRequestError("No data provided to update.")
queryApp = Application.query.filter_by(id=appId).first()
# Checks application exists in database
if not queryApp:
return res.resourceMissing("No application found.")
# Saves app description (if provided)
if data.get('description'):
queryApp.description = data.get('description')
db.session.commit()
return res.getSuccess(
"{} successfully updated.".format(queryApp.appname),
application_schema.dump(queryApp).data)
def put(self, accountId):
data = request.get_json()
if not data:
return res.badRequestError("No data to update for account {}.".format(accountId))
queryAccount = Account.query.filter_by(id=accountId).first()
if not queryAccount:
return res.resourceMissing("No account with id {} was found.".format(accountId))
if "customer" in data.keys():
queryAccount.customer = not queryAccount.customer
db.session.commit()
return res.putSuccess("Account {} has customer priviledges.".format(accountId))
if "developer" in data.keys():
queryAccount.developer = not queryAccount.developer
db.session.commit()
return res.putSuccess("Account {} has developer priviledges.".format(accountId))
if "admin" in data.keys():
queryAccount.admin = not queryAccount.admin
db.session.commit()
return res.putSuccess("Account {} has admin priviledges.".format(accountId))
return res.badRequestError("No data to update for account {}.".format(accountId))
def get(self):
queryAccounts = Account.query.filter_by(active=True).all()
if not queryAccounts:
return res.resourceMissing("No accounts found.")
return res.getSuccess(data=accounts_schema.dump(queryAccounts).data)
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)
def get(self, accountId):
query = Account.query.filter_by(id=accountId).first()
if not query:
return res.resourceMissing("No account with id {} was found.".format(accountId))
return res.getSuccess(data=account_schema.dump(query).data)
