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, 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, 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 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, 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):
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, 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, 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, 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 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 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 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):
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 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)
