def emitUnsupportedBrowserPage(iev):
Logr.log("page","EMITTING ABOUT PAGE")
pg0 = """<!DOCTYPE html>
<html>
<head>
<title>ImageDiver</title>
<link rel="stylesheet" type="text/css" href="/pages/imagestyle.css"/>
</head>
<body>
<div class="aboutTitleDiv">
<span class="aboutLogo">imageDiver</span><span class="titleSpan"><i>explore the depths of high-resolution images</i></span>
</div>
<div class="unsupportedBrowser">
In versions of Internet Explorer prior to version 9, ImageDiver requires the chromeframe plugin, which can be
installed <a href="http://www.google.com/chromeframe>here</a>. (This is because ImageDiver uses a web standard
for image display known as "html5 canvas", which is supported in all other major browsers). Alternatively,
please return with <a href="http://mozilla.com">Firefox</a>, <a href="http://www.apple.com/safari/">Safari</a>,
<a href="http://opera.com">Opera</a>, or <a href="http://google.com/chrome">Chrome</a>, or with
<a href="http://microsoft.com/ie9">version 9</a> of Internet Explorer. Thanks!
</div>
</body>
</html>
"""
return okResponse()
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 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 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 albumsAndImages(webin):
""" both kinds of entities for the logged in user. Includes images mentioned in albums, and images owned by the user"""
cks = webin.checkSessionResponse()
if cks: return cks
sess = webin.session
user = sess.user
albums = album.allAlbums(user)
images = image.allImages(user)
imbytopic = {}
for im in images:
tp = im.topic
imbytopic[tp] = im
missingIms = {}
for a in albums:
aim = a.image
if imbytopic.get(aim, None) == None:
missingIms[aim] = 1
mlist = missingIms.keys()
if len(mlist) > 0:
getem = image.getImages(mlist)
images.extend(getem)
adicts = [a.__dict__ for a in albums]
imdicts = [i.__dict__ for i in images]
rs = {"albums": adicts, "images": imdicts}
return okResponse(rs)
def addAlbum(webin):
raise Exception("Obsolete function addAlbum")
"""
HOW IS THIS DIFFERENT FROM NEWALUM? It is the one that is in use.
Handles the api/addAlbum request
"""
raise exc
cks = webin.checkSessionResponse()
if cks: return cks
sess = webin.session
user = sess.user
cob = json.loads(webin.content())
im = str(cob["image"]) # the topic name /image/whatever
importSnaps = cob.get("importSnaps", None)
albumD = album.AlbumD(None)
albumD.image = im
albumD.owner = user
imD = image.loadImageD(im, webin.pageStore)
if (not getattr(imD, "shared", False)) and (imD.owner != user):
imD.shared = 1
imD.dynsave(False)
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.dynsave()
if importSnaps:
sna = dynamo.getSnapsAlbumTopic(im, user)
if sna:
albumD.importSnaps(sna)
return okResponse(albumD.__dict__)
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 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 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 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 twitterRequestToken(webin):
#print "tumblrRequestToken"
#cks = webin.checkSessionResponse()
#if cks: return cks
sess = webin.session
#user = sess.user
tk = oauth_twitter.requestToken()
return okResponse(tk)
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 albumTopicsForImage(webin):
cks = webin.checkSessionResponse()
if cks: return cks
sess = webin.session
user = sess.user
cob = json.loads(webin.content())
topic = cob["image"]
rso = dynamo.albumTopicsForImage(topic, user)
#rs = [alb.__dict__ for alb in rso]
return okResponse(rso)
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 albumsForImage(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["image"]
rso = album.albumsForImage(topic, user)
#rs = [alb.__dict__ for alb in rso]
return okResponse(rso)
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 albumHistory(webin):
""" both kinds of entities for the logged in user. Includes images mentioned in albums, and images owned by the user"""
cks = webin.checkSessionResponse()
if cks: return cks
sess = webin.session
cob = json.loads(webin.content())
Logr.log("api", "COB: " + str(cob))
albn = str(cob["album"]) # the topic name /image/whatever
rs = snapm.getSnaps(albn, getAllVersions=True)
return okResponse(rs)
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 allAlbums(webin):
cks = webin.checkSessionResponse()
if cks: return cks
cob = json.loads(webin.content())
sess = webin.session
user = cob.get("user", None)
if not user:
user = sess.user
albums = album.allAlbums(user)
rs = [a.__dict__ for a in albums]
toemit = {"status": "ok", "value": rs}
return okResponse(rs)
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 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 getPosts(webin):
posts = dyn.allItems("Post")
udict = {}
for p in posts:
utp = p["user"]
udict[utp] = 1
ui = dyn.allItems("User")
unms = []
for u in ui:
tp = u["topic"]
if udict.get(tp, None):
unms.append({"topic": tp, "name": u["name"]})
rs = {"posts": posts, "users": unms}
return okResponse(rs)
def allUsers(webin):
cks = webin.checkSessionResponse()
#f cks: return okResponse("virtual")
if cks: return cks
sess = webin.session
user = sess.user
rsi = models.allUsers()
rsf = []
for u in rsi:
ctm = getattr(u, "current_item_create_time", 0)
nm = getattr(u, "name", "none").lower()
if (ctm >= 1351028738215) and (nm != "chrisgoad"): #1344880615724:
rsf.append(u)
rs = [d.__dict__ for d in rsf]
return okResponse(rs)
def emitPage(webin):
rs = gen.pageHeader(webin, "Sign Out") + gen.pageBodyF(
"", "", ["login", "logout", "account"]) + """
<body>
<script>
document.cookie = "sessionId=deleted; expires=" + new Date(0).toUTCString();
</script>
<div class="infoDiv" style="color:black;background-color:#aaaaaa">You are now logged out. Come back soon!</div>
</body>
</html>
"""
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 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 tumblrRequestToken(webin):
#print "tumblrRequestToken"
#cks = webin.checkSessionResponse()
#if cks: return cks
sess = webin.session
#user = sess.user
tk = oauth_tumblr.requestToken()
"""
tkj = json.dumps(tk)
#print "TKJ",tkj
" the token needs to be saved for a few minutes: until the user authorizes or declines the app "
dir = "/mnt/ebs1/imagediver/tokens/"
uname = misc.pathLast(user)
fln = dir+uname
f = open(fln,'w')
f.write(tkj)
f.close()
"""
return okResponse(tk)
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})
