login token and privilege check logic

+# -*- coding: utf-8 -*-
+
+
+from flask import request
+
+from server.database import db_adapter
+from server.database.models import User, UserToken
+from server.utils import get_now
+from server.utils.api_response import unauthorized, forbidden
+
+
+def token_required(func):
+    """
+    User must login when this decorator is enabled
+    (for both user and admin)
+    """
+    def authenticate_and_call(*args, **kwargs):
+        if not __validate_token():
+            return unauthorized("login required")
+        return func(*args, **kwargs)
+
+    # keep the original func name for API intput/output validation
+    # where original name is required
+    authenticate_and_call.original = func.__name__
+    if hasattr(func, "original"):
+        authenticate_and_call.original = func.original
+
+    return authenticate_and_call
+
+
+def admin_privilege_required(func):
+    """
+    user must login , hackathon_name must be available,
+    and 'user' has proper admin privilege on this hackathon
+    """
+
+    def authenticate_and_call(*args, **kwargs):
+        user = __validate_token()
+        if not user:
+            return unauthorized("login required")
+
+        if not user.role == 'admin':
+            return forbidden("Permission denied need admin role")
+
+        return func(*args, **kwargs)
+
+    # keep the original func name for API intput/output
+    # validation where original name is required
+    authenticate_and_call.original = func.__name__
+    if hasattr(func, "original"):
+        authenticate_and_call.original = func.original
+
+    return authenticate_and_call
+
+
+def __validate_token():
+    if 'token' not in request.headers:
+        return False
+
+    t = db_adapter.find_first_object_by(UserToken,
+                                        token=request.headers['token'])
+    if not t or t.expire_date <= get_now():
+        return False
+
+    return t.user

@@ -19,4 +19,4 @@ Base = declarative_base()
 Base.query = db_session.query_property()
 Base.query = db_session.query_property()
 db_adapter = SQLAlchemyAdapter(db_session)
 db_adapter = SQLAlchemyAdapter(db_session)
 
 
-from models import *
\ No newline at end of file
+from models import *

@@ -6,6 +6,8 @@ from . import Base, db_adapter
 from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Text, TypeDecorator
 from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Text, TypeDecorator
 from sqlalchemy.orm import relation, backref
 from sqlalchemy.orm import relation, backref
 
 
+from server.utils import get_now
+
 
 
 def relationship(*arg, **kw):
 def relationship(*arg, **kw):
     ret = relation(*arg, **kw)
     ret = relation(*arg, **kw)
@@ -56,78 +58,32 @@ class DBBase(Base):
         return '%s: %s' % (self.__class__.__name__, self.json())
         return '%s: %s' % (self.__class__.__name__, self.json())
 
 
 
 
-class Host(DBBase):
-    __tablename__ = 'host'
-
-    id = Column(Integer, primary_key=True)
-    hostname = Column(String(50), unique=True, nullable=False)
-    public_ip = Column(String(50), unique=True, nullable=False)
-    private_ip = Column(String(50), unique=True, nullable=False)
-    mem = Column(String(50), nullable=False)
-    cores = Column(Integer, nullable=False)
-    disk = Column(String(50), nullable=False)
-    create_time = Column(DateTime, nullable=False)
-    update_time = Column(DateTime)
-
-
-class VM(DBBase):
-    __tablename__ = 'vm'
+class User(DBBase):
+    __tablename__ = 'user'
 
 
     id = Column(Integer, primary_key=True)
     id = Column(Integer, primary_key=True)
-    vm_name = Column(String(50), unique=True, nullable=False)
-    os_type = Column(String(50), nullable=False)  # constants 0:linux 1:windows
-    cores = Column(Integer, nullable=False)
-    mem = Column(String(50), nullable=False)
-    capacity_g = Column(Integer, nullable=False)
-    config = Column(String(50))
-    user = Column(String(50), nullable=False)
-    create_time = Column(DateTime, nullable=False)
-    update_time = Column(DateTime)
-
-    image_id = Column(Integer, ForeignKey('image.id', ondelete='CASCADE'))
-    image = relationship('Image', backref=backref('images_vms', lazy='dynamic'))
-
-    host_id = Column(Integer, ForeignKey('host.id', ondelete='CASCADE'))
-    host = relationship('Host', backref=backref('host_vms', lazy='dynamic'))
-
+    name = Column(String(64))
+    password = Column(String(128))
+    role = Column(String(16))
+    status = Column(String(32))
+    create_time = Column(DateTime, default=get_now())
+    last_login_time = Column(DateTime, default=get_now())
 
 
-class Network(DBBase):
-    __tablename__ = "network"
-
-    id = Column(Integer, primary_key=True)
-    mac = Column(String(50), unique=True, nullable=False)
-    type = Column(String(50), nullable=False)  # constants 0:public 1:private
-    address = Column(String(50), unique=True, nullable=False)
-    device = Column(String(50), nullable=False)
-    create_time = Column(DateTime, nullable=False)
-    update_time = Column(DateTime)
-
-    vm_id = Column(Integer, ForeignKey('vm.id', ondelete='CASCADE'))
-    vm = relationship('VM', backref=backref('networks', lazy='dynamic'))
+    def __init__(self, **kwargs):
+        super(User, self).__init__(**kwargs)
 
 
 
 
-class Disk(DBBase):
-    __tablename__ = "disk"
+class UserToken(DBBase):
+    __tablename__ = 'user_token'
 
 
     id = Column(Integer, primary_key=True)
     id = Column(Integer, primary_key=True)
-    type = Column(Integer, nullable=True)  # constants 0:system 1:mounted
-    capacity_g = Column(Integer, nullable=False)
-    format = Column(Integer, nullable=False)  # constants 0:ntfs 1:ext4
-    path = Column(String(50), unique=True, nullable=False)
-    create_time = Column(DateTime, nullable=False)
-    update_time = Column(DateTime)
+    token = Column(String(64), unique=True, nullable=False)
 
 
-    vm_id = Column(Integer, ForeignKey('vm.id', ondelete='CASCADE'))
-    vm = relationship('VM', backref=backref('disks', lazy='dynamic'))
+    user_id = Column(Integer, ForeignKey('user.id', ondelete='CASCADE'))
+    user = relationship('User', backref=backref('tokens', lazy='dynamic'))
 
 
+    create_time = Column(DateTime, default=get_now())
+    expire_time = Column(DateTime, nullable=False)
 
 
-class Image(DBBase):
-    __tablename__ = "image"
-
-    id = Column(Integer, primary_key=True)
-    name = Column(String(50), unique=True, nullable=False)
-    type = Column(Integer, nullable=True)  # constants 0:default 1:provide 2:customize
-    path = Column(String(50), unique=True, nullable=False)
-    create_by = Column(String(50))
-    create_time = Column(DateTime, nullable=False)
-    update_time = Column(DateTime)
+    def __init__(self, **kwargs):
+        super(UserToken, self).__init__(**kwargs)

+from log import Log
+
+log = Log()

 # -*- coding: utf-8 -*-
 # -*- coding: utf-8 -*-
 
 
-__author__ = 'hubian'
 
 
 import logging
 import logging
 from os.path import realpath, dirname
 from os.path import realpath, dirname
 from logging import config, DEBUG, INFO
 from logging import config, DEBUG, INFO
 
 
+
 class Log(object):
 class Log(object):
     """Wrapper of Python logging module for easier usage
     """Wrapper of Python logging module for easier usage
 
 
@@ -61,6 +61,9 @@ class Log(object):
         self.logger.critical(critical)
         self.logger.critical(critical)
 
 
     def __init__(self):
     def __init__(self):
-        """initialize the log wrapper through 'logging.conf' file which should be in the same dir of this file"""
+        """
+        initialize the log wrapper through 'logging.conf' file
+        which should be in the same dir of this file
+        """
         logging.config.fileConfig("%s/logging.conf" % dirname(realpath(__file__)))
         logging.config.fileConfig("%s/logging.conf" % dirname(realpath(__file__)))
         self.logger = logging.getLogger("myLogger")
         self.logger = logging.getLogger("myLogger")
\ No newline at end of file

-# -*- coding: utf-8 -*-

+# -*- coding: utf-8 -*-
+
+
+import uuid
+
+from datetime import timedelta
+from flask import request, g
+
+from server.database import db_adapter
+from server.database import models
+from server.log import log
+from server.utils import get_now
+from server.utils.api_response import ok, bad_request, internal_server_error
+
+
+class UserService(object):
+
+    def logout(self, user_id):
+        pass
+
+    def login(self, username, password):
+        user = db_adapter.find_first_object_by(models.User,
+                                               name=username,
+                                               password=password)
+        if not user:
+            return bad_request("login failed")
+        else:
+            user_token = self.__generate_api_token(user)
+            return {
+                "user": user.to_dict(),
+                "token": user_token.token()
+            }
+
+    # --------------- helper private functions ---------------------#
+
+    def __generate_api_token(self, user):
+        token_issue_date = get_now()
+        token_expire_date = token_issue_date + timedelta(minutes=30)
+        user_token = models.UserToken(token=str(uuid.uuid1()),
+                                      user=user,
+                                      expire_date=token_expire_date,
+                                      issue_date=token_issue_date)
+        user_token.save()
+        return user_token

-# -*- coding: utf-8 -*-
-
-__author__ = 'hubian'
-

-# -*- coding: utf-8 -*-
-
-__author__ = 'hubian'
-
-
-class VMManager():
-
-    def create_vm(self):
-        pass
-
-    def update_vm(self):
-        pass
-
-    def delete_vm(self):
-        pass
-
-    def get_vm_list(self):
-        pass
-
-    # ------------------------helper functions ---------------------- #
-
-    def __generate_vm_xml(self):
-        pass

 # -*- coding: utf-8 -*-
 # -*- coding: utf-8 -*-
 
 
 
 
-from factory import factory
+from datetime import datetime
 
 
-from server.database import db_session
-from server.database.db_adapters import SQLAlchemyAdapter
-from server.log.log import Log
-from utils import Utils
 
 
+def get_now():
+    return datetime.now()
 
 
-def init_factory():
-    factory.provide("util", Utils)
-    factory.provide("log", Log)
-    factory.provide("db", SQLAlchemyAdapter, db_session)
 
 
+def get_config():
+    return None
+
+
+def get_safe_config():
+    return None

+# -*- coding: utf-8 -*-
+
+
+from server.log import log
+
+
+# Customize Formatted Response
+# with status code 200 and the real status code and message in body
+
+
+def ok(data=None, message=""):
+    return {
+        "status": "success",
+        "code": 200,
+        "data": data,
+        "message": message
+    }
+
+
+def __response_with_code(code, message, friendly_message=""):
+    log.debug("response with code: %d and message: %s" % (code, message))
+    return {
+        "status": "failed",
+        "code": code,
+        "message": message,
+        "friendly_message": friendly_message
+    }
+
+
+def bad_request(message="",
+                friendly_message=(
+                        'Your request does not make sense'
+                )):
+    return __response_with_code(400, message, friendly_message)
+
+
+def unauthorized(message="",
+                 friendly_message=(
+                         'Please login to get a valid token')):
+    return __response_with_code(401, message, friendly_message)
+
+
+def forbidden(message="",
+              friendly_message=(
+                      'You don\'t have the permission to access the request')):
+    return __response_with_code(403, message, friendly_message)
+
+
+def not_found(message="",
+              friendly_message=(
+                      'The requested URL was not found on the server.')):
+    return __response_with_code(404, message, friendly_message)
+
+
+def internal_server_error(message="",
+                          friendly_message=(
+                                  'Encountered an internal error ,'
+                                  'unable to complete your request.'
+                                  'Either the server is overloaded or there '
+                                  'is an error in the application.'
+                          )):
+    return __response_with_code(500, message, friendly_message)
+
+
+

-# -*- coding: utf-8 -*-
-
-
-from datetime import datetime
-
-
-def get_now():
-    return datetime.now()
-
-
-def get_config():
-    return None
-
-
-def get_safe_config():
-    return None