def send(self):
feedback = request.params['feedback']
response.write("Your feedback has been sent to the triggr team - thanks for getting in touch!")
# Send a new account notification
addrFrom = '*****@*****.**'
addrTo = '*****@*****.**'
subject = 'Triggr: Customer Feedback'
body = """\
From: %s
To: %s
Subject: %s
%s
""" % (addrFrom, addrTo, subject, feedback)
server = smtplib.SMTP('smtp.gmail.com', 587)
server.ehlo()
server.starttls()
server.login('*****@*****.**', 'T3llM3Wh3n')
server.sendmail(addrFrom, addrTo, body)
server.quit()
def GetInfo(self):
from pprint import pformat
request.headers['Content-Type'] = 'text/ascii'
response.write('Some info about this service\n')
for layer in model.ukcip02.layers:
response.write('Layer %s: %s\n' %
(layer, pformat(g.ukcip02_layers[layer].__dict__)))
def _writeImageResponse(self, pilImage, format):
buf = StringIO()
pilImage.save(buf, self._pilImageFormats[format])
response.headers['Content-Type'] = format
if config.get('cows.browser_caching_enabled', '').lower() == 'true':
response.headers["cache-control"] = "public, max-age=3600"
response.headers["pragma"] = ""
response.write(buf.getvalue())
def void(self):
"""send VoID of every dataset in a ZIP file"""
rdfdocs = Session.query(model.RDFDoc).filter(model.RDFDoc.active==True).join(model.RDFDoc.current_stats).filter(and_(model.StatResult.triples > 0, model.RDFDoc.format != 'sparql'))
zip_temp_file = tempfile.NamedTemporaryFile(prefix='lodstatswww_voidzip')
zip_temp = zipfile.ZipFile(zip_temp_file, 'w', zipfile.ZIP_DEFLATED)
for r in rdfdocs:
zip_temp.writestr("%s.ttl" % r.name, r.current_stats.void)
zip_temp.close()
zip_temp_file.seek(0)
response.content_type = 'application/zip'
response.headers['Content-Disposition'] = "filename=LODStats_all_void.zip"
# FIXME: use paste.fileapp if this ever gets too large
for data in zip_temp_file:
response.write(data)
def getnewadchart(self):
def writeInt(x):
response.write(struct.pack(">I",x))
def writeLong(x):
response.write(struct.pack(">Q",x))
def writeUTF(s):
if s==None: s=u""
try:
encoded=s.encode('utf8')
except Exception,cause:
print "While trying to encode: %s"%(s,)
raise
l=len(encoded)
response.write(struct.pack(">H",l)) #short
response.write(encoded)
def getnewadchart(self):
def writeInt(x):
response.write(struct.pack(">I", x))
def writeLong(x):
response.write(struct.pack(">Q", x))
def writeUTF(s):
if s == None: s = u""
try:
encoded = s.encode('utf8')
except Exception, cause:
print "While trying to encode: %s" % (s, )
raise
l = len(encoded)
response.write(struct.pack(">H", l)) #short
response.write(encoded)
def getadchart(self):
def writeInt(x):
response.write(struct.pack(">I",x))
def writeFloat(f):
response.write(struct.pack(">f",f))
def writeDouble(f):
response.write(struct.pack(">d",f))
def writeUTF(s):
if s==None: s=u""
try:
encoded=s.encode('utf8')
except Exception,cause:
print "While trying to encode: %s"%(s,)
raise
l=len(encoded)
#print "Writing %s, length %d"%(repr(encoded),l)
response.write(struct.pack(">H",l)) #short
response.write(encoded)
def fetchFile(self, file):
logging.info("Fetching file, '%s'" % file)
#given the filename, these are the paths to the file, and to the accompanying text file
filePath = config['cows.csml.publish_dir'] + '/' + file
#just return the file, no security check implemented for now.
fileToReturn = open(filePath, 'r')
mType = self._getMimeType(file)
response.headers['Content-Type'] = mType
return response.write(fileToReturn.read())
def getadchart(self):
def writeInt(x):
response.write(struct.pack(">I", x))
def writeFloat(f):
response.write(struct.pack(">f", f))
def writeDouble(f):
response.write(struct.pack(">d", f))
def writeUTF(s):
if s == None: s = u""
try:
encoded = s.encode('utf8')
except Exception, cause:
print "While trying to encode: %s" % (s, )
raise
l = len(encoded)
#print "Writing %s, length %d"%(repr(encoded),l)
response.write(struct.pack(">H", l)) #short
response.write(encoded)
def GetCoverage(self):
# Housekeeping
version = self.getOwsParam('version', default=self.validVersions[0])
if version not in self.validVersions:
raise InvalidParameterValue('Version %s not supported' % version,
'version')
# Layer handling
layerName, layerObj = self._getLayerParam()
# Coordinate parameters
bbox = tuple(float(x) for x in self.getOwsParam('bbox').split(','))
srs = self.getOwsParam('crs')
#if srs not in layerObj.crss:
# raise InvalidParameterValue('Layer %s does not support SRS %s' % (layerName, srs))
# Get format
format = self.getOwsParam('format')
if srs not in layerObj.crss:
raise InvalidParameterValue('Layer %s does not support SRS %s' % (layerName, srs))
times= self.getOwsParam('time', default=None)
#process times parameter so it is either a single string (one time) or a tuple (range) (OR None)
if times is not None:
if len(times.split(',')) >1:
times=tuple(times.split(','))
kwargs={}
for axis in layerObj.axisDescriptions: #TODO - axisDescriptions attribute
log.debug('axis: %s'%axis.name)
axisvalues=self.getOwsParam(axis.name, default=None)
log.debug('values: %s'%axisvalues)
if axisvalues:
values=tuple(float(x) for x in axisvalues.split(','))
if len(values)==1:
values=(values[0], values[0],) #set min and max to be equal if single value
kwargs[axis.name]=values
#
filepath = layerObj.getCvg(bbox, time=times, **kwargs) #TODO, refactor so is more flexible (e.g. not just netcdf)
fileToReturn=open(filepath, 'r')
mType='application/cf-netcdf'
response.headers['Content-Type']=mType
response.headers['Content-Disposition'] = paste.httpheaders.CONTENT_DISPOSITION(attachment=True, filename=filepath)
u=fileToReturn.read()
#close and delete file from file system
fileToReturn.close()
log.debug('deleting temporary file %s'%filepath)
os.system('rm %s'%filepath)
return response.write(u)
return decorator(ExceptionToCode)
@decorator
def ExceptionToError(f, *args, **kwargs):
try:
return f(*args, **kwargs)
except HTTPError, e:
# Let explicit HTTP error codes that we raise pass through as-is.
response.status = e.code
except Exception, e:
# So that it shows up under the caller's logger.
log = logging.getLogger(f.__module__)
log.exception('Error')
error = { 'type': e.__class__.__name__, 'message': str(e) }
response.write(json.dumps(error))
response.status = httplib.BAD_REQUEST
class BaseController(WSGIController):
def _getClient(self, environ):
client = environ.get('converter.client')
# Can't put this in environ.get() call because the
# config['converter.client'] isn't set for testing.
if client is None:
client = config['converter.client']
return client
def _sendFileResponse(self, filePath, fileName):
writeDouble(matrix[5])
if version >= 2:
writeInt(width)
writeInt(height)
print "Writing width,height", chartname, width, height
writeInt(0xaabbccde)
for level in xrange(5):
chart, cksum = parse_landing_chart.get_chart(blobname=chartname,
cksum=cksum,
level=level)
writeUTF(cksum)
print "Chart:", cksum, "Writing level", level, "size:", len(chart)
writeInt(len(chart))
response.write(chart)
writeInt(0xaabbccdf)
writeInt(0xf111)
print "finished writing chart"
return
def getmap(self):
users = meta.Session.query(User).filter(
User.user == request.params['user']).all()
badpass = False
if len(users) == 0:
badpass = True
else:
user, = users
if user.password != request.params[
def GetFeatureInfo(self):
# Housekeeping
version = self.getOwsParam('version', default=self.validVersions[0])
if version not in self.validVersions:
raise InvalidParameterValue('Version %s not supported' % version,
'version')
# Coordinate parameters
bbox = tuple(float(x) for x in self.getOwsParam('bbox').split(','))
width = int(self.getOwsParam('width'))
height = int(self.getOwsParam('height'))
# Get pixel location
i = int(self.getOwsParam('i'))
j = int(self.getOwsParam('j'))
format = self.getOwsParam('info_format', default='text/html')
layers = self._getLayerParam('query_layers')
for layerObj in layers:
layerName = layerObj.name
log.debug('Format: %s' % format)
log.debug('Title: %s' % layerObj.title)
log.debug('FeatureInfoFormats: %s' % layerObj.featureInfoFormats)
# ### Only process first layer if more than one. ###
layerObj = layers[0]
if format not in layerObj.featureInfoFormats:
raise InvalidParameterValue(
'Layer %s does not support GetFeatureInfo in format %s' %
(layerName, format), 'info_format')
srs = self._getSrsParam(version)
if srs not in layerObj.crss:
raise InvalidParameterValue('Layer %s does not support SRS %s' %
(layerName, srs))
# Convert coordinates to (long, lat) if necessary.
bbox = self._convertBboxForCrs(bbox, version, srs)
log.debug("(i,j) (%d,%d) bbox ((%d,%d)(%d,%d)) crs %s" %
(i, j, bbox[0], bbox[1], bbox[2], bbox[3], srs))
# Translate to geo-coordinates
x, y = bbox_util.pixelToGeo(i, j, bbox, width, height)
#start preparing GetFeatureInfo response. Assumes "HTML" output format
# htmlResponse = "<html><body><p> <b>Feature Information about pixel position: "+self.getOwsParam('i')+","+self.getOwsParam('j')+"/geo position: "+str(x)+","+str(y) +"<b/></p>"
#Adjusts response for multiple layers
# if len(layers) > 1:
# htmlResponse = htmlResponse+" Multiple possible features found as follows:"
# htmlResponse = htmlResponse+"<ul>"
# Dimension handling
dimValues = {}
for dimName, dim in layerObj.dimensions.items():
defaultValue = dim.extent[0]
dimValues[dimName] = self.getOwsParam(dimName,
default=defaultValue)
log.debug("dimName: %s dimValue: %s" %
(dimName, dimValues[dimName]))
value = layerObj.getFeatureInfo(format, srs, (x, y), dimValues)
htmlResponse = ((
"<table style='width:100%%'><tr><td>Longitude</td><td>%s</td></tr>"
+ "<tr><td>Latitude</td><td>%s</td></tr>" +
"<tr><td>Value</td><td>%s</td></tr></table>") %
(str(x), str(y), value))
response.headers['Content-Type'] = format
response.write(htmlResponse)
def writeInt(x):
response.write(struct.pack(">I",x))
def writeLong(x):
response.write(struct.pack(">Q",x))
def getmap(self):
users=meta.Session.query(User).filter(User.user==request.params['user']).all()
badpass=False
if len(users)==0:
badpass=True
else:
user,=users
if user.password!=request.params['password'] and user.password!=md5str(request.params['password']):
badpass=True
maptype=request.params.get('maptype','nolabel')
def writeInt(x):
response.write(struct.pack(">I",x))
def writeLong(x):
response.write(struct.pack(">Q",x))
response.headers['Content-Type'] = 'application/binary'
version,level,offset,maxlen,maxlevel=\
[int(request.params[x]) for x in "version","level","offset","maxlen","maxlevel"];
writeInt(0xf00df00d)
writeInt(1) #version
if badpass:
print "badpassword"
writeInt(1) #error, bad pass
return None
#print "Correct password"
totalsize=0
stamp=0
for lev in xrange(maxlevel+1):
tlevelfile=os.path.join(os.getenv("SWFP_DATADIR"),"tiles/"+maptype+"/level"+str(lev))
totalsize+=os.path.getsize(tlevelfile)
stamp=max(stamp,os.stat(tlevelfile)[stat.ST_MTIME])
#print "Maxlevel: %d, stamp: %d"%(maxlevel,stamp)
levelfile=os.path.join(os.getenv("SWFP_DATADIR"),"tiles/"+maptype+"/level"+str(level))
curlevelsize=os.path.getsize(levelfile)
cursizeleft=curlevelsize-offset
#print "cursize left:",cursizeleft
#print "maxlen:",maxlen
if cursizeleft<0:
cursizeleft=0
if maxlen>cursizeleft:
maxlen=cursizeleft
if maxlen>1000000:
maxlen=1000000
writeInt(0) #no error
#print "No error"
writeLong(stamp) #"data version"
#print "stamp:",stamp
writeLong(curlevelsize)
writeLong(totalsize)
writeLong(cursizeleft)
writeInt(0xa51c2)
latest=meta.Session.query(Download).filter(Download.user==user.user).order_by(sa.desc(Download.when)).first()
if not latest or datetime.utcnow()-latest.when>timedelta(0,3600):
down=Download(user.user, maxlen)
meta.Session.add(down)
else:
down=latest
down.bytes+=maxlen
meta.Session.flush()
meta.Session.commit()
f=open(levelfile)
if offset<curlevelsize:
#print "seeking to %d of file %s, then reading %d bytes"%(offset,levelfile,maxlen)
f.seek(offset)
data=f.read(maxlen)
#print "Writing %d bytes to client"%(len(data),)
response.write(data)
f.close()
return None
def writeDouble(f):
response.write(struct.pack(">d",f))
def writeFloat(f):
response.write(struct.pack(">f",f))
def no_lang(self):
set_lang(None)
response.write(_('No language'))
set_lang([])
response.write(_('No languages'))
return ''
def no_lang(self):
set_lang(None)
response.write(_('No language'))
set_lang([])
response.write(_('No languages'))
return ''
def writeDouble(f):
response.write(struct.pack(">d", f))
def writeLong(x):
response.write(struct.pack(">Q", x))
# We should insert our HTML block at the bottom of the page with
# the appropriate CSS to render it at the top. Easier to insert
# before </body>.
c.url = resource.url
replacement = render("data/cache_header.html")
try:
compiled_body = re.compile(re.escape("</body>"), re.IGNORECASE)
content = compiled_body.sub("{0}</body>".format(replacement),
content, re.IGNORECASE)
except Exception, e:
log.warn(
"Failed to do the replacement in resource<{0}> and file: {1}"
.format(resource.id, filepath))
return
response.write(content)
def viz_upload(self):
"""
Provides direct upload to DGU for users in specific publishers.
This is specifically for the social investment publishers so that
they can host their files somewhere.
"""
import ckan.model as model
ALLOWED_PUBLISHERS = set([
'seedbed'
'health-social-ventures',
'big-issue-cooperate',
'social-incubator-east',
'young-academy',
def writeFloat(f):
response.write(struct.pack(">f", f))
writeDouble(matrix[4])
writeDouble(matrix[5])
if version>=2:
writeInt(width)
writeInt(height)
print "Writing width,height",chartname,width,height
writeInt(0xaabbccde)
for level in xrange(5):
chart,cksum=parse_landing_chart.get_chart(blobname=chartname,cksum=cksum,level=level)
writeUTF(cksum)
print "Chart:",cksum,"Writing level",level,"size:",len(chart)
writeInt(len(chart))
response.write(chart)
writeInt(0xaabbccdf)
writeInt(0xf111)
print "finished writing chart"
return
def getmap(self):
users=meta.Session.query(User).filter(User.user==request.params['user']).all()
badpass=False
if len(users)==0:
badpass=True
else:
user,=users
if user.password!=request.params['password'] and user.password!=md5str(request.params['password']):
badpass=True
def getmap(self):
users = meta.Session.query(User).filter(
User.user == request.params['user']).all()
badpass = False
if len(users) == 0:
badpass = True
else:
user, = users
if user.password != request.params[
'password'] and user.password != md5str(
request.params['password']):
badpass = True
maptype = request.params.get('maptype', 'nolabel')
def writeInt(x):
response.write(struct.pack(">I", x))
def writeLong(x):
response.write(struct.pack(">Q", x))
response.headers['Content-Type'] = 'application/binary'
version,level,offset,maxlen,maxlevel=\
[int(request.params[x]) for x in "version","level","offset","maxlen","maxlevel"]
writeInt(0xf00df00d)
writeInt(1) #version
if badpass:
print "badpassword"
writeInt(1) #error, bad pass
return None
#print "Correct password"
totalsize = 0
stamp = 0
for lev in xrange(maxlevel + 1):
tlevelfile = os.path.join(os.getenv("SWFP_DATADIR"),
"tiles/" + maptype + "/level" + str(lev))
totalsize += os.path.getsize(tlevelfile)
stamp = max(stamp, os.stat(tlevelfile)[stat.ST_MTIME])
#print "Maxlevel: %d, stamp: %d"%(maxlevel,stamp)
levelfile = os.path.join(os.getenv("SWFP_DATADIR"),
"tiles/" + maptype + "/level" + str(level))
curlevelsize = os.path.getsize(levelfile)
cursizeleft = curlevelsize - offset
#print "cursize left:",cursizeleft
#print "maxlen:",maxlen
if cursizeleft < 0:
cursizeleft = 0
if maxlen > cursizeleft:
maxlen = cursizeleft
if maxlen > 1000000:
maxlen = 1000000
writeInt(0) #no error
#print "No error"
writeLong(stamp) #"data version"
#print "stamp:",stamp
writeLong(curlevelsize)
writeLong(totalsize)
writeLong(cursizeleft)
writeInt(0xa51c2)
latest = meta.Session.query(Download).filter(
Download.user == user.user).order_by(sa.desc(
Download.when)).first()
if not latest or datetime.utcnow() - latest.when > timedelta(0, 3600):
down = Download(user.user, maxlen)
meta.Session.add(down)
else:
down = latest
down.bytes += maxlen
meta.Session.flush()
meta.Session.commit()
f = open(levelfile)
if offset < curlevelsize:
#print "seeking to %d of file %s, then reading %d bytes"%(offset,levelfile,maxlen)
f.seek(offset)
data = f.read(maxlen)
#print "Writing %d bytes to client"%(len(data),)
response.write(data)
f.close()
return None
def no_lang(self):
set_lang(None)
response.write(_("No language"))
set_lang([])
response.write(_("No languages"))
return ""
def writeInt(x):
response.write(struct.pack(">I", x))
def __init__ (self, PrintableClass):
for name in dir(PrintableClass):
value = getattr(PrintableClass,name)
if '_' not in str(name).join(str(value)):
response.write(' .%s: %r' % (name, value))
try:
f = open(filepath, "r")
except IOError:
log.error('Error reading resource cache file: %s', filepath)
abort(403, "The system was unable to read this resource from the cache. Admins have been notified")
content = f.read()
f.close()
if not re.search("<base ", content, re.IGNORECASE):
compiled_head = re.compile(re.escape("<head>"), re.IGNORECASE)
content = compiled_head.sub( base_string, content, re.IGNORECASE)
if not '__archiver__cache__header__' in content:
# We should insert our HTML block at the bottom of the page with
# the appropriate CSS to render it at the top. Easier to insert
# before </body>.
c.url = resource.url
replacement = render("data/cache_header.html")
try:
compiled_body = re.compile(re.escape("</body>"), re.IGNORECASE)
content = compiled_body.sub( "{0}</body>".format(replacement), content, re.IGNORECASE)
except Exception, e:
log.error("Failed to do the replacement in resource<{0}> and file: {1}".format(resource.id, filepath))
return
response.write(content)
def resource_cache(self, root, resource_id, filename):
"""
Called when a request is made for an item in the resource cache and
is responsible for rendering the data. When the data to be rendered
is HTML it will add a header to show that the content is cached, and
set a <base> header if not present to make sure all relative links are
resolved correctly.
"""
from pylons import response
from paste.fileapp import FileApp
from ckanext.dgu.lib.helpers import tidy_url
archive_root = pylons.config.get('ckanext-archiver.archive_dir')
if not archive_root:
# Bad configuration likely to cause this.
abort(404, "Could not find archive folder")
resource = model.Resource.get(resource_id)
is_html = False
content_type = "application/octet-stream"
fmt = ""
task_status = model.Session.query(model.TaskStatus).\
filter(model.TaskStatus.task_type=='qa').\
filter(model.TaskStatus.key=='status').\
filter(model.TaskStatus.entity_id==resource.id).first()
if task_status:
status = json.loads(task_status.error)
fmt = status['format']
# Make an attempt at getting the correct content type but fail with
# application/octet-stream in cases where we don't know.
formats = {
"CSV": "application/csv",
"XLS": "application/vnd.ms-excel",
"HTML": 'text/html; charset=utf-8' }
content_type = formats.get(fmt, "application/octet-stream")
is_html = fmt == "HTML"
filepath = os.path.join(archive_root, root, resource_id, filename).decode('utf-8')
if not os.path.exists(filepath):
abort(404, "Resource is not cached")
file_size = os.path.getsize(filepath)
if not is_html:
headers = [('Content-Type', content_type),
('Content-Length', str(file_size))]
fapp = FileApp(filepath, headers=headers)
return fapp(request.environ, self.start_response)
origin = tidy_url(resource.url)
parts = urlparse.urlparse(origin)
url = "{0}://{1}".format(parts.scheme, parts.netloc)
base_string = "<head><base href='{0}'>".format(url)
response.headers['Content-Type'] = content_type
with open(filepath, "r") as f:
content = f.read()
if not re.search("<base ", content, re.IGNORECASE):
compiled_head = re.compile(re.escape("<head>"), re.IGNORECASE)
content = compiled_head.sub( base_string, content, re.IGNORECASE)
if not '__archiver__cache__header__' in content:
# We should insert our HTML block at the bottom of the page with
# the appropriate CSS to render it at the top. Easier to insert
# before </body>.
c.url = resource.url
replacement = render("data/cache_header.html")
try:
compiled_body = re.compile(re.escape("</body>"), re.IGNORECASE)
content = compiled_body.sub( "{0}</body>".format(replacement), content, re.IGNORECASE)
except Exception, e:
log.error("Failed to do the replacement in resource<{0}> and file: {1}".format(resource.id, filepath))
return
response.write(content)
