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                         print res
 116                         return False
 117                 return True
 118
 119         def createDocument(self, designId, name, contents):
 120                 res = self._request('POST', '/designs/%d/documents.json' % (designId), {'document[name]': name, 'document[description]': 'Uploaded from Cura'}, {'document[file]': (name, contents)})
 121                 if 'id' in res:
 122                         return res['id']
 123                 print res
 124                 return None
 125
 126         def createImage(self, designId, name, contents):
 127                 res = self._request('POST', '/designs/%d/images.json' % (designId), {'image[name]': name, 'image[description]': 'Uploaded from Cura'}, {'image[file]': (name, contents)})
 128                 if 'id' in res:
 129                         return res['id']
 130                 print res
 131                 return None
 132
 133         def listDesigns(self):
 134                 res = self._request('GET', '/users/%s/designs.json' % (self._userID))
 135                 return res
 136
 137         def _request(self, method, url, postData = None, files = None):
 138                 retryCount = 2
 139                 if self._authToken is not None:
 140                         url += '?auth_token=%s' % (self._authToken)
 141                 error = 'Failed to connect to %s' % self._hostUrl
 142                 for n in xrange(0, retryCount):
 143                         if self._http is None:
 144                                 self._http = httpclient.HTTPSConnection(self._hostUrl)
 145                         try:
 146                                 if files is not None:
 147                                         boundary = 'wL36Yn8afVp8Ag7AmP8qZ0SA4n1v9T'
 148                                         s = httpUploadDataStream(self._progressCallback)
 149                                         for k, v in files.iteritems():
 150                                                 filename = v[0]
 151                                                 fileContents = v[1]
 152                                                 s.write('--%s\r\n' % (boundary))
 153                                                 s.write('Content-Disposition: form-data; name="%s"; filename="%s"\r\n' % (k, filename))
 154                                                 s.write('Content-Type: application/octet-stream\r\n')
 155                                                 s.write('Content-Transfer-Encoding: binary\r\n')
 156                                                 s.write('\r\n')
 157                                                 s.write(fileContents)
 158                                                 s.write('\r\n')
 159
 160                                         for k, v in postData.iteritems():
 161                                                 s.write('--%s\r\n' % (boundary))
 162                                                 s.write('Content-Disposition: form-data; name="%s"\r\n' % (k))
 163                                                 s.write('\r\n')
 164                                                 s.write(str(v))
 165                                                 s.write('\r\n')
 166                                         s.write('--%s--\r\n' % (boundary))
 167
 168                                         self._http.request(method, url, s, {"Content-type": "multipart/form-data; boundary=%s" % (boundary), "Content-Length": len(s)})
 169                                 elif postData is not None:
 170                                         self._http.request(method, url, urllib.urlencode(postData), {"Content-type": "application/x-www-form-urlencoded"})
 171                                 else:
 172                                         self._http.request(method, url)
 173                         except IOError:
 174                                 self._http.close()
 175                                 continue
 176                         try:
 177                                 response = self._http.getresponse()
 178                                 responseText = response.read()
 179                         except:
 180                                 self._http.close()
 181                                 continue
 182                         try:
 183                                 if responseText == '':
 184                                         return None
 185                                 return json.loads(responseText)
 186                         except ValueError:
 187                                 print response.getheaders()
 188                                 print responseText
 189                                 error = 'Failed to decode JSON response'
 190                 self._hostReachable = False
 191                 return {'error': error}
 192
 193
 194 #Fake Youmagine class to test without internet
 195 class FakeYoumagine(Youmagine):
 196         def __init__(self, authToken):
 197                 super(FakeYoumagine, self).__init__(authToken)
 198                 self._authUrl = 'file:///C:/Models/output.html'
 199                 self._authToken = None
 200
 201         def isAuthorized(self):
 202                 if self._authToken is None:
 203                         return False
 204                 if self._userName is None:
 205                         self._userName = 'FakeYoumagine'
 206                         self._userID = '1'
 207                 return True
 208
 209         def isHostReachable(self):
 210                 return True
 211
 212         def createDesign(self, name, description, category, license):
 213                 return 1
 214
 215         def publishDesign(self, id):
 216                 pass
 217
 218         def createDocument(self, designId, name, contents):
 219                 print "Create document: %s" % (name)
 220                 f = open("C:/models/%s" % (name), "wb")
 221                 f.write(contents)
 222                 f.close()
 223                 return 1
 224
 225         def createImage(self, designId, name, contents):
 226                 print "Create image: %s" % (name)
 227                 f = open("C:/models/%s" % (name), "wb")
 228                 f.write(contents)
 229                 f.close()
 230                 return 1
 231
 232         def listDesigns(self):
 233                 return []
 234
 235         def _request(self, method, url, postData = None, files = None):
 236                 print "Err: Tried to do request: %s %s" % (method, url)
 237
 238 def main():
 239         ym = Youmagine('j3rY9kQF62ptuZF7vqbR')
 240         if not ym.isAuthorized():
 241                 print "Failed to authorize"
 242                 return
 243         for design in ym.listDesigns():
 244                 print design['name']