tabbit

Wed Nov 09 2016
Copied to clipboard! Copy reply
#import sys
#sys.path.append('./')
import os
from json import dumps as jsonify
from json import loads as unjsonify
#import datetime


import webapp2
#from google.appengine.api import memcache, app_identity

from webapp2_extras import sessions, sessions_memcache, sessions_ndb
import jinja2
import MySQLdb

# Bucket ops
import cloudstorage as gcs
from google.appengine.ext import ndb
from google.appengine.api import memcache, app_identity
from imghdr import what as getmime

from slugify import slugify

from models.db import DB
from models.tables import Tables


# Simply initialize our SQLAlchemy models
tables = Tables()

#CLOUDSQL_PROJECT = 'fcheckus'
#CLOUDSQL_INSTANCE = 'fcheckus:us-east1:fcheck'

def nl2br(value): 
  split = value.split('\n')
  return jinja2.Markup('<br>').join(split)
  


jinja_env = jinja2.Environment(
  loader=jinja2.FileSystemLoader(os.path.dirname(__file__) + '/templates/'),
  extensions=['jinja2.ext.autoescape'],
  autoescape=True)

jinja_env.filters['nl2br'] = nl2br





class BaseHandler(webapp2.RequestHandler):
  def dispatch(self):
    self.session_store = sessions.get_store(request=self.request)
    try:
      webapp2.RequestHandler.dispatch(self)
    finally:
      self.session_store.save_sessions(self.response)

  @webapp2.cached_property
  def session(self):
    return self.session_store.get_session(name='fcheck', max_age=31104000, backend='datastore')


  def render(self, template, templatedata = {}, spfdata = {}, spf=''):
    template = jinja_env.get_template(template + '.html')
    
    if self.session.get('name'):
      templatedata['first_name'] = self.session.get('name').split(' ')[0]
      print '----'
      print templatedata['first_name'] 

    if spf:
      templatedata['full'] = False
      spfdata['body'] = {'content': template.render(**templatedata) }
      return jsonify(spfdata)
    else:
      return template.render(**templatedata)


class Home(BaseHandler):

  def get(self):
    templatedata, spfdata  =  ({'full' : True}, {})
    spfdata['title'] = '$ fcheck /'
    
    db = DB(tables)
    sets = db.set_get_all()
    
    templatedata['sets'] = [
      {
        "id": set[0],
        "name": set[1],
        "slug": set[2]
      } 
      for set in sets
    ]

    self.response.write(self.render('index', templatedata, spfdata, self.request.get('spf')))


class SetCreate(BaseHandler):
  def get(self):
    templatedata, spfdata  =  ({'full' : True}, {})
    spfdata['title'] = 'Create a set of QA tasks'

    if not self.session.get('email'):
      webapp2.redirect('/', abort=True)
      return

    self.response.write(self.render('set-create', templatedata, spfdata, self.request.get('spf')))


class SetView(BaseHandler):
  def get(self, id, slug): #TODO remove these args
    templatedata, spfdata  =  ({'full' : True}, {})
    
    db = DB(tables)
    set = db.set_get_one(id)
    urls = db.urls_get_by_set_id(id)
    #issues = db.issues_get_by_url_id(url_id)
    #comments = db.comments_get_by_issue_id(issue_id)
    urls = [
    {
      'id': url['id'], 
      'url': url['url'], 
      'issues': [
      {
        'id': issue['id'], 
        'description': issue['description'], 
        'status': issue['status'], 
        'author': issue['author'],
        'insert_date': issue['insert_date'],
        #'comments': [
        #  {
        #    'id': comment['id'],
        #    'comment': comment['comment'],
        #    'author': comment['author'],
        #    'insert_date': comment['insert_date']
        #  } for comment in db.comments_get_by_issue_id(issue['id'])
        #]
      } for issue in db.issues_get_by_url_id(url['id'])
    ]} for url in urls]
    
    #[{'id': str(result[0]), 'url':result[1]} for result in results.fetchall()]
    

    
    templatedata['name'] = set[1]
    templatedata['description'] = set[3]
    templatedata['urls'] = urls
    
    self.response.write(self.render('set-view', templatedata, spfdata, self.request.get('spf')))

  def post(self):
    pass


class Dashboard(BaseHandler):

  def get(self):
    templatedata, spfdata  =  ({'full' : True}, {})
    spfdata['title'] = '$ fcheck : Dashboard'
    self.response.write(self.render('dashboard', templatedata, spfdata, self.request.get('spf')))

class APISetCreate(BaseHandler):
  def get(self):
    pass

  def post(self):
    

    if not self.session.get('email'):
      
      return

    try:
      name = self.request.get('name')
      urls = self.request.get('urls')
      description = self.request.get('description')
      qaers = self.request.get('qaers')            
    except:
      self.response.write( jsonify({'result':'error', 'message': 'couldnt create set'}) )
      return

    db = DB(tables)
    
    slug_name = slugify(name)
    last_id = db.set_insert(name, slug_name , description, qaers, self.session.get('name'))
    if last_id:
      urls_list = urls.split('\n')
      urls = []
      for url in urls_list:
        urls.append({'url' : url.strip(), 'set_id' : last_id})

      db.urls_insert(last_id, urls)   

    self.response.write( jsonify({'result':'success', 'set_id': last_id, 'slug': slug_name}) )


class APIUrlFetch(BaseHandler):
  def get(self, set_id):
    """
    Fetches urls and their issuses (with their comments).
    @param set_id: The Set's ID the urls belong to
    """    
    db = DB(tables)
    all_urls = db.urls_get_by_set_id(set_id)
    
    
    #issues = db.issues_get_by_url_id(url_id)
    #comments = db.comments_get_by_issue_id(issue_id)
    urls = [
    {
      'id': url['id'], 
      'url': url['url'], 
      'issues': [
      {
        'id': issue['id'], 
        'description': issue['description'], 
        'status': issue['status'], 
        'author': issue['author'],
        'comments': db.comments_get_by_issue_id(issue['id'])
        #'insert_date': issue['insert_date'],
        
      } for issue in db.issues_get_by_url_id(url['id'])
    ]} for url in all_urls]
    
    self.response.write( jsonify({'result': 'success', 'payload':urls}) )

  def post(self):
    pass


class APIIssueCreate(BaseHandler):
  def get(self):
    pass

  def post(self):
    url_id = self.request.get('urlid')
    description = self.request.get('description')
    files = self.request.POST.getall('files[]')    
    
    # Store bucket filespaths here - will go into database
    db_files = []

    # TODO sanitize file name
    if files:
      bucket = os.environ.get('BUCKET_NAME', app_identity.get_default_gcs_bucket_name())
      

      for f in files:
        filename = f.filename
        content = f.file.getvalue()      
        bucket_filepath = '/%s/%s' % (bucket, filename)  
        gcs_file = gcs.open(bucket_filepath, 'w', options={'x-goog-acl': 'public-read'})
        gcs_file.write(content)
        gcs_file.close()
        gcs_url = 'https://storage.googleapis.com/%(bucket)s/%(file)s' % {'bucket':bucket, 'file':f.filename}
        db_files.append(gcs_url)

    
    # TODO validate above
    if len(description) < 5:
      self.response.write( jsonify({'result':'error', 'payload': 'description is too short'}) )
      return
    
    db = DB(tables)
    if db.issues_insert(url_id, description):
      self.response.write( jsonify({'result':'success', 'payload': {
        'url_id': url_id, 'description': description, 'author': 'mmanii', 'comments': []
      }}) )
    else:
      self.response.write( jsonify({'result':'error', 'payload': 'couldnt create issue'}) )


class APICommentCreate(BaseHandler):
  def get(self):
    pass

  def post(self):
    issue_id = self.request.get('issueId')
    comment = self.request.get('comment')    

    if len(comment) < 2:
      self.response.write( jsonify({'result':'error', 'payload': 'description is too short'}) )
      return

    if issue_id == None:
      return

    db = DB(tables)
    if db.comment_insert(issue_id, comment, 'mani'):
      self.response.write(jsonify({
        'result':'success',
        'payload': {
          'issue_id': issue_id,
          'comment': comment,
          'author': 'mmanii'
          }
        })
      )
      
    else:
      self.response.write(jsonify({
        'result':'error',
        'payload': 'could not add your comment'
      }))


class APIStatusUpdate(BaseHandler):
  def get(self):
    pass

  def post(self):

    issue_id = self.request.get('issueid')
    status = self.request.get('status')
    print '-----'
    print issue_id
    print status
    print '------'
    valid_statuses = ['open', 'ignore', 'fixed', 'worked on', 'not fixed']
    if status not in valid_statuses or issue_id == None or not issue_id.isdigit():
      self.response.write( jsonify({'result':'error', 'payload': 'invalid status'}) )
      return

    


    db = DB(tables)
    if db.status_update(issue_id, status):
      self.response.write( jsonify({'result':'success'}) )
      
    else:
      self.response.write( jsonify({'result':'error', 'payload': 'could not add your comment'}) )


class Login(BaseHandler):
  def get(self):
    templatedata, spfdata  =  ({'full' : True}, {})
    spfdata['title'] = 'Create a set of QA tasks'
    self.response.write(self.render('login', templatedata, spfdata, self.request.get('spf')))
    

  def post(self):
    pass


class APIUserLogin(BaseHandler):
  def get(self):
    pass    

  def post(self):
    email = self.request.get('email')
    password = self.request.get('password')
    # TODO validate
    if email == None or email == '':
      return
    if password == None or password == '':
      return
    
    
    db = DB(tables)
    row = db.user_login(email, password)

    if  row is None:
      self.response.write(jsonify({
        'result':'error',
        'payload': 'Wrong email & password'          
      }))
      return
    else:
      self.session['name'] = row[1]
      self.session['email'] = email
      self.response.write(jsonify({'result':'success'}))
      return
    

class APIUserRegister(BaseHandler):
  def get(self):
    pass    

  def post(self):
    name = self.request.get('name')
    email = self.request.get('email')
    password = self.request.get('password')

    # TODO validate
    if name == None or name == '' or len(name.split(' ')) != 2:
      return
    if email == None or email == '':
      return
    if password == None or password == '':
      return

    # TODO make sure email doesnt exist
    
    
    db = DB(tables)
    if  db.user_create(name, email, password) is None:
      self.response.write(jsonify({
        'result':'error',
        'payload': 'An error happened'          
      }))
      return
    else:
      self.session['name'] = name
      self.session['email'] = email
      self.response.write(jsonify({'result':'success'}))
      return


class APIFetchQaersList(BaseHandler):
  def get(self):
    
    db = DB(tables)
    qaers = [ [qa[0], qa[1]] for qa in db.qaers_fetch_all() ]   
    
    if qaers:
      self.response.write( jsonify({'result': 'success', 'payload':qaers}) )   
    

class Logout(BaseHandler):
  def get(self):
    self.session.clear()
    webapp2.redirect('/', abort=True)
    return
  

routes = [
  ('/', Home),
  ('/login', Login),
  ('/logout', Logout),
  ('/create-set', SetCreate),
  ('/set/(\d+)/(.+)', SetView),
  ('/dashboard', Dashboard),
  ('/api/create-set', APISetCreate),
  ('/api/create-issue', APIIssueCreate),
  ('/api/create-comment', APICommentCreate),
  ('/api/fetch-url/(\d+)', APIUrlFetch),
  ('/api/update-status', APIStatusUpdate),
  ('/api/user-login', APIUserLogin),
  ('/api/user-register', APIUserRegister),
  ('/api/qaers-list', APIFetchQaersList),
]

conf = {
   'webapp2_extras.sessions': {
     'secret_key': 'A0Zr98j/3yX~$HH!jmN]-LWX/,?RT',
     'cookie_args': {
     'max_age': 31104000
     }
   }
}


app = webapp2.WSGIApplication(routes=routes, config=conf, debug=True)