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)