def doInitialization(self):
""" actually do the initialization and look up the models """
if not self.initialized:
parentModel = getModelByName(self.parentModelName)
super(ModelCollectionManager, self).__init__(parentModel)
for childName in self.childModelNames:
childModel = getModelByName(childName)
self.registerChildClass(childModel)
self.initialized = True
def doInitialization(self):
""" actually do the initialization and look up the models """
if not self.initialized:
parentModel = getModelByName(self.parentModelName)
super(ModelCollectionManager, self).__init__(parentModel)
for childName in self.childModelNames:
childModel = getModelByName(childName)
self.registerChildClass(childModel)
self.initialized = True
def get_channel_descriptions_json(request):
"""
Returns a JsonResponse of the channel descriptions described by the model
:param request: the request
:param request.POST.model_name: the fully qualified name of the model
:param request.POST.channel_name: (optional) the name of the channel
:return: JsonResponse with the result.
"""
if request.method == 'POST':
try:
model_name = request.POST.get('model_name', None)
# model name is required
if model_name:
model = getModelByName(model_name)
if model:
channel_name = request.POST.get('channel_name', None)
result = get_channel_descriptions(model, channel_name)
if result:
for key, value in result.iteritems():
if not isinstance(value, dict):
result[key] = value.__dict__
return JsonResponse(result)
return JsonResponse({'error': 'bad parameters'}, status=204)
except Exception as e:
return HttpResponseNotAllowed(["POST"],
content=traceback.format_exc())
return HttpResponseForbidden()
def do_initialization(self):
""" actually do the initialization and look up the models """
if not self.initialized:
model_name = eval(self.model_name_variable)
self.model = getModelByName(model_name)
super(LazyQuerySet, self).__init__(self.model, self.initial_query, self.initial_using, self.initial_hints)
self.initialized = True
def saveNewInstrumentData(request, instrumentName, jsonResult=False):
errors = None
if request.method == 'POST':
form = BasaltInstrumentDataForm(request.POST, request.FILES)
if form.is_valid():
if request.user.is_authenticated():
user = request.user
else:
user = None
instrument = form.cleaned_data["instrument"]
messages.success(request, 'Instrument data is successfully saved.' )
importFxn = lookupImportFunctionByName(settings.XGDS_INSTRUMENT_IMPORT_MODULE_PATH,
instrument.dataImportFunctionName)
object_id = None
if 'object_id' in request.POST:
object_id = int(request.POST['object_id'])
result = importFxn(instrument=instrument,
portableDataFile=request.FILES.get("portableDataFile", None),
manufacturerDataFile=request.FILES.get("manufacturerDataFile", None),
utcStamp=form.cleaned_data["dataCollectionTime"],
timezone=form.getTimezone(),
vehicle=form.getVehicle(),
name=form.cleaned_data['name'],
description=form.cleaned_data['description'],
minerals=form.cleaned_data['minerals'],
user=user,
latitude=form.cleaned_data['lat'],
longitude=form.cleaned_data['lon'],
altitude=form.cleaned_data['alt'],
collector=form.cleaned_data['collector'],
object_id=object_id)
if result['status'] == 'success':
if 'relay' in request.POST:
theModel = getModelByName(settings.XGDS_MAP_SERVER_JS_MAP[result['modelName']]['model'])
theInstance = theModel.objects.get(pk=result['pk'])
deletePostKey(request.POST, 'relay')
addRelay(theInstance, request.FILES, json.dumps(request.POST), request.get_full_path())
if jsonResult:
return HttpResponse(json.dumps(result), content_type='application/json')
else:
return HttpResponseRedirect(reverse('search_map_single_object', kwargs={'modelPK':result['pk'],
'modelName':result['modelName']}))
else:
errors = result['message']
else:
errors = str(form.errors)
print 'form errors in receiving instrument data'
if jsonResult:
return HttpResponse(json.dumps({'status': 'error', 'message': errors}), content_type='application/json', status=httplib.NOT_ACCEPTABLE)
else:
messages.error(request, 'Errors %s' % errors)
return render(request,
'xgds_instrument/importBasaltInstrumentData.html',
{'form': form,
'errors': form.errors,
'instrumentDataImportUrl': reverse('save_instrument_data', kwargs={'instrumentName': instrumentName}),
'instrumentType': instrumentName},
status=httplib.NOT_ACCEPTABLE)
def do_initialization(self):
""" actually do the initialization and look up the models """
if not self.initialized:
model_name = eval(self.model_name_variable)
self.model = getModelByName(model_name)
super(LazyModelManager, self).__init__()
self.initialized = True
def __init__(self, meta):
self.model = getModelByName(meta['queryModel'])
self.timestampField = meta['queryTimestampField']
self.timestampMicrosecondsField = meta.get('queryTimestampMicrosecondsField', None)
self.timestampNanosecondsField = meta.get('queryTimestampNanosecondsField', None)
self.startTime = meta.get('startTime', None)
self.endTime = meta.get('endTime', None)
self.filterDict = dict(meta.get('queryFilter', []))
self.queryTopic = meta['queryModel']
queryFilter = meta.get('queryFilter', [])
for _field, value in queryFilter:
self.queryTopic += '.%s' % value
self.queryTopic += ':'
def __init__(self, meta):
self.model = getModelByName(meta['queryModel'])
self.timestampField = meta['queryTimestampField']
self.timestampMicrosecondsField = meta.get(
'queryTimestampMicrosecondsField', None)
self.timestampNanosecondsField = meta.get(
'queryTimestampNanosecondsField', None)
self.startTime = meta.get('startTime', None)
self.endTime = meta.get('endTime', None)
self.filterDict = dict(meta.get('queryFilter', []))
self.queryTopic = meta['queryModel']
queryFilter = meta.get('queryFilter', [])
for _field, value in queryFilter:
self.queryTopic += '.%s' % value
self.queryTopic += ':'
def unravel_post(post_dict):
"""
Read the useful contents of the post dictionary
:param post_dict:
:return: the PostData properly filled out
"""
class PostData(object):
model = None
channel_names = None
flight_ids = None
start_time = None
end_time = None
filter_dict = None
time = None
downsample = None
result = PostData()
model_name = post_dict.get('model_name', None)
# model name is required
if model_name:
result.model = getModelByName(model_name)
result.channel_names = post_dict.getlist('channel_names', None)
if 'flight_ids' in post_dict:
result.flight_ids = post_dict.getlist('flight_ids', None)
elif 'flight_ids[]' in post_dict:
result.flight_ids = post_dict.getlist('flight_ids[]', None)
start_time_string = post_dict.get('start_time', None)
if start_time_string:
result.start_time = dateparser(start_time_string)
end_time_string = post_dict.get('end_time', None)
if end_time_string:
result.end_time = dateparser(end_time_string)
time_string = post_dict.get('time', None)
if time_string:
result.time = dateparser(time_string)
filter_json = post_dict.get('filter', None)
if filter_json:
result.filter_dict = json.loads(filter_json)
result.downsample = post_dict.get('downsample', None)
if result.downsample is not None:
result.downsample = int(result.downsample)
return result
def __init__(self, options):
ensure_vehicle(options)
patch_yaml_path(options)
# Create a CsvImporter object with no corresponding CSV file:
self.importer = self.construct_importer(options)
self.keys = self.importer.config['fields'].keys()
self.delimiter = self.importer.config['delimiter']
self.model = getModelByName(self.importer.config['class'])
if 'verbose' in options:
self.verbose = options['verbose']
else:
self.verbose = False
self.needs_flight = False
if hasattr(self.model(), 'flight'):
self.needs_flight = True
super(CsvSaver, self).__init__(options)
def initProfiles():
for profileMeta in settings.XGDS_PLOT_PROFILES:
profile = Profile()
profile.valueField = profileMeta['valueField']
profile.valueCode = profile.valueField
profile.model = getModelByName(profileMeta['queryModel'])
profile.timestampField = profileMeta['queryTimestampField']
profile.zField = profileMeta['queryZField']
profile.filter = profileMeta['queryFilter']
fields = profile.model._meta._field_name_cache
fieldLookup = dict([(f.name, f) for f in fields])
profile.name = firstcaps(fieldLookup[profile.valueField].verbose_name)
profile.timeLabel = firstcaps(fieldLookup[profile.timestampField].verbose_name)
profile.zLabel = firstcaps(fieldLookup[profile.zField].verbose_name)
PROFILES.append(profile)
PROFILE_LOOKUP[profile.valueField] = profile
def importPlan(cls, name, buf, meta, planSchema=None, path=None):
PLAN_MODEL = getModelByName(settings.XGDS_PLANNER_PLAN_MODEL)
importer = cls()
meta.setdefault('name', name)
if not planSchema:
try:
wholePlatform = meta['platform']
planSchema = models.getPlanSchema(wholePlatform.name)
except: # pylint: disable=W0702
# bad news
print "no platform, you need to pass the plan Schema" + name
return
importer.setDefaultMeta(meta, path, planSchema)
planDoc = importer.importPlanFromBuffer(buf, meta, planSchema)
dbPlan = PLAN_MODEL()
dbPlan.jsonPlan = xpjson.dumpDocumentToDotDict(planDoc)
dbPlan.extractFromJson(overWriteDateModified=False)
return dbPlan
def importPlan(cls, name, buf, meta, planSchema=None, path=None):
PLAN_MODEL = getModelByName(settings.XGDS_PLANNER2_PLAN_MODEL)
importer = cls()
meta.setdefault('name', name)
if not planSchema:
try:
wholePlatform = meta['platform']
planSchema = models.getPlanSchema(wholePlatform.name)
except: # pylint: disable=W0702
# bad news
print "no platform, you need to pass the plan Schema" + name
return
importer.setDefaultMeta(meta, path, planSchema)
planDoc = importer.importPlanFromBuffer(buf, meta, planSchema)
dbPlan = PLAN_MODEL()
dbPlan.jsonPlan = xpjson.dumpDocumentToDotDict(planDoc)
dbPlan.extractFromJson(overWriteDateModified=False)
return dbPlan
