import os
from flask import Flask, abort, request, jsonify, g, url_for, render_template, send_from_directory, redirect
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.httpauth import HTTPBasicAuth
from passlib.apps import custom_app_context as pwd_context
from itsdangerous import (TimedJSONWebSignatureSerializer
                          as Serializer, BadSignature, SignatureExpired)

from models import*
from flask_restful import reqparse, abort, Api, Resource, fields, marshal_with
from sqlalchemy import exc
from werkzeug import secure_filename
import boto3
import magic
import requests
from bs4 import BeautifulSoup
import hashlib
import binascii
from flask.ext.cors import CORS, cross_origin
import datetime
import random
headers = {
	'User-Agent':'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.98 Safari/537.36',
	'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8'

}
auth = HTTPBasicAuth()
s3 = boto3.resource('s3')
app.secret_key = 'some_secret'
bucket = 'ben-uguru'
filename = 'db.sqlite'
s3 = boto3.resource('s3')

cors = CORS(app, resources={r"/api/channels.json": {"origins": "localhost"}})


cardsVal = 0
@auth.verify_password
def verify_password(email_or_token, password):
    user = User.verify_auth_token(email_or_token)
    if not user:
        user = User.query.filter_by(email=email_or_token).first()
        if not user or not user.verify_password(password):
            return False
    g.user = user
    return True


user_fields = {
	'email':fields.String,
	'token':fields.String
}

RegisterUserFields = {
	'id': fields.Integer,
	'email': fields.String,
}
putRequestFields = {
	'token':fields.String,
	'Message':fields.String(default='Successfully uploaded!')
}
class RegisterUser(Resource):
	@marshal_with(RegisterUserFields)
	def post(self):
		jsonData = request.get_json(force=True)
		bucket = jsonData['bucket']
		email = jsonData['email']
		password = jsonData['password']
		if email is None or password is None:
			abort(400)
		if User.query.filter_by(email=email).first() is not None:
			abort(400)
		user = User(email=email)
		# file = jsonData['filename']
		# if file:
		# 	generate_static_token = user.generate_auth_token(700)
		# 	renameFile = file.replace(file,str(generate_static_token))
  #       	s3.meta.client.upload_file(renameFile, str(bucket),renameFile)
  #       	user.static_uri_token = generate_static_token
  #       else:
  #       	user.static_uri_token = None
		user.hash_password(password)
		db.session.add(user)
		db.session.commit()
		return user

	@auth.login_required
	@marshal_with(putRequestFields)
	def put(self):
		token = g.user.generate_auth_token(700)
		user.token = token
		db.session.commit()
		return user


class UploadMultipleFiles(Resource):
	def post(self):
		jsonData = request.get_json(force=True)
		token = jsonData['token']
		user = User.query.filter_by(token=token).first()
		if not user:
			abort(400)
		filename = jsonData['filename']
		filetype = jsonData['filetype']
		bucket = jsonData['bucket']
		project_id = jsonData['project_id']
		viewIDData = jsonData['view_id']
		getFileType = magic.from_file(filename)
		if filetype not in getFileType:
			abort(422)
		user = User.query.filter_by(token=token).first()
		getProjects = UserProjects.query.filter_by(id=project_id).first()
		getViews = getProjects.projectAttr.filter_by(id=viewIDData).first()
		queryViews = Views.query.filter_by(id=viewIDData).first()
		bucketFile = s3.meta.client.upload_file(filename, str(bucket),filename)
		fileSizeSummary = s3.ObjectSummary(str(bucket), filename)
		objectS = fileSizeSummary.get()
		contentLength = objectS.get('ContentLength')
		components = component(comp=queryViews, filetype=getFileType, filename=filename,file_url='https://ben-uguru.s3.amazonaws.com/'+filename, filesize=contentLength)
		db.session.add(components)
		objectSummary = s3.ObjectSummary(bucket,filename)
		sumViewSize = Views.query.get(viewIDData)
		getComponentForView = sumViewSize.component.all()
		totalSumArr = []
		for sizesinfo in getComponentForView:
			totalSumArr.append(int(sizesinfo.filesize))
		sumViewSize.filesize = sum(totalSumArr)
		user.total_size = sumViewSize.filesize
		db.session.commit()
		object = objectSummary.get()
		getComponents = component.query.filter_by(filename=filename).first()
		getLastUploadedFileVersion = object.get('VersionId')
		object_version = s3.ObjectVersion(str(bucket),filename,getLastUploadedFileVersion)
		object1 = object_version.get()
		ETag = object1.get('ETag')
		queryversions = versions.query.filter_by(eTag=ETag).first()
		limit = 10
		getTotalItemsForAFile = versions.query.filter_by(filename=filename).all()
		if len(getTotalItemsForAFile) == limit:
			return jsonify({"Error":"Reached maximum limit for same file versions!"})
			abort(400)
		if queryversions:
			return jsonify({"Error":"Can't upload if the file has no changes been made!"})
			abort(400)
		versionsAdd = versions(version_url='https://ben-uguru.s3.amazonaws.com/db.sqlite?versionID='+str(getLastUploadedFileVersion),filename=filename, version=getComponents, eTag=ETag)
		db.session.add(versionsAdd)
		db.session.commit()
		return jsonify({'Msg':'file uploaded to a bucket!'})




class NewObject(Resource):
	def put(self):
		jsonData = request.get_json(force=True)
		comp_id = jsonData['comp_id']

class APIUser(Resource):
	@auth.login_required
	@marshal_with(user_fields)
	def get(self):
		try:
			token = g.user.generate_auth_token(700)
			user = User.query.filter_by(email=g.user.email).first()
			user.token = token
			db.session.commit()
			return user
		except AttributeError:
			abort(400)

	@auth.login_required
	def put(self,id):
		newpassword = request.json.get('password')
		user = User.query.get(id)
		if not user:
			abort(400)
		else:
			user.hash_password(newpassword)
			db.session.commit()
		return jsonify({'Msg:':'Updated Password!'})

	@auth.login_required
	def delete(self,id):
		token = g.user.generate_auth_token(700)
		user = User.query.filter_by(email=g.user.email).first()
		user.token = token
		db.session.commit()
		return jsonify({'Msg':'Logged out!'})


class AccessUser(Resource):
	def get(self,auth_token,id):
		user = User.verify_auth_token(auth_token)
		try:
			if user is None:
				return jsonify({'Error':'invalid token/expired token'})
			else:
				queryUserBasedOnToken = User.query.filter_by(token=auth_token).first()
				return jsonify({'data':'Welcome %s' % queryUserBasedOnToken.email})
		except AttributeError:
			return jsonify({'Error':'invalid token/expired token'})


courses = {
	'userCourses': fields.String,
	'userID': fields.Integer
}



ViewsAttrs = {
	'viewsNickName':fields.String,
	'projectID':fields.Integer
}

# class AddProjectViews(Resource):
# 	@marshal_with(ViewsAttrs)
# 	def post(self):
# 		## Adds extra attributes to each views for instance project nickname etc.
# 		## This adds a new view to specified project_id
# 		## Parameters for this requests are:
# 		### -- Nickname
# 		### -- Token
# 		### -- project ID You want to create a VIEW FOR.
# 		token = request.get_json(force=True)
# 		tokenData = token['token']
# 		viewID = request.get_json(force=True)
# 		viewidData = viewID['project_id']
# 		getViewID = UserProjects.query.filter_by(id=viewidData).first()
# 		user = User.query.filter_by(token=tokenData).first()
# 		if not user:
# 			abort(400)
# 		projectNickName = request.get_json(force=True)
# 		projectNickNameData = projectNickName['nickname']
# 		addProjectAttr = Views(viewsNickName=projectNickNameData,views=getViewID)
# 		db.session.add(addProjectAttr)
# 		db.session.commit()
# 		return addProjectAttr


projectData = {
	'projectName':fields.String,
}
class CreateProject(Resource):
	@marshal_with(projectData)
	def post(self):
			####---- Parameters needed to make this requests:
			# *ProjectName
			# *Token
			token = request.get_json(force=True)
			tokenData = token['token']
			user = User.query.filter_by(token=tokenData).first()
			if not user:
				abort(400)
			jsonData = request.get_json(force=True)
			filename = jsonData['filename']
			file_url='https://ben-uguru.s3.amazonaws.com/'+filename
			s3.meta.client.upload_file(str(filename), 'ben-uguru',str(filename))
			m = hashlib.md5()
			m.update(file_url)
			hexnumber = m.hexdigest()[:5]
			#hasher = abs(hash(file_url)) % (10 ** 5)
			projectnamedata = UserProjects(projectName=filename, project=user, fileURL = file_url, static_uri_token = hexnumber)
			db.session.add(projectnamedata)
			db.session.commit()
			return projectnamedata



projectsList = {
	'projectName': fields.String,
	'id':fields.Integer
}

class ViewProjects(Resource):
	@marshal_with(projectsList)
	def get(self,token):
		#id = User.query.get(id)
		user = User.query.filter_by(token=token).first()
		userID = str(user.id)
		if not user:
			abort(400)
		projects = user.projects.all()
		return projects


eachProjects = {
	'projectName': fields.String,
	'userID': fields.Integer,
	'id': fields.Integer,
}

class ViewProjectID(Resource):
	@marshal_with(eachProjects)
	def get(self, auth_token,project_id):
		user = User.query.filter_by(token=auth_token).first()
		getProjects = user.projects.filter_by(id=project_id).first()
		return getProjects


viewsList = {
	'viewsNickName': fields.String,
	'projectID': fields.Integer, # Project ID - > ALL VIEWS Shown!
	'id': fields.Integer
}
class ListofViews(Resource):
	@marshal_with(viewsList)
	def get(self,auth_token,project_id):
		user = User.query.filter_by(token=auth_token).first()
		getProjects = UserProjects.query.filter_by(id=project_id).first()
		getViews = getProjects.projectAttr.all()
		return getViews



componentDict = {
	'id':fields.Integer,
	'viewID':fields.Integer,
	'file_url':fields.String,
	'filename':fields.String,
	'permission':fields.String,
	'filetype':fields.String,
	'hidden':fields.Boolean,
	'filesize':fields.Integer
}
eachViews = {
	'view.filename': fields.String(default='shoes.json'),
	'view.projectID':fields.Integer,
	'view.id': fields.Integer,
	'view.filesize':fields.String,
	'components':fields.List(fields.Nested(componentDict))
}
class EachViews(Resource):
	@marshal_with(eachViews)
	def get(self, auth_token, project_id, view_id):
		user = User.query.filter_by(token=auth_token).first()
		getProjects = UserProjects.query.filter_by(id=project_id).first()
		getViews = getProjects.projectAttr.filter_by(id=view_id).first()
		view = Views.query.get(view_id)
		component = view.component.all()
		outputDict = {
			'components':component,
			'view':getViews
		}
		return outputDict
### -> user/userID/projects/views/view_id/containers

outputhasher = {
	'id':fields.Integer,
	'fileURL':fields.String
}
@app.route('/views/<hasher>', methods=['GET'])
def EacViewsWithHash(hasher):
	views = Views.query.filter_by(static_uri_token=hasher).first()
	return render_template('test.html', views=views)

# class EachViewsWithHash(Resource):
# 	#@marshal_with(outputhasher)
# 	def get(self,token, hasher):
# 		user = User.query.filter_by(token=token).first()
# 		if not user:
# 			abort(400)
# 		views = Views.query.filter_by(static_uri_token=hasher).first()
# 		return render_template('eachviews.html', views=views)

# api.add_resource(EachViewsWithHash,'/api/<token>/<hasher>')

containers = {
	'id': fields.Integer,
	'viewID': fields.Integer
}
class Containers(Resource):
	@marshal_with(containers)
	def get(self, auth_token, project_id, view_id):
		user = User.query.filter_by(token=auth_token).first()
		getProjects = UserProjects.query.filter_by(id=project_id).first()
		getViews = getProjects.projectAttr.filter_by(id=view_id).first()
		containers = getViews.containers.all()
		return containers

cards = {
	'id': fields.Integer,
	'viewID': fields.Integer
}
class Cards(Resource):
	@marshal_with(cards)
	def get(self, auth_token, project_id, view_id):
		user = User.query.filter_by(token=auth_token).first()
		getProjects = UserProjects.query.filter_by(id=project_id).first()
		getViews = getProjects.projectAttr.filter_by(id=view_id).first()
		cards = getViews.containers.all()
		return cards

class AddProjectViews(Resource):
	@marshal_with(ViewsAttrs)
	def post(self):
		## Adds extra attributes to each views for instance project nickname etc.
		## This adds a new view to specified project_id
		## Parameters for this requests are:
		### -- Nickname
		### -- Token
		### -- project ID You want to create a VIEW FOR.
		token = request.get_json(force=True)
		tokenData = token['token']
		viewID = request.get_json(force=True)
		viewidData = viewID['project_id']
		getViewID = UserProjects.query.filter_by(id=viewidData).first()
		filename = token['filename']
		bucketFile = s3.meta.client.upload_file(str(filename), 'ben-uguru',str(filename))
		file_url='https://ben-uguru.s3.amazonaws.com/'+filename
		user = User.query.filter_by(token=tokenData).first()
		if not user:
			abort(400)
		#AddViewsDynamic = User.views.query.filter_by('21')
		#getViewsTotalSum = Views.component.query.all()
		#for sizes in getViewsTotalSum:
		#	sizes = sizes.filesize
		#user.hash_password(file_url)
		#hasher = abs(hash(file_url)) % (10 ** 5)
		m = hashlib.md5()
		m.update(file_url)
		hexnumber = m.hexdigest()[:5]
		addViews = Views(projectID=getViewID.id,static_uri_token=hexnumber, fileURL=file_url)
		db.session.add(addViews)
		db.session.commit()
		# user = User.query.get(2)
		# view = Views.query.get('21')
		# user.views.append(view)
	#	db.session.commit()
	#	addProjectAttr = Views(viewsNickName=projectNickNameData,views=getViewID)
	#	db.session.add(addProjectAttr)
	#	db.session.commit()
	#	return addProjectAttr



addedContainer = {
	'id': fields.Integer,
	'viewID': fields.Integer
}

class AddContainer(Resource):
	@marshal_with(addedContainer)
	def post(self):
		token = request.get_json(force=True)
		tokenData = token['token']
		projectID = request.get_json(force=True)
		projectIDData = projectID['project_id']
		viewID = request.get_json(force=True)
		viewIDData = viewID['view_id']
		queryViews = Views.query.filter_by(id=viewIDData).first()
		user = User.query.filter_by(token=tokenData).first()
		if not user:
			abort(400)
		addContainerDb = ContainersDB(containers=queryViews)
		db.session.add(addContainerDb)
		db.session.commit()
		return addContainerDb


addedCards = {
	'id':fields.Integer,
	'viewID': fields.Integer
}

class AddCards(Resource):
	@marshal_with(addedCards)
	def post(self):
		token = request.get_json(force=True)
		tokenData = token['token']
		projectID = request.get_json(force=True)
		projectIDData = projectID['project_id']
		viewID = request.get_json(force=True)
		viewIDData = viewID['view_id']
		queryViews = Views.query.filter_by(id=viewIDData).first()
		user = User.query.filter_by(token=tokenData).first()
		if not user:
			abort(400)
		addContainerDb = CardsDB(cards=queryViews)
		db.session.add(addContainerDb)
		db.session.commit()
		return addContainerDb

containerDict = {
	'viewID':fields.String(attribute='viewID'),
	'id':fields.String(attribute='id')
}

cardsDict = {
	'viewID':fields.String(attribute='viewID',default='None'),
	'id':fields.String(attribute='id', default='None')
}


cards_marshaller = {
		'viewsNickName': fields.String,
		'containers':fields.List(fields.Nested(containerDict)),
		'cards':fields.List(fields.String)
		}



tableExists = db.engine.dialect.has_table(db.engine, "Cards")
if tableExists == True:
	cards_marshaller = {
		'viewsNickName': fields.String,
		'containers':fields.List(fields.Nested(containerDict)),
		'cards':fields.List(fields.Nested(cardsDict))
		}
else:
	cards_marshaller = {
		'viewsNickName': fields.String,
		'containers':fields.List(fields.Nested(containerDict)),
		}


parameter_marshaller = {
	'projectID':fields.String(attribute='projectID'),
	'views':fields.List(fields.Nested(cards_marshaller)),
	'projectName':fields.String(attribute='projectName')
}

# set_marshaller = {
# 	'user.email':fields.String,
# 	'user.id':fields.Integer,
# 	'projects':fields.Nested(parameter_marshaller)
# }

imgDict = {
	'imgURL':fields.String,
	'width':fields.Integer,
	'height':fields.Integer
}

# @app.route('/api/bing/img/<query>', methods=['GET'])
# def ImgQuery(self, query):
# 	response = requests.get('https://c.bingapis.com/api/custom/opal/image/search?form=OPSBTI&rnoreward=1&count=5&q='+str(query)+'&offset=0&version=5').text
# 	loadAsJson = json.loads(response)
# 	value = loadAsJson['value']
# 	arr =[]
# 	for items in value:
# 		if "png" in items['encodingFormat']
# 			if 200 < items['width']:
# 				dictionary = {}
# 				dictionary['imgURL'] = items['contentUrl']
# 				dictionary['width'] = items['width']
# 				dictionary['height'] = items['height']
# 				arr.append(dictionary)
# 	return render_template('imglist.html', arr=arr)

@app.route('/api/img/<query>', methods=['GET'])
def WikiQuery(query):
	response = requests.get('https://commons.wikimedia.org/w/index.php?search='+str(query)+'&title=Special:Search&go=Go&uselang=en').text
	soup = BeautifulSoup(response)
	searchResults = soup.find('ul',attrs={'class':'mw-search-results'}).findAll('li')[:5]
	arr = []
	for items in searchResults:
		dictionary = {}
		#dictionary['png'] = items.find('img')['src']
		dictionary['svg'] = items.find('img')['src'].replace('thumb/','').split('svg/')[0]+'svg'
		arr.append(dictionary)
	return render_template('imglist.html', arr=arr )
@app.route('/user/<hasher>', methods=['GET'])
@auth.login_required
def UserObject(token, hasher):
	allCards = []
	id = g.user.id
	user = User.query.filter_by(id=id).first() ## all the users
	projects = user.projects.all()
	for eachView in projects:
		id = eachView.id
		dictionary = {}
		dictionary['projectID'] = id
		dictionary['projectName'] = eachView.projectName
		views = eachView.projectAttr.filter_by(static_uri_token=hasher).all()
		viewArr = []
		for eachItems in views:
			viewDict = {}
			viewDict['fileURL'] = eachItems.fileURL
			viewDict['id'] = eachItems.id
			viewDict['static_uri_token'] = eachItems.static_uri_token
			viewArr.append(viewDict)
		dictionary['views'] = viewArr

		allCards.append(dictionary)


	dictionary = {
	'user':user,
	'projects': allCards
	}
	return render_template('userobj.html', arr = dictionary)


class UserObjects(Resource):
	#@marshal_with(set_marshaller)
	def get(self, token):
		allCards = []
		user = User.query.filter_by(id=id).first() ## all the users
		projects = user.projects.all()

		for eachView in projects:
			id = eachView.id
			dictionary = {}
			dictionary['projectID'] = id
			dictionary['projectName'] = eachView.projectName
			views = eachView.projectAttr.filter_by(projectID=id).all()
			dictionary['views'] = views
			allCards.append(dictionary)


		dictionary = {
		'user':user,
		'projects': allCards
		}
		return render_template('userobj.html', arr = dictionary)
		#return dictionary


class CreateTable(Resource):
	def get(self):
		try:
			print "TEST"
			CardsDB.__table__.create(db.engine)
			cardsVal =+ 1
			query = DatabaseTables.query.first()
			db.session.commit()
			return jsonify({'Msg':'Created!'})
		except exc.SQLAlchemyError:
			return jsonify({'Error':'Couldnt create the table as it exists! :('})


class DeleteTable(Resource):
	def get(self):
		try:
			versions.__table__.drop(db.engine)
			db.session.commit()
			return jsonify({'Msg':'Deleted!'})
		except exc.SQLAlchemyError:
			return jsonify({'Error':'Couldnt delete the table :('})



BucketObj = {
	'filename':fields.String,
	'file_url':fields.String
}

##Componenets are bucket files in this case.
class GetAllBucketFiles(Resource):
	@marshal_with(BucketObj)
	def get(self,token,bucket):
		user = User.query.filter_by(token=token).first()
		if not user:
			abort(400)
		buckets = s3.Bucket(str(bucket))
		allObj = buckets.objects.all()
		arr = []
		for items in allObj:
			dictionary = {}
			dictionary['filename'] = items.key
			dictionary['file_url'] = 'https://ben-uguru.s3.amazonaws.com/'+str(items.key)
			arr.append(dictionary)
		return arr


class SetFilePerms(Resource):
	def put(self):
		try:
			jsonData = request.get_json(force=True)
			token = jsonData['token']
			fileperm = jsonData['permission']
			filename = jsonData['filename']
			user = User.query.filter_by(token=token).first
			if not user:
				abort(400)
			object = s3.Bucket('ben-uguru').Object(filename)
			object.Acl().put(ACL=fileperm)
			return jsonify({'Msg':'Updated file perm to'+ ' '+fileperm+ ' for file'+ ' '+ filename})
		except:
			abort(400)


component_marshaller = {
	'id': fields.Integer,
	'viewID': fields.Integer
}

@app.route('/component/<hasher>')
def getComponentForHasher(hasher):
	queryC = component.query.fitler_by(static_uri_token=hasher).first()
	if not queryC:
		abort(400)
	return render_template('eachcomponent.html', arr=queryC)
class Component(Resource):
	@marshal_with(component_marshaller)
	def put(self):
		jsonData = request.get_json(force=True)
		token = jsonData['token']
		project_id = jsonData['project_id']
		viewIDData = jsonData['view_id']
		filename = jsonData['filename']
		bucketFile = s3.meta.client.upload_file(str(filename), 'ben-uguru',str(filename))
		user = User.query.filter_by(token=token).first()
		file_url = 'https://ben-uguru.s3.amazonaws.com/'+str(filename)
		m = hashlib.md5()
		m.update(file_url)
		hexnumber = m.hexdigest()[:5]
		#hasher = abs(hash(file_url)) % (10 ** 5)

		getProjects = UserProjects.query.filter_by(id=project_id).first()
		getViews = getProjects.projectAttr.filter_by(id=viewIDData).first()
		queryViews = Views.query.filter_by(id=viewIDData).first()
		addContainerDb = component(comp=queryViews,file_url=file_url,static_uri_token=hexnumber)
		db.session.add(addContainerDb)
		db.session.commit()
		return addContainerDb

	def delete(self):
		jsonData = request.get_json(force=True)
		token = jsonData['token']
		project_id = jsonData['project_id']
		viewIDData = jsonData['view_id']
		comp_id = jsonData['comp_id']
		user = User.query.filter_by(token=token).first()
		getProjects = UserProjects.query.filter_by(id=project_id).first()
		getViews = getProjects.projectAttr.filter_by(id=viewIDData).first()
		queryViews = Views.query.filter_by(id=viewIDData).first()
		compQuery = component.query.filter_by(id=comp_id).first()
		db.session.delete(compQuery)
		db.session.commit()
		return jsonify({'Msg':'Deleted!'})
		if not comp_id:
			abort(400)







popularreleases = {
	'shoe_name':fields.String,
	'release_date':fields.String
}
class Shoes(Resource):
	@marshal_with(popularreleases)
	def get(self):
		response = requests.get('http://sneakernews.com/release-dates/',headers=headers).text
		soup = BeautifulSoup(response)
		popularReleases = soup.find('div',attrs={'class':'popular-releases-block'}).findAll('li')
		arr = []
		for eachShoes in popularReleases:
			dictionary={}
			dictionary['shoe_name'] = eachShoes.find('a').text
			dictionary['release_date'] = eachShoes.find('em').text
			arr.append(dictionary)
		return arr




api.add_resource(Shoes,'/api/release')
#api.add_resource(Shoes,'/api/releases/<date>')

class removeComponentFromViews(Resource):
	def post(self):
		jsonData = request.get_json(force=True)
		token = jsonData['token']
		project_id = jsonData['project_id']
		viewIDData = jsonData['view_id']
		comp_id = jsonData['comp_id']
		user = User.query.filter_by(token=token).first()
		getProjects = UserProjects.query.filter_by(id=project_id).first()
		getViews = getProjects.projectAttr.filter_by(id=viewIDData).first()
		queryViews = Views.query.filter_by(id=viewIDData).first()
		compQuery = component.query.filter_by(id=comp_id).first()
		compQuery.hidden = True
		db.session.commit()
		return jsonify({'Message':'Component Hidden!'})

versionsz  = {
	'versions.version_url':fields.String
}

viewMarshaller = {
    'viewID':fields.Integer,
	'id':fields.Integer,
	'filename':fields.String,
	'permission':fields.String,
	'file_url':fields.String,
	'filetype':fields.String,
	'component.versions':fields.String,
}
listComp = {
	# 'viewID':fields.Integer,
	# 'id':fields.Integer,
	# 'filename':fields.String,
	# 'permission':fields.String,
	# 'file_url':fields.String,
	# 'filetype':fields.String,
	'views':fields.Nested(viewMarshaller),
	#'versions':fields.Nested(versionsz)
}



class BartAPI(Resource):
	def get(self):
		arrBart = []
		response = requests.get('http://api.bart.gov/api/etd.aspx?cmd=etd&orig=MONT&key=MW9S-E7SL-26DU-VV8V').text
		soup = BeautifulSoup(response)
		outputDictionary = {}
		outputDictionary['date'] = soup.find('date').text.encode('ascii','ignore')
		outputDictionary['time'] = soup.find('time').text.encode('ascii','ignore')
		station = soup.find('station')
		station_name = station.find('name').text.encode('ascii','ignore')
		outputDictionary['station'] = station_name
		stationETD = soup.find('station').findAll('etd')
		outputArr = []
		for stationETDText in stationETD:
			etdDict = {}
			etdDict['desitnation'] = stationETDText.find('destination').text.encode('ascii','ignore')
			etdDict['abbreviation'] = stationETDText.find('abbreviation').text.encode('ascii','ignore')
			etdDict['limited'] = stationETDText.find('limited').text.encode('ascii','ignore')
			estimatedTimeArrival = stationETDText.findAll('estimate')
			estArr = []
			for estimatedTime in estimatedTimeArrival:
				estimationDict = {}
				estimationDict['minutes'] = estimatedTime.find('minutes').text.encode('ascii','ignore')
				estimationDict['platform'] = estimatedTime.find('platform').text.encode('ascii','ignore')
				estimationDict['direction'] = estimatedTime.find('direction').text.encode('ascii','ignore')
				estimationDict['length'] = estimatedTime.find('length').text.encode('ascii','ignore')
				estimationDict['color'] = estimatedTime.find('color').text.encode('ascii','ignore')
				estimationDict['hexcolor'] = estimatedTime.find('hexcolor').text.encode('ascii','ignore')
				estimationDict['bikeflag'] = estimatedTime.find('bikeflag').text.encode('ascii','ignore')
				estArr.append(estimationDict)
			etdDict['estimation'] = estArr
			outputArr.append(etdDict)
		outputDictionary['station'] = outputArr
		arrBart.append(outputDictionary)
		return jsonify(results=arrBart)
		# with open('static/bart.json','wb') as outfile:
		# 	json.dump(arrBart,outfile,indent=4)
		# return app.send_static_file('bart.json')
		#return send_from_directory('/static','bart.json')
		#return jsonify(results=arrBart)
api.add_resource(BartAPI,'/api/bart.json')


class ChannelListings(Resource):
	def get(self):
		response = requests.get('http://mobilelistings.tvguide.com/Listingsweb/ws/rest/schedules/80004.null/start/1480636800/duration/120?ChannelFields=Name%2CFullName%2CNumber%2CSourceId&ScheduleFields=ProgramId%2CEndTime%2CStartTime%2CTitle%2CAiringAttrib%2CCatId&formattype=json&disableChannels=music%2Cppv%2C24hr').text
		LoadAsJson = json.loads(response)
		with open('channelListings.json','wb') as outfile:
			json.dump(LoadAsJson,outfile,indent=4)
		with open('channelListings.json','r+') as jsonFile:
			data = json.load(jsonFile)
			for items in data:
				tmp = items['ProgramSchedules']
				for startTime in tmp:
					itemEr = startTime['StartTime']
					parser = datetime.datetime.fromtimestamp(int(itemEr)).strftime('%Y-%m-%d %H:%M')
					ConvertToStr = str(parser).split('-')
					newDict = {}
					newDict['year'] = str(ConvertToStr[0])
					newDict['month'] = str(ConvertToStr[1])
					newDict['day'] = str(ConvertToStr[-1]).split(' ')[0]
					splitDay = str(newDict['day'])
					newDict['time'] = str(ConvertToStr[-1]).split(' ')[-1]
					startTime['StartTime'] = newDict

					endEr = startTime['EndTime']
					endTimeParser = datetime.datetime.fromtimestamp(int(endEr)).strftime('%Y-%m-%d %H:%M')
					ConvertEndTimeToStr = str(endTimeParser).split('-')
					secondDict = {}
					secondDict['year'] = str(ConvertEndTimeToStr[0])
					secondDict['month'] = str(ConvertEndTimeToStr[1])
					secondDict['day'] = str(ConvertEndTimeToStr[-1]).split(' ')[0]
					splitDayz = str(secondDict['day'])
					secondDict['time'] = str(ConvertEndTimeToStr[-1]).split(' ')[-1]
					startTime['EndTime'] = secondDict
					firstNumberHour = secondDict['time'].split(':')[0]
					secondNumberHour = newDict['time'].split(':')[0]
					HourLess = int(firstNumberHour) + int(secondNumberHour)
					firstNumberMinutes = secondDict['time'].split(':')[-1]
					secondNumberMinutes = secondDict['time'].split(':')[-1]
					secondsLess = int(secondNumberMinutes) - int(firstNumberHour)
					divideby60 = secondsLess/60
					print HourLess
					print divideby60
					total =  HourLess + divideby60
					startTime['TotalAmount'] = total
					jsonFile.seek(0)
					jsonFile.write(json.dumps(data))
					jsonFile.truncate()
			with open('static/channelListingsChanges.json','wb') as outfile:
				json.dump(data,outfile,indent=4)
			# with open('static/channelListings.json','wb') as outfile:
			# 	json.dump(LoadAsJson,outfile,indent=4)
		return app.send_static_file('channelListingsChanges.json')

api.add_resource(ChannelListings,'/api/channels.json')



class getComponent(Resource):
	@marshal_with(listComp)
	def get(self, token, project_id, view_id):
		fullArr = []
		user = User.query.filter_by(token=token).first()
		getProjects = UserProjects.query.filter_by(id=project_id).first()
		getViews = getProjects.projectAttr.filter_by(id=view_id).first()
		getComponent = getViews.component.filter_by(hidden=0).all()
		for component in getComponent:
			dictionary = {}
			versions = component.versions.all()
			dictionary['versions'] = versions
			fullArr.append(dictionary)

		dictionary = {
		'views':getComponent,
		'versions':fullArr
		}
		return dictionary


class unSplash(Resource):
	def get(self):
		response = requests.get('https://unsplash.it/list').text
		unsplashJson = json.loads(response)
		return jsonify(results=unsplashJson)


##/api/unsplash --> Gives them the FAT list.
#/api/unsplash/q=random --> Gets a random picture from the FAT LIST
#/api/unsplash/random/q=green -> Gets one random queried image
#/api/unsplash/q=green -> Gets image information for all the query



@app.route('/api/unsplash', methods=['GET'])
def unSplash():
	response = requests.get('https://unsplash.it/list').text
	unsplashJson = json.loads(response)
	return jsonify(results=unsplashJson)


@app.route('/api/unsplash/random/html', methods=['GET'])
def getOneRandom():
	response = requests.get('https://unsplash.it/list').text
	unsplashJson = json.loads(response)
	getRandomURL = random.choice(unsplashJson)
	parseRandomURL = getRandomURL['post_url']
	makeAnotherGet = requests.get(parseRandomURL).text
	soup = BeautifulSoup(makeAnotherGet)
	getimgSrc = soup.find('img')['src']
	getImageSize = getimgSrc.replace('https','http')
	return render_template('unsplash.html', arr=getImageSize)


@app.route('/api/unsplash/random/<query>/html', methods=['GET'])
def queryRandom(query):
	header = {
	'authorization':"Client-ID d69927c7ea5c770fa2ce9a2f1e3589bd896454f7068f689d8e41a25b54fa6042"
	}
	response = requests.get('https://unsphlash.com/napi/search/photos?query='+str(query)+'&page=1',headers=header).text
	jsonFile = json.loads(response)
	randomizer = jsonFile['results']
	getRandomURL = random.choice(randomizer)
	getOneURLToRender = getRandomURL['urls']['regular']
	return render_template('unsplash.html', arr=getOneURLToRender)



@app.route('/api/unsplash/<query>', methods=['GET'])
@marshal_with(outputList)
def queryunsplash(query):
	header = {
	'authorization':"Client-ID d69927c7ea5c770fa2ce9a2f1e3589bd896454f7068f689d8e41a25b54fa6042"
	}
	response = requests.get('https://unsplash.com/napi/search/photos?query='+str(query)+'&page=1',headers=header).text
	jsonFile = json.loads(response)['results']
	outputArray = []
	for imagesURLs in jsonFile:
		dictionary = {}
		dictionary['img_url'] = imagesURLs['urls']['regular']
		outputArray.append(dictionary)
	return jsonify(results=outputArray)

#SHOULD WORK
@app.route('/api/unsplash/random/json', methods=['GET'])
def jsonFormat():
	response = requests.get('https://unsplash.it/list').text
	unsplashJson = json.loads(response)
	getRandomURL = random.choice(unsplashJson)
	parseRandomURL = getRandomURL['post_url']
	makeAnotherGet = requests.get(parseRandomURL).text
	soup = BeautifulSoup(makeAnotherGet)
	getimgSrc = soup.find('img')['src']
	getImageSize = getimgSrc.replace('https','http')
	return jsonify({'img_url':getImageSize})
	#return render_template('unsplash.html', arr=getImageSize)

@app.route('/api/unsplash/random/<query>/json', methods=['GET'])
def queryRandomJson(query):
	header = {
	'authorization':"Client-ID d69927c7ea5c770fa2ce9a2f1e3589bd896454f7068f689d8e41a25b54fa6042"
	}
	response = requests.get('https://unsplash.com/napi/search/photos?query='+str(query)+'&page=1',headers=header).text
	jsonFile = json.loads(response)
	randomizer = jsonFile['results']
	getRandomURL = random.choice(randomizer)
	getOneURLToRender = getRandomURL['urls']['regular']
	return jsonify({'img_url':getOneURLToRender})







#api.add_resource(unSplash,'/api/unsplash')
api.add_resource(SetFilePerms, '/user/updateperm')
api.add_resource(GetAllBucketFiles,'/user/<token>/<bucket>/files')
api.add_resource(UploadMultipleFiles,'/user/upload')
api.add_resource(CreateTable,'/user/create/table')
api.add_resource(DeleteTable,'/user/delete/table')
#api.add_resource(UserObjects,'/user/<token>')
api.add_resource(Containers,'/user/<auth_token>/projects/<project_id>/<view_id>/containers')
api.add_resource(Cards,'/user/<auth_token>/projects/<project_id>/<view_id>/cards')
api.add_resource(getComponent,'/user/<token>/projects/<project_id>/<view_id>/component')
api.add_resource(EachViews, '/user/<auth_token>/projects/<project_id>/<view_id>')
api.add_resource(ListofViews, '/user/<auth_token>/projects/<project_id>/views')
api.add_resource(ViewProjectID, '/user/<auth_token>/projects/<project_id>')
api.add_resource(ViewProjects,'/user/<token>/projects')

## ----> user -> projects -> views - > views has  many cards and containers

#### ------ Below are extra routes to add stuff in the databaase ------ ####
api.add_resource(removeComponentFromViews,'/user/updatecomponent')
api.add_resource(Component, '/api/users/component')
api.add_resource(AddCards, '/api/users/cards')
api.add_resource(AddContainer,'/api/users/ac')
api.add_resource(AddProjectViews,'/api/users/views') ## ---> Adds a new views to a project.
api.add_resource(CreateProject,'/api/users/createproject') ## --> Creates a new project in the database
api.add_resource(APIUser, '/api/token') ## --> Needs authentication then gives user a set of token
api.add_resource(RegisterUser,'/api/register') ## -> Creates a new user in the database

if __name__ == "__main__":
	app.run(host='192.168.20.165')