def post(self):
kwargs = {
'key_name': self.request.get('id'),
'device': self.request.get('type'),
'version': self.request.get('version'),
'country': self.request.get('country'),
'carrier': self.request.get('carrier'),
}
Device.add(**kwargs)
def get(self):
db.delete(DeviceVersions.all().fetch(400))
total = (Device.all().count() / 10) + 1
for x in xrange(total):
offset = x * 10
taskqueue.add(url='/tasks/AggregateVersionsWorker', params={'offset': offset})
def post(self):
offset = int(self.request.get('offset'))
devices = Device.all().filter('version =', 'Unknown').fetch(10, offset)
for device in devices:
logging.debug("Device: %s" % device.key().name())
if device.version_raw:
UnknownVersions.increment(device.version_raw)
def post(self):
offset = int(self.request.get('offset'))
devices = Device.all().fetch(10, offset)
for device in devices:
logging.debug("Device: %s" % device.key().name())
if device.type:
DeviceAggregate.increment(device.type)
def post(self):
offset = int(self.request.get('offset'))
devices = Device.all().fetch(10, offset)
for device in devices:
logging.debug("Device: %s" % device.key().name())
if device.version:
DeviceVersions.increment(device.version)
def old_xml_import(xmlfile, user, request_form):
filename = xmlfile.filename
data = xmlfile.readlines()
if isinstance(data[0], bytes):
data = [str(x.decode('utf-8')) for x in data]
data[0] = data[0] + "<sml>"
data.append("</sml>")
filematch = re.match(
r'log-([A-F0-9]{16})-\d{4}-\d{2}-\d{2}T\d{2}_\d{2}_\d{2}-\d+\.xml',
filename)
if not filematch:
flash("illegal filename: '%s'" % filename, 'error')
return
serial_number = filematch.group(1)
tree = objectify.fromstring("\n".join(data).encode('utf-8'))
move = parse_move(tree)
move.source = filename
move.import_module = __name__
device = Device.query.filter_by(serial_number=serial_number).scalar()
if not device:
device = Device()
device.serial_number = serial_number
db.session.add(device)
if Move.query.filter_by(user=user, date_time=move.date_time,
device=device).scalar():
flash("%s at %s already exists" % (move.activity, move.date_time),
'warning')
else:
move.user = user
move.device = device
db.session.add(move)
for sample in parse_samples(tree.Samples.iterchildren(), move):
db.session.add(sample)
postprocess_move(move)
db.session.commit()
return move
def get(self):
db.delete(UnknownVersions.all().fetch(400))
total = (Device.all().filter('version =', 'Unknown').count() / 10) + 1
for x in xrange(total):
offset = x * 10
taskqueue.add(url='/tasks/AggregateUnknownVersionsWorker',
params={'offset': offset})
def post(self):
offset = int(self.request.get('offset'))
devices = Device.all().fetch(10, offset)
for device in devices:
logging.debug("Device: %s" % device.key().name())
if device.country_code:
DeviceCountries.increment(device.country_code)
def get(self):
db.delete(DeviceCountries.all().fetch(1000))
total = (Device.all().count() / 10) + 1
for x in xrange(total):
offset = x * 10
taskqueue.add(url='/tasks/AggregateCountriesWorker',
params={'offset': offset})
def post(self):
offset = int(self.request.get('offset'))
devices = Device.all().fetch(10, offset)
for device in devices:
logging.debug("Device: %s" % device.key().name())
if device.version:
DeviceVersions.increment(device.version)
def post(self):
offset = int(self.request.get('offset'))
devices = Device.all().fetch(10, offset)
for device in devices:
logging.debug("Device: %s" % device.key().name())
if device.country_code:
DeviceCountries.increment(device.country_code)
def initialize_device():
"""
Set up the Device info into the database.
By this time, the HardwareDefinition and SoftwareDefinition
entries must be entered.
"""
session = Session()
hd = session.query(HardwareDefinition).one()
sd = session.query(SoftwareDefinition).one()
device = Device(id=hd.serial_number,
interior_sensor=hd.interior_sensor,
exterior_sensor=hd.exterior_sensor)
device.hardware_version = hd.hardware_version
device.software_version = sd.software_version
device.database_service = True # database always set to True
device.device_service = sd.device_service
device.grainbin_service = sd.grainbin_service
session.add(device)
# set grainbin info
if sd.grainbin_service:
grainbins = initialize_grainbin(device.id, hd.grainbin_reader_count)
device.grainbin_count = len(grainbins)
session.add_all(grainbins)
session.commit()
session.close()
return
def post(self):
offset = int(self.request.get('offset'))
devices = Device.all().fetch(10, offset)
for device in devices:
logging.debug("Device: %s" % device.key().name())
if not device.carrier:
device.carrier = "Unknown"
DeviceCarriers.increment(device.carrier)
def post(self):
offset = int(self.request.get('offset'))
devices = Device.all().fetch(10, offset)
for device in devices:
logging.debug("Device: %s" % device.key().name())
if not device.carrier:
device.carrier = "Unknown"
DeviceCarriers.increment(device.carrier)
def __create_device(self) -> Device:
firmware = self.__get_firmware()
protocol = self.__get_protocol()
errors = self.__get_errors()
return Device(name='Advanced Sample Device',
firmware=firmware,
protocol=protocol,
errors=errors)
def edit(device_id):
device = Device.get(device_id)
if not device:
device = Device()
form = DeviceProfileForm()
form.type.choices = [('1', u'Base Station'), ('2', u'Node')]
if request.method == 'POST':
form.save_form(device)
return redirect(url_for('devices'))
return render_template('edit.html', form=form, device=device)
def get(self):
tpl_values = {
'device_count': Device.getCount(),
'devices_count': DeviceAggregate.getKeyCount(),
'device_data': DeviceAggregate.generateGraphData(),
'carrier_count': DeviceCarriers.getKeyCount(),
'country_count': DeviceCountries.getKeyCount(),
}
self.render(tpl_values)
def get(self):
tpl_values = {
'device_count': Device.getCount(),
'devices_count': DeviceAggregate.getKeyCount(),
'device_data': DeviceAggregate.generateGraphData(),
'carrier_count': DeviceCarriers.getKeyCount(),
'country_count': DeviceCountries.getKeyCount(),
}
self.render(tpl_values)
def old_xml_import(xmlfile, user, request_form):
filename = xmlfile.filename
data = xmlfile.readlines()
if isinstance(data[0], bytes):
data = [str(x.decode('utf-8')) for x in data]
data[0] = data[0] + "<sml>"
data.append("</sml>")
filematch = re.match(r'log-([A-F0-9]{16})-\d{4}-\d{2}-\d{2}T\d{2}_\d{2}_\d{2}-\d+\.xml', filename)
if not filematch:
flash("illegal filename: '%s'" % filename, 'error')
return
serial_number = filematch.group(1)
tree = objectify.fromstring("\n".join(data).encode('utf-8'))
move = parse_move(tree)
move.source = filename
move.import_module = __name__
device = Device.query.filter_by(serial_number=serial_number).scalar()
if not device:
device = Device()
device.serial_number = serial_number
db.session.add(device)
if Move.query.filter_by(user=user, date_time=move.date_time, device=device).scalar():
flash("%s at %s already exists" % (move.activity, move.date_time), 'warning')
else:
move.user = user
move.device = device
db.session.add(move)
for sample in parse_samples(tree.Samples.iterchildren(), move):
db.session.add(sample)
postprocess_move(move)
db.session.commit()
return move
def clientRegisterDevice(self, data):
try:
if self.authenticated:
self.user.update()
device_id = data['device']
if not device_id:
self.sendAPI(1,447,'Value empty')
return
if len(device_id) > 120:
self.sendAPI(1,449,'Value exceeds maximum input length')
return
device = Device(device_id)
phone_number = data['phone_number']
if not isinstance(phone_number, int):
self.sendAPI(1,448,'Value is wrong data type')
return
if phone_number > 2147483646:
self.sendAPI(1,449,'Value exceeds maximum input length')
return
if phone_number < 0:
self.sendAPI(1,447,'Value empty')
return
if device.exist():
self.sendAPI(1,436,'Device already exist')
return
device.user = self.user
if 'phone_number' in data:
device.phone_number = phone_number
self.user.addDevice(device)
self.sendAPI(0,236,'Device registered')
else:
self.sendAPI(1,410,'User unauthorized')
except (KeyError, TypeError):
self.sendAPI(1,401,'Not in reference format')
def get_faulty_devices_for_user(self, user_id):
faulty_devices = self.repositories.device_repository.get_faulty_devices()
house_id = self.collection.get_houses_for_user(user_id)[0].house_id
target_devices = []
fault_check = False
for device in faulty_devices:
if device.house_id == house_id:
fault_check = True
target_devices.append(Device(device))
self.collection.update_one({'_id': user_id}, {"$set": {'faulty': fault_check}}, upsert=False)
return target_devices
def load_devices(cls):
cls.devicenamelist = []
for device in cls.config['Devices']:
deviceobject = Device(device['deviceid'])
deviceobject.devicename = device['devicename']
deviceobject.serverport = device['serverport']
deviceobject.bootstrapport = device['bootstrapport']
deviceobject.platformname = device['platformname']
deviceobject.platformversion = device['platformversion']
deviceobject.server = device['server']
cls.devices[deviceobject.deviceid] = deviceobject
cls.devicenamelist.append(device['devicename'])
Log.logger.info(u"配置yaml列表中一共有 %s 台设备" % len(cls.devices))
def get_devices(self):
"""Return a list of devices with Spotify players running.
Returns:
list: The Devices.
"""
results = self.get_api_v1("me/player/devices")
if results and "devices" in results:
return tuple(Device(device) for device in results['devices'])
else:
return []
def index():
if request.method == 'POST':
four_node_data = list()
res = None
for node in request.form:
device_id = int(node.rsplit('_')[1])
device = Device.get(device_id)
if device:
lng = device.lng
lat = device.lat
t = float(request.form[node])
data = (lng, lat, t)
four_node_data.append(data)
if len(four_node_data) >= 4:
res = get_position(four_node_data)
return jsonify({'lng': res[0], 'lat': res[1]})
devices = Device.get_base_station()
return render_template('index.html', devices=devices)
def load_devices(cls):
cls.device_name_list = []
for device in cls.config['Devices']:
device_object = Device(device['deviceid'])
device_object.device_name = device['devicename']
device_object.server_port = device['serverport']
device_object.bootstrap_port = device['bootstrapport']
device_object.platform_name = device['platformname']
device_object.platform_version = device['platformversion']
device_object.server = device['server']
cls.devices[device_object.device_id] = device_object
cls.device_name_list.append(device['devicename'])
Log.logger.info("There are %s devices in the configuration list" %
len(cls.devices))
def submitDigital(self, subject):
device = subject.get('i')
self.statusDevice[device] = subject.get('v')
self.log.info("change : {} = {}".format(device, self.statusDevice[device]))
self.publish(u'io.robotica.controle.on_{}'.format(device), self.statusDevice[device])
self.publish(u'io.robotica.controle.on_digital', self.statusDevice)
#Write to Mongodb last status of device
deviceDB = Device.objects(mac = device).get()
deviceDB.date = datetime.now()
deviceDB.status = self.statusDevice[device]
deviceDB.save()
return subject
def getResults(resultsDir, build, version, pipeline, commiter):
testResults = []
date = time.strftime('%x')
for subdir, dirs, files in os.walk(resultsDir, topdown=True):
testList = prepareTestList(files, subdir)
if testList:
deviceMeta = getDeviceMeta(subdir)
device = Device(deviceMeta[0], build, version, pipeline,
deviceMeta[3], deviceMeta[2], "00:00", date,
commiter, "Android, " + deviceMeta[1], testList)
testResults.append(device)
return testResults
def get_device_by_id(self, device_id):
device = self.collection.find_one({'_id': device_id})
if device is None:
return None
device_type = device['device_type'] if 'device_type' in device else None
if device_type == "thermostat":
return Thermostat(device)
elif device_type == "motion_sensor":
return MotionSensor(device)
elif device_type == "light_switch":
return LightSwitch(device)
elif device_type == "open_sensor":
return OpenSensor(device)
return Device(device)
def clientDeleteDevice(self, data):
try:
if self.authenticated:
self.user.update()
device_id = data['device']
if not device_id:
self.sendAPI(1,447,'Value empty')
return
if not isinstance(device_id, basestring):
self.sendAPI(1,448,'Value is wrong data type')
return
device = Device(device_id)
if device.exist():
self.user.deleteDevice(device)
self.sendAPI(0,266,'Device deleted')
else:
self.sendAPI(1,410,'User unauthorized')
except (KeyError, TypeError):
self.sendAPI(1,401,'Not in reference format')
def createSpineIFDs(self, pod, spines):
devices = []
interfaces = []
for spine in spines:
user = spine.get('user')
password = spine.get('pass')
device = Device(spine['name'], pod.spineDeviceType, user, password, 'spine', spine['mac_address'], spine['mgmt_ip'], pod)
devices.append(device)
portNames = util.getPortNamesForDeviceFamily(device.family, self.conf['deviceFamily'])
for name in portNames['ports']: # spine does not have any uplink/downlink marked, it is just ports
ifd = InterfaceDefinition(name, device, 'downlink')
interfaces.append(ifd)
self.dao.createObjects(devices)
self.dao.createObjects(interfaces)
def devices_lnglat():
data = []
devices = Device.get_devices()
for device in devices:
d = {}
d['device_id'] = device.id
d['lng'] = device.lng
d['lat'] = device.lat
d['name'] = device.name
if device.type == NODE:
d['icon_uri'] = url_for('static', filename=NODE_IMG_URI)
else:
d['icon_uri'] = url_for('static', filename=BASESTATION_IMG_URI)
data.append(d)
return jsonify({'data': data})
def createLeafIFDs(self, pod, leafs):
devices = []
interfaces = []
for leaf in leafs:
user = leaf.get('user')
password = leaf.get('pass')
device = Device(leaf['name'], pod.leafDeviceType, user, password, 'leaf', leaf['mac_address'], leaf['mgmt_ip'], pod)
devices.append(device)
portNames = util.getPortNamesForDeviceFamily(device.family, self.conf['deviceFamily'])
for name in portNames['uplinkPorts']: # all uplink IFDs towards spine
ifd = InterfaceDefinition(name, device, 'uplink')
interfaces.append(ifd)
for name in portNames['downlinkPorts']: # all downlink IFDs towards Access/Server
ifd = InterfaceDefinition(name, device, 'downlink')
interfaces.append(ifd)
self.dao.createObjects(devices)
self.dao.createObjects(interfaces)
def add_device_readings():
# huey.courses.add(Course.select().where(Course.name.contains('English')))
device = Device.get(name='Sensor-300578')
print(device.id, device.name, device.health)
def parse_device(tree):
device = Device()
device.name = tree.DeviceLog.Device.Name.text
device.serial_number = tree.DeviceLog.Device.SerialNumber.text
return device
def get(self):
self.render({'device_count': Device.getCount()})
def get_all_devices(self):
devices = self.collection.find()
target_devices = []
for device in devices:
target_devices.append(Device(device))
return target_devices
def get_devices_for_room(self, room_id):
devices = self.collection.find({'room_id': room_id})
target_devices = []
for device in devices:
target_devices.append(Device(device))
return target_devices
def delete(device_id):
Device.delete(device_id)
return redirect(url_for('devices'))
def PollRequest(device_id):
db = session()
tree = cut_namespace_request()
# create or update parameters for device
device = db.query(Device).get(device_id)
if device == None:
device = Device()
device.id = device_id
db.add(device)
device.management_system = tree.lookup('ManagementSystem/Name')
device.management_version = tree.lookup('ManagementSystem/Version')
device.name = tree.lookup('Identification/DeviceName')
device.username = tree.lookup('Identification/UserName')
device.platform = tree.lookup('Identification/Platform')
device.processor = tree.lookup('Identification/Processor')
device.ip_address = tree.lookup('Identification/NetworkAdapter/IPAddress')
device.ip_subnet = tree.lookup('Identification/NetworkAdapter/IPSubnet')
device.codepage = tree.lookup('Identification/CodePage')
device.default_locale_id = tree.lookup('Identification/SystemDefaultLCID')
device.last_poll_update()
db.commit()
# send current parameters back to device
return render_template('poll_response.xml', device = device, server = Server())
def create_device():
device = Device()
device.name = GPX_DEVICE_NAME
device.serial_number = GPX_DEVICE_SERIAL
return device
def parse_device(tree):
device = Device()
device.name = tree.DeviceLog.Device.Name.text
device.serial_number = tree.DeviceLog.Device.SerialNumber.text
return device
def get(self):
self.render({'device_count': Device.getCount()})
def __init__(self, config):
ApplicationSession.__init__(self, config)
self.payload = {}
self.user = User()
self.device = Device()
self.statusDevice = {}
def get(self):
self.response.out.write("%s" % Device.getCount())
def collectLldpAndMatchDevice(self):
if (self.configurationInProgressCache.checkAndAddDevice(self.deviceIp)):
# for real device the password is coming from pod
tmpDevice = Device(self.deviceIp, None, 'root', self.pod.getCleartextPassword(), 'leaf', None, self.deviceIp, None)
tmpDevice.id = self.deviceIp
self.updateSelfDeviceContext(tmpDevice)
logger.debug('Started two stage configuration for %s' % (self.deviceIp))
for i in range(1, self.attempt+1):
# wait first: this will replace the original delay design
logger.debug('Wait for %d seconds...' % (self.interval))
# don't do unnecessary context switch
if self.interval > 0:
self.stopEvent.wait(self.interval)
if self.stopEvent.is_set():
return
logger.debug('Connecting to %s: attempt %d' % (self.deviceIp, i))
try:
self.connectToDevice()
logger.debug('Connected to %s' % (self.deviceIp))
break
except Exception as exc:
pass
if self.deviceConnectionHandle is None:
logger.error('All %d attempts failed for %s' % (self.attempt, self.deviceIp))
self.configurationInProgressCache.doneDevice(self.deviceIp)
raise DeviceConnectFailed('All %d attempts failed for %s' % (self.attempt, self.deviceIp))
try:
self.device.family = self.deviceConnectionHandle.facts['model'].lower()
self.device.serialNumber = self.deviceConnectionHandle.facts['serialnumber']
self.runPreLldpCommands()
lldpData = self.collectLldpFromDevice()
except Exception as exc:
logger.error('Failed to execute deleteVcpPorts for %s, %s' % (self.deviceIp, exc))
raise DeviceRpcFailed('Failed to execute deleteVcpPorts %s' % (self.deviceIp), exc)
uplinksWithIfds = self.filterUplinkAppendRemotePortIfd(lldpData, self.device.family)
self.updateSpineStatusFromLldpData([x['ifd2'] for x in uplinksWithIfds])
device = self.findMatchedDevice(uplinksWithIfds)
if device is None:
logger.info('Did not find good enough match for %s' % (self.deviceIp))
self.configurationInProgressCache.doneDevice(self.deviceIp)
return
self.fixInterfaces(device, self.device.family, uplinksWithIfds)
# persist serialNumber
device.serialNumber = self.device.serialNumber
self._dao.updateObjectsAndCommitNow(self._session, [device])
self.updateSelfDeviceContext(device)
try:
try:
self.runPostLldpCommands()
except SkipCommit:
self.updateDeviceConfigStatus('good')
return
self.updateDeviceConfigStatus('processing')
self.updateDeviceConfiguration()
self.updateDeviceConfigStatus('good')
except DeviceRpcFailed as exc:
logger.error('Two stage configuration failed for %s, %s' % (self.deviceLogStr, exc))
self.updateDeviceConfigStatus(None, error = exc)
raise
except Exception as exc:
logger.error('Two stage configuration failed for %s, %s' % (self.deviceLogStr, exc))
self.updateDeviceConfigStatus('error', str(exc))
raise
finally:
self.releaseConfigurationInProgressLock(self.deviceIp)
logger.debug('Ended two stage configuration for %s' % (self.deviceLogStr))
else:
logger.debug('Two stage configuration is already in progress for %s', (self.deviceLogStr))
def devices():
devices = Device.get_devices()
return render_template('devices.html', devices=devices)
def collectLldpAndMatchDevice(self):
if (self.configurationInProgressCache.checkAndAddDevice(
self.deviceIp)):
# for real device the password is coming from pod
tmpDevice = Device(self.deviceIp, None, 'root',
self.pod.getCleartextPassword(), 'leaf', None,
self.deviceIp, None)
tmpDevice.id = self.deviceIp
self.updateSelfDeviceContext(tmpDevice)
logger.debug('Started two stage configuration for %s' %
(self.deviceIp))
for i in range(1, self.attempt + 1):
# wait first: this will replace the original delay design
logger.debug('Wait for %d seconds...' % (self.interval))
# don't do unnecessary context switch
if self.interval > 0:
self.stopEvent.wait(self.interval)
if self.stopEvent.is_set():
return
logger.debug('Connecting to %s: attempt %d' %
(self.deviceIp, i))
try:
self.connectToDevice()
logger.debug('Connected to %s' % (self.deviceIp))
break
except Exception as exc:
pass
if self.deviceConnectionHandle is None:
logger.error('All %d attempts failed for %s' %
(self.attempt, self.deviceIp))
self.configurationInProgressCache.doneDevice(self.deviceIp)
raise DeviceConnectFailed('All %d attempts failed for %s' %
(self.attempt, self.deviceIp))
try:
self.device.family = self.deviceConnectionHandle.facts[
'model'].lower()
self.device.serialNumber = self.deviceConnectionHandle.facts[
'serialnumber']
self.runPreLldpCommands()
lldpData = self.collectLldpFromDevice()
except Exception as exc:
logger.error('Failed to execute deleteVcpPorts for %s, %s' %
(self.deviceIp, exc))
raise DeviceRpcFailed(
'Failed to execute deleteVcpPorts %s' % (self.deviceIp),
exc)
uplinksWithIfds = self.filterUplinkAppendRemotePortIfd(
lldpData, self.device.family)
self.updateSpineStatusFromLldpData(
[x['ifd2'] for x in uplinksWithIfds])
device = self.findMatchedDevice(uplinksWithIfds)
if device is None:
logger.info('Did not find good enough match for %s' %
(self.deviceIp))
self.configurationInProgressCache.doneDevice(self.deviceIp)
return
self.fixInterfaces(device, self.device.family, uplinksWithIfds)
# persist serialNumber
device.serialNumber = self.device.serialNumber
self._dao.updateObjectsAndCommitNow(self._session, [device])
self.updateSelfDeviceContext(device)
try:
try:
self.runPostLldpCommands()
except SkipCommit:
self.updateDeviceConfigStatus('good')
return
self.updateDeviceConfigStatus('processing')
self.updateDeviceConfiguration()
self.updateDeviceConfigStatus('good')
except DeviceRpcFailed as exc:
logger.error('Two stage configuration failed for %s, %s' %
(self.deviceLogStr, exc))
self.updateDeviceConfigStatus(None, error=exc)
raise
except Exception as exc:
logger.error('Two stage configuration failed for %s, %s' %
(self.deviceLogStr, exc))
self.updateDeviceConfigStatus('error', str(exc))
raise
finally:
self.releaseConfigurationInProgressLock(self.deviceIp)
logger.debug('Ended two stage configuration for %s' %
(self.deviceLogStr))
else:
logger.debug(
'Two stage configuration is already in progress for %s',
(self.deviceLogStr))
def __create_device() -> Device:
return Device(name='Sample Device',
firmware=0xa2c3f,
protocol='SAMPLE',
errors=[0x0000])
def get(self):
self.response.out.write("%s" % Device.getCount())
def create_device():
device = Device()
device.name = GPX_DEVICE_NAME
device.serial_number = GPX_DEVICE_SERIAL
return device
def get_devices_for_house(self, house_id):
devices = self.collection.find({'house_id': house_id})
target_devices = []
for device in devices:
target_devices.append(Device(device))
return target_devices
def parse_device(tree):
device = Device()
device.name = GPX_DEVICE_NAME
device.serial_number = GPX_DEVICE_SERIAL
return device
def post(self):
post = simplejson.loads(self.request.body)
phoneKey = None
deviceKey = None
brandKey = None
benchmarkKey = None
phoneID = None
device = None
brand = None
totalScore = None
testResults = []
# get post data
try:
phoneID = post["phoneid"]
device = post["device"]
brand = post["brand"]
totalScore = int(post["total_score"])
testResults = post["results"]
except KeyError:
self.error(404)
if phoneID is not None and device is not None and brand is not None and totalScore is not None and testResults:
query = Phone.all()
query.filter("phoneid =", phoneID)
results = query.fetch(1)
# get phone key
if query.count(1) > 0:
phoneKey = results[0].key()
else:
phoneKey = Phone(
phoneid = phoneID
).put()
query = Device.all()
query.filter("name =", device)
results = query.fetch(1)
# get device key
if query.count(1) > 0:
deviceKey = results[0].key()
else:
query = Brand.all()
query.filter("brandname =", brand)
results = query.fetch(1)
# get brand key
if query.count(1) > 0:
brandKey = results[0].key()
else:
# add brand
brandKey = Brand(
brandname = brand
).put()
# add device
deviceKey = Device(
brandkey = Key(brandKey),
name = device
).put()
# new benchmark
if phoneKey is not None and deviceKey is not None:
benchmarkKey = Benchmark(
phonekey = phoneKey,
devicekey = deviceKey,
total_score = totalScore
).put()
if benchmarkKey is not None:
for result in testResults:
test = None
testKey = None
try:
test = result["test"]
except KeyError:
self.error(404)
# get test key
query = Test.all()
query.filter("name =", test)
results = query.fetch(1)
# get phone key
if query.count(1) > 0:
testKey = results[0].key()
score = None
successful = None
try:
score = int(result["score"])
successful = bool(result["successful"])
except KeyError:
self.error(404)
if testKey is not None and score is not None and successful is not None:
# put test result
testResultKey = TestResult(
benchmarkkey = benchmarkKey,
testkey = testKey,
score = score,
successful = successful
).put()
if not testResultKey:
self.error(405)
break;
else:
self.error(404)
else:
self.error(404)
else:
self.error(404)
else:
self.error(404)
