|
|
@@ -0,0 +1,598 @@
|
|
|
+"""
|
|
|
+ CloudView Engine 2.0
|
|
|
+ The Phi Technology LLC - Steve L. Nyemba <steve@the-phi.com>
|
|
|
+
|
|
|
+ This is a basic cloud view engine that is designed to be integrated into any service and intended to work for anyone provided they have signed up with the cloud service provider
|
|
|
+ The intent is to make the engine a general purpose engine that can be either deployed as a service (3-launchpad) or integrated as data feed for a third party utility
|
|
|
+
|
|
|
+"""
|
|
|
+from __future__ import division
|
|
|
+from threading import Thread
|
|
|
+import json
|
|
|
+import requests
|
|
|
+from xmljson import yahoo as bf
|
|
|
+from xml.etree.ElementTree import Element, tostring, fromstring, ElementTree as ET
|
|
|
+import xmltodict
|
|
|
+from email.mime.base import MIMEBase
|
|
|
+from email.mime.multipart import MIMEMultipart
|
|
|
+from StringIO import StringIO
|
|
|
+class Cloud:
|
|
|
+ BYTES_TO_GB = 1000000000
|
|
|
+ Config = None
|
|
|
+ STREAMING_URI = None
|
|
|
+ @staticmethod
|
|
|
+ def instance(id,**args):
|
|
|
+ id = id.strip()
|
|
|
+ if id == 'skydrive' :
|
|
|
+ id = 'one-drive'
|
|
|
+
|
|
|
+ handler = None
|
|
|
+ path = args['path'] if 'path' in args else None
|
|
|
+ if not Cloud.Config and path:
|
|
|
+ f = open(path)
|
|
|
+ Cloud.Config = json.loads(f.read())
|
|
|
+ Cloud.STREAMING_URI = str(Cloud.Config['api'])
|
|
|
+ Cloud.Config = Cloud.Config['cloud']
|
|
|
+ f.close()
|
|
|
+ if path and id in Cloud.Config :
|
|
|
+ context = Cloud.Config[id]
|
|
|
+ className = context['class']
|
|
|
+ config = json.dumps(context['config'])
|
|
|
+ handler = eval( "".join([className,"(",config,")"]))
|
|
|
+
|
|
|
+ #
|
|
|
+ # In case a stream was passed in ...
|
|
|
+ #
|
|
|
+ if 'stream' in args:
|
|
|
+ stream = args['stream']
|
|
|
+ context = Cloud.Config[id]
|
|
|
+ className = context['class']
|
|
|
+
|
|
|
+ handler = eval("".join([className,"(None)"]))
|
|
|
+ handler.from_json(stream)
|
|
|
+ #
|
|
|
+ # Once the handler is rovided we must retrieve the service given the key
|
|
|
+ # The key provides information about what files to extract as well as the preconditions
|
|
|
+ # @TODO:
|
|
|
+ # - Keys are maintained within the stripe account/couchdb
|
|
|
+ # -
|
|
|
+ return handler
|
|
|
+
|
|
|
+ def __init__(self):
|
|
|
+ self.access_token = None
|
|
|
+ self.refresh_token= None
|
|
|
+ self.files = []
|
|
|
+ self.client_id = None
|
|
|
+ self.secret = None
|
|
|
+ self.mfiles = {}
|
|
|
+ self.folders={}
|
|
|
+
|
|
|
+ def to_json(self):
|
|
|
+ object = {}
|
|
|
+ keys = vars(self)
|
|
|
+ for key in keys:
|
|
|
+ value = getattr(self,key)
|
|
|
+ object[key] = value
|
|
|
+ return json.dumps(object)
|
|
|
+ def from_json(self,stream):
|
|
|
+ ref = json.loads(stream) ;
|
|
|
+ for key in ref.keys() :
|
|
|
+ value = ref[key]
|
|
|
+ setattr(self,key,value)
|
|
|
+ # self.access_token = ref['access_token']
|
|
|
+ # self.refesh_token = ref['refresh_token']
|
|
|
+ # self.files = ref['files']
|
|
|
+ """
|
|
|
+ This function matches a name with a list of possible features/extensions
|
|
|
+
|
|
|
+ """
|
|
|
+ def match(self,filename,filters):
|
|
|
+ if isinstance(filters,str):
|
|
|
+ filters = [filters]
|
|
|
+ return len(set(filename.lower().split('.')) & set(filters)) > 0
|
|
|
+
|
|
|
+ def getName(self):
|
|
|
+ return self.__class__.__name__.lower()
|
|
|
+ def get_authURL(self):
|
|
|
+
|
|
|
+ config = Cloud.Config[self.getName()]['config']
|
|
|
+ url = config['authURL']
|
|
|
+
|
|
|
+ if '?' in url == False:
|
|
|
+ url += '?'
|
|
|
+ keys=['client_id','redirect_uri']
|
|
|
+ p = []
|
|
|
+ for id in keys:
|
|
|
+ value = config[id]
|
|
|
+ p.append(id+'='+value)
|
|
|
+ url = url +"&"+ "&".join(p)
|
|
|
+
|
|
|
+ return url
|
|
|
+Cloud.Config = {}
|
|
|
+
|
|
|
+class Google(Cloud):
|
|
|
+ def __init__(self,conf=None):
|
|
|
+ Cloud.__init__(self)
|
|
|
+ def getName(self):
|
|
|
+ return 'google-drive'
|
|
|
+ def init(self,token):
|
|
|
+ self.refresh_token = token
|
|
|
+ self._refresh()
|
|
|
+
|
|
|
+ def _refresh(self,code=None):
|
|
|
+ url = "https://accounts.google.com/o/oauth2/token"
|
|
|
+ headers = {"Content-Type":"application/x-www-form-urlencoded"}
|
|
|
+ data = {"client_id":self.client_id,"client_secret":self.secret}
|
|
|
+ if code :
|
|
|
+ grant_type = 'authorization_code'
|
|
|
+ data['code'] = code
|
|
|
+ else:
|
|
|
+ data['refresh_token'] = self.refresh_token
|
|
|
+ grant_type = 'refresh_token'
|
|
|
+
|
|
|
+ data['grant_type'] = grant_type
|
|
|
+ data['redirect_uri'] = self.redirect_uri
|
|
|
+
|
|
|
+ resp = requests.post(url,headers=headers,data=data)
|
|
|
+ r = json.loads(resp.text)
|
|
|
+ if 'access_token' in r:
|
|
|
+ self.access_token = r['access_token']
|
|
|
+ self.refresh_token = r['refresh_token'] if 'refresh_token' in r else r['access_token']
|
|
|
+ self.id_token = r['id_token']
|
|
|
+
|
|
|
+
|
|
|
+ def create_file(self,**args):
|
|
|
+ url = "https://www.googleapis.com/upload/drive/v2/files" ;
|
|
|
+ headers = {"Authorization":"Bearer "+self.access_token}
|
|
|
+ headers['Content-Type'] = args['mimetype']
|
|
|
+ params = args['params']
|
|
|
+ if 'data' not in args :
|
|
|
+ r = requests.post(url,params = params,headers=headers)
|
|
|
+ else:
|
|
|
+ data = args['data']
|
|
|
+ r = requests.post(url,data=data,params = params,headers=headers)
|
|
|
+ return r.json()
|
|
|
+ def update_metadata(self,id,metadata) :
|
|
|
+ url = "https://www.googleapis.com/drive/v2/files"
|
|
|
+ headers = {"Authorization":"Bearer "+self.access_token}
|
|
|
+ headers['Content-Type'] = 'application/json; charset=UTF-8'
|
|
|
+
|
|
|
+ if id is not None :
|
|
|
+ url += ("/"+id)
|
|
|
+ r = requests.put(url,json=metadata,headers=headers)
|
|
|
+ else:
|
|
|
+ # url += ("/?key="+self.secret)
|
|
|
+ r = requests.post(url,data=json.dumps(metadata),headers=headers)
|
|
|
+
|
|
|
+ return r.json()
|
|
|
+
|
|
|
+ def upload(self,folder,mimetype,file):
|
|
|
+ """
|
|
|
+ This function will upload a file to a given folder and will provide
|
|
|
+ If the folder doesn't exist it will be created otherwise the references will be fetched
|
|
|
+ This allows us to avoid having to create several folders with the same name
|
|
|
+ """
|
|
|
+ r = self.get_files(folder)
|
|
|
+
|
|
|
+ if len(r) == 0 :
|
|
|
+ info = {"name":folder, "mimeType":"application/vnd.google-apps.folder"}
|
|
|
+ r = self.update_metadata(None,{"name":folder,"title":folder, "mimeType":"application/vnd.google-apps.folder"})
|
|
|
+ else:
|
|
|
+ r = r[0]
|
|
|
+ parent = r
|
|
|
+ parent = {"kind":"drive#file","name":folder,"id":parent['id'],"mimeType":"application/vnd.google-apps.folder"}
|
|
|
+
|
|
|
+
|
|
|
+ r = self.create_file(data=file.read(),mimetype=mimetype,params={"uploadType":"media"})
|
|
|
+ info = {"title":file.filename,"description":"Create by Cloud View"}
|
|
|
+ info['parents'] = [parent]
|
|
|
+
|
|
|
+ r = self.update_metadata(r['id'],metadata=info)
|
|
|
+ return r
|
|
|
+
|
|
|
+
|
|
|
+"""
|
|
|
+ This class is designed to allow users to interact with one-drive
|
|
|
+"""
|
|
|
+class OneDrive(Cloud):
|
|
|
+ def __init__(self,conf):
|
|
|
+ Cloud.__init__(self)
|
|
|
+ def getName(self):
|
|
|
+ return 'one-drive'
|
|
|
+ def init(self,token):
|
|
|
+ self.refresh_token = token
|
|
|
+ self._refresh()
|
|
|
+
|
|
|
+ def _refresh(self,code=None):
|
|
|
+ url = "https://login.live.com/oauth20_token.srf"
|
|
|
+ #url="https://login.microsoftonline.com/common/oauth2/v2.0/token"
|
|
|
+
|
|
|
+ headers = {"Content-Type":"application/x-www-form-urlencoded"}
|
|
|
+ form = {"client_id":self.client_id,"client_secret":self.secret}
|
|
|
+ if code:
|
|
|
+ grant_type = 'authorization_code'
|
|
|
+ form['code'] = str(code)
|
|
|
+ else:
|
|
|
+ grant_type = 'refresh_token'
|
|
|
+ form['refresh_token'] = self.refresh_token
|
|
|
+ form['grant_type'] = grant_type
|
|
|
+ if self.redirect_uri:
|
|
|
+ form['redirect_uri'] = self.redirect_uri
|
|
|
+ r = requests.post(url,headers=headers,data=form)
|
|
|
+ r = json.loads(r.text)
|
|
|
+ if 'access_token' in r:
|
|
|
+ self.access_token = r['access_token']
|
|
|
+ self.refresh_token = r['refresh_token']
|
|
|
+
|
|
|
+ def upload(self,folder,mimetype,file):
|
|
|
+ """
|
|
|
+ @param folder parent.id
|
|
|
+ @param name name of the file with extension
|
|
|
+ @param stream file content
|
|
|
+
|
|
|
+ """
|
|
|
+ path = folder+"%2f"+file.filename
|
|
|
+ url = "https://apis.live.net/v5.0/me/skydrive/files/:name?access_token=:token".replace(":name",path).replace(":token",self.access_token) ;
|
|
|
+
|
|
|
+ header = {"Authorization": "Bearer "+self.access_token,"Content-Type":mimetype}
|
|
|
+ header['Content-Type']= mimetype
|
|
|
+ r = requests.put(url,header=header,files=file)
|
|
|
+ r = r.json()
|
|
|
+ return r
|
|
|
+
|
|
|
+"""
|
|
|
+ This class uses dropbox version 2 API
|
|
|
+"""
|
|
|
+class Dropbox(Cloud):
|
|
|
+ def __init__(self):
|
|
|
+ Cloud.__init__(self)
|
|
|
+ def init(self,access_token):
|
|
|
+ self.access_token = access_token
|
|
|
+ def upload(self,folder,mimetype,file):
|
|
|
+ """
|
|
|
+ @param folder parent.id
|
|
|
+ @param name name of the file with extension
|
|
|
+ @param stream file content
|
|
|
+
|
|
|
+ @TODO: This upload will only limit itself to 150 MB, it is possible to increase this size
|
|
|
+ """
|
|
|
+ url = "https://content.dropboxapi.com/2/files/upload"
|
|
|
+ folder = folder if folder is not None else ""
|
|
|
+ path = "/"+folder+"/"+file.name.split('/')[-1]
|
|
|
+ path = path.replace("//","/")
|
|
|
+ header = {"Authorization":"Bearer "+self.access_token,"Content-Type":mimetype}
|
|
|
+ #header['autorename']= "false"
|
|
|
+ header['mode'] = "add"
|
|
|
+ #header['mute'] = "false"
|
|
|
+ header['Dropbox-API-Arg'] = json.dumps({"path":path})
|
|
|
+ r = requests.post(url,headers=header,data=file.read())
|
|
|
+ print r.text
|
|
|
+ r = r.json()
|
|
|
+ return r
|
|
|
+
|
|
|
+
|
|
|
+"""
|
|
|
+ This class implements basic interactions with box (cloud service providers)
|
|
|
+ Available functionalities are: authentication, file access,share and stream/download
|
|
|
+"""
|
|
|
+class Box(Cloud) :
|
|
|
+ def __init__(self,conf):
|
|
|
+ Cloud.__init__(self);
|
|
|
+ if conf is not None:
|
|
|
+ self.client_id = conf['client_id']
|
|
|
+ self.secret = conf['secret']
|
|
|
+ self.redirect_uri = conf['redirect_uri'] if 'redirect_uri' in conf else None
|
|
|
+ def init(self,token):
|
|
|
+ self.refresh_token = token
|
|
|
+ def set(self,code) :
|
|
|
+ self._access(code)
|
|
|
+ return 1 if self.access_token else 0
|
|
|
+
|
|
|
+ def _access(self,code):
|
|
|
+ body = {"client_id":self.client_id,"client_secret":self.secret,"grant_type":"authorization_code","code":code,"redirect_uri":self.redirect_uri}
|
|
|
+ headers = {"Content-Type":"application/x-www-form-urlencoded"}
|
|
|
+ url = "https://app.box.com/api/oauth2/token"
|
|
|
+ r = requests.post(url,headers=headers,data=body)
|
|
|
+ r = json.loads(r.text)
|
|
|
+ if 'error' not in r:
|
|
|
+ self.access_token = r['access_token']
|
|
|
+ self.refresh_token= r['refresh_token']
|
|
|
+ def _refresh(self,authToken) :
|
|
|
+ body = {"client_id":self.client_id,"client_secret":self.secret,"grant_type":"refresh_token"}
|
|
|
+ url = "https://app.box.com/api/oauth2/token";
|
|
|
+ headers = {"Content-Type":"application/x-www-form-urlencoded"}
|
|
|
+ r = requests.post(url,headers=headers,data=body)
|
|
|
+ r = json.loads(r.text)
|
|
|
+ if 'error' not in r :
|
|
|
+ self.access_token = r['access_token']
|
|
|
+ def get_user(self):
|
|
|
+ url = "https://api.box.com/2.0/users/me"
|
|
|
+ headers = {"Authorization":"Bearer "+self.access_token}
|
|
|
+ r = requests.get(url,headers=headers)
|
|
|
+ r = json.loads(r.text)
|
|
|
+ if 'login' in r :
|
|
|
+ #BYTES_TO_GB = 1000000000
|
|
|
+ user = {"uii":r['name'],"uid":r['login']}
|
|
|
+ usage = {"size":r['space_amount']/Cloud.BYTES_TO_GB,"used":r['space_used']/Cloud.BYTES_TO_GB,"units":"GB"}
|
|
|
+ user['usage'] = usage
|
|
|
+ return user
|
|
|
+ else:
|
|
|
+ return None
|
|
|
+
|
|
|
+ def format(self,item) :
|
|
|
+ file = {"name":item['name'],"origin":"box","id":item['id'],"url":""}
|
|
|
+ meta = {"last_modified":item['content_modified_at']}
|
|
|
+ return file
|
|
|
+ def get_files(self,ext,url=None):
|
|
|
+ ext = " ".join(ext)
|
|
|
+ url = "https://api.box.com/2.0/search?query=:filter&type=file"
|
|
|
+ url = url.replace(":filter",ext)
|
|
|
+ headers = {"Authorization":"Bearer "+self.access_token}
|
|
|
+
|
|
|
+ r = requests.get(url,headers=headers) ;
|
|
|
+ r = json.loads(r.text)
|
|
|
+ if 'entries' in r:
|
|
|
+ #self.files = [ self.format(file) for file in r['entries'] if file['type'] == 'file' and 'id' in file]
|
|
|
+ for item in r :
|
|
|
+ if item['type'] == 'file' and 'id' in item :
|
|
|
+ self.files.append( self.format(item))
|
|
|
+ else:
|
|
|
+ #
|
|
|
+ # We are dealing with a folder, this is necessary uploads
|
|
|
+ #
|
|
|
+ self.folder[item['name']] = item["id"]
|
|
|
+
|
|
|
+ return self.files
|
|
|
+ def stream(self,url):
|
|
|
+ headers = {"Authorization":"Bearer "+self.access_token}
|
|
|
+ r = requests.get(url,headers=headers,stream=True)
|
|
|
+ yield r.content
|
|
|
+ def share(self,id):
|
|
|
+ url = "https://api.box.com/2.0/files/:id".replace(":id",id);
|
|
|
+ headers = {"Authorization":"Bearer "+self.access_token,"Content-Type":"application/json"}
|
|
|
+ body = {"shared_link":{"access":"open","permissions":{"can_download":True}}}
|
|
|
+ r = requests.put(url,headers=headers,data=json.dumps(body))
|
|
|
+ r = json.loads(r.text)
|
|
|
+ if 'shared_link' in r:
|
|
|
+ return r['shared_link']['download_url']
|
|
|
+
|
|
|
+ return None
|
|
|
+ def upload(self,folder,mimetype,file):
|
|
|
+ """
|
|
|
+ @param folder parent.id
|
|
|
+ @param name name of the file with extension
|
|
|
+ @param stream file content
|
|
|
+ """
|
|
|
+ if folder not in self.folders :
|
|
|
+ #
|
|
|
+ # Let us create the folder now
|
|
|
+ #
|
|
|
+ url = "https://api.box.com/2.0/folders"
|
|
|
+ header = {"Authorization":"Bearer "+self.access_token}
|
|
|
+ pid = self.folders["/"] if "/" in self.folders else self.folders[""]
|
|
|
+ data = {"parent":{"id":str(pid)}}
|
|
|
+
|
|
|
+ r = requests.post(url,header=header,data=data)
|
|
|
+ r = r.json()
|
|
|
+ pid = r["id"]
|
|
|
+ else:
|
|
|
+ pid = self.folders[folder]
|
|
|
+ url = "https://upload.box.com/api/2.0/files/content"
|
|
|
+ header = {"Authorization Bearer ":self.access_token,"Content-Type":mimetype}
|
|
|
+ r = requests.post(url,header=header,file=file)
|
|
|
+ r = r.json()
|
|
|
+ return r
|
|
|
+
|
|
|
+
|
|
|
+class SugarSync(Cloud):
|
|
|
+ def __init__(self):
|
|
|
+ Cloud.__init__(self)
|
|
|
+
|
|
|
+ def __init__(self,conf):
|
|
|
+ Cloud.__init__(self);
|
|
|
+ if conf is not None:
|
|
|
+ self.client_id = conf['app_id']
|
|
|
+ self.private_key = conf['private_key']
|
|
|
+ self.access_key = conf['access_key']
|
|
|
+ #self.access_token = None
|
|
|
+ #self.refresh_token= None
|
|
|
+ # self.redirect_uri = conf['redirect_uri'] if 'redirect_uri' in conf else None
|
|
|
+ #self.files = []
|
|
|
+ def init(self,token):
|
|
|
+ self.refresh_token = token
|
|
|
+ self._refresh()
|
|
|
+ def login(self,email,password):
|
|
|
+ xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><appAuthorization><username>:username</username><password>:password</password><application>:app_id</application><accessKeyId>:accesskey</accessKeyId><privateAccessKey>:privatekey</privateAccessKey></appAuthorization>'
|
|
|
+ xml = xml.replace(":app_id",self.app_id).replace(":privatekey",self.private_key).replace(":accesskey",self.access_key).replace(":username",email).replace(":password",password)
|
|
|
+ headers = {"Content-Type":"application/xml","User-Agent":"The Phi Technology"}
|
|
|
+ r = requests.post(url,headers=headers,data=xml)
|
|
|
+ self.refresh_token = r.headers['Location']
|
|
|
+
|
|
|
+
|
|
|
+ def _refresh(self):
|
|
|
+ xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><tokenAuthRequest><accessKeyId>:accesskey</accessKeyId><privateAccessKey>:privatekey</privateAccessKey><refreshToken>:authtoken</refreshToken></tokenAuthRequest>'
|
|
|
+ xml = xml.replace(":accesskey",self.access_key).replace(":privatekey",self.private_key).replace(":authtoken",self.refresh_token)
|
|
|
+
|
|
|
+ headers = {"Content-Type":"application/xml","User-Agent":"The Phi Technology LLC"}
|
|
|
+ url = "https://api.sugarsync.com/authorization"
|
|
|
+ r = requests.post(url,data=xml,headers=headers)
|
|
|
+
|
|
|
+ self.access_token = r.headers['Location']
|
|
|
+ def format(self,item):
|
|
|
+ file = {}
|
|
|
+ file['name'] = item['displayName']
|
|
|
+ file['url'] = item['fileData']
|
|
|
+ file['id'] = item['ref']
|
|
|
+ meta = {}
|
|
|
+ meta['last_modified'] = item['lastModified']
|
|
|
+ file['meta'] = meta
|
|
|
+ return file
|
|
|
+
|
|
|
+ def get_files(self,ext,url=None) :
|
|
|
+ if url is None:
|
|
|
+ url = "https://api.sugarsync.com/folder/:sc:3989243:2/contents";
|
|
|
+ headers = {"Authorization":self.access_token,"User-Agent":"The Phi Technology LLC","Content-Type":"application/xml;charset=utf-8"}
|
|
|
+ r = requests.get(url,headers=headers)
|
|
|
+ stream = r.text #.encode('utf-8')
|
|
|
+ r = xmltodict.parse(r.text)
|
|
|
+
|
|
|
+ if 'collectionContents' in r:
|
|
|
+
|
|
|
+ r = r['collectionContents']
|
|
|
+ #
|
|
|
+ # Extracting files in the current folder then we will see if there are any subfolders
|
|
|
+ # The parser has weird behaviors that leave inconsistent objects (field names)
|
|
|
+ # This means we have to filter it out by testing the item being processed
|
|
|
+ if 'file' in r:
|
|
|
+ if isinstance(r['file'],dict):
|
|
|
+ self.files += [ self.format(r['file']) ]
|
|
|
+ else:
|
|
|
+
|
|
|
+ #self.files += [self.format(item) for item in r['file'] if isinstance(item,(str, unicode)) == False and item['displayName'].endswith(ext)]
|
|
|
+ self.files += [self.format(item) for item in r['file'] if isinstance(item,(str, unicode)) == False and self.match(item['displayName'],ext)]
|
|
|
+
|
|
|
+ if 'collection' in r:
|
|
|
+ if isinstance(r['collection'],dict) :
|
|
|
+ #
|
|
|
+ # For some unusual reason the parser handles single instances as objects instead of collection
|
|
|
+ # @NOTE: This is a behavior that happens when a single item is in the collection
|
|
|
+ #
|
|
|
+ self.get_files(ext,r['collection']['contents'])
|
|
|
+ for item in r['collection'] :
|
|
|
+ if 'contents' in item:
|
|
|
+ if isinstance(item,(str, unicode)) == False:
|
|
|
+ self.files += self.get_files(ext,item['contents'])
|
|
|
+ #[ self.get_files(ext,item['contents']) for item in r['collection'] if item['type'] == 'folder']
|
|
|
+ return self.files
|
|
|
+
|
|
|
+ def get_user(self):
|
|
|
+ url = "https://api.sugarsync.com/user"
|
|
|
+ headers = {"Authorization":self.access_token,"User-Agent":"The Phi Technology LLC","Content-Type":"application/xml;charset=utf-8"}
|
|
|
+ r = requests.get(url,headers=headers)
|
|
|
+
|
|
|
+ r = xmltodict.parse(r.text)
|
|
|
+ r = r['user']
|
|
|
+
|
|
|
+
|
|
|
+ if 'username' in r and 'quota' in r:
|
|
|
+ user = {"uid":r['username'],"uii":r['nickname']}
|
|
|
+ size = long(r['quota']['limit'])
|
|
|
+ used = long(r['quota']['usage'])
|
|
|
+ usage = {"size":size/Cloud.BYTES_TO_GB,"used":used/Cloud.BYTES_TO_GB,"units":"GB"}
|
|
|
+ user['usage'] = usage
|
|
|
+ return user
|
|
|
+ else:
|
|
|
+ return None
|
|
|
+ def stream(self,url):
|
|
|
+ headers = {"Authorization":self.access_token}
|
|
|
+ r = requests.get(url,headers=headers,stream=True)
|
|
|
+ yield r.content
|
|
|
+ """
|
|
|
+ This function will create a public link and share it to designated parties
|
|
|
+ """
|
|
|
+ def share(self,id):
|
|
|
+ url = "https://api.sugarsync.com/file/:id".replace(":id",id);
|
|
|
+ xml = '<?xml version="1.0" encoding="UTF-8" ?><file><publicLink enabled="true"/></file>';
|
|
|
+ headers = {"Content-Type":"application/xml","Authorization":self.access_token,"User-Agent":"The Phi Technology LLC"}
|
|
|
+ r = requests.put(url,header=header,data=xml)
|
|
|
+ r = xmltodict.parse(r.text)
|
|
|
+ if 'file' in r:
|
|
|
+ return r['file']['publicLink']['content']+"?directDownload=true"
|
|
|
+ else:
|
|
|
+ return None
|
|
|
+
|
|
|
+ def upload(self,folder,mimetype,file):
|
|
|
+
|
|
|
+ name = foler+"/"+file.filename
|
|
|
+ xml = '<?xml version="1.0" encoding="UTF-8" ?><file><displayName>:name</displayName><mediaType>:type</mediaType></file>'
|
|
|
+ xml = xml.replace(':name',name).replace(':type',mimetype)
|
|
|
+ header = {"content-type":"application/xml","User-Agent":"The Phi Technology LLC"}
|
|
|
+ header['Authorization'] = self.access_token
|
|
|
+
|
|
|
+ r = requests.post(url,headers=header,files=file,data=xml)
|
|
|
+ pass
|
|
|
+
|
|
|
+class iTunes(Cloud):
|
|
|
+ def __init__(self):
|
|
|
+ Cloud.__init__(self)
|
|
|
+ self.url_topsongs = "http://ax.itunes.apple.com/WebObjects/MZStoreServices.woa/ws/RSS/topsongs/limit=:limit/explicit=false/json"
|
|
|
+ self.url_search = "http://itunes.apple.com/search?term=:keyword&limit=:limit&media=music"
|
|
|
+ def parse_search(self,obj):
|
|
|
+
|
|
|
+ files = []
|
|
|
+ try:
|
|
|
+ logs = obj['results']
|
|
|
+
|
|
|
+ for item in logs :
|
|
|
+
|
|
|
+ file = {}
|
|
|
+ file['id'] = item['trackId']
|
|
|
+ file['name'] = item['trackName']
|
|
|
+ file['id3'] = {}
|
|
|
+ file['id3']['track'] = item['trackName']
|
|
|
+ file['id3']['title'] = item['trackName']
|
|
|
+ file['id3']['artist']= item['artistName']
|
|
|
+ file['id3']['album'] = item['collectionName']
|
|
|
+ file['id3']['genre'] = item['primaryGenreName']
|
|
|
+ file['id3']['poster']= item['artworkUrl100']
|
|
|
+ file['url'] = item['previewUrl']
|
|
|
+
|
|
|
+ files.append(file)
|
|
|
+ except Exception,e:
|
|
|
+ print e
|
|
|
+ return files
|
|
|
+ def parse_chart(self,obj):
|
|
|
+ """
|
|
|
+ This function will parse the tonsongs returned by the itunes API
|
|
|
+ """
|
|
|
+ files = []
|
|
|
+
|
|
|
+ try:
|
|
|
+ logs = obj['feed']['entry']
|
|
|
+ if isinstance(logs,dict) :
|
|
|
+ logs = [logs]
|
|
|
+
|
|
|
+ for item in logs :
|
|
|
+
|
|
|
+ file = {'name':item['im:name']['label'],'id3':{}}
|
|
|
+ file['id'] = item['id']['attributes']['im:id']
|
|
|
+ file['id3'] = {}
|
|
|
+ file['id3']['artist'] = item['im:artist']['label']
|
|
|
+ file['id3']['track'] = item['title']['label']
|
|
|
+ file['id3']['title'] = item['title']['label']
|
|
|
+ file['id3']['album'] = item['im:collection']['im:name']['label']
|
|
|
+ file['id3']['genre'] = item['category']['attributes']['term']
|
|
|
+ index = len(item['im:image'])-1
|
|
|
+ file['id3']['poster'] = item['im:image'][index]['label']
|
|
|
+ url = [link['attributes']['href'] for link in item['link'] if 'im:assetType' in link['attributes'] and link['attributes']['im:assetType']=='preview']
|
|
|
+
|
|
|
+ if len(url) > 0:
|
|
|
+ url = url[0]
|
|
|
+ file['url'] = url #item['link'][1]['attributes']['href'] //'im:assetType' == 'preview' and 'im:duration' is in the sub-item
|
|
|
+ files.append(file)
|
|
|
+
|
|
|
+ else:
|
|
|
+ continue
|
|
|
+ except Exception,e:
|
|
|
+ print e
|
|
|
+ #
|
|
|
+ # @TODO: Log the error somewhere to make it useful
|
|
|
+
|
|
|
+ return files
|
|
|
+
|
|
|
+ def parse(self,obj) :
|
|
|
+ if 'feed' in obj and 'entry' in obj['feed']:
|
|
|
+ return self.parse_chart(obj)
|
|
|
+ elif 'results' in obj :
|
|
|
+ return self.parse_search(obj)
|
|
|
+ else:
|
|
|
+ return []
|
|
|
+ def get_files(self,keyword=None,limit="1") :
|
|
|
+ url = self.url_search if keyword is not None else self.url_topsongs
|
|
|
+ keyword = "" if keyword is None else keyword
|
|
|
+ # limit = "50" if keyword == "" else "1"
|
|
|
+
|
|
|
+ url = url.replace(":keyword",keyword.replace(' ','+')).replace(':limit',limit)
|
|
|
+ r = requests.get(url)
|
|
|
+ r= r.json()
|
|
|
+ return self.parse(r)
|
