Cura/util/youmagine.py

   1 from __future__ import absolute_import
   2 __copyright__ = "Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License"
   3
   4 import json
   5 import httplib as httpclient
   6 import urllib
   7
   8 class httpUploadDataStream(object):
   9         def __init__(self, progressCallback):
  10                 self._dataList = []
  11                 self._totalLength = 0
  12                 self._readPos = 0
  13                 self._progressCallback = progressCallback
  14
  15         def write(self, data):
  16                 size = len(data)
  17                 if size < 1:
  18                         return
  19                 blocks = size / 2048
  20                 for n in xrange(0, blocks):
  21                         self._dataList.append(data[n*2048:n*2048+2048])
  22                 self._dataList.append(data[blocks*2048:])
  23                 self._totalLength += size
  24
  25         def read(self, size):
  26                 if self._readPos >= len(self._dataList):
  27                         return None
  28                 ret = self._dataList[self._readPos]
  29                 self._readPos += 1
  30                 if self._progressCallback is not None:
  31                         self._progressCallback(float(self._readPos / len(self._dataList)))
  32                 return ret
  33
  34         def __len__(self):
  35                 return self._totalLength
  36
  37 class Youmagine(object):
  38         def __init__(self, authToken, progressCallback = None):
  39                 self._hostUrl = 'api.youmagine.com'
  40                 self._viewUrl = 'www.youmagine.com'
  41                 self._authUrl = 'https://www.youmagine.com/integrations/cura/authorized_integrations/new'
  42                 self._authToken = authToken
  43                 self._userName = None
  44                 self._userID = None
  45                 self._http = None
  46                 self._hostReachable = True
  47                 self._progressCallback = progressCallback
  48                 self._categories = [
  49                         ('Art', 2),
  50                         ('Fashion', 3),
  51                         ('For your home', 4),
  52                         ('Gadget', 5),
  53                         ('Games', 6),
  54                         ('Jewelry', 7),
  55                         ('Maker/DIY', 8),
  56                         ('Miniatures', 9),
  57                         ('Other', 1),
  58                 ]
  59                 self._licenses = [
  60                         ('Creative Commons - Share Alike', 'cc'),
  61                         ('Creative Commons - Attribution-NonCommercial-ShareAlike', 'ccnc'),
  62                         ('GPLv3', 'gplv3'),
  63                 ]
  64
  65         def getAuthorizationUrl(self):
  66                 return self._authUrl
  67
  68         def getCategories(self):
  69                 return map(lambda n: n[0], self._categories)
  70
  71         def getLicenses(self):
  72                 return map(lambda n: n[0], self._licenses)
  73
  74         def setAuthToken(self, token):
  75                 self._authToken = token
  76                 self._userName = None
  77                 self._userID = None
  78
  79         def getAuthToken(self):
  80                 return self._authToken
  81
  82         def isHostReachable(self):
  83                 return self._hostReachable
  84
  85         def viewUrlForDesign(self, id):
  86                 return 'https://%s/designs/%d' % (self._viewUrl, id)
  87
  88         def editUrlForDesign(self, id):
  89                 return 'https://%s/designs/%d/edit' % (self._viewUrl, id)
  90
  91         def isAuthorized(self):
  92                 if self._authToken is None:
  93                         return False
  94                 if self._userName is None:
  95                         #No username yet, try to request the username to see if the authToken is valid.
  96                         result = self._request('GET', '/authorized_integrations/%s/whoami.json' % (self._authToken))
  97
  98                         if 'error' in result:
  99                                 self._authToken = None
 100                                 return False
 101                         self._userName = result['screen_name']
 102                         self._userID = result['id']
 103                 return True
 104
 105         def createDesign(self, name, description, category, license):
 106                 res = self._request('POST', '/designs.json', {'design[name]': name, 'design[excerpt]': description, 'design[design_category_id]': filter(lambda n: n[0] == category, self._categories)[0][1], 'design[license]': filter(lambda n: n[0] == license, self._licenses)[0][1]})
 107                 if 'id' in res:
 108                         return res['id']
 109                 print res
 110                 return None
 111
 112         def publishDesign(self, id):
 113                 res = self._request('PUT', '/designs/%d/mark_as/publish.json' % (id), {'ignore': 'me'})
 114                 if res is not None:
 115                         return False
 116                 return True
 117
 118         def createDocument(self, designId, name, contents):
 119                 res = self._request('POST', '/designs/%d/documents.json' % (designId), {'document[name]': name, 'document[description]': 'Uploaded from Cura'}, {'document[file]': (name, contents)})
 120                 if 'id' in res:
 121                         return res['id']
 122                 print res
 123                 return None
 124
 125         def createImage(self, designId, name, contents):
 126                 res = self._request('POST', '/designs/%d/images.json' % (designId), {'image[name]': name, 'image[description]': 'Uploaded from Cura'}, {'image[file]': (name, contents)})
 127                 if 'id' in res:
 128                         return res['id']
 129                 print res
 130                 return None
 131
 132         def listDesigns(self):
 133                 res = self._request('GET', '/users/%s/designs.json' % (self._userID))
 134                 return res
 135
 136         def _request(self, method, url, postData = None, files = None):
 137                 retryCount = 2
 138                 if self._authToken is not None:
 139                         url += '?auth_token=%s' % (self._authToken)
 140                 error = 'Failed to connect to %s' % self._hostUrl
 141                 for n in xrange(0, retryCount):
 142                         if self._http is None:
 143                                 self._http = httpclient.HTTPSConnection(self._hostUrl)
 144                         try:
 145                                 if files is not None:
 146                                         boundary = 'wL36Yn8afVp8Ag7AmP8qZ0SA4n1v9T'
 147                                         s = httpUploadDataStream(self._progressCallback)
 148                                         for k, v in files.iteritems():
 149                                                 filename = v[0]
 150                                                 fileContents = v[1]
 151                                                 s.write('--%s\r\n' % (boundary))
 152                                                 s.write('Content-Disposition: form-data; name="%s"; filename="%s"\r\n' % (k, filename))
 153                                                 s.write('Content-Type: application/octet-stream\r\n')
 154                                                 s.write('Content-Transfer-Encoding: binary\r\n')
 155                                                 s.write('\r\n')
 156                                                 s.write(fileContents)
 157                                                 s.write('\r\n')
 158
 159                                         for k, v in postData.iteritems():
 160                                                 s.write('--%s\r\n' % (boundary))
 161                                                 s.write('Content-Disposition: form-data; name="%s"\r\n' % (k))
 162                                                 s.write('\r\n')
 163                                                 s.write(str(v))
 164                                                 s.write('\r\n')
 165                                         s.write('--%s--\r\n' % (boundary))
 166
 167                                         self._http.request(method, url, s, {"Content-type": "multipart/form-data; boundary=%s" % (boundary), "Content-Length": len(s)})
 168                                 elif postData is not None:
 169                                         self._http.request(method, url, urllib.urlencode(postData), {"Content-type": "application/x-www-form-urlencoded"})
 170                                 else:
 171                                         self._http.request(method, url)
 172                         except IOError:
 173                                 self._http.close()
 174                                 continue
 175                         try:
 176                                 response = self._http.getresponse()
 177                                 responseText = response.read()
 178                         except:
 179                                 self._http.close()
 180                                 continue
 181                         try:
 182                                 if responseText == '':
 183                                         return None
 184                                 return json.loads(responseText)
 185                         except ValueError:
 186                                 print response.getheaders()
 187                                 print responseText
 188                                 error = 'Failed to decode JSON response'
 189                 self._hostReachable = False
 190                 return {'error': error}
 191
 192
 193 #Fake Youmagine class to test without internet
 194 class FakeYoumagine(Youmagine):
 195         def __init__(self, authToken, callback):
 196                 super(FakeYoumagine, self).__init__(authToken)
 197                 self._authUrl = 'file:///C:/Models/output.html'
 198                 self._authToken = None
 199
 200         def isAuthorized(self):
 201                 if self._authToken is None:
 202                         return False
 203                 if self._userName is None:
 204                         self._userName = 'FakeYoumagine'
 205                         self._userID = '1'
 206                 return True
 207
 208         def isHostReachable(self):
 209                 return True
 210
 211         def createDesign(self, name, description, category, license):
 212                 return 1
 213
 214         def publishDesign(self, id):
 215                 pass
 216
 217         def createDocument(self, designId, name, contents):
 218                 print "Create document: %s" % (name)
 219                 f = open("C:/models/%s" % (name), "wb")
 220                 f.write(contents)
 221                 f.close()
 222                 return 1
 223
 224         def createImage(self, designId, name, contents):
 225                 print "Create image: %s" % (name)
 226                 f = open("C:/models/%s" % (name), "wb")
 227                 f.write(contents)
 228                 f.close()
 229                 return 1
 230
 231         def listDesigns(self):
 232                 return []
 233
 234         def _request(self, method, url, postData = None, files = None):
 235                 print "Err: Tried to do request: %s %s" % (method, url)
 236
 237 def main():
 238         ym = Youmagine('j3rY9kQF62ptuZF7vqbR')
 239         if not ym.isAuthorized():
 240                 print "Failed to authorize"
 241                 return
 242         for design in ym.listDesigns():
 243                 print design['name']