def argos_insert(request):
stations = []
argos_id = array('i')
gps_id = array('i')
# Query that check for duplicate stations
check_duplicate_station = select([func.count(Station.id)]).where(
and_(Station.name == bindparam('name'), Station.lat == bindparam('lat'),
Station.lon == bindparam('lon'), Station.ele == bindparam('ele')))
# For each objet in the request body
for ptt_obj in request.json_body:
ptt = ptt_obj['ptt']
ind_id = ptt_obj['ind_id']
# For each location associated with this object
for location in ptt_obj['locations']:
# Argos
if location['type'] == 0:
# Get all the informations about the sensor data
argos_data = DBSession.query(Argos).filter_by(id=location['id']).one()
name = 'ARGOS_' + str(argos_data.ptt) + '_' + argos_data.date.strftime('%Y%m%d%H%M%S')
if DBSession.execute(check_duplicate_station, {'name':name, 'lat':argos_data.lat, 'lon':argos_data.lon, 'ele':argos_data.ele}).scalar() == 0:
argos = ProtocolArgos(ind_id=ind_id, lc=argos_data.lc, iq=argos_data.iq, nbMsg=argos_data.nbMsg, nbMsg120=argos_data.nbMsg120,
bestLvl=argos_data.bestLvl, passDuration=argos_data.passDuration, nopc=argos_data.nopc, frequency=argos_data.frequency)
station = Station(date=argos_data.date, name=name, fieldActivityId=27, fieldActivityName='Argos', lat=argos_data.lat, lon=argos_data.lon, ele=argos_data.ele, protocol_argos=argos)
# Add the station in the list
argos_id.append(location['id'])
stations.append(station)
# Gps
elif location['type'] == 1:
gps_data = DBSession.query(Gps).filter_by(id=location['id']).one()
name = 'ARGOS_' + str(gps_data.ptt) + '_' + gps_data.date.strftime('%Y%m%d%H%M%S')
if DBSession.execute(check_duplicate_station, {'name':name, 'lat':argos_data.lat, 'lon':argos_data.lon, 'ele':argos_data.ele}).scalar() == 0:
gps = ProtocolGps(ind_id=ind_id, course=gps_data.course, speed=gps_data.speed)
station = Station(date=argos_data.date, name=name, fieldActivityId=27, fieldActivityName='Argos', lat=argos_data.lat, lon=argos_data.lon, ele=argos_data.ele, protocol_gps=gps)
# Add the station in the list
gps_id.append(location['id'])
stations.append(station)
# Insert the stations (and protocols thanks to ORM)
DBSession.add_all(stations)
# Update the sensor database
DBSession.execute(update(Argos).where(Argos.id.in_(argos_id)).values(checked=True, imported=True))
DBSession.execute(update(Gps).where(Gps.id.in_(gps_id)).values(checked=True, imported=True))
return {'status':'ok'}
def rfid_active_byDate(request):
date = datetime.strptime(request.params['date'], '%d/%m/%Y %H:%M:%S')
data = DBSession.query(MonitoredSite.name, MonitoredSite.type_, MonitoredSitePosition.lat, MonitoredSitePosition.lon
).outerjoin(MonitoredSitePosition, MonitoredSite.id==MonitoredSitePosition.id
).filter(MonitoredSitePosition.begin_date <= date
).filter(or_(MonitoredSitePosition.end_date >= date, MonitoredSitePosition.end_date == None )).all()
siteName_type=[{'type':row[1] , 'name':row[0], 'positions': {'lat': row[2], 'lon': row[3] }} for row in data]
result = {'siteType': list(set([row[1] for row in data])), 'siteName_type': siteName_type}
return result
def rfid_detail(request):
name = request.matchdict['name']
data = DBSession.query(ObjectRfid, MonitoredSite, MonitoredSiteEquipment
).outerjoin(MonitoredSiteEquipment, ObjectRfid.id==MonitoredSiteEquipment.obj
).outerjoin(MonitoredSite, MonitoredSiteEquipment.site==MonitoredSite.id
).filter(ObjectRfid.identifier==name
).order_by(desc(MonitoredSiteEquipment.begin_date)).first()
module, site, equip = data
result = {'module': module, 'site':site, 'equip':equip}
return result
def login(request):
user_id = request.POST.get('user_id', '')
pwd = request.POST.get('password', '')
user = DBSession.query(User).filter(User.id==user_id).one()
if user is not None and user.check_password(pwd):
headers = remember(request, user_id)
response = request.response
response.headerlist.extend(headers)
return response
else:
return HTTPUnauthorized()
def rfid_add(request):
try:
obj = ObjectRfid()
obj.identifier = request.json_body.get('identifier', None)
obj.creator = request.authenticated_userid
DBSession.add(obj)
rfid = DBSession.query(ObjectRfid.id
).filter(ObjectRfid.identifier==obj.identifier).scalar()
except IntegrityError:
request.response.status_code = 500
return 'Error: An object with the same identifier already exists.'
return ' '.join(['Success: RFID module created with ID =', str(rfid), '.'])
def monitored_site_equipment_pose(request):
t = MonitoredSiteEquipment
pose_info = request.POST
creator= request.authenticated_userid
values = {t.creator.name:creator}
obj = DBSession.query(ObjectRfid.id).filter(ObjectRfid.identifier==pose_info['identifier']).scalar()
site = DBSession.execute(select([MonitoredSite.id]
).where(MonitoredSite.type_==pose_info['type']
).where(MonitoredSite.name==pose_info['name'])).scalar()
begin_date = parse(request.POST['begin'])
if(pose_info['action'] == 'pose'):
stmt = insert(MonitoredSiteEquipment)
message = '1 row inserted'
values[t.obj.name] = obj
values[t.site.name] = site
values[t.begin_date.name] = begin_date
lat, lon = DBSession.execute(select([MonitoredSitePosition.lat, MonitoredSitePosition.lon]).where(
MonitoredSitePosition.site == site).where(MonitoredSitePosition.begin_date <= begin_date).where(
or_(MonitoredSitePosition.end_date == None, MonitoredSitePosition.end_date <= begin_date))).fetchone()
values[t.lat.name] = lat
values[t.lon.name] = lon
values[t.end_date.name] = parse(pose_info['end'])
elif(pose_info['action'] == 'remove'):
stmt = update(MonitoredSiteEquipment
).where(MonitoredSiteEquipment.obj==obj
).where(MonitoredSiteEquipment.site==site)
message = '1 row updated'
d = parse(pose_info['end'])
if d is not None:
values[t.end_date.name] = d
else:
request.response.status_code = 500
return 'Nothing to update'
else:
request.response.status_code = 500
return 'Unknown action'
try:
DBSession.execute(stmt, values)
except IntegrityError as e:
request.response.status_code = 500
return e
return message
def core_individual(request):
""" Get the attributes of an identified individual.
"""
id = int(request.matchdict["id"])
indiv = DBSession.query(Individual).filter(Individual.id == id).one()
query = (
select(
[
V_Individuals_History.c.label,
V_Individuals_History.c.value,
cast(V_Individuals_History.c.begin_date, Date),
cast(V_Individuals_History.c.end_date, Date),
]
)
.where(V_Individuals_History.c.id == id)
.order_by(V_Individuals_History.c.carac, desc(V_Individuals_History.c.begin_date))
)
carac = DBSession.execute(query).fetchall()
null_date_filter = lambda date: None if date is None else str(date)
indiv.history = [
OrderedDict([("name", label), ("value", value), ("from", str(begin_date)), ("to", null_date_filter(end_date))])
for label, value, begin_date, end_date in carac
]
return indiv
def monitoredSite(request): id_ = request.matchdict['id'] data = DBSession.query(MonitoredSite).filter(MonitoredSite.id == id_).order_by(MonitoredSite.name).one() return data
def monitoredSites(request): data = DBSession.query(MonitoredSite).order_by(MonitoredSite.name).all() return data
def role_loader(user_id, request):
return DBSession.query(User.role).filter(User.id==user_id).one()
def rfid_get(request):
return DBSession.query(ObjectRfid).all()
def gps_unchecked_count(request):
"""Returns the unchecked gps data count."""
return {'count': DBSession.query(func.count(Gps.pk)
).filter(Gps.checked == 0).scalar()}
def argos_unchecked_count(request):
"""Returns the unchecked argos data count."""
return DBSession.query(func.count(Argos.pk)
).filter(Argos.checked == False).scalar()
