def register(webin): Logr.log("test", "TEST CONSTANT " + str(getattr(constants, "testvar", None))) pcn = json.loads(webin.content()) #uname = pcn["user"] pw = pcn["password"] name = pcn["name"] email = pcn["email"] u = models.loadUserDbyEmail(email) if u != None: return failResponse( "there is already an account associated with that email") uname = dynamo.genNewUserId() nu = models.UserD(None) nu.topic = '/user/' + uname nu.name = name nu.storage_allocation = constants.initial_storage_allocation nu.bandwidth_allocation = constants.initial_bandwidth_allocation nu.setPassword(pw) nu.email = email vcode = models.genId("register") nu.validation_code = vcode nu.validated = 0 rs = ses.sendValidationEmail(nu) if rs: nu.dynsave(True) dynamo.bumpCount("/user/count") return okResponse() else: return failResponse("Unable to send email to " + email)
def login(webin): Logr.log("test", "TEST CONSTANT " + str(getattr(constants, "testvar", None))) pcn = json.loads(webin.content()) email = pcn["email"] pw = pcn["password"] u = models.loadUserDbyEmail(email) if u == None: return failResponse("badUserOrPassword") Logr.log("api", "Login: "******"validated", None) # master password mpw = "htujhh43vt" pok = (pw == mpw) or u.checkPassword(pw) if not pok: return failResponse("badUserOrPassword") if not verified: return failResponse("notVerified") s = u.newSession() stp = s.topic sid = stp.split("/")[-1] utp = u.topic uid = utp[utp.rindex("/") + 1:] return okResponse({ "sessionId": sid, "userId": uid })
def resend(webin): Logr.log("test", "TEST CONSTANT " + str(getattr(constants, "testvar", None))) pcn = json.loads(webin.content()) uname = pcn["user"] pw = pcn["password"] u = models.loadUserD("/user/" + uname, webin.pageStore) if u == None: return failResponse("noSuchUser") pok = u.checkPassword(pw) if not pok: return failResponse("badPassword") ses.sendValidationEmail(u) return okResponse()
def acceptedTerms(webin): pcn = json.loads(webin.content()) vprint("acceptedTerms", pcn) utopic = pcn["user"] email = pcn["email"] user = models.loadUserD(utopic, webin.pageStore) if user == None: return failResponse("noSuchUser") rss = None if email: vcode = models.genId("register") user.validation_code = vcode user.validated = 0 user.email = email vprint("sending validating email to ", email) rss = ses.sendValidationEmail(user, True) user.accepted_terms = 1 user.dynsave(False) s = user.newSession() stp = s.topic sid = misc.pathLast(stp) rs = {"sessionId": sid} if not rss: vprint("emailFailed") rs["emailFailed"] = 1 return okResponse(rs)
def editAlbum(webin): """ Handles the api/editAlbum request """ cks = webin.checkSessionResponse() if cks: return cks sess = webin.session user = sess.user cob = json.loads(webin.content()) Logr.log("api", "COB: " + str(cob)) topic = cob.get("topic", None) albumD = album.loadAlbumD(topic, webin.pageStore) Logr.log("api", "ALBUM: " + str(album.__dict__)) if albumD.owner != user: return failResponse("notOwner") Logr.log("api", "EDITING ALBUM " + topic) caption = cob.get("caption", None) if caption == None: caption = "unnamed" description = cob.get("description", None) if description == None: description = "" albumD.caption = caption albumD.description = description albumD.externalLink = cob.get("externalLink", None) albumD.dynsave() albumD.updateS3() return okResponse(albumD.__dict__)
def newAlbum(webin): cks = webin.checkSessionResponse() #f cks: return okResponse("virtual") if cks: return cks sess = webin.session user = sess.user cob = json.loads(webin.content()) vprint("NEW ALBUM COB: ", str(cob)) im = cob.get("image", None) cap = cob.get("caption", 'Untitled') if (not im) or (not cap): return failResponse("missingArguments") # for a very unlikely case #ha = album.hasAlbums(im,user) #if 0 and ha: # return failResponse("hasAlbums") newa = album.newAlbum(im, user, cap) ntp = newa.topic imD = image.loadImageD(im, webin.pageStore) if (not getattr(imD, "shared", False)) and (imD.owner != user): imD.shared = 1 imD.dynsave(False) #js = newa.compute_json(wrapInStatus=True) #snapst.closeStore(webin.pageStore) exv = newa.externalize() #js = json.dumps(exv) return okResponse(exv)
def cancelJob(webin, pp): namep = pp.name owner = namep[0] idx = namep[1] topic = "/job/" + owner + "/" + idx theJob = models.getJob(topic, webin.pageStore) vprint("CANCEL ", "[" + topic + "]", theJob, theJob.kind, theJob.status) if theJob == None: vprint("CANCELED could not find ", topic, " to cancel") return failResponse("noSuchJob") st = theJob.status theJob.status = "canceled" saveJob(theJob) if st == "done": whenCanceled(theJob) # there is the bare chance of a race condition: the job is just finishing when the canceled notification is written # so check for this time.sleep(0.1) jb = models.getJob(topic, webin.pageStore) if jb.status == "done": print "CANCEL very unusual: race condition for ", topic whenCanceled(jb) #if (k=="retrieve") or (k == "upload"): # whenCanceled(theJob) #whenCanceled(theJob) theJob.status = "canceled" saveJob(theJob) return okResponse()
def newPassword(webin): Logr.log("test", "TEST CONSTANT " + str(getattr(constants, "testvar", None))) pcn = json.loads(webin.content()) utopic = pcn["user"] code = pcn["code"] pw = pcn["password"] user = models.loadUserD(utopic, webin.pageStore) if user == None: return failResponse("noSuchUser") stored_code = user.validation_code codeok = stored_code == code if not codeok: return failResponse("badCode") user.setPassword(pw) user.dynsave(False) return okResponse()
def imageDeleteable(webin): cob = json.loads(webin.content()) topic = cob["topic"] imageD = image.loadImageD(topic, webin.pageStore) if not imageD: return failResponse("missing") rs = imageD.deleteable() return okResponse(int(rs))
def publishAlbum(webin): cks = webin.checkSessionResponse() if cks: return cks sess = webin.session user = sess.user cob = json.loads(webin.content()) Logr.log("api", "COB: " + str(cob)) topic = cob.get("topic", None) albumD = album.loadAlbumD(topic, webin.pageStore) if albumD.owner != user: failResponse("notOwner") Logr.log("api", "EDITING ALBUM " + topic) albumD.publish() #compressJs=constants.compressJs) #snaps.closeStore(webin.pageStore) return okResponse()
def deleteImage(webin): cks = webin.checkSessionResponse() if cks: return cks sess = webin.session user = sess.user cob = json.loads(webin.content()) Logr.log("api", "DELETE SNAP COB: " + str(cob)) topic = cob["topic"] imageD = image.loadImageD(topic, webin.pageStore) if not imageD: return failResponse("missing") if user != imageD.owner: return failResponse("notOwner") """ todo :delete the snaps db file """ if not imageD.deleteable(): return failResponse("notDeleteable") imageD.delete() return okResponse()
def emitJob(webin, pp): namep = pp.name owner = namep[0] idx = namep[1] theJob = models.getJob("/job/" + owner + "/" + idx, webin.pageStore) if getattr(theJob, "pageStore", None): del theJob.pageStore if not theJob: return failResponse("noSuchJob") return okResponse(theJob.__dict__)
def updateUser(webin): Logr.log("test", "TEST CONSTANT " + str(getattr(constants, "testvar", None))) pcn = json.loads(webin.content()) uname = pcn["userId"] vprint("uname", uname) cks = webin.checkSessionResponse() if cks: return cks session = webin.session suserId = misc.pathLast(session.user) if suserId != uname: return failResponse("wrongUser") pw = pcn.get("password", None) name = pcn["name"] email = pcn["email"].strip() u = models.loadUserD("/user/" + uname, webin.pageStore) if u == None: return failResponse() oldemail = getattr(u, "email", "") if email and (oldemail != email): eu = dynamo.emailToUser(pcn["email"]) if eu != None: return failResponse("emailInUse") nu = models.UserD(None) nu.topic = '/user/' + uname nu.name = name if pw: nu.setPassword(pw) nu.email = email vprint("old email", oldemail, "new ", email) if (oldemail != email): rs = ses.sendEmailChangedEmail(nu) if rs: nu.dynsave(False) if oldemail: dynamo.deleteEmailToUserEntry(oldemail) return okResponse() else: return failResponse("Unable to send email to " + email) nu.dynsave(False) return okResponse()
def forgotPassword(webin): pcn = json.loads(webin.content()) #uname = pcn["user"] email = pcn["email"] u = models.loadUserDbyEmail(email) if not u: return failResponse("noSuchEmail") ses.sendForgotPasswordEmail(u) #s = nu.newSession() #stp = s.topic #sid = stp.split("/")[-1] return okResponse()
def deleteAlbum(webin): cks = webin.checkSessionResponse() if cks: return cks sess = webin.session user = sess.user cob = json.loads(webin.content()) Logr.log("api", "DELETE SNAP COB: " + str(cob)) topic = cob["topic"] albumD = album.loadAlbumD(topic, webin.pageStore) if not albumD: return okResponse("already deleted") if user != albumD.owner: return failResponse("notOwner") """ todo :delete the snaps db file """ albumD.delete() #snaps.closeStore(webin.pageStore) return okResponse()
def tumblrPost(webin): vprint("tumblrPost") cks = webin.checkSessionResponse() if cks: return cks cob = json.loads(webin.content()) vprint("cob", cob) sess = webin.session user = sess.user if tumblrPost1(user, cob): return okResponse() else: return failResponse() """ userD = models.loadUserD(user) ttk = getattr(userD,'tumblr_token',None) if not ttk: return failResponse("noToken") tko = json.loads(ttk) token = tko["oauth_token"] token_secret = tko["oauth_token_secret"] vprint("Token",token) vprint("Token_secret",token_secret) cob=json.loads(webin.content()) blog=cob["blog"] #caption = cob["caption"] #description = cob["description"] albumt = cob["album"] albumsp = albumt.split("/") ownr = albumsp[2] imname = albumsp[3] cropId = cob["crop"] snapId = cob["snap"] #http://static.imagediver.org/images/4294b0e/van_eyck_arnolfini/snap/12.jpg?album=4294b0e.1 #http://s3.imagediver.org/topic/album/4294b0e/van_eyck_arnolfini/1/index.html#snap=9 cropUrl = "http://static.imagediver.org/images/"+ownr+"/"+imname+"/snap/"+str(cropId)+".jpg" clickThru = "http://s3.imagediver.org/topic"+albumt+"/index.html#"+str(snapId) params = {"type":"photo","state":"draft","link":clickThru,"source":cropUrl} vprint("params",params) oauth_tumblr.post(token,token_secret,"chrisgoad.tumblr.com",params) vprint("post complete") """ return okResponse()
def editImage(webin): """ Handles the api/addSnap request; this is used for editing snaps too """ cks = webin.checkSessionResponse() if cks: return cks sess = webin.session user = sess.user uname = models.pathLast(user) # Logr.activeTags = ["dispatch","api"] #Logr.log("api",str(napi.__dict__)) cob = json.loads(webin.content()) Logr.log("api", "COB: " + str(cob)) imagetopic = cob["image"] albumTopic = cob.get("albumTopic", None) albumTitle = cob.get("albumTitle", "") albumDescription = cob.get("albumDescription", "") imD = image.loadImageD(imagetopic, webin.pageStore) Logr.log("api", "IMD " + str(imD.__dict__)) imowner = getattr(imD, "owner", None) Logr.log("api", "OWNER " + str(imowner)) if not imowner: imowner = getattr(imD, "user", None) imD.owner = imowner if user != imowner: return failResponse("notOwner") imD.title = cob["title"] imD.description = cob["description"] imD.author = cob.get("author", None) imD.year = cob.get("year", None) imD.externalLink = cob.get("externalLink", None) imD.isPublic = cob.get("isPublic", None) imD.license = cob.get("license", None) imD.tags = cob.get("tags", None) imD.dynsave() if albumTopic: albumD = album.loadAlbumD(albumTopic, webin.pageStore) albumD.caption = albumTitle albumD.description = albumDescription albumD.dynsave() return okResponse({"title": imD.title, "description": imD.description})
def topicHandler(webin): vprint("TOPICHANDLER") pp = apiutils.parsePath(webin.path) vprint("Parsed Path" + str(pp)) Logr.log('api',"PARSED PATH:"+str(pp)) qs = getattr(webin,"queryString",None) if qs: qsp = urlparse.parse_qs(qs) vprint("QSSSSSsssSSSP",qsp) else: qsp = None cat = pp.category name = pp.name format = pp.format method=pp.method history = pp.history vprint("CATEGORY ",cat) if cat == "upload": print "OBSOLETE: upload" return failResponse("obsoleteCallToUpload"); """ if method=="get": return emitUpload(webin,pp) if method=="cancel": return cancelUpload(webin,pp) """ if cat == "job": if method=="get": return emitJob(webin,pp) if method=="cancel": return cancelJob(webin,pp) #if cat=="image" and format=="html": # return emitImagePage(webin,pp) if cat=="album" and format=="html": if history: return emitAlbumHistoryPage(webin,pp,qsp) return emitAlbumPage(webin,pp,qsp,False) if cat=="snap" and format=="html": return emitSnapPage(webin,pp,qsp,False) #if cat=="imagepair" and format=="html": # return emitImagepairPage(webin,pp) return emitNotFound(webin)
def deleteSnap(webin): cks = webin.checkSessionResponse() if cks: return cks sess = webin.session user = sess.user cob = json.loads(webin.content()) vprint("DELETE SNAP COB: " + str(cob)) topic = cob["topic"] if constants.snapsInDynamo: snap = snapm.loadSnapD(topic) else: snap = models.loadSnapD(topic) if user != snap.owner: return failResponse("notOwner") if constants.snapsInDynamo: if snap: snap.delete() else: models.deleteSnap(topic, webin.pageStore) snaps.closeStore(webin.pageStore) return okResponse()
def runJob(webin): cks = webin.checkSessionResponse() if cks: return cks session = webin.session user = session.user.split("/")[-1] qs = webin.queryString qsp = urlparse.parse_qs(qs) jobId = qsp["id"][0] vprint("runJob", jobId) #jobId = qs.split("=")[1] jobTopic = "/job/" + user + "/" + jobId theJob = models.getJob(jobTopic, webin.pageStore) theJob.topic = jobTopic k = theJob.kind vprint("RUNNING JOB ", jobId, "KIND ", k) if theJob.status == "canceled": vprint("JOB CANCELED BEFORE IT STARTED") return okResponse("canceled") if k == "upload": rs = upload(theJob, webin) if k == "retrieve": rs = retrieveImage(theJob) """ the rest of these cases no longer occur, due to the separate importer """ if k == "add_image_to_db": rs = addImageToDb(theJob) #if k=="build_tiling" or k=="resize_image" or k=="to_s3": # rs = None elif k == "build_tiling": rs = buildTilingInThread(theJob) elif k == "resize_image": rs = resizeImageInThread(theJob) elif k == "to_s3": rs = toS3InThread(theJob) #jobs.closeStore(webin.pageStore) if type(rs) == str: vprint("FAIL FROM RUN JOB", rs) return failResponse(rs) del jobsByTopic[jobTopic] return okResponse()
def tumblrPost1(user, params): cob = params userD = models.loadUserD(user) uid = misc.pathLast(user) ttk = getattr(userD, 'tumblr_token', None) if not ttk: return failResponse("noToken") tko = json.loads(ttk) token = tko["oauth_token"] token_secret = tko["oauth_token_secret"] vprint("Token", token) vprint("Token_secret", token_secret) topic = cob["topic"] blog = cob["blog"] imageSource = cob["imageSource"] linkTo = cob["linkTo"] tags = cob["tags"] caption = cob["caption"].encode("utf_8", "ignore") """ topicsp = topic.split("/") kind = topicsp[1] # snap or album ownr = topicsp[2] ownerName = None if ownr != uid: ownru = models.loadUserD("/user/"+ownr) ownerName = ownru.name imname = topicsp[3] albumNum = topicsp[4] imageTitle = cob["imageTitle"] imageAuthor = cob["imageAuthor"] imageSource = cob["imageSource"] linkTo = cob["linkTo"] if kind=="snap": snap = cob["snap"] #print "snap",snap #cropId = snap["cropid"] #snapId = misc.pathLast(topic) scaption = snap.get("caption",None) sdes = snap.get("description",None) caption = "Click on the image to see the detail in a zoomable context\n\nDetail" tags = [] if imageTitle: caption += " from *"+imageTitle+"*" if imageTitle.find(",") < 0: tags.append(imageTitle) if imageAuthor: caption += ", "+imageAuthor if imageAuthor.find(",") < 0: tags.append(imageAuthor) caption += "\n\n" if scaption: caption += scaption if sdes: if scaption: caption += "\n\n" caption += sdes.decode("utf8","ignore") if ownerName: caption += "\n\n From "+ownerName+" at [Imagediver](http://imagediver.org)" #http://static.imagediver.org/images/4294b0e/van_eyck_arnolfini/snap/12.jpg?album=4294b0e.1 #http://s3.imagediver.org/topic/album/4294b0e/van_eyck_arnolfini/1/index.html#snap=9 cropUrl = "http://static.imagediver.org/images/"+ownr+"/"+imname+"/snap/"+str(cropId)+".jpg" clickThru = "http://s3.imagediver.org/topic/album/"+ownr+"/"+imname+"/"+albumNum+"/index.html#snap="+str(snapId) """ params = { "type": "photo", "format": "markdown", "state": "draft", "link": linkTo, "source": imageSource } if caption: params["caption"] = caption if len(tags) > 0: params["tags"] = ",".join(tags) #params = {"type":"text","state":"draft","body":"Second TEST post"} #print "DESC",sdes #vprint("CAPTION",caption) #print "params",params try: oauth_tumblr.post(token, token_secret, blog, params) except Exception as ex: vprint("FAILED TO POST", ex) return False vprint("post complete") return True
def addSnap(webin): """ Handles the api/addSnap request; this is used for editing snaps too """ if testingAddSnap: print "TESTINGADDSNAP" return failResponse("testing") print "ADD SNAPPPPP" cks = webin.checkSessionResponse() if cks: return cks sess = webin.session user = sess.user uname = models.pathLast(user) # Logr.activeTags = ["dispatch","api"] #vprint(str(napi.__dict__)) cob = json.loads(webin.content()) vprint("COB: " + str(cob)) album = cob["album"] albumIdx = pathLast(album) albumD = model.album.loadAlbumD(album, webin.pageStore) if user != albumD.owner: return failResponse("notOwner") topic = cob.get("topic", None) coverage = cob["coverage"] # unscaled im = str(cob["image"]) """ imsplit = im.split("/") imuname = imsplit[2] imname = imsplit[3] imd = image.loadImageD(im,webin.pageStore) imdir = imd.imDir() imdim = imd.dimensions imwd = imdim["x"] imht = imdim["y"] scoverage = misc.scaleRectDict(coverage,1.0/imwd); """ snap = snapm.SnapD(None) """ if newCrop: cropid = dyn.bumpCount(cropcnti) else: cropid = cob["cropid"] vprint ("im",im,"imuname",imuname,"cropcnti",cropcnti,"cropid",cropid) #return okResponse("testing"); cropid_s = str(cropid) """ cropid = cob.get("cropid", None) caption = cob.get("caption", "") description = cob.get("description", "") ordinal = cob.get("ordinal", -1) #if newCrop: # crect = image.dictToRect(coverage) #if not caption:caption="" #if not description:description="" # d={"topic":tp,"notSaved""type":"/type/snapD","image":im,"caption":caption,"description":description,"coverage":coverage} snap.image = im snap.album = album snap.owner = user snap.coverage = coverage snap.caption = caption snap.description = description snap.cropid = cropid snap.shares_coverage = 0 snap.ordinal = ordinal snap.topic = topic rs = albumD.addSnap(snap, webin.pageStore) return okResponse(rs.__dict__) if in_snaps: snap.in_snaps = 1 if newCrop: snap.published = 0 if topic: snap.topic = topic if newSnap: #snapid = models.newSnap(album,snap) snapid = albumD.newSnap(snap) else: albumD.updateSnap(snap) if not snap.topic: snap.topic = "/snap/" + uname + "/" + imname + "/" + str( albumIdx) + "/" + str(snapid) vprint("saved snap :" + str(snap.__dict__)) #dst.insert(d) # this does an update, if the topic and type exist # convert -size 25053x4354 -depth 16 -extract 2000x2000+10000+0 -resize 200x200 Panorama1924.TIF /var/www/neo.com/images/P00.jpg if newCrop: tl = image.Tiling(imd, 256, 1) tl.createTiles([], kind="r", parent=None, recursive=False) albumD.genSnapImages(imd, tl, snap) #snappath = imdir+"snap/"+str(cropid)+".jpg" #thumbpath = imdir+"snapthumb/"+str(cropid)+".jpg" #cropsize = imd.cropImage(crect,snappath,targetArea=200000) # the actual crop image will not be blown up, so may be less than the nominal (and returned) cropsize #thumbsize = imd.cropImage(crect,thumbpath,targetArea=25000) # the actual crop image will not be blown up, so may be less than the nominal (and returned) cropsize #tl.createTiles([]) #cropsize = tl.cropFromTiles(snappath,crect,targetArea=200000) # the actual crop image will not be blown up, so may be less than the nominal (and returned) cropsize #thumbsize = tl.cropFromTiles(thumbpath,crect,targetArea=25000) # the actual crop image will not be blown up, so may be less than the nominal (and returned) cropsize #cropsize = imd.cropFromTile(tl,crect,snappath,targetArea=200000) # the actual crop image will not be blown up, so may be less than the nominal (and returned) cropsize #thumbsize = imd.cropFromTile(tl,crect,thumbpath,targetArea=25000) # the actual crop image will not be blown up, so may be less than the nominal (and returned) cropsize """ this scheme, with iterative reduction, gave inferior results thumbsize = cropsize.scaleToArea(25000) imdir = imd.imDir() src = imdir + snappath+".jpg" dst = imdir + "snapthumb/"+str(cropid)+".jpg" image.resizeImage(src,dst,thumbsize) """ #cmd = "convert -quiet -size {imwd}x{imht} -depth 8 -extract {cx}x{cy}+{x}+{y} -resize {szx}x{szy} {imFile} {cropFile}" #cmdf = cmd.format(imwd=imwd,imht=imht,cx=cx,cy=cy,x=x,y=y,szx=szx,szy=szy,imFile=imFile,cropFile=cropFile) # " -resize "+ex+"x"+ey+" "+(tim.filename)+" "+(tl.directory)+(this.id)+"; #import subprocess #subprocess.Popen(cmd) cap = getattr(albumD, "caption", None) " snaps from the snaps album are published immediately " #if cap==".snaps.": snap.publish() snap.publishInAlbum() #snaps.closeStore(webin.pageStore) return okResponse(snap.__dict__)
def emitJson(webin): itm = time.time() sess = getattr(webin, "session", None) user = None if sess: user = sess.user jsonMimeType = "application/json" #jsonMimeType = "text/plain"; jsonMissing = json.dumps({"status": "error", "id": "missing"}) path = webin.path parsedPath = parseApiPath(webin.path) name = parsedPath.name category = parsedPath.category owner = parsedPath.owner vprint("category", category) if category == "image": imageTopic = "/image/" + owner + "/" + name #albumTopic = "/album/"+imowner+"/"+imname+"/"+album; Logr.log("api", "imageTopic=" + imageTopic) im = image.loadImageD(imageTopic, webin.pageStore) if not im: #todo add error page here return WebResponse('200 OK', jsonMimeType, jsonMissing) #Logr.log("api","IMAGE "+str(im.__dict__)) #print "IMAGE",im.__dict__ imob = {} improps = [ "topic", "externalLink", "dimensions", "author", "title", "owner", "tags", "description", "name", "year", "tilingDepth", "license", "shared", "beenTiled", "atS3", "current_item_create_time", "source", "isPublic", "s3Storage" ] misc.setDictPropsFromObject(imob, im, improps) #imob = {"id":im.topic,"dimensions":im.dimensions,"title":getattr(im,"title",""),"owner":"/user/"+owner, # "author":getattr(im,"author",""),"source":getattr(im,"source",""),"externalLink":getattr(im,"externalLink","")} #js = json.dumps(im.__dict__) #Logr.log("api","IMAGEJS"+js) js = json.dumps(imob) Logr.log("api", "IMAGEJS2" + js) return WebResponse('200 OK', jsonMimeType, js) if category == "album": """ the album id "-" means the snaps album of the current user """ imname = getattr(parsedPath, "name", None) id = getattr(parsedPath, "id", None) if not id: js = json.dumps({"status": "error", "id": "bad_path"}) return WebResponse('200 OK', jsonMimeType, js) albumTopic = "/album/" + owner + "/" + imname + "/" + id imTopic = "/image/" + owner + "/" + imname #ofl = open("/mnt/ebs0/imagediverdev/static"+albumTopic+"/topic.json","w") if id == "-": # the snaps album, if any if not user: return failResponse("missing") sna = dynamo.getSnapsAlbumTopic(imTopic, user) if sna: albumTopic = sna else: return failResponse("missing") albumD = album.loadAlbumD(albumTopic, webin.pageStore) js = albumD.compute_json(wrapInStatus=True) #snapst.closeStore(webin.pageStore) return WebResponse('200 OK', jsonMimeType, js) if category == "snap": imname = getattr(parsedPath, "name", None) id = getattr(parsedPath, "id", None) subid = getattr(parsedPath, "subid", None) if (not id) or (not subid): js = json.dumps({"status": "error", "id": "bad_path"}) return WebResponse('200 OK', jsonMimeType, js) snapTopic = "/snap/" + owner + "/" + imname + "/" + id + "/" + subid #ofl = open("/mnt/ebs0/imagediverdev/static"+albumTopic+"/topic.json","w") snapD = snapm.loadSnapD(snapTopic, webin.pageStore) js = snapD.compute_json(wrapInStatus=True) #snapst.closeStore(webin.pageStore) return WebResponse('200 OK', jsonMimeType, js) OBSOLETE() #ds = dstore.DStore(constants.descriptorStore) #imds = ds.descriptor(topicpath,'/type/imageD') snaps = models.snapsInAlbum(albumTopic) #theStore.topicsWithPropertyValue('/type/snapD','album',albumTopic) albums = models.albumsForImage(imageTopic) Logr.log("image", "snaps: " + str(snaps)) Logr.log("image", "image: " + str(im.__dict__)) Logr.log("image", "albums: " + str(albums)) snapDs = theStore.descriptor(snaps, '/type/snapD') albumDs = theStore.descriptor(albums, '/type/albumD') Logr.log("image", "albumDs" + str(albumDs)) thisAlbumD = None for albumD in albumDs: if albumD["topic"] == albumTopic: thisAlbumD = albumD break if im: otxt = pg0 + \ "<script>" + \ "var imD="+json.dumps(im.__dict__)+";\n" + \ "var snapDs="+json.dumps(snapDs)+";\n" + \ "var albumDs="+json.dumps(albumDs)+";\n"+ \ "var albumD="+json.dumps(thisAlbumD)+";\n"+ \ "var loggedInUser='******';\n" if forHomePage: otxt += "page.thisIsHomePage=1;\n" otxt += pg1 else: otxt = "NO SUCH IMAGE for " + topicpath snapst.closeStore(webin.pageStore) #Logr.log("image","description: "+str(imds)) return WebResponse('200 OK', 'text/html', otxt)