Merge branch 'dashboard-filters' of github.com:metabase/metabase into dashboard-filters

frontend/src/metabase/dashboard/containers/DashCardCardParameterMapper.jsx

+/* @flow */
+
 import React, { Component, PropTypes } from "react";
 import { connect } from "react-redux";
 
@@ -5,6 +7,10 @@ import { getEditingParameter, getParameterTarget, makeGetParameterMappingOptions
 import { fetchDatabaseMetadata } from "../metadata";
 import { setParameterMapping } from "../dashboard";
 
+import type { CardObject } from "metabase/meta/types/Card";
+import type { DashCardObject, ParameterId, ParameterObject, ParameterMappingOption, ParameterMappingTarget } from "metabase/meta/types/Dashboard";
+import type { DatabaseId } from "metabase/meta/types/base";
+
 const makeMapStateToProps = () => {
     const getParameterMappingOptions = makeGetParameterMappingOptions()
     const mapStateToProps = (state, props) => ({
@@ -22,10 +28,15 @@ const mapDispatchToProps = {
 
 @connect(makeMapStateToProps, mapDispatchToProps)
 export default class DashCardParameterMapping extends Component {
-    constructor(props, context) {
-        super(props, context);
-        this.state = {};
-    }
+    props: {
+        card: CardObject,
+        dashcard: DashCardObject,
+        parameter: ParameterObject,
+        target: ParameterMappingTarget,
+        mappingOptions: Array<ParameterMappingOption>,
+        fetchDatabaseMetadata: (id: ?DatabaseId) => void,
+        setParameterMapping: (parameter_id: ParameterId, dashcard_id: number, card_id: number, target: ParameterMappingTarget) => void,
+    };
 
     static propTypes = {
         dashcard: PropTypes.object.isRequired,
@@ -44,7 +55,7 @@ export default class DashCardParameterMapping extends Component {
             <select className="m1" value={JSON.stringify(target)||""} onChange={(e) => setParameterMapping(parameter.id, dashcard.id, card.id, JSON.parse(e.target.value))}>
                 <option value=""></option>
                 {mappingOptions.map(mappingOption =>
-                    <option value={JSON.stringify(mappingOption.value)}>{mappingOption.name}</option>
+                    <option value={JSON.stringify(mappingOption.target)}>{mappingOption.name}</option>
                 )}
             </select>
         );

frontend/src/metabase/dashboard/selectors.js

@@ -69,28 +69,20 @@ export const getParameterTarget = createSelector(
     }
 );
 
-export const makeGetParameterMappingOptions = () => {
+import * as Dashboard from "metabase/meta/Dashboard";
+import Database from "metabase/meta/metadata/Database";
+import type { CardObject } from "metabase/meta/types/Card";
+import type { ParameterMappingOption } from "metabase/meta/types/Dashboard";
 
+export const makeGetParameterMappingOptions = () => {
+    const getDatabaseMetadata = createSelector(
+        [getDatabase],
+        (database) => database && new Database(database)
+    )
     const getParameterMappingOptions = createSelector(
-        [getEditingParameter, getDatabase, getCard, getDashCard],
-        (parameter, database, card, dashcard) => {
-            if (card.dataset_query.type === "query") {
-                const table = database && database.tables_lookup[card.dataset_query.query.source_table];
-                if (table) {
-                    return table.fields.map(field => {
-                        const target = ["dimension", ["field", field.id]];
-                        return {
-                            name: field.display_name,
-                            value: target
-                        };
-                    });
-                }
-            } else {
-                return [
-                    { name: "FIXME: SQL parameter options not yet implemented" }
-                ];
-            }
-            return [];
+        [getDatabaseMetadata, getEditingParameter, getCard],
+        (metadata: ?Database, parameter: ParameterObject, card: CardObject): Array<ParameterMappingOption> => {
+            return metadata ? Dashboard.getParameterMappingOptions(metadata, parameter, card) : [];
         }
     );
     return getParameterMappingOptions;

frontend/src/metabase/meta/Dashboard.js

 /* @flow */
 
-import type { ParameterOption, ParameterObject } from "./types/Dashboard";
+import type Metadata from "./metadata/Metadata";
+import type Table from "./metadata/Table";
+import type { CardObject } from "./types/Card";
+import type { ParameterOption, ParameterObject, ParameterMappingOption } from "./types/Dashboard";
 
 import { slugify } from "metabase/lib/formatting";
 
@@ -86,6 +89,24 @@ for (const option of PARAMETER_OPTIONS) {
     section.options.push(option);
 }
 
+export function getParameterMappingOptions(metadata: Metadata, parameter: ParameterObject, card: CardObject): Array<ParameterMappingOption> {
+    if (card.dataset_query.type === "query") {
+        const table = card.dataset_query.query.source_table != null ? metadata.table(card.dataset_query.query.source_table) : null;
+        if (table) {
+            return table.fields().map(field => {
+                const target = ["dimension", ["field-id", field.id]];
+                return {
+                    name: field.display_name,
+                    target: target
+                };
+            });
+        }
+    } else {
+        return [];
+    }
+    return [];
+}
+
 export function createParameter(option: ParameterOption): ParameterObject {
     return {
        id: Math.floor(Math.random()*Math.pow(2,32)).toString(16),

frontend/src/metabase/meta/metadata/Base.js

@@ -60,12 +60,19 @@ export default class Base {
 
     // return an array of wrapped entities
     @memoize
-    _entities<T: Base>(Klass: Class<T>, ids: Array<number>): Array<?T> {
+    _entities<T: Base>(Klass: Class<T>, ids: Array<number>): Array<T> {
         if (this !== this._metadata) {
             return this._metadata._entities(...arguments);
         }
 
-        return ids.map(id => this._entity(Klass, id));
+        let entities: Array<T> = [];
+        for (const id of ids) {
+            let entity = this._entity(Klass, id);
+            if (entity != null) {
+                entities.push(entity);
+            }
+        }
+        return entities;
     }
 }
 

frontend/src/metabase/meta/metadata/Field.js

@@ -9,6 +9,8 @@ export default class Field extends Base {
     static type = "field";
     static schema = {};
 
+    id: number;
+    display_name: string;
     table_id: number;
     fk_target_field_id: number;
 

frontend/src/metabase/meta/types/Dashboard.js

@@ -37,6 +37,11 @@ export type ParameterMappingTarget =
     ["parameter", string] |
     ["dimension", ConcreteField];
 
+export type ParameterMappingOption = {
+    name: string,
+    target: ParameterMappingTarget
+};
+
 export type ParameterMappingObject = {
     card_id: CardId,
     parameter_id: ParameterId,
@@ -46,6 +51,6 @@ export type ParameterMappingObject = {
 export type ParameterOption = {
     id: string,
     name: string,
-    description: string,
+    description?: string,
     type: ParameterType
 };