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 emitPage(webin):
#def genHtmlPage(webin,txt,redirectOnTimeout=True,styleSheets=None,pageTitle=None):
def genPage(txt):
return gen.genHtmlPage(webin,
txt,
redirectOnTimeout=False,
pageTitle="Email Verification")
"""
Handles the api/contact - for people contacting ImageDiver
"""
#print "VERIFY EMAIL"
qs = getattr(webin, "queryString", None)
if qs:
qsp = urlparse.parse_qs(qs)
usernames = qsp.get("user", None)
if usernames == None:
return genPage("Incorrect form for verification")
username = usernames[0]
codes = qsp.get("code", None)
if codes == None:
return genPage("Incorrect form for verification")
code = codes[0]
user = models.loadUserD("/user/" + username, webin.pageStore)
#print "USER ",user.__dict__
isTumblr = getattr(user, "tumblr_name", None)
if user == None:
return genPage("Problem in verification: unknown user")
if user.validated:
if isTumblr:
return genPage("Your email has already been verified. Thanks!")
else:
return genPage(
"Your email has already been verified. You can log in now. Thanks!"
)
stored_code = user.validation_code
codeok = stored_code == code
if codeok:
user.validated = 1
user.dynsave(isNew=False)
if isTumblr:
return genPage("Your email has been verified. Thanks!")
else:
return genPage(
"Your email has been verified. You can log in now. Thanks!")
else:
return genPage("Problem in verification: incorrect code")
txt = "BAD CODE"
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 emitPage(webin):
qs = webin.queryString
#print "WEBIN", webin.__dict__
cn = webin.content()
if not cn:
emitError()
vprint("CN", cn)
#print "CN",cn
cnd = cn[cn.find("=") + 1:]
if cnd[0:3] == "%7B":
cnd = urllib.unquote_plus(cnd)
vprint("UNQUOTED TO ", cnd)
else:
vprint("NO UNQUOTING NEEDED")
qd = json.loads(cnd)
"""
if not ("topic" in qd):
emitError()
topic = qd["topic"]
"""
sess = webin.session
if not sess:
body = """
<div>To post an annotation to Tumblr, you need to be logged in.</div><div>You can use your Tumblr account to <a href="/login">log in</a>.</div>"""
return gen.genStaticPage(webin, "ImageDiver Message", body)
user = sess.user
userD = models.loadUserD(user)
uName = getattr(userD, "name", "Anonymous")
tk = getattr(userD, "tumblr_token", None)
if not tk:
return authorizeTumblr()
try:
uinf = userD.tumblrInfo()
except Exception as ex: # case where tumblr access has been revoked
return authorizeTumblr(topic)
blogs = uinf['blogs']
blogUrls = [b['url'] for b in blogs]
qd["blogs"] = blogUrls
qd["userName"] = uName
#def genDynPage(webin,jsFiles,options,redirectOnTimeout=True,pageTitle =None,body='',staticSize=False):
#options = {"blogs":blogUrls,"topic":topic} #,"snap":snapD.__dict__}
return gen.genDynPage(webin,
js,
qd,
headLines,
pageTitle="Post to Tumblr",
staticSize=True)
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 emitPage(webin):
sess = webin.session
if sess:
#return gen.genHtmlPage(webin,"",headerTitle,headLines,"You are already logged in.")
return gen.genHtmlPage(webin,
"",
styleSheets=styleSheets,
pageTitle="You are already logged in.")
else:
qs = webin.queryString
if not qs:
return gen.genHtmlPage(webin,
"",
styleSheets=styleSheets,
pageTitle="Expected '?user=<uid>'")
qsp = urlparse.parse_qs(qs)
uid = qsp.get("user", None)
if not uid:
return gen.genHtmlPage(webin,
"",
styleSheets=styleSheets,
pageTitle="Expected '?user=<uid>'")
uid = uid[0]
user = "******" + uid
usrd = models.loadUserD(user)
if not usrd:
return gen.genHtmlPage(webin,
"",
styleSheets=styleSheets,
pageTitle="No such user.")
opts = {
"uid": uid,
"name": usrd.name,
"accepted_terms": getattr(usrd, "accepted_terms"),
"tumblr_name": getattr(usrd, "tumblr_name", ""),
"twitter_name": getattr(usrd, "twitter_name", "")
}
return gen.genStdPage(webin,
'terms',
options=opts,
pageTitle="Welcome",
staticSize=True)
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 emitPage(webin):
sess = webin.session
if sess == None:
return gen.genHtmlPage(
webin, "", "ImageDiver session timeout", [],
"Your session has expired. Please log in again.")
user = ""
else:
user = sess.user
usrd = models.loadUserD(user, webin.pageStore)
hasEmail = 1 if getattr(usrd, "email", None) else 0
opts = {
"loggedInUser": user,
"utilization": usrd.storageUtilization(),
"allocation": usrd.allocation()["storage"],
"hasEmail": hasEmail
}
return gen.genStdPage(webin, 'upload', opts, 'import', staticSize=True)
return gen.genDynPage(webin, js, {"topbarTitle": "<i>Import</i>"},
opts)
def emitPage(webin):
qs = webin.queryString
print "WEBIN", webin.__dict__
cn = webin.content()
if not cn:
emitError()
print "CN",cn
cnd = cn[cn.find("=")+1:]
print "CND ",cnd
qd=json.loads(cnd)
"""
print qd
if not ("topic" in qd):
emitError()
topic = qd["topic"]
print "TOPIC ",topic
"""
sess = webin.session
if not sess:
body = """
<div>To post an annotation to Tumblr, you need to be logged in. (Registering at ImageDiver is free)</div>"""
return gen.genStaticPage(webin,"ImageDiver Message",body);
user = sess.user;
userD = models.loadUserD(user)
tk = getattr(userD,"tumblr_token",None)
if not tk:
return authorizeTumblr()
try:
uinf = userD.tumblrInfo()
except Exception as ex: # case where tumblr access has been revoked
return authorizeTumblr(topic)
blogs = uinf['blogs']
blogUrls = [b['url'] for b in blogs]
qd["blogs"] = blogUrls
#options = {"blogs":blogUrls,"topic":topic} #,"snap":snapD.__dict__}
return gen.genDynPage(webin,js,{},qd,headLines,pageTitle="Post to Tumblr")
def emitPage(webin):
def genErrPage(txt):
return gen.emitMessagePage(webin, "Reset Password", txt)
#def genPage(jsOptions):
# return gen.genDynPage(webin,jsIncludes,{"topbarTitle":"<i>the depths of high-resolution images, annotated</i>"},jsOptions=jsOptions,headLines=headLines)
#return WebResponse("200 OK","text/html",gen.genHtmlPage(webin,'',"ImageDiver Email Verification",[],txt))
qs = getattr(webin, "queryString", None)
if qs:
qsp = urlparse.parse_qs(qs)
usernames = qsp.get("user", None)
if usernames == None:
return genPage("Incorrect form for password-reset URL")
username = usernames[0]
codes = qsp.get("code", None)
if codes == None:
return genErrPage("Incorrect form for password-reset URL")
code = codes[0]
user = models.loadUserD("/user/" + username, webin.pageStore)
if user == None:
return genErrPage("Problem in reset-password: unknown user")
stored_code = user.validation_code
codeok = stored_code == code
if codeok:
return gen.genStdPage(webin,
'reset_password', {
"user": "******" + username,
"code": code,
"email": user.email
},
staticSize=True)
else:
return genErrPage("Problem: incorrect code")
txt = "BAD CODE"
def emitPage(webin):
sess = webin.session
if sess == None:
return gen.emitMessagePage(webin, "Not logged in.", "Please log in.")
user = ""
else:
user = sess.user
usrd = models.loadUserD(user, webin.pageStore)
uid = models.pathLast(usrd.topic)
timed_out = sess.timed_out
opts = {
"timed_out": timed_out,
"name": usrd.name,
"email": getattr(usrd, "email", ""),
"tumblr_name": getattr(usrd, "tumblr_name", ""),
"twitter_name": getattr(usrd, "twitter_name", ""),
"utilization": usrd.utilization(),
"userId": uid,
"allocation": usrd.allocation()
}
return gen.genStdPage(webin, 'me', opts, 'account', staticSize=True)
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
emitError()
print "CN",cn
cnd = cn[cn.find("=")+1:]
print "CND ",cnd
qd=json.loads(cnd)
if not ("topic" in qd):
emitError()
topic = qd["topic"][0]
sess = webin.session
if not sess:
body = """
<div>To post an annotation to Tumblr, you need to be logged in. (Registering at ImageDiver is free)</div>"""
return gen.genStaticPage(webin,"ImageDiver Message",body);
user = sess.user;
userD = models.loadUserD(user)
url = authorizeTumblr(user,topic)
tk = getattr(userD,"tumblr_token",None)
if not tk:
url = authorizeTumblr(user,topic)
return redirectResponse(url)
try:
uinf = userD.tumblrInfo()
except Exception as ex: # case where tumblr access has been revoked
url = authorizeTumblr(user,topic)
return redirectResponse(url)
blogs = uinf['blogs']
blogUrls = [b['url'] for b in blogs]
print "topic",topic
#snapD = snapm.loadSnapD(topic)
def sendCompletionEmail(job):
o = job.owner
u = models.loadUserD('/user/' + o, thePageStore)
if getattr(u, "email", None):
ses.sendImportDoneEmail(u, job.subject)
def buildTiling(job, backend=False):
print("BUILDING the TILING **************************")
frontend = not backend
job.status = "active"
if frontend: saveJob(job)
im = imageForJob(job)
job.imTopic = im.topic # not saved; used for cancelation
tl = image.Tiling(im, 256, 1)
stm = time.time()
tl.createTiles([])
numtiles = len(tl.tiles)
print "TEST"
print "BBuildingg Tiling of ", numtiles, " for " + im.topic
job.total = numtiles
job.status = "active"
if frontend: saveJob(job)
vprint(str(len(tl.tiles)))
def recorder(tile, cnt):
if backend:
if cnt % 25 == 0: print "created ", cnt, " tiles"
return True
if checkJobCanceled(job): return False
vprint(tile.__dict__)
vprint(job.subject)
job.so_far = cnt + 1
saveJob(job)
return True
tl.createImageFiles(recorder)
if job.status == "canceled":
return
imdir = im.imDir()
sz = misc.du(imdir + "tiling")
o = job.owner
usr = models.loadUserD('/user/' + o, thePageStore)
alc = usr.allocation()
sta = alc["storage"]
sut = usr.storageUtilization()
vprint(o, "ALLOCATION ", sta, "UTILIZATION ", sut, "SIZE ", sz)
if (sz + sut) > sta:
job.status = "storageLimitExceeded"
im.delete(fromS3=False)
if getattr(usr, "email"):
ses.sendStorageAllocationExceededEmail(usr,
job.subject,
allocation=sta,
utilization=sut,
size=sz)
else:
im.s3Storage = sz
im.beenTiled = 1
im.dynsave()
job.status = "done"
#im.removeSubdir("stepdown")
im.deleteStepdowns(1) # keep the original image
job.so_far = numtiles
job.resources_used = json.dumps({
"time": time.time() - stm,
"num_tiles": numtiles
})
saveJob(job)
def emitAlbumPage(webin, parsedPath, parsedQuery, forHomePage):
pageStore = {}
import model.album
album = model.album
vprint("parsedQuery " + str(parsedQuery))
vprint("emitAlbumPage")
sess = webin.session
if sess == None:
user = ""
else:
user = sess.user
qs = getattr(webin, "queryString", None)
published = 0 # is this the published version?
"""
now, if we're here its unpublished
if qs:
qsp = urlparse.parse_qs(qs)
published = 0 if qsp.get('unpublished',False) else 1
"""
name = parsedPath.name
Logr.log("newdb", str(name))
if len(name) < 3:
return gen.emitNotFound(webin)
#return gen.genStaticPage(webin,"ImageDiver Message"," <center><b>404</b></center><p><center>No such page</center></p>");
imowner = name[0]
imname = name[1]
albumname = name[2]
albumTopic = "/album/" + imowner + "/" + imname + "/" + albumname
imageTopic = "/image/" + imowner + "/" + imname
if albumname == "-":
albumD = "-"
else:
albumD = album.loadAlbumD(albumTopic, webin.pageStore)
if not albumD:
#todo add error page here
return gen.genStaticPage(webin, "ImageDiver Message",
"<center><b>No such album</b></center>")
im = image.loadImageD(imageTopic, webin.pageStore)
imHasAlbums = album.hasAlbums(
imageTopic, user) # does this user have albums on this image
imDict = models.toDict(im, [
"dimensions", "title", "name", "author", "year", "externalLink",
"description", "owner", "topic", "tilingDepthBump", "zoomDepthBump",
"source"
])
if albumD == "-":
ownerD = models.loadUserD(user, webin.pageStore)
ownerName = getattr(ownerD, "name", None)
options = {
"imageD": imDict,
"imageTopic": imageTopic,
"loggedInUser": user,
"ownerName": ownerName,
"albumOwner": user,
"published": False
}
otxt = genAlbumPage(options)
return htmlResponse(otxt)
#print "IMDICT ",imDict
author = getattr(im, "author", None)
if author == None:
author = ""
else:
author = ", " + author
ttl = getattr(im, "title", "")
albowner = albumD.owner
vprint("OWNER ", albowner, user)
if (not constants.devVersion) and (albowner != user):
return gen.genStaticPage(
webin, "ImageDiver Message",
"<center><b>This is an unpublished album</b></center>")
beenPublished = getattr(albumD, "published", 0)
vprint("beenPublished", beenPublished)
ownerD = models.loadUserD(albowner, webin.pageStore)
ownerName = getattr(ownerD, "name", None)
apub = getattr(albumD, "published", None)
if published and (not apub):
return gen.genStaticPage(
webin, "ImageDiver Message",
"<center><b>This album has not yet been published</b></center>")
#imageTopic = albumD.image
#options = {"imageD":imDict,"albumOwner":albumD.owner,"albumOwnerName":ownerName,"loggedInUser":user,"hasAlbums":imHasAlbums,
# "albumTopic":albumD.topic,"published":published,"beenPublished":beenPublished,"path":"/"}
options = {
"imageD": imDict,
"albumOwner": albumD.owner,
"albumOwnerName": ownerName,
"loggedInUser": user,
"imTitle": ttl,
"imAuthor": author,
"albumTopic": albumD.topic,
"imageTopic": imageTopic,
"published": published,
"beenPublished": beenPublished,
"path": webin.path
}
vprint("OPTIONS", options)
otxt = genAlbumPage(options)
#snaps.closeStore(webin.pageStore)
return htmlResponse(otxt)
#!/usr/bin/env python
# python /var/www/neo.com/script_tests/dstoretest2.py
PYTHONPATH=$PYTHONPATH:"/mnt/ebs0/imagediverdev/py"
export PYTHONPATH
cd /mnt/ebs0/imagediverdev/py
python
import store.theStore
theStore = store.theStore
import store.dynamo
dyn = store.dynamo
import model.models
models = model.models
import store.snaps
snaps = store.snaps
uu = models.loadUserD("/user/cg")
uu.validated = 1
uu.dynsave()
def setTumblrToken(webin):
cn = webin.content()
#print "CONTENT",cn
cob = json.loads(cn)
token = cob["oauth_token"]
token_secret = cob["oauth_token_secret"]
verifier = cob["verifier"]
signingIn = cob.get("signingIn", False)
if not signingIn:
cks = webin.checkSessionResponse()
if cks: return cks
access_token = oauth_tumblr.getAccessToken(verifier, token, token_secret)
#print "ACCESS TOKEN ",access_token
atkj = json.dumps(access_token)
if signingIn:
uinfj = oauth_tumblr.getUserInfo(access_token["oauth_token"],
access_token["oauth_token_secret"])
#print "UINFJ",uinfj
uinf = json.loads(uinfj)
tuname = uinf["response"]['user']['name']
vprint("TUNAME", tuname)
exu = models.loadUserDbyTumblr(tuname)
rs = {"tumblr_name": tuname}
if exu:
vprint("Existing tumblr user")
exu.tumblr_token = atkj
exu.dynsave(False)
tac = getattr(exu, "accepted_terms", 0)
#tac = 1
rs["accepted_terms"] = tac
utp = exu.topic
uid = misc.pathLast(utp)
rs["userId"] = uid
if tac:
# go ahead and generate a new session for this fellow
s = exu.newSession()
stp = s.topic
sid = misc.pathLast(stp)
rs["sessionId"] = sid
return okResponse(rs)
else:
vprint("NEW TUMBLR USER")
ucnt = dynamo.getCount("/user/count")
if ucnt >= constants.maxUsers:
rs["hit_limit"] = 1
return okResponse(rs)
uid = dynamo.genNewUserId()
nu = models.UserD(None)
nu.topic = '/user/' + uid
nu.name = tuname
nu.tumblr_name = tuname
nu.storage_allocation = constants.initial_storage_allocation
nu.bandwidth_allocation = constants.initial_bandwidth_allocation
nu.accepted_terms = 0
nu.tumblr_token = atkj
nu.dynsave(True)
dynamo.bumpCount("/user/count")
vprint("NEW TUMBLR USER SAVED")
rs["accepted_terms"] = 0
rs["userId"] = uid
return okResponse(rs)
""" getting a access token in the course of a post to tumblr """
sess = webin.session
user = sess.user
userD = models.loadUserD(user)
atkj = json.dumps(access_token)
userD.tumblr_token = atkj
userD.dynsave(False)
return okResponse()
jb.save()
jb.save()
models.addImageToDb("cg","sthellens")
models.loadImageD("/image/cg/sthellens")
dyn.getDict("Album","/album/ccc/bathing_1/8")
ims = models.allImages()
uu = dyn.getUser('/user/cg')
uuu = models.loadUserD('/user/foobmm')
nn = models.UserD(None)
nn.topic = '/user/foob'
nn.name = "mr foob"
nn.setPassword("abcdef")
nn.email = "*****@*****.**"
nn.dynsave()
models.deleteSnap("/album/cg/The_Ambassadors/3/1")
models
ss = models.loadSnapD("/album/cg/The_Ambassadors/3/1")
PYTHONPATH=$PYTHONPATH:"/mnt/ebs0/imagediverdev/py"
export PYTHONPATH
cd /mnt/ebs0/imagediverdev/py
python
import store.theStore
theStore = store.theStore
import store.dynamo
dyn = store.dynamo
import model.models
models = model.models
import store.snaps
snaps = store.snaps
import store.jobs
jobs = store.jobs
import ops.logs
logs = ops.logs
import store.log
logstore = store.log
import api.register
import boto
#api.register.connectToSes()
test9 = models.loadUserD('/user/test9')
api.register.sendValidationEmail(test1)
