Beispiel #1
0
def current_uploads(request):
    """ """
    kwds = _process_subpath(request.subpath)
    
    session = get_session()

    user = None

    # TODO: exclude failed UploadEvents
    U, UE = ~_models.User, ~_models.UploadEvent
    rp = (session.query(U, UE)
            .filter(U.id==int(kwds['user_id']))
            .filter(UE.user_id==U.id)
            .filter(UE.date_completed==None)
            ).all()
    upl_evnts = []
    if rp:
        for row in rp:
            u, ue = row
            user = u
            upl_evnts.append(ue)

    # and... get previous uploads
    rp = (session.query(U, UE)
            .filter(U.id==int(kwds['user_id']))
            .filter(UE.user_id==U.id)
            .filter(UE.date_completed!=None)
            ).all()
    prv_upl_evnts = []
    if rp:
        for row in rp:
            u, ue = row
            user = u
            prv_upl_evnts.append(ue)

    # and... finally the full history
    UESH = ~_models.UploadEventStatusHistory
    rp = (session.query(U, UE, UESH)
            .filter(U.id==int(kwds['user_id']))
            .filter(UE.user_id==U.id)
            .filter(UESH.upload_event_id==UE.id)
            ).all()
    hist = []
    if rp:
        for row in rp:
            u, ue, uesh = row
            user = u
            hist.append(uesh) 

    print 'HISTORY', hist  

    return {
        'user':user,
        'upload_events':upl_evnts,
        'prev_upload_events':prv_upl_evnts,
        'history':hist
    }
Beispiel #2
0
def proximity(request):
    try:
        args = list(request.subpath)
        kwds = _process_subpath(args)
        ghash = (kwds['ghash'] 
                    if 'ghash' in kwds 
                    else GPSPOINT_FCTRY(**kwds).AsGeoHash)
        sssf = SQLAlchemySessionFactory()
        sess = sssf.Session
        model = sssf.ModelsModule.__dict__[kwds['geomodel']]
        val = ghash+'%'
        rp = sess.query(~model).filter((~model).geohash.like(val)).all()
        results = [model(entity=r) for r in rp]
        return make_result_repr(model, results)
    except:
        print traceback.format_exc()
        raise HTTPNotAcceptable(body="Error finding Geo Entities within proximity of requested information.")
Beispiel #3
0
def geo_gpspoint(request):
    """ 
    Three optional arguments, ghash, lat and long, or address

    c/geo-gpspoint/ghash=sp3e92xrmnzu
    c/geo-gpspoint/longitude=2.174488138407469/latitude=41.40051246620715
    c/geo-gpspoint/addressAvinguda Diagonal, 332, 08013 Barcelona, Spain

    JSON resource repr

    {   "city": "Barcelona", "country": "Spain", "longitude": 2.174488138407469, 
        "geohash": "sp3e92xrmnzu", "address": 
        "Avinguda Diagonal, 332, 08013 Barcelona, Spain", 
        "latitude": 41.40051246620715, "postal_code": "08013"
    }
    """
    try:
        start = datetime.datetime.now()
        #print 'geo_gpspoint called', start
        args = list(request.subpath)
        kwds = _process_subpath(args)
        gp = GPSPOINT_FCTRY(**kwds)
        country_code_dispatch = {
            'United States':'USA',
            'Italy':'ITA',
            'Spain':'ESP'
        }
        r = {
            'latitude':gp.Latitude,
            'longitude':gp.Longitude,
            'geohash':gp.AsGeoHash,
            'full_address':gp.FullAddress,
            'street_address':gp.StreetAddress,
            'city':gp.City,
            'country':gp.Country,
            'country_code':country_code_dispatch[gp.Country],
            'postal_code':gp.PostalCode,
            'areas': gp.AdministrativeAreas
        }
        return r
    except:
        print traceback.format_exc()
        raise HTTPNotAcceptable(body="Couldn't guess the geolocation using the supplied information.")