def get(self):
esta_manufacturer = common.GetManufacturer(self.ESTA_ID)
self.response.headers['Content-Type'] = 'text/plain'
# Can be '', 'esta', 'esta-draft', 'manufacturers' or 'manufacturer-names'
pid_selection = self.request.get('pids')
if pid_selection == 'manufacturer-names':
manufacturers = []
query = Manufacturer.all()
query.order('name')
for manufacturer in query:
if manufacturer.esta_id in [self.ESTA_ID, 0xffff]:
continue
self.WriteManufacturer(manufacturer, [])
else:
pids = Pid.all()
if pid_selection == 'esta':
pids.filter('draft =', False)
pids.filter('manufacturer = ', esta_manufacturer)
elif pid_selection == 'esta-draft':
pids.filter('draft =', True)
pids.filter('manufacturer = ', esta_manufacturer)
elif pid_selection == "manufacturers":
pids.filter('manufacturer != ', esta_manufacturer)
manufacturers = {}
esta_pids = []
for pid in pids:
if pid.manufacturer.esta_id == self.ESTA_ID:
esta_pids.append(pid)
else:
# Build the hash of manufacturer pids by manufacturer
manufacturers.setdefault(pid.manufacturer.esta_id,
[]).append(pid)
esta_pids.sort(key=lambda p: p.pid_id)
for pid in esta_pids:
self.WritePid(pid)
for manufacturer_id in sorted(manufacturers):
manufacturer_pids = manufacturers[manufacturer_id]
manufacturer_pids.sort(key=lambda p: p.pid_id)
self.WriteManufacturer(
manufacturers[manufacturer_id][0].manufacturer,
manufacturer_pids)
query = LastUpdateTime.all()
if pid_selection == 'manufacturer-names':
query.filter('name = ', timestamp_keys.MANUFACTURERS)
else:
query.filter('name = ', timestamp_keys.PIDS)
update_time = query.fetch(1)
if update_time:
timestamp = TimestampToInt(update_time[0].update_time)
self.Write('version: %d' % timestamp)
def _LookupManufacturer(self, manufacturer_id):
"""Lookup a Manufacturer entity by id and cache the result.
Returns:
The entity object, or None if not found.
"""
if manufacturer_id not in self._manufacturers:
self._manufacturers[manufacturer_id] = common.GetManufacturer(
manufacturer_id)
return self._manufacturers[manufacturer_id]
def FilterByManufacturer(self, page, manufacturer):
manufacturer_id = StringToInt(manufacturer)
manufacturer = common.GetManufacturer(manufacturer_id)
if manufacturer is None:
return 0, []
query = self.ProductType().all()
query.filter('manufacturer = ', manufacturer.key())
query.order('name')
total = query.count()
return total, query.fetch(None)
def get(self):
manufacturer = common.GetManufacturer(self.request.get('manufacturer'))
if manufacturer is None:
self.error(404)
return
output = {
'name': manufacturer.name,
'esta_id': manufacturer.esta_id,
}
self.response.headers['Content-Type'] = 'text/plain'
self.response.headers['Cache-Control'] = 'public; max-age=300;'
self.response.out.write(json.dumps(output))
def ApplyChanges(self, key, fields):
responder_info = UploadedResponderInfo.get(key)
if not responder_info:
return 'Invalid key'
logging.info(responder_info)
fields_to_update = set(fields.split(','))
logging.info(fields_to_update)
data_dict = self.EvalData(responder_info.info)
# same format as in data/model_data.py
model_data = {'device_model': responder_info.device_model_id}
if ('model_description' in fields_to_update
and 'model_description' in data_dict):
model_data['model_description'] = data_dict['model_description']
if 'image_url' in fields_to_update and responder_info.image_url:
model_data['image_url'] = responder_info.image_url
if 'url' in fields_to_update and responder_info.link_url:
model_data['link'] = responder_info.link_url
if ('product_category' in fields_to_update
and 'product_category' in data_dict):
model_data['product_category'] = data_dict['product_category']
if 'software_versions' in data_dict:
for version_id, version_data in data_dict[
'software_versions'].iteritems():
if type(version_id) in (int, long):
version_dict = self.BuildVersionDict(
version_id, version_data, fields_to_update)
if version_dict:
versions = model_data.setdefault(
'software_versions', {})
versions[version_id] = version_dict
logging.info(model_data)
manufacturer = common.GetManufacturer(responder_info.manufacturer_id)
if manufacturer is None:
return 'Invalid manufacturer_id %d' % responder_info.manufacturer_id
updater = model_loader.ModelUpdater()
was_added, was_changed = updater.UpdateResponder(
manufacturer, model_data)
logging.info('Was added %s' % was_added)
logging.info('Was changed %s' % was_changed)
# finally mark this one as done
responder_info.processed = True
responder_info.put()
return ''
def ClearManufacturerPids(self):
manufacturer_id = StringToInt(self.request.get('manufacturer'))
manufacturer = common.GetManufacturer(manufacturer_id)
count = 0
if manufacturer is not None:
memcache.delete(memcache_keys.MANUFACTURER_PID_COUNT_KEY)
memcache.delete(memcache_keys.MANUFACTURER_PID_COUNTS)
for pid in manufacturer.pid_set:
if pid.discovery_command:
pid.discovery_command.delete()
if pid.get_command:
pid.get_command.delete()
if pid.set_command:
pid.set_command.delete()
pid.delete()
count += 1
return 'Deleted %d PIDs' % count
def LookupPid(self, pid_id, manufacturer_id):
"""
Lookup a PID
Returns:
A tuple of (manufacturer, pid) data objects.
"""
manufacturer = common.GetManufacturer(manufacturer_id)
if manufacturer is None:
raise UnknownManufacturerException(manufacturer_id)
pid_query = Pid.all()
pid_query.filter('pid_id = ', pid_id)
pid_query.filter('manufacturer = ', manufacturer.key())
result_set = pid_query.fetch(1)
if result_set:
return manufacturer, result_set[0]
else:
return manufacturer, None
def LookupPIDFromRequest(self):
pid_id = self.request.get('pid')
try:
pid_id = int(pid_id)
except ValueError:
return None
manufacturer = common.GetManufacturer(self.request.get('manufacturer'))
if manufacturer is None or pid_id is None:
return None
models = Pid.all()
models.filter('pid_id = ', pid_id)
models.filter('manufacturer = ', manufacturer.key())
pid_data = models.fetch(1)
if pid_data:
return pid_data[0]
else:
return None
def GetTemplateData(self):
manufacturer = common.GetManufacturer(self.request.get('manufacturer'))
if not manufacturer:
self.error(404)
return
device_query = manufacturer.responder_set
device_query.order('model_description')
pid_query = manufacturer.pid_set
pid_query.order('name')
data = {
'manufacturer': manufacturer.name,
'id': manufacturer.esta_id,
'url': manufacturer.link,
'image_url': manufacturer.image_serving_url,
'devices': device_query.fetch(None),
'pids': pid_query.fetch(None),
}
for product in manufacturer.product_set:
data.setdefault(product.class_name().lower(), []).append(product)
return data
def GetTemplateData(self):
model = common.LookupModelFromRequest(self.request)
if not model:
self.error(404)
return
esta_manufacturer = common.GetManufacturer(0)
if not esta_manufacturer:
logging.error("Can't find ESTA manufacturer!")
# 404 early here
self.error(404)
return
self.response.headers['Content-Type'] = 'text/plain'
# software version info
software_versions = []
for version_info in model.software_version_set:
version_output = {
'version_id': version_info.version_id,
'label': version_info.label,
}
supported_parameters = version_info.supported_parameters
if supported_parameters is not None:
param_output = []
for param in supported_parameters:
param_dict = { 'id': param, }
query = Pid.all()
query.filter('pid_id =' , param)
if param >= 0x8000:
query.filter('manufacturer = ', model.manufacturer)
param_dict['manufacturer_id'] = model.manufacturer.esta_id
else:
query.filter('manufacturer = ', esta_manufacturer)
param_dict['manufacturer_id'] = esta_manufacturer.esta_id
results = query.fetch(1)
if results:
param_dict['name'] = results[0].name
param_output.append(param_dict)
version_output['supported_parameters'] = sorted(
param_output,
key=lambda x: x['id'])
software_versions.append(version_output)
personalities = []
for personality in version_info.personality_set:
personality_info = {
'description': personality.description,
'index': personality.index,
}
if personality.slot_count is not None:
personality_info['slot_count'] = personality.slot_count
personalities.append(personality_info)
if personalities:
personalities.sort(key=lambda x: x['index'])
version_output['personalities'] = personalities;
sensors = []
for sensor in version_info.sensor_set:
sensor_info = {
'description': sensor.description,
'index': sensor.index,
'type': sensor.type,
'supports_recording': sensor.supports_recording,
'supports_min_max': sensor.supports_min_max_recording,
}
type_str = SENSOR_TYPES.get(sensor.type)
if type_str is not None:
sensor_info['type_str'] = type_str
sensors.append(sensor_info)
if sensors:
sensors.sort(key=lambda x: x['index'])
version_output['sensors'] = sensors
output = {
'description': model.model_description,
'manufacturer': model.manufacturer.name,
'manufacturer_id': model.manufacturer.esta_id,
'model_id': model.device_model_id,
'software_versions': software_versions,
'software_versions_json': json.dumps(software_versions),
}
# link and product_category are optional
if model.link:
output['link'] = model.link
category = model.product_category
if category:
output['product_category'] = category.name
output['product_category_id'] = category.id
# tags
for tag in model.tag_set:
tags = output.setdefault('tags', [])
tags.append(tag.tag.label)
if model.image_data:
serving_url = model.image_serving_url
if not serving_url:
serving_url = images.get_serving_url(model.image_data.key())
model.image_serving_url = serving_url
model.put()
output['image_key'] = serving_url
return output
def Init(self):
self._manufacturer_id = StringToInt(self.request.get('manufacturer'))
self._manufacturer = common.GetManufacturer(self._manufacturer_id)
def DiffResponder(self, responder, template_data):
errors = []
template_data['device_id'] = responder.device_model_id
template_data['manufacturer_id'] = responder.manufacturer_id
if responder.email_or_name:
template_data['contact'] = responder.email_or_name
manufacturer = common.GetManufacturer(responder.manufacturer_id)
template_data['manufacturer'] = manufacturer
if not manufacturer:
return
template_data['manufacturer_name'] = manufacturer.name
existing_model = common.LookupModel(responder.manufacturer_id,
responder.device_model_id)
# build a dict for the existing responder
existing_responder_dict = {}
if existing_model is not None:
existing_responder_dict = {
'model_description': existing_model.model_description,
'image_url': existing_model.image_url,
'url': existing_model.link,
}
category = existing_model.product_category
if category:
existing_responder_dict['product_category'] = category.name
# Build a dict for the new responder
new_responder_dict = self.EvalData(responder.info)
new_responder_dict['image_url'] = responder.image_url or None
new_responder_dict['url'] = responder.link_url or None
if 'product_category' in new_responder_dict:
category = common.LookupProductCategory(
new_responder_dict['product_category'])
if category:
new_responder_dict['product_category'] = category.name
else:
errors.append('Unknown product category %d' %
new_responder_dict['product_category'])
fields = [
('Model Description', 'model_description'),
('Image URL', 'image_url'),
('URL', 'url'),
('Product Category', 'product_category'),
]
changed_fields, unchanged_fields = self.DiffProperties(fields,
new_responder_dict, existing_responder_dict)
template_data['changed_fields'] = changed_fields
template_data['unchanged_fields'] = unchanged_fields
# populate the model_description
template_data['model_description'] = new_responder_dict.get(
'model_description')
if existing_model:
template_data['model_description'] = existing_model.model_description
# now work on the software versions
new_software_versions = new_responder_dict.get('software_versions', {})
if new_software_versions:
versions = self.DiffVersions(new_software_versions, existing_model)
template_data['versions'] = versions
template_data.setdefault('errors', []).extend(errors)
def __init__(self):
self._pid_cache = {}
self._esta = common.GetManufacturer(0)
