public function export(Export\ExportStream $stream, Export\ExportContext $context) {

        $metamodel = data_controller_get_metamodel();
        $datasetUuidMappings = array();

        // get datasets
        $datasetNids = array();
        foreach ($metamodel->datasets as $dataset) {
            $datasetUuidMappings[$dataset->source] = DatasetExportHelper::getExportDatasetName($dataset->name, $metamodel);
            if (!isset($dataset->nid)) {
                continue;
            }
            $datasetNids[] = $dataset->nid;
        }

        // find all references with above reference points
        $measures = array();
        if (!empty($datasetNids)) {
            $measureNodes = gd_measure_get_measures_4_dataset($datasetNids, LOAD_ENTITY);
            if (!empty($measureNodes)) {
                foreach ( $measureNodes as $measure ) {
                    $export = new stdClass();

                    $export->id = (int) $measure->nid;
                    $export->title = $measure->title;

                    $export->sysname = get_node_field_value($measure,'field_measure_sysname');
                    $export->description = get_node_field_value($measure,'field_measure_desc');

                    $dataset = node_load(get_node_field_value($measure, 'field_measure_dataset', 0, 'nid'));
                    $export->dataset = get_node_field_value($dataset, 'field_dataset_uuid');

                    $function = get_node_field_value($measure,'field_measure_function');

                    foreach($datasetUuidMappings as $source => $uuid) {
                        $function = str_replace($source, $uuid, $function);
                    }

                    $export->function = $function;

                    $measures[] = $export;
                }
            }
        }

        $stream->set('measures',$measures);
    }
    protected function processConfig ( $export ) {
        $metamodel = data_controller_get_metamodel();

        // replace report nid with report uuid
        foreach ( $export->config->items as $key => $item ) {
            if ( $item->type == 'report' ) {
                $reportNode = node_load($item->content);
                $export->config->items[$key]->content = get_node_field_value($reportNode,'field_report_uuid',0,'value',true);
            }
        }

        // array cast to deal with json decoder creating objects for arrays with missing keys
        $export->config->drilldowns = (array) $export->config->drilldowns;

        // replace report nid with report uuid
        // replace dashboard nid with dashboard uuid
        // replace dataset column reference with dataset uuid
        $updated_drilldowns = array();
        foreach ( $export->config->drilldowns as $drilldown ) {

            $reportNode = gd_report_get_by_nid($drilldown->report);
            $dashboardNode = gd_dashboard_get_by_nid($drilldown->dashboard);

            if ( !$reportNode || !$dashboardNode ) {
                $message = t('Skipping corrupt drilldown for node: @nodeId.',array('@nodeId' => $export->id));
                drupal_set_message($message, 'warning');
                LogHelper::log_warn($message);
            } else {
                $updated_drilldown = $drilldown;
                $updated_drilldown->report = get_node_field_value($reportNode,'field_report_uuid',0,'value',true);
                $updated_drilldown->column = DatasetExportHelper::getExportColumnName($drilldown->column,$metamodel);
                $updated_drilldown->dashboard = get_node_field_value($dashboardNode,'field_dashboard_uuid',0,'value',true);
                $updated_drilldown->id = count($updated_drilldowns);
                $updated_drilldowns[] = $updated_drilldown;
            }
        }

        $export->config->drilldowns = $updated_drilldowns;
    }
    protected function processConfig ( &$config ) {
        $metamodel = data_controller_get_metamodel();

        if ( !empty($config->model->datasets) ) {
            foreach ( $config->model->datasets as $key => $datasetName ) {
                $dataset = $metamodel->getDataset($datasetName);
                if (isset($dataset->uuid)) {
                    $config->model->datasets[$key] = $dataset->uuid;
                } else {
                    $config->model->datasets[$key] = NameSpaceHelper::removeNameSpace($dataset->name);
                }
            }
        }

        // update columns
        if ( !empty($config->model->columns) ) {
            foreach ( $config->model->columns as $key => $value ) {
                $config->model->columns[$key] = DatasetExportHelper::getExportColumnName($value,$metamodel);
            }
        }

        // update column configs
        if ( !empty($config->columnConfigs) ) {
            foreach ( $config->columnConfigs as $key => $value ) {
                $config->columnConfigs[$key]->columnId = DatasetExportHelper::getExportColumnName($value->columnId,$metamodel);
            }
        }

        // update column orders
        if ( !empty($config->model->columnOrder) ) {
            foreach ( $config->model->columnOrder as $key => $value ) {
                $config->model->columnOrder[$key] = DatasetExportHelper::getExportColumnName($value,$metamodel);
            }
        }

        // update column sorts
        if ( !empty($config->model->orderBy) ) {
            foreach ( $config->model->orderBy as $key => $value ) {
                $config->model->orderBy[$key]->column = DatasetExportHelper::getExportColumnName($value->column,$metamodel);
            }
        }

        // update visual series
        if ( !empty($config->visual->series) ) {
            $newSeries = array();
            foreach ( $config->visual->series as $key => $value ) {
                $newSeries[DatasetExportHelper::getExportColumnName($key,$metamodel)] = $value;
            }
            $config->visual->series = $newSeries;
        }

        // update traffic column
        if ( !empty($config->visual->trafficColumn) ) {
            $config->visual->trafficColumn = DatasetExportHelper::getExportColumnName($config->visual->trafficColumn,$metamodel);
        }

        // update color column
        if ( !empty($config->visual->useColumnDataForColor) ) {
            $config->visual->useColumnDataForColor = DatasetExportHelper::getExportColumnName($config->visual->useColumnDataForColor,$metamodel);
        }

        // update traffic columns
        if ( !empty($config->visual->traffic) ) {
            $newTraffic = array();
            foreach ( $config->visual->traffic as $key => $value ) {
                $value->trafficColumn = DatasetExportHelper::getExportColumnName($key,$metamodel);
                $newTraffic[DatasetExportHelper::getExportColumnName($key,$metamodel)] = $value;
            }
            $config->visual->traffic = $newTraffic;
        }

        // update filters
        if ( !empty($config->model->filters) ) {
            foreach ( $config->model->filters as $key => $value ) {
                $config->model->filters[$key]->column = DatasetExportHelper::getExportColumnName($value->column,$metamodel);
            }
        }
    }
    protected function update(Import\ImportStream $stream, Import\ImportContext $context) {
        $measures = $stream->get('measures');
        if (empty($measures)) {
            return;
        }

        $metamodel = data_controller_get_metamodel();
        $this->datasets = $metamodel->datasets;

        foreach ( $measures as $k => $measure ) {
            foreach ( $this->datasets as $dataset ) {
                if ( DatasetExportHelper::getExportDatasetName($dataset->name, $metamodel) == $measure->dataset ) {
                    $measure->dataset = $dataset->name;
                    $measure->function = str_replace(DatasetExportHelper::getExportDatasetName($dataset->name, $metamodel), $dataset->source, $measure->function);

                    $existingMeasureNode = $this->findExistingMeasure($measure->sysname);
                    if ( !$existingMeasureNode ) {
                        // create
                        $node = gd_measure_create($measure, $dataset);
                        if ( !empty($node->nid ) ) {
                            $measures[$k] = $node;
                        } else {
                            throw new Exception('Measure node creation failed');
                        }
                    } else {

                        $existingMeasureNode->title = $measure->title;
                        $existingMeasureNode->field_measure_desc[$existingMeasureNode->language][] = array('value' => $measure->description);
                        $existingMeasureNode->field_measure_dataset[$existingMeasureNode->language][] = array('value' => $measure->dataset);
                        $existingMeasureNode->field_measure_function[$existingMeasureNode->language][] = array('value' => $measure->function);

                        node_save($existingMeasureNode);
                    }
                    break;
                }
            }
        }

        $stream->set('measures', $measures);
    }