def test_update(self):
device = Device(id='dev_id_23', device_class='PSI', device_type='PBR')
self.DM.insert(device, Device)
dev_from_DB = Device.query.filter_by(id='dev_id_23').first()
self.assertIsNone(dev_from_DB.address)
# get rid of objects in the session
db.session.remove()
device.address = "home"
self.DM.update(device)
dev_from_DB = Device.query.filter_by(id='dev_id_23').first()
self.assertEqual(dev_from_DB.address, "home")
def post(self):
# receive (from app): (query, device_id)
# service:
# check for strange chars in text
# if not strange:
# save text in Device object(device_id)
# send request with page 1 to device
# respond to app: success
# else respond to app: fail
query = request.json.get('query')
device_id = request.json.get('device_id')
if query and device_id:
# todo: check strange text
try:
text = convert(query) # convert to braille data
# save to device
if device_exist(device_id):
device = Device.query.filter_by(name=device_id).first()
device.update(text)
else:
device = Device(name=device_id, text=text)
device.save()
# todo: send request to device with device_id
# request to device: device.page()
send_to_device(device_id, device.page())
# ***** failed *****
# msg = json.dumps(device.page())
# try:
# iothub_messaging = IoTHubMessaging(connection_string)
# iothub_messaging.open(open_complete_callback, 0)
# message = IoTHubMessage(bytearray(msg, 'utf8'))
# iothub_messaging.send_async(device_id, message, send_complete_callback, 1)
# except IoTHubError as iothub_error:
# print("Unexpected error {0}" % iothub_error)
return {'success': True}
except:
return {
'success': False,
'error': 'an error has occurred'
}, 500
else:
return {
'success': False,
'error': "'query' or 'device_id' not found"
}, 400
def create_app(config_name='default'):
"""
Create Flask app
:param config_name:
:return: Flask
"""
from .api import blueprint as api_blueprint
app = Flask(__name__)
CORS(app, resources={r"/api/*": {"origins": "*"}})
app.config.from_object(config[config_name])
config[config_name].init_app(app)
connections.create_connection(
hosts=[config[config_name].ELASTICSEARCH_HOST], timeout=20)
from app.models import User, Customer, Deal, Device, BluetoothLog
with app.app_context():
User.init()
Customer.init()
Deal.init()
Device.init()
BluetoothLog.init()
user_search = User.search().execute()
if len(user_search) == 0:
user = User(username='******')
user.hash_password('averdier')
user.save()
app.register_blueprint(api_blueprint)
extensions(app)
@app.after_request
def after_request(response):
response.headers.add('Access-Control-Allow-Origin', '*')
if request.method == 'OPTIONS':
response.headers[
'Access-Control-Allow-Methods'] = 'DELETE, GET, POST, PUT'
headers = request.headers.get('Access-Control-Request-Headers')
if headers:
response.headers['Access-Control-Allow-Headers'] = headers
return response
return app
def test_insert(self):
# empty
exists = Device.query.filter_by(id='dev_id_23').first()
self.assertIsNone(exists)
# new device
device = Device(id='dev_id_23', device_class='PSI', device_type='PBR')
self.DM.insert(device, Device)
exists = Device.query.filter_by(id='dev_id_23').first()
self.assertIsNotNone(exists)
# not all required attributes
device = Device(id='dev_id_wrong', device_class='PSI')
self.assertRaises(OperationalError, self.DM.insert, device, Device)
def device(key):
target_device = Device.by_key(key)
if target_device is None:
return jsonify({
"status": "not found",
"message": "no device found by the key {}".format(key)
}), 404
if str(target_device.owner.id) != get_jwt_identity()['id']:
return jsonify({
"status": "failed",
"message": "you do not have the required permisson"
}), 403
if request.method == "GET":
return jsonify({
"status": "success",
"device": DeviceSchema().dump(target_device)
})
if request.method == "DELETE":
target_device.delete()
return jsonify({
"status": "success",
"message": "deleted successfully"
}), 204
def add_device():
form = AddDeviceForm()
if form.validate_on_submit():
address = form.address.data.upper()
device = Device.query.filter_by(address=address).one_or_none()
if device is None:
device = Device(address=address, user=current_user)
db.session.commit()
return redirect(url_for("main.edit_device", device_id=device.id))
else:
if device.user == current_user:
flash(_("You already own this device"), category="warning")
return redirect(url_for("main.my_devices"))
else:
device_claim = DeviceClaim.query.\
filter_by(device_id=device.id).\
filter_by(claimer=current_user).one_or_none()
if device_claim is None:
flash(_("This device is used by another user"),
category="danger")
return redirect(
url_for("main.claim_device", device_id=device.id))
else:
flash(
_("This device is used by another user, but you already opened a claim"
))
return redirect(url_for("main.my_devices"))
return render_template("form_generator.html",
title=_("Add Device"),
form=form)
def action():
""" PUT request to do action
{
device: 'light',
place: 'hall',
action: 'turn_on'
}
if target device not found return suggestions with devices have similar name/ devices in same place
if action is to read :
currently supported sensors : temperature
request temperature:
{
device: 'temperature'
place: 'room1',
action: 'read'
}
"""
data = request.get_json()
user_id = data.get("user_id")
try:
name = data.get("name")
place = data.get("place")
action = data.get("action")
except Exception as e:
return jsonify({"error":
"Provide a name, a place and an action."}), 400
user = User.objects().first() # this is just for testing
user = User.get_by_id(user_id)
print("user", user.id, "req_param", user_id)
# get the device then filter them by name
devices = Device.by_owner(user)
target_device = None
target_device = devices.filter(name=name, place=place).first()
if not target_device:
return jsonify({"error": "Not found"}), 404
if action == "read":
val = read_sensor(target_device)
if val:
return jsonify({"data": val})
return jsonify(), 500
flag = False
if action == "turn_on":
flag = set_switch_state(target_device, "1")
elif action == "turn_off":
flag = set_switch_state(target_device, "0")
else:
return jsonify({"error": "Unknown Action."}), 400
if flag:
return jsonify({"data": "success"}), 200
return jsonify("Internal Error"), 500
def create_device():
print(request.json)
sn = request.json.get('sn')
name = request.json.get('name')
img = request.json.get('img')
type = request.json.get('type')
device = Device(sn=sn,name=name,img=img,type=type,)
static_folder = current_app.config['STATIC_FOLDER']
user_dir = os.path.join(static_folder, 'user_folder', f"{g.current_user.uid}")
tmp_file_path = os.path.join(user_dir, img)
if not os.path.exists(tmp_file_path):
return jsonify({'success':False,'error_code':-1,'errmsg':f'文件{tmp_file_path}不存在'})
db.session.add(device)
try:
db.session.commit()
dst_dir = os.path.join(static_folder, 'deviceimg', f"{device.id}")
dst_file_path = os.path.join(dst_dir, img)
os.makedirs(dst_dir,exist_ok=True)
shutil.move(tmp_file_path,dst_file_path)
shutil.rmtree(user_dir)
except Exception as e:
db.session.rollback()
logging.error(f'添加数据库发生错误,已经回退:{e}')
return jsonify({'success': False, 'error_code': -123, 'errmsg': '数据库插入错误，请查看日志'})
return jsonify({'success':True,
'error_code':0,
})
def import_devices():
# We don't have the 'original' ddb with emails so we create a single user who takes it all
user = User(email="*****@*****.**")
user.set_password("topsecret")
db.session.add(user)
with open(os.path.join(basepath, "ressources/ddb.txt")) as csvfile:
csvreader = csv.DictReader(csvfile, delimiter=",", quotechar="'")
for row in csvreader:
device_type = {"F": DeviceType.FLARM, "I": DeviceType.ICAO, "O": DeviceType.OGN}[row["#DEVICE_TYPE"]]
address = row["DEVICE_ID"]
aircraft_type_name = row["AIRCRAFT_MODEL"]
registration = row["REGISTRATION"]
cn = row["CN"]
show_track = row["TRACKED"] == "Y"
show_identity = row["IDENTIFIED"] == "Y"
aircraft_category = AircraftCategory.coerce(row["AIRCRAFT_TYPE"])
aircraft_type = AircraftType.query.filter_by(name=aircraft_type_name).one_or_none()
if not aircraft_type:
aircraft_type = AircraftType(name=aircraft_type_name, category=aircraft_category)
Device(device_type=device_type, aircraft_type=aircraft_type, address=address, registration=registration, cn=cn, show_track=show_track, show_identity=show_identity, user=user)
db.session.commit()
def handle_mqtt_message(client, userdata, message):
app.logger.info(message.topic + ' ' + message.payload.decode())
match = hydro_json_re.match(message.topic)
if match:
name = match.group(1)
data = json.loads(message.payload.decode())
dev = Device.query.filter_by(name=name).first()
if not dev:
dev = Device(name=name)
db.session.add(dev)
db.session.commit()
log = Log(
device=dev.id,
session=dev.cur_session,
bat_v=data['bat_v'],
temp_f=data['temp_f'],
light_vis=data['light_vis'],
light_ir=data['light_ir'],
light_uv=data['light_uv'],
accel_x=data['accel_x'],
accel_y=data['accel_y'],
accel_z=data['accel_z'],
tilt=data['tilt'],
wifi_conn_fail=data['wifi_conn_fail'],
mqtt_conn_fail=data['mqtt_conn_fail'],
last_run_time=data['last_run_time']
)
db.session.add(log)
db.session.commit()
def delete(self, id):
"""
Delete sensor
"""
sensor = Device.get(id=id, ignore=404)
if sensor is None:
abort(404, 'Sensor not found.')
sensor.delete()
if Device.get(id=id, ignore=404) is not None:
abort(400, error='Unable to delete sensor.')
return 'Sensor successfully deleted.', 204
def test_save_value(self):
device = Device(id='dev_id_23', device_class='PSI', device_type='PBR')
self.DM.insert(device, Device)
self.DM._store_permanent()
# empty
exists = Value.query.filter_by(id='dev_id_23').first()
self.assertIsNone(exists)
# new value
value = Value(id=1,
time=now(),
value=23,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None)
self.DM.save_value(value)
result = Value.query.filter_by(var_id='od').first()
self.assertEqual(result, value)
# new value with non-existing variable
value = Value(id=2,
time=now(),
value=32,
dev_id='dev_id_23',
var_id='new_var',
attribute=1,
note=None)
self.DM.save_value(value)
result = Value.query.filter_by(var_id='new_var').first()
self.assertEqual(result, value)
# check variables
self.assertIn('new_var', set(self.DM.load_variables()))
def sync():
'''Showing all logger'''
url = "https://prinus.net/api/sensor"
username = os.environ['PRINUS_USER']
password = os.environ['PRINUS_PASS']
response = requests.get(url, auth=(username, password))
devices = Device.query.all()
raw = response.json()
sn_list = [key['sn'] for key in raw]
for dev in devices:
if dev.sn in sn_list:
sn_list.remove(dev.sn)
# update device and lokasi in pbase, and
# send new device and lokasi to pweb
for sn in sn_list:
# update device
device = Device(sn=f"{sn}")
db.session.add(device)
db.session.commit()
# send post data
try:
post_url = f"{os.environ['PWEB_URL']}/api/device"
post_data = {'sn': f"{sn}", 'id': device.id}
res = requests.post(post_url, data=post_data)
result = res.json()
print(result)
except Exception as e:
print(e)
return redirect(url_for('logger.index'))
def test_user_device_relationship(self):
user = User()
device = Device()
user.followed_devices.append(device)
self.assertTrue(user in device.following_users)
self.assertTrue(device in user.followed_devices)
def patch(self, id):
"""
Patch sensor
"""
sensor = Device.get(id=id, ignore=404)
if sensor is None:
abort(404, 'Sensor not found.')
data = request.json
updated = False
if data.get('mqtt_account', None) is not None:
if data['mqtt_account'].get('username'):
sensor_search = Device.search().query(
'term', **{
'mqtt_account.username':
data['mqtt_account']['username']
}).execute()
if len(sensor_search) != 0 and sensor_search.hits[
0].meta.id != sensor.meta.id:
abort(400, error='MQTT username already exist.')
if sensor.update_mqtt_account(data['mqtt_account']):
updated = True
if data.get('key', None) is not None:
sensor.hash_key(data['key'])
updated = True
if data.get('pos_x', None) is not None:
sensor.pos_x = data['pos_x']
updated = True
if data.get('pos_y', None) is not None:
sensor.pos_y = data['pos_y']
updated = True
if data.get('radius', None) is not None:
sensor.radius = data['radius']
updated = True
if updated:
sensor.save()
return 'Sensor successfully patched.', 204
def device_available(device):
if app.config['DEBUG']:
return True
active_info = Device.get_device_active(device.id)
if active_info and active_info.startswith("1"):
return True
return False
def create_device(id):
if g.current_user.id != id:
abort(403)
user = User.query.get_or_404(id)
devices = Device.query.all()
data = request.get_json() or {}
if 'name' not in data or 'device_type' not in data:
return bad_request('must include name and device_type fields')
#TODO:Find a way to get specific users devices and check for reoccuring names
for i in devices:
if g.current_user == i.owner:
if i.name == data['name']:
return bad_request('Please choose a different name')
#Sets owner for device
device = Device(owner=User.query.get(id))
device.date_reg = datetime.utcnow()
#TODO: Set comments for certain device types
device.comment = 'NA'
device.from_dict(data, new_device=True)
db.session.add(device)
db.session.commit()
response = jsonify(device.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_device', id=user.id)
return response
def get_devices(id):
if g.current_user.id != id:
abort(403)
page = request.args.get('page', 1, type=int)
per_page = min(request.args.get('per_page', 10, type=int), 100)
data = Device.to_collection_dict(Device.query.filter_by(user_id=id), page,
per_page, 'api.get_users')
return jsonify(data)
def get(self, id):
"""
Get sensor
"""
sensor = Device.get(id=id, ignore=404)
if sensor is None:
abort(404, 'Sensor not found.')
return sensor.to_dict(include_id=True)
def get(self):
"""
Return sensor list
"""
return {
'sensors': [
sensor.to_dict(include_id=True) for sensor in
Device.search().query('term', device_type='sensor').execute()
]
}
def test_coprimarykey(self):
u1 = User(email='*****@*****.**', password='******')
u2 = User(email='*****@*****.**', password='******')
db.session.add(u1)
db.session.add(u2)
d1 = Device(name='d1')
d1.users.append(u1)
d1.users.append(u2)
db.session.add(d1)
db.session.commit()
self.assertTrue(d1.users[1].email == '*****@*****.**')
def register_device():
form = DeviceRegistrationForm()
if form.validate_on_submit():
device = Device(deviceId=form.deviceId.data, devicename=form.devicename.data, name=form.name.data, dept_code=form.dept_code.data, device_function=form.device_function.data,device_bg=form.device_bg.data)
db.session.add(device)
db.session.commit()
flash('Congratulations, your device is in the system!\nThe URL your device is localhost:5000/device/'+str(form.deviceId.data))
new_device_info = Device.query.filter_by(deviceId=form.deviceId.data).first_or_404()
bg_pic=background_dictionary[deviceId.device_bg]
return render_template('new_device.html', deviceId=new_device_info, bg_pic=bg_pic)
return render_template('register_device.html', title='Add New Device', form=form)
def decorated_view(*args, **kwargs):
device_code = request.headers.get('Device-Code')
if not device_code:
raise UnauthorizedError('请输入Device-Code')
device = Device.get_device(device_code)
if not device:
raise UnauthorizedError('设备未配置')
project_id = device.project_id
if project_id == 0:
raise UnauthorizedError('设备未配置')
g.current_device = device
return func(*args, **kwargs)
def get_device_claim(self):
owner = User(email='klaus@localhost')
claimer = User(email='kurt@localhost')
device = Device(user=owner, address='DD1234')
device_claim = DeviceClaim(device=device, owner=owner, claimer=claimer)
db.session.add(device_claim)
db.session.commit()
self.assertTrue(device_claim.is_approved is None)
self.assertEqual(device.user, owner)
return device_claim
def import_fakedata():
a1 = AircraftType(name="ASK-13", category=AircraftCategory.SAILPLANE)
a2 = AircraftType(name="ASH-25", category=AircraftCategory.SAILPLANE)
a3 = AircraftType(name="Rhönlärche Ил-32", category=AircraftCategory.SAILPLANE)
a4 = AircraftType(name="Aquila A210", category=AircraftCategory.PLANE)
a5 = AircraftType(name="Concorde", category=AircraftCategory.PLANE)
a6 = AircraftType(name="Eurofox", category=AircraftCategory.ULTRALIGHT)
a7 = AircraftType(name="Gyrocopter", category=AircraftCategory.ULTRALIGHT)
a8 = AircraftType(name="EC 120", category=AircraftCategory.HELICOPTER)
a9 = AircraftType(name="EC 130", category=AircraftCategory.HELICOPTER)
a10 = AircraftType(name="EC 135", category=AircraftCategory.HELICOPTER)
a11 = AircraftType(name="DJI S800", category=AircraftCategory.DRONE)
a12 = AircraftType(name="DJI S900", category=AircraftCategory.DRONE)
a13 = AircraftType(name="DJI S1000", category=AircraftCategory.DRONE)
a14 = AircraftType(name="Balloon", category=AircraftCategory.OTHER)
a15 = AircraftType(name="Paraglider", category=AircraftCategory.OTHER)
a16 = AircraftType(name="UFO", category=AircraftCategory.OTHER)
db.session.add_all([a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16])
u1 = User(email="user1@localhost")
u1.set_password("topsecret1")
Device(address="DD1234", device_type=DeviceType.FLARM, aircraft_type=a1, registration="D-1234", cn="34", user=u1)
Device(address="DD4711", device_type=DeviceType.FLARM, aircraft_type=a2, registration="D-4711", cn="11", user=u1)
u2 = User(email="user2@localhost")
u2.set_password("topsecret2")
Device(address="ABCDEF", device_type=DeviceType.OGN, aircraft_type=a3, registration="D-OTTO", cn="TO", user=u2)
Receiver(name="Koenigsdf", antenna=Antenna.CHINESE_9DB_JPOLE, preamplifier=Preamplifier.TERRA_AB010, rx_filter=RxFilter.CAVITY, sdr_dongle=SdrDongle.RTLSDR_COM, user=u1)
Receiver(name="Wank", antenna=Antenna.CHINESE_9DB_JPOLE, preamplifier=Preamplifier.NONE, rx_filter=RxFilter.CBP840, sdr_dongle=SdrDongle.RTLSDR_COM, user=u1)
Receiver(name="Arber", antenna=Antenna.WIMO_SPERRTOPF, preamplifier=Preamplifier.NONE, rx_filter=RxFilter.CAVITY, sdr_dongle=SdrDongle.RTLSDR_COM, user=u1)
Receiver(name="Marmolada", antenna=Antenna.CHINESE_9DB_JPOLE, preamplifier=Preamplifier.SELF_BUILT_WITH_FILTER, rx_filter=RxFilter.NONE, sdr_dongle=SdrDongle.RTLSDR_COM, user=u1)
db.session.add(u1)
db.session.add(u2)
db.session.commit()
def register():
data = request.get_json()
temp_device = db.session.query(Device).filter(
Device.devicename == data['name'])
if (temp_device.count() > 0):
temp_device.first().ipaddress = data['ipaddr']
temp_device.first().updatetime = datetime.datetime.utcnow()
db.session.commit()
return "Updated Device"
d = Device(devicename=data['name'], ipaddress=data['ipaddr'])
db.session.add(d)
db.session.commit()
return "Added New Device"
def set_device_info(device_id, info_type, content):
if info_type == 0 or info_type == '0':
Device.set_device_info(device_id, SERVICE_STATE, content['status'])
return
if info_type == 6 or info_type == '6':
Device.set_device_info(device_id, SERVICE_VERSION, content)
return
if info_type == 8 or info_type == '8' or info_type == 9 or info_type == '9':
for (k, v) in content.items():
Device.set_device_info(device_id, k, v)
return
Device.set_device_info(device_id, info_type, content)
def api_create_device():
if not request.is_json:
return json_responses.invalid_json()
data = request.get_json()
check_fields = json_responses.check_fields([
"friendly_name", "ip", "port", "netmiko_driver", "authentication_user"
], data)
if check_fields["error"]:
return check_fields
check_device = dbfunctions.check_device_exist_ip(data["ip"])
if check_device:
return json_responses.generic_response(
True, "device with IP {} already exist.".format(data["ip"]))
check_driver = dbfunctions.check_netmiko_driver(data["netmiko_driver"])
if not check_driver:
return json_responses.generic_response(
True,
"{} is an invalid netmiko_driver. Please see Netmiko supported drivers at: https://github.com/ktbyers/netmiko"
.format(data["netmiko_driver"]))
check_user = dbfunctions.check_user_exist(data["authentication_user"])
if not check_user:
return json_responses.generic_response(
True,
"user {} does not exist.".format(data["authentication_user"]))
try:
device = Device(**data)
db.session.add(device)
db.session.commit()
except Exception as error:
return json_responses.generic_response(True, error)
return json_responses.generic_response(False, [device.as_dict()])
def test_get_latest_data(self):
# preparations
device = Device(id='dev_id_23', device_class='PSI', device_type='PBR')
self.DM.insert(device, Device)
self.DM._store_permanent()
# store some values
values = [
Value(id=1,
time=now(),
value=23.0,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None),
Value(id=2,
time=now(),
value=24.0,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None),
Value(id=3,
time=now(),
value=25.0,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None),
Value(id=4,
time=now(),
value=26.0,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None),
Value(id=5,
time=now(),
value=27.0,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None)
]
for value in values:
self.DM.save_value(value)
# get last value
result = self.DM.get_latest_data(device.id, 'values')
self.assertEqual(values[4], result)
def create_app(config_name='default'):
"""
Create Flask app
:param config_name:
:return: Flask
"""
from .api import blueprint as api_blueprint
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
connections.create_connection(hosts=[config[config_name].ELASTICSEARCH_HOST], timeout=20)
from app.models import Device
with app.app_context():
Device.init()
app.register_blueprint(api_blueprint)
return app
def devices():
payload = get_jwt_identity()
user_id = payload["id"]
if request.method == "GET":
devices = Device.by_owner(user_id)
res = {
"status": "success",
"devices": DeviceSchema(many=True).dump(devices)
}
return jsonify(res)
if request.method == "POST":
"""Create new device. Example:
POST the JSON "{'port': 14, 'name': 'TV', 'place': 'room2', 'type': 1}"
return device object if data is valid
if the port already has a device update to the new parameters
"""
json_data = request.get_json()
device_schema = DeviceSchema()
owner = User.get_by_id(user_id)
try:
device_schema.load(json_data)
new_device = Device(name=json_data["name"],
port=json_data["port"],
place=json_data["place"],
d_type=json_data["type"],
owner=owner)
new_device.save()
except ValidationError as e:
res = {"status": "validation failed", "messages": e.messages}
return jsonify(res), 400
res = {"status": "sucess", "device": device_schema.dump(new_device)}
return jsonify(res), 201
def fetch_logger():
res = requests.get(URL, auth=bws_sul1)
if res.status_code == 200:
logger = json.loads(res.text)
local_logger = [d.sn for d in Device.query.all()]
if len(local_logger) != len(logger):
for l in logger:
if l.get('sn') not in local_logger:
new_logger = Device(sn=l.get('sn'))
db.session.add(new_logger)
db.session.commit()
print('Tambah:', new_logger.sn)
else:
print(res.status_code)
def format_device_info(device_id, device_info, is_list=0):
property_map = DETAIL_DEVICE_INFO
ret_device_info = {}
if is_list:
property_map = LIST_DEVICE_INFO
for (k, v) in property_map.items():
if k not in device_info.keys():
ret_device_info[k] = v
else:
ret_device_info[k] = device_info[k]
if ALLOT_TIME in property_map.iterkeys() and START_USE_TIME in device_info.keys() \
and device_info[START_USE_TIME] != '0':
ret_device_info[ALLOT_TIME] = int(time.time()) - int(device_info[START_USE_TIME])
ret_device_info[USE_TIMES] = "%d" % (int(ret_device_info[USE_TIMES]) + ret_device_info[ALLOT_TIME])
if HARD_STATE in property_map.iterkeys() and Device.get_device_active(device_id):
ret_device_info[HARD_STATE] = 1
ret_device_info[DEVICE_ID] = device_id
return ret_device_info
from app.models import Device
lat = raw_input("Please enter latitude: ")
lng = raw_input("Please enter longitude: ")
device = Device(lat, lng)
device.persist()
def map():
devices = Device.get_all()
list = [{'lat': device.lat, 'lng': device.lng} for device in devices]
return render_template('map.html', title='Map', devices=list)
def sample_data(request):
from app.models import App_User,Vendor,Currier,Device,Order,Location
# . Make User ALPHA
# . Make Vendor 1 ("vendor_mgr")
# . Device ALPHA
# . Make User BRAVO
# . Make Currier 1
# . Device BRAVO
# . Make Order 1
# . - add locations
# MAKE VENDOR 1
a = App_User(first_name='ALPHA',
last_name='ALPHA',
app_user_type='vendor_mgr'
)
a.save()
ONE_vendor_app_user_id = a.app_user_id
c = Vendor(app_user_id=ONE_vendor_app_user_id,
name='ALPHA BIZ',
addr1='ONE_pickup_addr',
days='Tue-Thu,Sat-Sun',
start_times='11:00 AM, 1:00 AM',
end_times='11:00 PM, 8:00 PM',
area='Murray Hill',
holidays=str({"Labor Day" : "closed"}),
)
c.save()
ONE_vendor_id = c.vendor_id
d = Device( vendor_id=ONE_vendor_id,
model='iphone',
platform='os7')
d.save()
ONE_vendor_device_id = d.device_id
# add device to vendor entry
c.device.add(d.device_id)
c.save()
# add device to app_user entry
a.device.add(d.device_id)
a.vendor_id = c.vendor_id
a.save()
# MAKE CURRIER 1
a = App_User(first_name='BRAVO',
last_name='BRAVO',
app_user_type='currier'
)
a.save()
ONE_dg_app_user_id = a.app_user_id
c = Currier(app_user_id=ONE_dg_app_user_id,
speed_rating='1.0',
worktime_rating='10.0'
)
c.save()
ONE_dg_id = c.currier_id
d = Device( currier_id=ONE_dg_id,
model='Samsung Galaxy',
platform='Ice Cream')
d.save()
ONE_dg_device_id = d.device_id
# add device to currier entry
c.device.add(d.device_id)
c.save()
# add device to app_user entry
a.device.add(d.device_id)
a.currier_id = c.currier_id
a.save()
# MAKE ORDER 1
c = Order( vendor_id=ONE_vendor_id,
vendor_dev_id=ONE_vendor_device_id,
currier_id=ONE_dg_id,
currier_dev_id=ONE_dg_device_id,
call_in =True,
deliv_addr='ONE_deliv_addr',
tag='TAG1'
)
c.save()
ONE_order_id = c.order_id
# add locations for order
l = Location(order_id=ONE_order_id,
loc_num=1,
currier_id=ONE_dg_id,
web=c.web,
call_in=c.call_in,
pickup=True,
addr=c.vendor.addr1,
tag=c.tag,
)
l.save()
c = Location(order_id=ONE_order_id,
loc_num=2,
currier_id=ONE_dg_id,
web=c.web,
call_in=c.call_in,
delivery=True,
addr=c.deliv_addr,
tag=c.tag,
)
c.save()
# . Make User CHARLIE
# . Make Vendor 2 ("vendor_empl")
# . Device CHARLIE
# . Make User DELTA
# . Make Currier 2
# . Device DELTA
# . Make Order Two
# MAKE VENDOR 2
a = App_User(first_name='CHARLIE',
last_name='CHARLIE',
app_user_type='vendor_empl'
)
a.save()
TWO_vendor_app_user_id = a.app_user_id
c = Vendor( app_user_id=TWO_vendor_app_user_id,
name='Charlie Biz',
addr1='TWO_pickup_addr',
days='Tue-Thu,Sat-Sun',
start_times='11:00 AM, 1:00 AM',
end_times='11:00 PM, 8:00 PM',
area='Murray Hill',
holidays=str({"Labor Day" : "closed"}),
)
c.save()
TWO_vendor_id = c.vendor_id
d = Device( vendor_id=TWO_vendor_id,
model='Blackberry',
platform='something old')
d.save()
TWO_vendor_device_id = d.device_id
# add device to vendor entry
c.device.add(d.device_id)
c.save()
# add device to app_user entry
a.device.add(d.device_id)
a.vendor_id = c.vendor_id
a.save()
# MAKE CURRIER 2
a = App_User(first_name='DELTA',
last_name='DELTA',
app_user_type='currier'
)
a.save()
TWO_dg_app_user_id = a.app_user_id
c = Currier(app_user_id=TWO_dg_app_user_id,
speed_rating='1.0',
worktime_rating='10.0'
)
c.save()
TWO_dg_id = c.currier_id
d = Device( currier_id=TWO_dg_id,
model='Samsung Galaxy',
platform='Ice Cream')
d.save()
TWO_dg_device_id = d.device_id
# add device to currier entry
c.device.add(d.device_id)
c.save()
# add device to app_user entry
a.device.add(d.device_id)
a.currier_id = c.currier_id
a.save()
# MAKE ORDER 2
time_in_90 = DT.now() + timedelta(hours=1,minutes=30)
c = Order( vendor_id=TWO_vendor_id,
vendor_dev_id=TWO_vendor_device_id,
currier_id=TWO_dg_id,
currier_dev_id=TWO_dg_device_id,
web=True,
req_pickup_time=time_in_90.isoformat(),
deliv_addr='TWO_deliv_addr',
tag='TAG2'
)
c.save()
TWO_order_id = c.order_id
# add locations
l = Location(order_id=TWO_order_id,
currier_id=TWO_dg_id,
web=c.web,
call_in=c.call_in,
loc_num=3,
pickup=True,
addr=c.vendor.addr1,
tag=c.tag,
)
l.save()
c = Location(order_id=TWO_order_id,
loc_num=4,
currier_id=TWO_dg_id,
web=c.web,
call_in=c.call_in,
delivery=True,
addr=c.deliv_addr,
tag=c.tag,
)
c.save()
return render(request, 'management/success.html', {})
def start_use_device(device_id):
Device.set_device_info(device_id, START_USE_TIME, int(time.time()))
Device.set_device_info(device_id, USER_FLAG, 1)
def end_use_device(device_id, timelong):
Device.set_device_info(device_id, START_USE_TIME, 0)
Device.set_device_info(device_id, USER_FLAG, 0)
Device.incr_device_info(device_id, USE_TIMES, timelong)
