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, adminId):
# Verifying data required was given
data = request.get_json()
if not data or not data.get("vin") or not data.get(
"carmodel") or not data.get("raspbpi"):
return res.badRequestError("Missing data to process POST request.")
# Verifying vin number is not duplicated
queryvin = Car.query.filter_by(vin=data.get("vin")).first()
if queryvin:
return res.resourceExistsError("VIN {} already registered.".format(
data.get("vin")))
# Verifying raspberry pi is not duplicated
querypi = Car.query.filter_by(raspbpi=data.get("raspbpi")).first()
if querypi:
return res.resourceExistsError(
"Raspberrypi {} already linked to car {}".format(
data.get("raspbpi"), querypi.id))
# Adding Car to Database
newCarDetails = {
"vin": data.get("vin"),
"carmodel": data.get("carmodel"),
"raspbpi": data.get("raspbpi")
}
newCar, error = car_schema.load(newCarDetails)
if error:
return res.badRequestError(error)
db.session.add(newCar)
db.session.commit()
return res.postSuccess("Successful car added to database.", newCar)
def post(self):
openid = None
try:
request = json.loads(self.request.body.decode())
id = request.get('id', None)
openid = request.get('openid', None)
if openid is None:
raise AttributeError
if id is None:
user = yield dbutil.do(
User.select(User.id).where(User.openid == openid).get)
id = user.get_id()
modified_user = shortcuts.dict_to_model(User,
request,
ignore_unknown=True)
modified_user.set_id(id)
yield dbutil.do(modified_user.save)
self.write(Response(status=1, msg='ok', result={}).json())
except AttributeError as e:
self.write(Response(msg='sorry，亲，修改用户信息时必须包含openid').json())
logging.exception('UpdateUserInfoHandler error: {0}'.format(
str(e)))
except DoesNotExist as e:
self.write(
Response(msg='sorry，亲，用户不存在 openid={0}'.format(openid)).json())
logging.exception('UpdateUserInfoHandler error: {0}'.format(
str(e)))
except Exception as e:
self.write(Response(msg='sorry，亲，修改用户信息失败').json())
logging.exception('UpdateUserInfoHandler error: {0}'.format(
str(e)))
def post(self):
try:
param = json.loads(self.request.body.decode())
url = urllib.request.unquote(param['url'])
if url.find('#') != -1:
url = url[0:url.index('#')]
jsapi_ticket = yield wxutil.get_jsapi_ticket()
noncestr = self.random_str()
timestamp = int(time.time())
param = {
'url': url,
'timestamp': timestamp,
'jsapi_ticket': jsapi_ticket,
'noncestr': noncestr
}
tmp_str = '&'.join([
'{0}={1}'.format(key, param[key])
for key in sorted(param.keys())
])
sha1 = hashlib.sha1(tmp_str.encode()).hexdigest()
del param['jsapi_ticket']
param['signature'] = sha1
config = yield dbutil.do(Config.get)
param['appid'] = config.appid
self.write(Response(status=1, msg='ok', result=param).json())
except Exception as e:
self.write(Response(msg='sorry，亲，js api签名失败').json())
logging.exception('GetUserInfoHandler error: {0}'.format(str(e)))
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 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 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 post(self, request):
"""
Execute app from user
---
response_serializer: api.serializers.ResultSerializer
parameters:
- name: app
type: integer
- name: params
type: string
"""
form = AppExecuteForm(request.POST)
if not form.is_valid():
return HttpResponseBadRequest()
data = form.cleaned_data
app = data['app']
if not request.user.userapp_set.filter(app=app).count():
return Response(
{
'errors': [{
'code':
'NOT_OWN_APP_EXECUTION',
'message':
'You need to own this application before using it.',
}],
},
status=status.HTTP_401_UNAUTHORIZED)
result = Result.objects.create(app=app, user=request.user)
execute_app.delay(result.id, json_params=data['json_params'])
return Response({'result': result})
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, 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 api_login(request):
"""
Function used for API login validation and authentication
(:http:post:`POST </accounts/login>`). There are two required parameters.
.. http:post:: /accounts/login
:DC-bound?:
* |dc-no|
:Permissions:
* |APIAccess|
:Asynchronous?:
* |async-no|
:arg string data.username: **required** - Username used for authentication
:arg string data.password: **required** - Password used for authentication
:status 200: Login successful
:status 400: Bad request
"""
serializer = APIAuthTokenSerializer(data=request.data)
if serializer.is_valid():
user = serializer.object['user']
token, created = Token.objects.get_or_create(user=user)
if not created: # Old Token - regenerate token and datetime
# TODO: We do this by deleting the old token (could be done better)
token.delete()
token = Token.objects.create(user=user)
auth_logger.info('User %s successfully logged in from %s (%s)', user,
get_client_ip(request),
request.META.get('HTTP_USER_AGENT', ''))
request.user = user
request.dc = Dc.objects.get_by_id(user.current_dc_id)
return Response(
{
'token': token.key,
'expires': (token.created + AUTHTOKEN_TIMEDELTA).isoformat(),
'detail': 'Welcome to Danube Cloud API.'
},
status=scode.HTTP_200_OK,
request=request)
auth_logger.warning('User %s login failed from %s (%s)',
request.data.get('username', None),
get_client_ip(request),
request.META.get('HTTP_USER_AGENT', ''))
try:
error_message = serializer.errors['non_field_errors'][0]
except (KeyError, IndexError):
error_message = serializer.errors
return Response({'detail': error_message},
status=scode.HTTP_400_BAD_REQUEST)
def post(self):
try:
request = json.loads(self.request.body.decode())
code = request['code']
logging.debug('code: {0}'.format(code))
result = yield event_service.query_fulltext_code(code)
self.write(Response(status=1, msg='ok', result=result).json())
except Exception as e:
self.write(Response(msg='sorry，亲，查询活动失败').json())
logging.exception('GetEventHandler error: {0}'.format(str(e)))
def get():
try:
data = get_leaderboards()
return Response.success(status=200,
message="Successful GET of page",
data=data)
except Exception as err:
return Response.server_error(
status=400, # TODO: Create proper status for server error
message="Server Error: {}".format(err))
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 put(self, requestId):
data = request.get_json()
if not data or not data.get("action"):
return res.badRequestError(
"Missing data to proccess action on app request")
if data.get("action") < 1 or data.get(
"action") > 5: # ********* too hardcoded change later
return res.badRequestError("Invalid Action")
apprequest = AppRequest.query.filter_by(id=requestId).first()
apprequest.status = data.get("action")
return res.putSuccess(
"Succesfully submitted action for request {}.".format(requestId))
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 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):
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 exception_handler(exc, request=None):
"""
Returns the response that should be used for any given exception.
By default we handle the REST framework `APIException`, and also
Django's builtin `Http404` and `PermissionDenied` exceptions.
Any unhandled exceptions may return `None`, which will cause a 500 error
to be raised.
"""
if isinstance(exc, exceptions.APIException):
headers = {}
if getattr(exc, 'auth_header', None):
# noinspection PyUnresolvedReferences
headers['WWW-Authenticate'] = exc.auth_header
if getattr(exc, 'wait', None):
# noinspection PyUnresolvedReferences
headers['Retry-After'] = '%d' % exc.wait
if isinstance(exc.detail, (list, dict)):
data = exc.detail
else:
data = {'detail': exc.detail}
set_rollback()
return Response(data,
status=exc.status_code,
headers=headers,
request=request)
elif isinstance(exc, Http404):
msg = _('Not found')
data = {'detail': six.text_type(msg)}
set_rollback()
return Response(data,
status=status.HTTP_404_NOT_FOUND,
request=request)
elif isinstance(exc, PermissionDenied):
msg = _('Permission denied')
data = {'detail': six.text_type(msg)}
set_rollback()
return Response(data,
status=status.HTTP_403_FORBIDDEN,
request=request)
# Note: Unhandled exceptions will raise a 500 error.
return None
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):
try:
data = json.loads(self.request.body.decode())
code = data['eventcode']
openid = data['openid']
star = yield dbutil.do(
Star.select().where((Star.eventcode == code)
& (Star.openid == openid)).get)
star.status = -1
star.updatetime = datetime.datetime.now()
yield dbutil.do(star.save)
self.write(Response(status=1, msg='ok', result={}).json())
except Exception as e:
self.write(Response(msg='sorry，亲，取消关注活动失败').json())
logging.exception('UnStarEventHandler error: {0}'.format(str(e)))
def post(self):
body = request.json
Logger.info("A user as been registered (%s, %s).",
body["username"], body["email"])
return Response.success(body, status=201)
def get(self):
return Response.success({
"description": f"{variables.SERVICE_LABEL} API "
f"{variables.V1_NAMESPACE}",
"status": "online",
"version": variables.V1_VERSION
})
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 options(self, request, *args, **kwargs):
"""
Handler method for HTTP 'OPTIONS' request.
We may as well implement this as Django will otherwise provide
a less useful default implementation.
"""
return Response(self.metadata(request), status=status.HTTP_200_OK)
class ResultSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = models.Result
fields = ('id', )
class UserAppSerializer(serializers.ModelSerializer):
app = AppDetailSerializer(read_only=True)
class Meta:
model = models.UserApp
fields = ('id', 'user', 'app', 'expires', 'expires_str')
class OrderSerializer(serializers.ModelSerializer):
class Meta:
model = models.Order
fields = ('id', 'user', 'website', 'steps', 'email', 'price')
class UserSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = get_user_model()
fields = ('id', 'username')
Response.register_serializers(AppSerializer, AppDetailSerializer, ResultSerializer, UserAppSerializer,
UserSerializer)
