diff --git a/client/app/components/ParameterMappingInput.jsx b/client/app/components/ParameterMappingInput.jsx
index 05c2f80925..e978b8cb42 100644
--- a/client/app/components/ParameterMappingInput.jsx
+++ b/client/app/components/ParameterMappingInput.jsx
@@ -17,7 +17,7 @@ import Form from 'antd/lib/form';
 import Tooltip from 'antd/lib/tooltip';
 import ParameterValueInput from '@/components/ParameterValueInput';
 import { ParameterMappingType } from '@/services/widget';
-import { Parameter } from '@/services/query';
+import { Parameter } from '@/services/parameters';
 import HelpTrigger from '@/components/HelpTrigger';
 
 import './ParameterMappingInput.less';
@@ -545,11 +545,11 @@ export class ParameterMappingListInput extends React.Component {
       param = param.clone().setValue(mapping.value);
     }
 
-    let value = Parameter.getValue(param);
+    let value = Parameter.getExecutionValue(param);
 
     // in case of dynamic value display the name instead of value
     if (param.hasDynamicValue) {
-      value = param.dynamicValue.name;
+      value = param.normalizedValue.name;
     }
 
     return this.getStringValue(value);
diff --git a/client/app/components/ParameterValueInput.jsx b/client/app/components/ParameterValueInput.jsx
index feb3ece900..7f28ad33a8 100644
--- a/client/app/components/ParameterValueInput.jsx
+++ b/client/app/components/ParameterValueInput.jsx
@@ -5,7 +5,7 @@ import Input from 'antd/lib/input';
 import InputNumber from 'antd/lib/input-number';
 import DateParameter from '@/components/dynamic-parameters/DateParameter';
 import DateRangeParameter from '@/components/dynamic-parameters/DateRangeParameter';
-import { toString } from 'lodash';
+import { isEqual } from 'lodash';
 import { QueryBasedParameterInput } from './QueryBasedParameterInput';
 
 import './ParameterValueInput.less';
@@ -59,7 +59,7 @@ class ParameterValueInput extends React.Component {
   }
 
   onSelect = (value) => {
-    const isDirty = toString(value) !== toString(this.props.value);
+    const isDirty = !isEqual(value, this.props.value);
     this.setState({ value, isDirty });
     this.props.onSelect(value, isDirty);
   }
@@ -96,13 +96,15 @@ class ParameterValueInput extends React.Component {
     const { enumOptions, parameter } = this.props;
     const { value } = this.state;
     const enumOptionsArray = enumOptions.split('\n').filter(v => v !== '');
+    // Antd Select doesn't handle null in multiple mode
+    const normalize = val => (parameter.multiValuesOptions && val === null ? [] : val);
     return (
       <Select
         className={this.props.className}
         mode={parameter.multiValuesOptions ? 'multiple' : 'default'}
         optionFilterProp="children"
         disabled={enumOptionsArray.length === 0}
-        value={value}
+        value={normalize(value)}
         onChange={this.onSelect}
         dropdownMatchSelectWidth={false}
         showSearch
diff --git a/client/app/components/Parameters.jsx b/client/app/components/Parameters.jsx
index 798315c867..b77c47401c 100644
--- a/client/app/components/Parameters.jsx
+++ b/client/app/components/Parameters.jsx
@@ -4,7 +4,7 @@ import { size, filter, forEach, extend } from 'lodash';
 import { react2angular } from 'react2angular';
 import { SortableContainer, SortableElement, DragHandle } from '@/components/sortable';
 import { $location } from '@/services/ng';
-import { Parameter } from '@/services/query';
+import { Parameter } from '@/services/parameters';
 import ParameterApplyButton from '@/components/ParameterApplyButton';
 import ParameterValueInput from '@/components/ParameterValueInput';
 import EditParameterSettingsDialog from './EditParameterSettingsDialog';
@@ -111,7 +111,7 @@ export class Parameters extends React.Component {
       .result.then((updated) => {
         this.setState(({ parameters }) => {
           const updatedParameter = extend(parameter, updated);
-          parameters[index] = new Parameter(updatedParameter, updatedParameter.parentQueryId);
+          parameters[index] = Parameter.create(updatedParameter, updatedParameter.parentQueryId);
           onParametersEdit();
           return { parameters };
         });
diff --git a/client/app/components/dynamic-parameters/DateParameter.jsx b/client/app/components/dynamic-parameters/DateParameter.jsx
index 0776196eca..64f52c6deb 100644
--- a/client/app/components/dynamic-parameters/DateParameter.jsx
+++ b/client/app/components/dynamic-parameters/DateParameter.jsx
@@ -3,7 +3,7 @@ import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import moment from 'moment';
 import { includes } from 'lodash';
-import { isDynamicDate, getDynamicDate } from '@/services/query';
+import { isDynamicDate, getDynamicDateFromString } from '@/services/parameters/DateParameter';
 import DateInput from '@/components/DateInput';
 import DateTimeInput from '@/components/DateTimeInput';
 import DynamicButton from '@/components/dynamic-parameters/DynamicButton';
@@ -12,11 +12,11 @@ import './DynamicParameters.less';
 
 const DYNAMIC_DATE_OPTIONS = [
   { name: 'Today/Now',
-    value: 'd_now',
-    label: () => getDynamicDate('d_now').value().format('MMM D') },
+    value: getDynamicDateFromString('d_now'),
+    label: () => getDynamicDateFromString('d_now').value().format('MMM D') },
   { name: 'Yesterday',
-    value: 'd_yesterday',
-    label: () => getDynamicDate('d_yesterday').value().format('MMM D') },
+    value: getDynamicDateFromString('d_yesterday'),
+    label: () => getDynamicDateFromString('d_yesterday').value().format('MMM D') },
 ];
 
 class DateParameter extends React.Component {
@@ -44,7 +44,7 @@ class DateParameter extends React.Component {
   onDynamicValueSelect = (dynamicValue) => {
     const { onSelect, parameter } = this.props;
     if (dynamicValue === 'static') {
-      const parameterValue = parameter.getValue();
+      const parameterValue = parameter.getExecutionValue();
       if (parameterValue) {
         onSelect(moment(parameterValue));
       } else {
@@ -77,7 +77,7 @@ class DateParameter extends React.Component {
     }
 
     if (hasDynamicValue) {
-      const dynamicDate = getDynamicDate(value);
+      const dynamicDate = value;
       additionalAttributes.placeholder = dynamicDate && dynamicDate.name;
       additionalAttributes.value = null;
     }
diff --git a/client/app/components/dynamic-parameters/DateRangeParameter.jsx b/client/app/components/dynamic-parameters/DateRangeParameter.jsx
index 3e7b75895a..8c6a86d865 100644
--- a/client/app/components/dynamic-parameters/DateRangeParameter.jsx
+++ b/client/app/components/dynamic-parameters/DateRangeParameter.jsx
@@ -3,7 +3,7 @@ import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import moment from 'moment';
 import { includes, isArray, isObject } from 'lodash';
-import { isDynamicDateRange, getDynamicDateRange } from '@/services/query';
+import { isDynamicDateRange, getDynamicDateRangeFromString } from '@/services/parameters/DateRangeParameter';
 import DateRangeInput from '@/components/DateRangeInput';
 import DateTimeRangeInput from '@/components/DateTimeRangeInput';
 import DynamicButton from '@/components/dynamic-parameters/DynamicButton';
@@ -12,29 +12,37 @@ import './DynamicParameters.less';
 
 const DYNAMIC_DATE_OPTIONS = [
   { name: 'This week',
-    value: 'd_this_week',
-    label: () => getDynamicDateRange('d_this_week').value()[0].format('MMM D') + ' - ' +
-                 getDynamicDateRange('d_this_week').value()[1].format('MMM D') },
-  { name: 'This month', value: 'd_this_month', label: () => getDynamicDateRange('d_this_month').value()[0].format('MMMM') },
-  { name: 'This year', value: 'd_this_year', label: () => getDynamicDateRange('d_this_year').value()[0].format('YYYY') },
+    value: getDynamicDateRangeFromString('d_this_week'),
+    label: () => getDynamicDateRangeFromString('d_this_week').value()[0].format('MMM D') + ' - ' +
+                 getDynamicDateRangeFromString('d_this_week').value()[1].format('MMM D') },
+  { name: 'This month',
+    value: getDynamicDateRangeFromString('d_this_month'),
+    label: () => getDynamicDateRangeFromString('d_this_month').value()[0].format('MMMM') },
+  { name: 'This year',
+    value: getDynamicDateRangeFromString('d_this_year'),
+    label: () => getDynamicDateRangeFromString('d_this_year').value()[0].format('YYYY') },
   { name: 'Last week',
-    value: 'd_last_week',
-    label: () => getDynamicDateRange('d_last_week').value()[0].format('MMM D') + ' - ' +
-                 getDynamicDateRange('d_last_week').value()[1].format('MMM D') },
-  { name: 'Last month', value: 'd_last_month', label: () => getDynamicDateRange('d_last_month').value()[0].format('MMMM') },
-  { name: 'Last year', value: 'd_last_year', label: () => getDynamicDateRange('d_last_year').value()[0].format('YYYY') },
+    value: getDynamicDateRangeFromString('d_last_week'),
+    label: () => getDynamicDateRangeFromString('d_last_week').value()[0].format('MMM D') + ' - ' +
+                 getDynamicDateRangeFromString('d_last_week').value()[1].format('MMM D') },
+  { name: 'Last month',
+    value: getDynamicDateRangeFromString('d_last_month'),
+    label: () => getDynamicDateRangeFromString('d_last_month').value()[0].format('MMMM') },
+  { name: 'Last year',
+    value: getDynamicDateRangeFromString('d_last_year'),
+    label: () => getDynamicDateRangeFromString('d_last_year').value()[0].format('YYYY') },
   { name: 'Last 7 days',
-    value: 'd_last_7_days',
-    label: () => getDynamicDateRange('d_last_7_days').value()[0].format('MMM D') + ' - Today' },
+    value: getDynamicDateRangeFromString('d_last_7_days'),
+    label: () => getDynamicDateRangeFromString('d_last_7_days').value()[0].format('MMM D') + ' - Today' },
 ];
 
 const DYNAMIC_DATETIME_OPTIONS = [
   { name: 'Today',
-    value: 'd_today',
-    label: () => getDynamicDateRange('d_today').value()[0].format('MMM D') },
+    value: getDynamicDateRangeFromString('d_today'),
+    label: () => getDynamicDateRangeFromString('d_today').value()[0].format('MMM D') },
   { name: 'Yesterday',
-    value: 'd_yesterday',
-    label: () => getDynamicDateRange('d_yesterday').value()[0].format('MMM D') },
+    value: getDynamicDateRangeFromString('d_yesterday'),
+    label: () => getDynamicDateRangeFromString('d_yesterday').value()[0].format('MMM D') },
   ...DYNAMIC_DATE_OPTIONS,
 ];
 
@@ -73,7 +81,7 @@ class DateRangeParameter extends React.Component {
   onDynamicValueSelect = (dynamicValue) => {
     const { onSelect, parameter } = this.props;
     if (dynamicValue === 'static') {
-      const parameterValue = parameter.getValue();
+      const parameterValue = parameter.getExecutionValue();
       if (isObject(parameterValue) && parameterValue.start && parameterValue.end) {
         onSelect([moment(parameterValue.start), moment(parameterValue.end)]);
       } else {
@@ -107,8 +115,7 @@ class DateRangeParameter extends React.Component {
     }
 
     if (hasDynamicValue) {
-      const dynamicDateRange = getDynamicDateRange(value);
-      additionalAttributes.placeholder = [dynamicDateRange && dynamicDateRange.name];
+      additionalAttributes.placeholder = [value && value.name];
       additionalAttributes.value = null;
     }
 
diff --git a/client/app/components/dynamic-parameters/DynamicButton.jsx b/client/app/components/dynamic-parameters/DynamicButton.jsx
index 49dbc0640b..7778b4b166 100644
--- a/client/app/components/dynamic-parameters/DynamicButton.jsx
+++ b/client/app/components/dynamic-parameters/DynamicButton.jsx
@@ -5,6 +5,8 @@ import Dropdown from 'antd/lib/dropdown';
 import Icon from 'antd/lib/icon';
 import Menu from 'antd/lib/menu';
 import Typography from 'antd/lib/typography';
+import { DynamicDateType } from '@/services/parameters/DateParameter';
+import { DynamicDateRangeType } from '@/services/parameters/DateRangeParameter';
 
 import './DynamicButton.less';
 
@@ -62,7 +64,7 @@ function DynamicButton({ options, selectedDynamicValue, onSelect, enabled }) {
 
 DynamicButton.propTypes = {
   options: PropTypes.arrayOf(PropTypes.object), // eslint-disable-line react/forbid-prop-types
-  selectedDynamicValue: PropTypes.string,
+  selectedDynamicValue: PropTypes.oneOfType([DynamicDateType, DynamicDateRangeType]),
   onSelect: PropTypes.func,
   enabled: PropTypes.bool,
 };
diff --git a/client/app/pages/queries/view.js b/client/app/pages/queries/view.js
index 39934c166c..aedc2c761a 100644
--- a/client/app/pages/queries/view.js
+++ b/client/app/pages/queries/view.js
@@ -1,4 +1,4 @@
-import { pick, some, find, minBy, map, intersection, isEmpty, isArray, omit } from 'lodash';
+import { pick, some, find, minBy, map, intersection, isEmpty, isArray } from 'lodash';
 import { SCHEMA_NOT_SUPPORTED, SCHEMA_LOAD_ERROR } from '@/services/data-source';
 import getTags from '@/services/getTags';
 import { policy } from '@/services/policy';
@@ -261,7 +261,7 @@ function QueryViewCtrl(
     if (request.options && request.options.parameters) {
       request.options = {
         ...request.options,
-        parameters: map(request.options.parameters, p => omit(p, 'pendingValue')),
+        parameters: map(request.options.parameters, p => p.toSaveableObject()),
       };
     }
 
diff --git a/client/app/services/parameters/DateParameter.js b/client/app/services/parameters/DateParameter.js
new file mode 100644
index 0000000000..0681d393b4
--- /dev/null
+++ b/client/app/services/parameters/DateParameter.js
@@ -0,0 +1,95 @@
+import { findKey, startsWith, has, includes, isNull, values } from 'lodash';
+import moment from 'moment';
+import PropTypes from 'prop-types';
+import { Parameter } from '.';
+
+const DATETIME_FORMATS = {
+  // eslint-disable-next-line quote-props
+  'date': 'YYYY-MM-DD',
+  'datetime-local': 'YYYY-MM-DD HH:mm',
+  'datetime-with-seconds': 'YYYY-MM-DD HH:mm:ss',
+};
+
+const DYNAMIC_PREFIX = 'd_';
+
+const DYNAMIC_DATES = {
+  now: {
+    name: 'Today/Now',
+    value: () => moment(),
+  },
+  yesterday: {
+    name: 'Yesterday',
+    value: () => moment().subtract(1, 'day'),
+  },
+};
+
+export const DynamicDateType = PropTypes.oneOf(values(DYNAMIC_DATES));
+
+function isDynamicDateString(value) {
+  return startsWith(value, DYNAMIC_PREFIX) && has(DYNAMIC_DATES, value.substring(DYNAMIC_PREFIX.length));
+}
+
+export function isDynamicDate(value) {
+  return includes(DYNAMIC_DATES, value);
+}
+
+export function getDynamicDateFromString(value) {
+  if (!isDynamicDateString(value)) {
+    return null;
+  }
+  return DYNAMIC_DATES[value.substring(DYNAMIC_PREFIX.length)];
+}
+
+class DateParameter extends Parameter {
+  constructor(parameter, parentQueryId) {
+    super(parameter, parentQueryId);
+    this.useCurrentDateTime = parameter.useCurrentDateTime;
+    this.setValue(parameter.value);
+  }
+
+  get hasDynamicValue() {
+    return isDynamicDate(this.normalizedValue);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  normalizeValue(value) {
+    if (isDynamicDateString(value)) {
+      return getDynamicDateFromString(value);
+    }
+
+    if (isDynamicDate(value)) {
+      return value;
+    }
+
+    const normalizedValue = moment(value);
+    return normalizedValue.isValid() ? normalizedValue : null;
+  }
+
+  setValue(value) {
+    const normalizedValue = this.normalizeValue(value);
+    if (isDynamicDate(normalizedValue)) {
+      this.value = DYNAMIC_PREFIX + findKey(DYNAMIC_DATES, normalizedValue);
+    } else if (moment.isMoment(normalizedValue)) {
+      this.value = normalizedValue.format(DATETIME_FORMATS[this.type]);
+    } else {
+      this.value = normalizedValue;
+    }
+    this.$$value = normalizedValue;
+
+    this.updateLocals();
+    this.clearPendingValue();
+    return this;
+  }
+
+  getExecutionValue() {
+    if (this.hasDynamicValue) {
+      return this.normalizedValue.value().format(DATETIME_FORMATS[this.type]);
+    }
+    if (isNull(this.value) && this.useCurrentDateTime) {
+      return moment().format(DATETIME_FORMATS[this.type]);
+    }
+    return this.value;
+  }
+}
+
+export default DateParameter;
diff --git a/client/app/services/parameters/DateRangeParameter.js b/client/app/services/parameters/DateRangeParameter.js
new file mode 100644
index 0000000000..dce8900283
--- /dev/null
+++ b/client/app/services/parameters/DateRangeParameter.js
@@ -0,0 +1,169 @@
+import { startsWith, has, includes, findKey, values, isObject, isArray } from 'lodash';
+import moment from 'moment';
+import PropTypes from 'prop-types';
+import { Parameter } from '.';
+
+const DATETIME_FORMATS = {
+  'date-range': 'YYYY-MM-DD',
+  'datetime-range': 'YYYY-MM-DD HH:mm',
+  'datetime-range-with-seconds': 'YYYY-MM-DD HH:mm:ss',
+};
+
+const DYNAMIC_PREFIX = 'd_';
+
+const DYNAMIC_DATE_RANGES = {
+  today: {
+    name: 'Today',
+    value: () => [moment().startOf('day'), moment().endOf('day')],
+  },
+  yesterday: {
+    name: 'Yesterday',
+    value: () => [moment().subtract(1, 'day').startOf('day'), moment().subtract(1, 'day').endOf('day')],
+  },
+  this_week: {
+    name: 'This week',
+    value: () => [moment().startOf('week'), moment().endOf('week')],
+  },
+  this_month: {
+    name: 'This month',
+    value: () => [moment().startOf('month'), moment().endOf('month')],
+  },
+  this_year: {
+    name: 'This year',
+    value: () => [moment().startOf('year'), moment().endOf('year')],
+  },
+  last_week: {
+    name: 'Last week',
+    value: () => [moment().subtract(1, 'week').startOf('week'), moment().subtract(1, 'week').endOf('week')],
+  },
+  last_month: {
+    name: 'Last month',
+    value: () => [moment().subtract(1, 'month').startOf('month'), moment().subtract(1, 'month').endOf('month')],
+  },
+  last_year: {
+    name: 'Last year',
+    value: () => [moment().subtract(1, 'year').startOf('year'), moment().subtract(1, 'year').endOf('year')],
+  },
+  last_7_days: {
+    name: 'Last 7 days',
+    value: () => [moment().subtract(7, 'days'), moment()],
+  },
+};
+
+export const DynamicDateRangeType = PropTypes.oneOf(values(DYNAMIC_DATE_RANGES));
+
+export function isDynamicDateRangeString(value) {
+  if (!startsWith(value, DYNAMIC_PREFIX)) {
+    return false;
+  }
+  return !!DYNAMIC_DATE_RANGES[value.substring(DYNAMIC_PREFIX.length)];
+}
+
+export function isDynamicDateRange(value) {
+  return includes(DYNAMIC_DATE_RANGES, value);
+}
+
+export function getDynamicDateRangeFromString(value) {
+  if (!isDynamicDateRangeString(value)) {
+    return null;
+  }
+  return DYNAMIC_DATE_RANGES[value.substring(DYNAMIC_PREFIX.length)];
+}
+
+class DateRangeParameter extends Parameter {
+  constructor(parameter, parentQueryId) {
+    super(parameter, parentQueryId);
+    this.setValue(parameter.value);
+  }
+
+  get hasDynamicValue() {
+    return isDynamicDateRange(this.normalizedValue);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  normalizeValue(value) {
+    if (isDynamicDateRangeString(value)) {
+      return getDynamicDateRangeFromString(value);
+    }
+
+    if (isDynamicDateRange(value)) {
+      return value;
+    }
+
+    if (isObject(value) && !isArray(value)) {
+      value = [value.start, value.end];
+    }
+
+    if (isArray(value) && (value.length === 2)) {
+      value = [moment(value[0]), moment(value[1])];
+      if (value[0].isValid() && value[1].isValid()) {
+        return value;
+      }
+    }
+    return null;
+  }
+
+  setValue(value) {
+    const normalizedValue = this.normalizeValue(value);
+    if (isDynamicDateRange(normalizedValue)) {
+      this.value = DYNAMIC_PREFIX + findKey(DYNAMIC_DATE_RANGES, normalizedValue);
+    } else if (isArray(normalizedValue)) {
+      this.value = {
+        start: normalizedValue[0].format(DATETIME_FORMATS[this.type]),
+        end: normalizedValue[1].format(DATETIME_FORMATS[this.type]),
+      };
+    } else {
+      this.value = normalizedValue;
+    }
+    this.$$value = normalizedValue;
+
+    this.updateLocals();
+    this.clearPendingValue();
+    return this;
+  }
+
+  getExecutionValue() {
+    if (this.hasDynamicValue) {
+      const format = date => date.format(DATETIME_FORMATS[this.type]);
+      const [start, end] = this.normalizedValue.value().map(format);
+      return { start, end };
+    }
+    return this.value;
+  }
+
+  toUrlParams() {
+    const prefix = this.urlPrefix;
+    if (isObject(this.value) && this.value.start && this.value.end) {
+      return {
+        [`${prefix}${this.name}`]: `${this.value.start}--${this.value.end}`,
+      };
+    }
+    return super.toUrlParams();
+  }
+
+  fromUrlParams(query) {
+    const prefix = this.urlPrefix;
+    const key = `${prefix}${this.name}`;
+
+    // backward compatibility
+    const keyStart = `${prefix}${this.name}.start`;
+    const keyEnd = `${prefix}${this.name}.end`;
+
+    if (has(query, key)) {
+      const dates = query[key].split('--');
+      if (dates.length === 2) {
+        this.setValue(dates);
+      } else {
+        this.setValue(query[key]);
+      }
+    } else if (has(query, keyStart) && has(query, keyEnd)) {
+      this.setValue([query[keyStart], query[keyEnd]]);
+    }
+  }
+
+  toQueryTextFragment() {
+    return `{{ ${this.name}.start }} {{ ${this.name}.end }}`;
+  }
+}
+
+export default DateRangeParameter;
diff --git a/client/app/services/parameters/EnumParameter.js b/client/app/services/parameters/EnumParameter.js
new file mode 100644
index 0000000000..752062d8fe
--- /dev/null
+++ b/client/app/services/parameters/EnumParameter.js
@@ -0,0 +1,76 @@
+import { isArray, isEmpty, includes, intersection, get, map, join, has } from 'lodash';
+import { Parameter } from '.';
+
+class EnumParameter extends Parameter {
+  constructor(parameter, parentQueryId) {
+    super(parameter, parentQueryId);
+    this.enumOptions = parameter.enumOptions;
+    this.multiValuesOptions = parameter.multiValuesOptions;
+    this.setValue(parameter.value);
+  }
+
+  normalizeValue(value) {
+    if (isEmpty(this.enumOptions)) {
+      return null;
+    }
+
+    const enumOptionsArray = this.enumOptions.split('\n') || [];
+    if (this.multiValuesOptions) {
+      if (!isArray(value)) {
+        value = [value];
+      }
+      value = intersection(value, enumOptionsArray);
+    } else if (!value || isArray(value) || !includes(enumOptionsArray, value)) {
+      value = enumOptionsArray[0];
+    }
+
+    if (isArray(value) && isEmpty(value)) {
+      return null;
+    }
+    return value;
+  }
+
+  getExecutionValue(extra = {}) {
+    const { joinListValues } = extra;
+    if (joinListValues && isArray(this.value)) {
+      const separator = get(this.multiValuesOptions, 'separator', ',');
+      const prefix = get(this.multiValuesOptions, 'prefix', '');
+      const suffix = get(this.multiValuesOptions, 'suffix', '');
+      const parameterValues = map(this.value, v => `${prefix}${v}${suffix}`);
+      return join(parameterValues, separator);
+    }
+    return this.value;
+  }
+
+  toUrlParams() {
+    const prefix = this.urlPrefix;
+
+    let urlParam = this.value;
+    if (this.multiValuesOptions && isArray(this.value)) {
+      urlParam = JSON.stringify(this.value);
+    }
+
+    return {
+      [`${prefix}${this.name}`]: !this.isEmpty ? urlParam : null,
+    };
+  }
+
+  fromUrlParams(query) {
+    const prefix = this.urlPrefix;
+    const key = `${prefix}${this.name}`;
+    if (has(query, key)) {
+      if (this.multiValuesOptions) {
+        try {
+          const valueFromJson = JSON.parse(query[key]);
+          this.setValue(isArray(valueFromJson) ? valueFromJson : query[key]);
+        } catch (e) {
+          this.setValue(query[key]);
+        }
+      } else {
+        this.setValue(query[key]);
+      }
+    }
+  }
+}
+
+export default EnumParameter;
diff --git a/client/app/services/parameters/NumberParameter.js b/client/app/services/parameters/NumberParameter.js
new file mode 100644
index 0000000000..997cdb4b29
--- /dev/null
+++ b/client/app/services/parameters/NumberParameter.js
@@ -0,0 +1,20 @@
+import { toNumber, isNull } from 'lodash';
+import { Parameter } from '.';
+
+class NumberParameter extends Parameter {
+  constructor(parameter, parentQueryId) {
+    super(parameter, parentQueryId);
+    this.setValue(parameter.value);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  normalizeValue(value) {
+    if (isNull(value)) {
+      return null;
+    }
+    const normalizedValue = toNumber(value);
+    return !isNaN(normalizedValue) ? normalizedValue : null;
+  }
+}
+
+export default NumberParameter;
diff --git a/client/app/services/parameters/Parameter.js b/client/app/services/parameters/Parameter.js
new file mode 100644
index 0000000000..8d64113b7d
--- /dev/null
+++ b/client/app/services/parameters/Parameter.js
@@ -0,0 +1,153 @@
+import { isNull, isObject, isFunction, isUndefined, isEqual, has, omit, isArray, each } from 'lodash';
+import {
+  TextParameter, NumberParameter, EnumParameter, QueryBasedDropdownParameter,
+  DateParameter, DateRangeParameter,
+} from '.';
+
+class Parameter {
+  constructor(parameter, parentQueryId) {
+    this.title = parameter.title;
+    this.name = parameter.name;
+    this.type = parameter.type;
+    this.global = parameter.global; // backward compatibility in Widget service
+    this.parentQueryId = parentQueryId;
+
+    // Used for meta-parameters (i.e. dashboard-level params)
+    this.locals = [];
+
+    // Used for URL serialization
+    this.urlPrefix = 'p_';
+  }
+
+  static create(param, parentQueryId) {
+    switch (param.type) {
+      case 'number':
+        return new NumberParameter(param, parentQueryId);
+      case 'enum':
+        return new EnumParameter(param, parentQueryId);
+      case 'query':
+        return new QueryBasedDropdownParameter(param, parentQueryId);
+      case 'date':
+      case 'datetime-local':
+      case 'datetime-with-seconds':
+        return new DateParameter(param, parentQueryId);
+      case 'date-range':
+      case 'datetime-range':
+      case 'datetime-range-with-seconds':
+        return new DateRangeParameter(param, parentQueryId);
+      default:
+        return new TextParameter({ ...param, type: 'text' }, parentQueryId);
+    }
+  }
+
+  static getExecutionValue(param, extra = {}) {
+    if (!isObject(param) || !isFunction(param.getExecutionValue)) {
+      return null;
+    }
+
+    return param.getExecutionValue(extra);
+  }
+
+  static setValue(param, value) {
+    if (!isObject(param) || !isFunction(param.setValue)) {
+      return null;
+    }
+
+    return param.setValue(value);
+  }
+
+  get isEmpty() {
+    return isNull(this.normalizedValue);
+  }
+
+  get hasPendingValue() {
+    return this.pendingValue !== undefined && !isEqual(this.pendingValue, this.normalizedValue);
+  }
+
+  /** Get normalized value to be used in inputs */
+  get normalizedValue() {
+    return this.$$value;
+  }
+
+  clone() {
+    return Parameter.create(this, this.parentQueryId);
+  }
+
+  isEmptyValue(value) {
+    return isNull(this.normalizeValue(value));
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  normalizeValue(value) {
+    if (isUndefined(value)) {
+      return null;
+    }
+    return value;
+  }
+
+  updateLocals() {
+    if (isArray(this.locals)) {
+      each(this.locals, (local) => {
+        local.setValue(this.value);
+      });
+    }
+  }
+
+  setValue(value) {
+    const normalizedValue = this.normalizeValue(value);
+    this.value = normalizedValue;
+    this.$$value = normalizedValue;
+
+    this.updateLocals();
+    this.clearPendingValue();
+    return this;
+  }
+
+  /** Get execution value for a query */
+  getExecutionValue() {
+    return this.value;
+  }
+
+  setPendingValue(value) {
+    this.pendingValue = this.normalizeValue(value);
+  }
+
+  applyPendingValue() {
+    if (this.hasPendingValue) {
+      this.setValue(this.pendingValue);
+    }
+  }
+
+  clearPendingValue() {
+    this.pendingValue = undefined;
+  }
+
+  /** Update URL with Parameter value */
+  toUrlParams() {
+    const prefix = this.urlPrefix;
+    // `null` removes the parameter from the URL in case it exists
+    return {
+      [`${prefix}${this.name}`]: !this.isEmpty ? this.value : null,
+    };
+  }
+
+  /** Set parameter value from the URL */
+  fromUrlParams(query) {
+    const prefix = this.urlPrefix;
+    const key = `${prefix}${this.name}`;
+    if (has(query, key)) {
+      this.setValue(query[key]);
+    }
+  }
+
+  toQueryTextFragment() {
+    return `{{ ${this.name} }}`;
+  }
+
+  /** Get a saveable version of the Parameter by omitting unnecessary props */
+  toSaveableObject() {
+    return omit(this, ['$$value', 'urlPrefix', 'pendingValue', 'parentQueryId']);
+  }
+}
+
+export default Parameter;
diff --git a/client/app/services/parameters/QueryBasedDropdownParameter.js b/client/app/services/parameters/QueryBasedDropdownParameter.js
new file mode 100644
index 0000000000..d2d4f3a689
--- /dev/null
+++ b/client/app/services/parameters/QueryBasedDropdownParameter.js
@@ -0,0 +1,77 @@
+import { isNull, isUndefined, isArray, isEmpty, get, map, join, has } from 'lodash';
+import { Query } from '@/services/query';
+import { Parameter } from '.';
+
+class QueryBasedDropdownParameter extends Parameter {
+  constructor(parameter, parentQueryId) {
+    super(parameter, parentQueryId);
+    this.queryId = parameter.queryId;
+    this.multiValuesOptions = parameter.multiValuesOptions;
+    this.setValue(parameter.value);
+  }
+
+  normalizeValue(value) {
+    if (isUndefined(value) || isNull(value) || (isArray(value) && isEmpty(value))) {
+      return null;
+    }
+
+    if (this.multiValuesOptions) {
+      value = isArray(value) ? value : [value];
+    } else {
+      value = isArray(value) ? value[0] : value;
+    }
+    return value;
+  }
+
+  getExecutionValue(extra = {}) {
+    const { joinListValues } = extra;
+    if (joinListValues && isArray(this.value)) {
+      const separator = get(this.multiValuesOptions, 'separator', ',');
+      const prefix = get(this.multiValuesOptions, 'prefix', '');
+      const suffix = get(this.multiValuesOptions, 'suffix', '');
+      const parameterValues = map(this.value, v => `${prefix}${v}${suffix}`);
+      return join(parameterValues, separator);
+    }
+    return this.value;
+  }
+
+  toUrlParams() {
+    const prefix = this.urlPrefix;
+
+    let urlParam = this.value;
+    if (this.multiValuesOptions && isArray(this.value)) {
+      urlParam = JSON.stringify(this.value);
+    }
+
+    return {
+      [`${prefix}${this.name}`]: !this.isEmpty ? urlParam : null,
+    };
+  }
+
+  fromUrlParams(query) {
+    const prefix = this.urlPrefix;
+    const key = `${prefix}${this.name}`;
+    if (has(query, key)) {
+      if (this.multiValuesOptions) {
+        try {
+          const valueFromJson = JSON.parse(query[key]);
+          this.setValue(isArray(valueFromJson) ? valueFromJson : query[key]);
+        } catch (e) {
+          this.setValue(query[key]);
+        }
+      } else {
+        this.setValue(query[key]);
+      }
+    }
+  }
+
+  loadDropdownValues() {
+    if (this.parentQueryId) {
+      return Query.associatedDropdown({ queryId: this.parentQueryId, dropdownQueryId: this.queryId }).$promise;
+    }
+
+    return Query.asDropdown({ id: this.queryId }).$promise;
+  }
+}
+
+export default QueryBasedDropdownParameter;
diff --git a/client/app/services/parameters/TextParameter.js b/client/app/services/parameters/TextParameter.js
new file mode 100644
index 0000000000..645adbc8e3
--- /dev/null
+++ b/client/app/services/parameters/TextParameter.js
@@ -0,0 +1,20 @@
+import { toString, isEmpty } from 'lodash';
+import { Parameter } from '.';
+
+class TextParameter extends Parameter {
+  constructor(parameter, parentQueryId) {
+    super(parameter, parentQueryId);
+    this.setValue(parameter.value);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  normalizeValue(value) {
+    const normalizedValue = toString(value);
+    if (isEmpty(normalizedValue)) {
+      return null;
+    }
+    return normalizedValue;
+  }
+}
+
+export default TextParameter;
diff --git a/client/app/services/parameters/index.js b/client/app/services/parameters/index.js
new file mode 100644
index 0000000000..f9f75cb163
--- /dev/null
+++ b/client/app/services/parameters/index.js
@@ -0,0 +1,7 @@
+export { default as Parameter } from './Parameter';
+export { default as TextParameter } from './TextParameter';
+export { default as NumberParameter } from './NumberParameter';
+export { default as EnumParameter } from './EnumParameter';
+export { default as QueryBasedDropdownParameter } from './QueryBasedDropdownParameter';
+export { default as DateParameter } from './DateParameter';
+export { default as DateRangeParameter } from './DateRangeParameter';
diff --git a/client/app/services/parameters/tests/DateParameter.test.js b/client/app/services/parameters/tests/DateParameter.test.js
new file mode 100644
index 0000000000..c0fdaa1800
--- /dev/null
+++ b/client/app/services/parameters/tests/DateParameter.test.js
@@ -0,0 +1,79 @@
+import { Parameter } from '..';
+import { getDynamicDateFromString } from '../DateParameter';
+import moment from 'moment';
+
+describe('DateParameter', () => {
+  let type = 'date';
+  let param;
+
+  beforeEach(() => {
+    param = Parameter.create({ name: 'param', title: 'Param', type });
+  });
+
+  describe('getExecutionValue', () => {
+    beforeEach(() => {
+      param.setValue(moment('2019-10-06 10:00:00'));
+    });
+
+    test('formats value as a string date', () => {
+      const executionValue = param.getExecutionValue();
+      expect(executionValue).toBe('2019-10-06');
+    });
+
+    describe('type is datetime-local', () => {
+      beforeAll(() => {
+        type = 'datetime-local';
+      });
+
+      test('formats value as a string datetime', () => {
+        const executionValue = param.getExecutionValue();
+        expect(executionValue).toBe('2019-10-06 10:00');
+      });
+    });
+
+    describe('type is datetime-with-seconds', () => {
+      beforeAll(() => {
+        type = 'datetime-with-seconds';
+      });
+
+      test('formats value as a string datetime with seconds', () => {
+        const executionValue = param.getExecutionValue();
+        expect(executionValue).toBe('2019-10-06 10:00:00');
+      });
+    });
+  });
+
+  describe('normalizeValue', () => {
+    test('recognizes dates from strings', () => {
+      const normalizedValue = param.normalizeValue('2019-10-06');
+      expect(moment.isMoment(normalizedValue)).toBeTruthy();
+      expect(normalizedValue.format('YYYY-MM-DD')).toBe('2019-10-06');
+    });
+
+    test('recognizes dates from moment values', () => {
+      const normalizedValue = param.normalizeValue(moment('2019-10-06'));
+      expect(moment.isMoment(normalizedValue)).toBeTruthy();
+      expect(normalizedValue.format('YYYY-MM-DD')).toBe('2019-10-06');
+    });
+
+    test('normalizes unrecognized values as null', () => {
+      const normalizedValue = param.normalizeValue('value');
+      expect(normalizedValue).toBeNull();
+    });
+
+    describe('Dynamic values', () => {
+      test('recognizes dynamic values from string index', () => {
+        const normalizedValue = param.normalizeValue('d_now');
+        expect(normalizedValue).not.toBeNull();
+        expect(normalizedValue).toEqual(getDynamicDateFromString('d_now'));
+      });
+
+      test('recognizes dynamic values from a dynamic date', () => {
+        const dynamicDate = getDynamicDateFromString('d_now');
+        const normalizedValue = param.normalizeValue(dynamicDate);
+        expect(normalizedValue).not.toBeNull();
+        expect(normalizedValue).toEqual(dynamicDate);
+      });
+    });
+  });
+});
diff --git a/client/app/services/parameters/tests/DateRangeParameter.test.js b/client/app/services/parameters/tests/DateRangeParameter.test.js
new file mode 100644
index 0000000000..3d04636dbb
--- /dev/null
+++ b/client/app/services/parameters/tests/DateRangeParameter.test.js
@@ -0,0 +1,76 @@
+import { Parameter } from '..';
+import { getDynamicDateRangeFromString } from '../DateRangeParameter';
+import moment from 'moment';
+
+describe('DateRangeParameter', () => {
+  let type = 'date-range';
+  let param;
+
+  beforeEach(() => {
+    param = Parameter.create({ name: 'param', title: 'Param', type });
+  });
+
+  describe('getExecutionValue', () => {
+    beforeEach(() => {
+      param.setValue({ start: '2019-10-05 10:00:00', end: '2019-10-06 09:59:59' });
+    });
+
+    test('formats value as a string date', () => {
+      const executionValue = param.getExecutionValue();
+      expect(executionValue).toEqual({ start: '2019-10-05', end: '2019-10-06' });
+    });
+
+    describe('type is datetime-range', () => {
+      beforeAll(() => {
+        type = 'datetime-range';
+      });
+
+      test('formats value as a string datetime', () => {
+        const executionValue = param.getExecutionValue();
+        expect(executionValue).toEqual({ start: '2019-10-05 10:00', end: '2019-10-06 09:59' });
+      });
+    });
+
+    describe('type is datetime-range-with-seconds', () => {
+      beforeAll(() => {
+        type = 'datetime-range-with-seconds';
+      });
+
+      test('formats value as a string datetime with seconds', () => {
+        const executionValue = param.getExecutionValue();
+        expect(executionValue).toEqual({ start: '2019-10-05 10:00:00', end: '2019-10-06 09:59:59' });
+      });
+    });
+  });
+
+  describe('normalizeValue', () => {
+    test('recognizes dates from moment arrays', () => {
+      const normalizedValue = param.normalizeValue([moment('2019-10-05'), moment('2019-10-06')]);
+      expect(normalizedValue).toHaveLength(2);
+      expect(normalizedValue[0].format('YYYY-MM-DD')).toBe('2019-10-05');
+      expect(normalizedValue[1].format('YYYY-MM-DD')).toBe('2019-10-06');
+    });
+
+    test('recognizes dates from object', () => {
+      const normalizedValue = param.normalizeValue({ start: '2019-10-05', end: '2019-10-06' });
+      expect(normalizedValue).toHaveLength(2);
+      expect(normalizedValue[0].format('YYYY-MM-DD')).toBe('2019-10-05');
+      expect(normalizedValue[1].format('YYYY-MM-DD')).toBe('2019-10-06');
+    });
+
+    describe('Dynamic values', () => {
+      test('recognizes dynamic values from string index', () => {
+        const normalizedValue = param.normalizeValue('d_last_week');
+        expect(normalizedValue).not.toBeNull();
+        expect(normalizedValue).toEqual(getDynamicDateRangeFromString('d_last_week'));
+      });
+
+      test('recognizes dynamic values from a dynamic date range', () => {
+        const dynamicDateRange = getDynamicDateRangeFromString('d_last_week');
+        const normalizedValue = param.normalizeValue(dynamicDateRange);
+        expect(normalizedValue).not.toBeNull();
+        expect(normalizedValue).toEqual(dynamicDateRange);
+      });
+    });
+  });
+});
diff --git a/client/app/services/parameters/tests/EnumParameter.test.js b/client/app/services/parameters/tests/EnumParameter.test.js
new file mode 100644
index 0000000000..ac64be5e4b
--- /dev/null
+++ b/client/app/services/parameters/tests/EnumParameter.test.js
@@ -0,0 +1,56 @@
+import { Parameter } from '..';
+
+describe('EnumParameter', () => {
+  let param;
+  let multiValuesOptions = null;
+  const enumOptions = 'value1\nvalue2\nvalue3\nvalue4';
+
+  beforeEach(() => {
+    const paramOptions = {
+      name: 'param',
+      title: 'Param',
+      type: 'enum',
+      enumOptions,
+      multiValuesOptions,
+    };
+    param = Parameter.create(paramOptions);
+  });
+
+  describe('normalizeValue', () => {
+    test('returns the value when the input in the enum options', () => {
+      const normalizedValue = param.normalizeValue('value2');
+      expect(normalizedValue).toBe('value2');
+    });
+
+    test('returns the first value when the input is not in the enum options', () => {
+      const normalizedValue = param.normalizeValue('anything');
+      expect(normalizedValue).toBe('value1');
+    });
+  });
+
+  describe('Multi-valued', () => {
+    beforeAll(() => {
+      multiValuesOptions = { prefix: '"', suffix: '"', separator: ',' };
+    });
+
+    describe('normalizeValue', () => {
+      test('returns only valid values', () => {
+        const normalizedValue = param.normalizeValue(['value3', 'anything', null]);
+        expect(normalizedValue).toEqual(['value3']);
+      });
+
+      test('normalizes empty values as null', () => {
+        const normalizedValue = param.normalizeValue([]);
+        expect(normalizedValue).toBeNull();
+      });
+    });
+
+    describe('getExecutionValue', () => {
+      test('joins values when joinListValues is truthy', () => {
+        param.setValue(['value1', 'value3']);
+        const executionValue = param.getExecutionValue({ joinListValues: true });
+        expect(executionValue).toBe('"value1","value3"');
+      });
+    });
+  });
+});
diff --git a/client/app/services/parameters/tests/NumberParameter.test.js b/client/app/services/parameters/tests/NumberParameter.test.js
new file mode 100644
index 0000000000..2a292ea880
--- /dev/null
+++ b/client/app/services/parameters/tests/NumberParameter.test.js
@@ -0,0 +1,26 @@
+import { Parameter } from '..';
+
+describe('NumberParameter', () => {
+  let param;
+
+  beforeEach(() => {
+    param = Parameter.create({ name: 'param', title: 'Param', type: 'number' });
+  });
+
+  describe('normalizeValue', () => {
+    test('converts Strings', () => {
+      const normalizedValue = param.normalizeValue('15');
+      expect(normalizedValue).toBe(15);
+    });
+
+    test('converts Numbers', () => {
+      const normalizedValue = param.normalizeValue(42);
+      expect(normalizedValue).toBe(42);
+    });
+
+    test('returns null when not possible to convert to number', () => {
+      const normalizedValue = param.normalizeValue('notanumber');
+      expect(normalizedValue).toBeNull();
+    });
+  });
+});
diff --git a/client/app/services/parameters/tests/Parameter.test.js b/client/app/services/parameters/tests/Parameter.test.js
new file mode 100644
index 0000000000..5280f1169d
--- /dev/null
+++ b/client/app/services/parameters/tests/Parameter.test.js
@@ -0,0 +1,25 @@
+import { Parameter, TextParameter, NumberParameter, EnumParameter,
+  QueryBasedDropdownParameter, DateParameter, DateRangeParameter } from '..';
+
+describe('Parameter', () => {
+  describe('create', () => {
+    const parameterTypes = [
+      ['text', TextParameter],
+      ['number', NumberParameter],
+      ['enum', EnumParameter],
+      ['query', QueryBasedDropdownParameter],
+      ['date', DateParameter],
+      ['datetime-local', DateParameter],
+      ['datetime-with-seconds', DateParameter],
+      ['date-range', DateRangeParameter],
+      ['datetime-range', DateRangeParameter],
+      ['datetime-range-with-seconds', DateRangeParameter],
+      [null, TextParameter],
+    ];
+
+    test.each(parameterTypes)('when type is \'%s\' creates a %p', (type, expectedClass) => {
+      const parameter = Parameter.create({ name: 'param', title: 'Param', type });
+      expect(parameter).toBeInstanceOf(expectedClass);
+    });
+  });
+});
diff --git a/client/app/services/parameters/tests/QueryBasedDropdownParameter.test.js b/client/app/services/parameters/tests/QueryBasedDropdownParameter.test.js
new file mode 100644
index 0000000000..46c5cbb7c6
--- /dev/null
+++ b/client/app/services/parameters/tests/QueryBasedDropdownParameter.test.js
@@ -0,0 +1,54 @@
+import { Parameter } from '..';
+
+describe('QueryBasedDropdownParameter', () => {
+  let param;
+  let multiValuesOptions = null;
+
+  beforeEach(() => {
+    const paramOptions = {
+      name: 'param',
+      title: 'Param',
+      type: 'query',
+      queryId: 1,
+      multiValuesOptions,
+    };
+    param = Parameter.create(paramOptions);
+  });
+
+  describe('normalizeValue', () => {
+    test('returns the value when the input in the enum options', () => {
+      const normalizedValue = param.normalizeValue('value2');
+      expect(normalizedValue).toBe('value2');
+    });
+
+    describe('Empty values', () => {
+      const emptyValues = [null, undefined, []];
+
+      test.each(emptyValues)('normalizes empty value \'%s\' as null', (emptyValue) => {
+        const normalizedValue = param.normalizeValue(emptyValue);
+        expect(normalizedValue).toBeNull();
+      });
+    });
+  });
+
+  describe('Multi-valued', () => {
+    beforeAll(() => {
+      multiValuesOptions = { prefix: '"', suffix: '"', separator: ',' };
+    });
+
+    describe('normalizeValue', () => {
+      test('returns an array with the input when input is not an array', () => {
+        const normalizedValue = param.normalizeValue('value');
+        expect(normalizedValue).toEqual(['value']);
+      });
+    });
+
+    describe('getExecutionValue', () => {
+      test('joins values when joinListValues is truthy', () => {
+        param.setValue(['value1', 'value3']);
+        const executionValue = param.getExecutionValue({ joinListValues: true });
+        expect(executionValue).toBe('"value1","value3"');
+      });
+    });
+  });
+});
diff --git a/client/app/services/parameters/tests/TextParameter.test.js b/client/app/services/parameters/tests/TextParameter.test.js
new file mode 100644
index 0000000000..a9a648c657
--- /dev/null
+++ b/client/app/services/parameters/tests/TextParameter.test.js
@@ -0,0 +1,30 @@
+import { Parameter } from '..';
+
+describe('TextParameter', () => {
+  let param;
+
+  beforeEach(() => {
+    param = Parameter.create({ name: 'param', title: 'Param', type: 'text' });
+  });
+
+  describe('normalizeValue', () => {
+    test('converts Strings', () => {
+      const normalizedValue = param.normalizeValue('exampleString');
+      expect(normalizedValue).toBe('exampleString');
+    });
+
+    test('converts Numbers', () => {
+      const normalizedValue = param.normalizeValue(3);
+      expect(normalizedValue).toBe('3');
+    });
+
+    describe('Empty values', () => {
+      const emptyValues = [null, undefined, ''];
+
+      test.each(emptyValues)('normalizes empty value \'%s\' as null', (emptyValue) => {
+        const normalizedValue = param.normalizeValue(emptyValue);
+        expect(normalizedValue).toBeNull();
+      });
+    });
+  });
+});
diff --git a/client/app/services/query.js b/client/app/services/query.js
index 1af3f25268..4c85c550df 100644
--- a/client/app/services/query.js
+++ b/client/app/services/query.js
@@ -2,83 +2,18 @@ import moment from 'moment';
 import debug from 'debug';
 import Mustache from 'mustache';
 import {
-  zipObject, isEmpty, map, filter, includes, union, uniq, has, get, intersection,
-  isNull, isUndefined, isArray, isObject, identity, extend, each, join, some, startsWith,
+  zipObject, isEmpty, map, filter, includes, union,
+  uniq, has, identity, extend, each, some,
 } from 'lodash';
 
+import { Parameter } from './parameters';
+
 Mustache.escape = identity; // do not html-escape values
 
 export let Query = null; // eslint-disable-line import/no-mutable-exports
 
 const logger = debug('redash:services:query');
 
-const DATETIME_FORMATS = {
-  // eslint-disable-next-line quote-props
-  'date': 'YYYY-MM-DD',
-  'date-range': 'YYYY-MM-DD',
-  'datetime-local': 'YYYY-MM-DD HH:mm',
-  'datetime-range': 'YYYY-MM-DD HH:mm',
-  'datetime-with-seconds': 'YYYY-MM-DD HH:mm:ss',
-  'datetime-range-with-seconds': 'YYYY-MM-DD HH:mm:ss',
-};
-
-const DYNAMIC_PREFIX = 'd_';
-
-const DYNAMIC_DATE_RANGES = {
-  today: {
-    name: 'Today',
-    value: () => [moment().startOf('day'), moment().endOf('day')],
-  },
-  yesterday: {
-    name: 'Yesterday',
-    value: () => [moment().subtract(1, 'day').startOf('day'), moment().subtract(1, 'day').endOf('day')],
-  },
-  this_week: {
-    name: 'This week',
-    value: () => [moment().startOf('week'), moment().endOf('week')],
-  },
-  this_month: {
-    name: 'This month',
-    value: () => [moment().startOf('month'), moment().endOf('month')],
-  },
-  this_year: {
-    name: 'This year',
-    value: () => [moment().startOf('year'), moment().endOf('year')],
-  },
-  last_week: {
-    name: 'Last week',
-    value: () => [moment().subtract(1, 'week').startOf('week'), moment().subtract(1, 'week').endOf('week')],
-  },
-  last_month: {
-    name: 'Last month',
-    value: () => [moment().subtract(1, 'month').startOf('month'), moment().subtract(1, 'month').endOf('month')],
-  },
-  last_year: {
-    name: 'Last year',
-    value: () => [moment().subtract(1, 'year').startOf('year'), moment().subtract(1, 'year').endOf('year')],
-  },
-  last_7_days: {
-    name: 'Last 7 days',
-    value: () => [moment().subtract(7, 'days'), moment()],
-  },
-};
-
-const DYNAMIC_DATES = {
-  now: {
-    name: 'Today/Now',
-    value: () => moment(),
-  },
-  yesterday: {
-    name: 'Yesterday',
-    value: () => moment().subtract(1, 'day'),
-  },
-};
-
-function normalizeNumericValue(value, defaultValue = null) {
-  const result = parseFloat(value);
-  return isFinite(result) ? result : defaultValue;
-}
-
 function collectParams(parts) {
   let parameters = [];
 
@@ -93,334 +28,6 @@ function collectParams(parts) {
   return parameters;
 }
 
-function isEmptyValue(value) {
-  return isNull(value) || isUndefined(value) || (value === '') || (isArray(value) && value.length === 0);
-}
-
-function isDateParameter(paramType) {
-  return includes(['date', 'datetime-local', 'datetime-with-seconds'], paramType);
-}
-
-function isDateRangeParameter(paramType) {
-  return includes(['date-range', 'datetime-range', 'datetime-range-with-seconds'], paramType);
-}
-
-export function isDynamicDate(value) {
-  if (!startsWith(value, DYNAMIC_PREFIX)) {
-    return false;
-  }
-  return !!DYNAMIC_DATES[value.substring(DYNAMIC_PREFIX.length)];
-}
-
-export function isDynamicDateRange(value) {
-  if (!startsWith(value, DYNAMIC_PREFIX)) {
-    return false;
-  }
-  return !!DYNAMIC_DATE_RANGES[value.substring(DYNAMIC_PREFIX.length)];
-}
-
-export function getDynamicDate(value) {
-  if (!isDynamicDate(value)) {
-    return null;
-  }
-  return DYNAMIC_DATES[value.substring(DYNAMIC_PREFIX.length)];
-}
-
-export function getDynamicDateRange(value) {
-  if (!isDynamicDateRange(value)) {
-    return null;
-  }
-  return DYNAMIC_DATE_RANGES[value.substring(DYNAMIC_PREFIX.length)];
-}
-
-export class Parameter {
-  constructor(parameter, parentQueryId) {
-    this.title = parameter.title;
-    this.name = parameter.name;
-    this.type = parameter.type;
-    this.useCurrentDateTime = parameter.useCurrentDateTime;
-    this.global = parameter.global; // backward compatibility in Widget service
-    this.enumOptions = parameter.enumOptions;
-    this.multiValuesOptions = parameter.multiValuesOptions;
-    this.queryId = parameter.queryId;
-    this.parentQueryId = parentQueryId;
-
-    // Used for meta-parameters (i.e. dashboard-level params)
-    this.locals = [];
-
-    // validate value and init internal state
-    this.setValue(parameter.value);
-
-    // Used for URL serialization
-    Object.defineProperty(this, 'urlPrefix', {
-      configurable: true,
-      enumerable: false, // don't save it
-      writable: true,
-      value: 'p_',
-    });
-  }
-
-  clone() {
-    return new Parameter(this, this.parentQueryId);
-  }
-
-  get isEmpty() {
-    return isNull(this.getValue());
-  }
-
-  get hasDynamicValue() {
-    if (isDateParameter(this.type)) {
-      return isDynamicDate(this.value);
-    }
-    if (isDateRangeParameter(this.type)) {
-      return isDynamicDateRange(this.value);
-    }
-    return false;
-  }
-
-  get dynamicValue() {
-    if (isDateParameter(this.type)) {
-      return getDynamicDate(this.value);
-    }
-    if (isDateRangeParameter(this.type)) {
-      return getDynamicDateRange(this.value);
-    }
-    return false;
-  }
-
-  getValue(extra = {}) {
-    return this.constructor.getValue(this, extra);
-  }
-
-  static getValue(param, extra = {}) {
-    const { value, type, useCurrentDateTime, multiValuesOptions } = param;
-    if (isDateRangeParameter(type) && param.hasDynamicValue) {
-      const { dynamicValue } = param;
-      if (dynamicValue) {
-        const dateRange = dynamicValue.value();
-        return {
-          start: dateRange[0].format(DATETIME_FORMATS[type]),
-          end: dateRange[1].format(DATETIME_FORMATS[type]),
-        };
-      }
-      return null;
-    }
-
-    if (isDateParameter(type) && param.hasDynamicValue) {
-      const { dynamicValue } = param;
-      if (dynamicValue) {
-        return dynamicValue.value().format(DATETIME_FORMATS[type]);
-      }
-      return null;
-    }
-
-    if (isEmptyValue(value)) {
-      // keep support for existing useCurentDateTime (not available in UI)
-      if (
-        includes(['date', 'datetime-local', 'datetime-with-seconds'], type) &&
-        useCurrentDateTime
-      ) {
-        return moment().format(DATETIME_FORMATS[type]);
-      }
-      return null; // normalize empty value
-    }
-    if (type === 'number') {
-      return normalizeNumericValue(value, null); // normalize empty value
-    }
-
-    // join array in frontend when query is executed as a text
-    const { joinListValues } = extra;
-    if (includes(['enum', 'query'], type) && multiValuesOptions && isArray(value) && joinListValues) {
-      const separator = get(multiValuesOptions, 'separator', ',');
-      const prefix = get(multiValuesOptions, 'prefix', '');
-      const suffix = get(multiValuesOptions, 'suffix', '');
-      const parameterValues = map(value, v => `${prefix}${v}${suffix}`);
-      return join(parameterValues, separator);
-    }
-    return value;
-  }
-
-  setValue(value) {
-    if (this.type === 'enum') {
-      const enumOptionsArray = this.enumOptions && this.enumOptions.split('\n') || [];
-      if (this.multiValuesOptions) {
-        if (!isArray(value)) {
-          value = [value];
-        }
-        value = intersection(value, enumOptionsArray);
-      } else if (!value || isArray(value) || !includes(enumOptionsArray, value)) {
-        value = enumOptionsArray[0];
-      }
-    }
-
-    if (this.type === 'query' && !isEmptyValue(value)) {
-      if (this.multiValuesOptions && !isArray(value)) {
-        value = [value];
-      }
-    }
-
-    if (isDateRangeParameter(this.type)) {
-      this.value = null;
-      this.$$value = null;
-
-      if (isObject(value) && !isArray(value)) {
-        value = [value.start, value.end];
-      }
-
-      if (isArray(value) && (value.length === 2)) {
-        value = [moment(value[0]), moment(value[1])];
-        if (value[0].isValid() && value[1].isValid()) {
-          this.value = {
-            start: value[0].format(DATETIME_FORMATS[this.type]),
-            end: value[1].format(DATETIME_FORMATS[this.type]),
-          };
-          this.$$value = value;
-        }
-      } else if (isDynamicDateRange(value)) {
-        const dynamicDateRange = getDynamicDateRange(value, this.type);
-        if (dynamicDateRange) {
-          this.value = value;
-          this.$$value = value;
-        }
-      }
-    } else if (isDateParameter(this.type)) {
-      this.value = null;
-      this.$$value = null;
-
-      if (isDynamicDate(value)) {
-        const dynamicDate = getDynamicDate(value);
-        if (dynamicDate) {
-          this.value = value;
-          this.$$value = value;
-        }
-      } else {
-        value = moment(value);
-        if (value.isValid()) {
-          this.value = value.format(DATETIME_FORMATS[this.type]);
-          this.$$value = value;
-        }
-      }
-    } else if (this.type === 'number') {
-      this.value = value;
-      this.$$value = normalizeNumericValue(value, null);
-    } else {
-      this.value = value;
-      this.$$value = value;
-    }
-
-    if (isArray(this.locals)) {
-      each(this.locals, (local) => {
-        local.setValue(this.value);
-      });
-    }
-
-    this.clearPendingValue();
-
-    return this;
-  }
-
-  setPendingValue(value) {
-    this.pendingValue = value;
-  }
-
-  applyPendingValue() {
-    if (this.hasPendingValue) {
-      this.setValue(this.pendingValue);
-    }
-  }
-
-  clearPendingValue() {
-    this.setPendingValue(undefined);
-  }
-
-  get hasPendingValue() {
-    // normalize empty values
-    const pendingValue = isEmptyValue(this.pendingValue) ? null : this.pendingValue;
-    const value = isEmptyValue(this.value) ? null : this.value;
-
-    return this.pendingValue !== undefined && pendingValue !== value;
-  }
-
-  get normalizedValue() {
-    return this.$$value;
-  }
-
-  // TODO: Remove this property when finally moved to React
-  get ngModel() {
-    return this.normalizedValue;
-  }
-
-  set ngModel(value) {
-    this.setValue(value);
-  }
-
-  toUrlParams() {
-    const prefix = this.urlPrefix;
-    if (this.isEmpty) {
-      return { [`${prefix}${this.name}`]: null };
-    }
-
-    if (isDateRangeParameter(this.type) && isObject(this.value)) {
-      return {
-        [`${prefix}${this.name}.start`]: this.value.start,
-        [`${prefix}${this.name}.end`]: this.value.end,
-        [`${prefix}${this.name}`]: null,
-      };
-    }
-    if (this.multiValuesOptions && isArray(this.value)) {
-      return { [`${prefix}${this.name}`]: JSON.stringify(this.value) };
-    }
-    return {
-      [`${prefix}${this.name}`]: this.value,
-      [`${prefix}${this.name}.start`]: null,
-      [`${prefix}${this.name}.end`]: null,
-    };
-  }
-
-  fromUrlParams(query) {
-    const prefix = this.urlPrefix;
-    if (isDateRangeParameter(this.type)) {
-      const key = `${prefix}${this.name}`;
-      const keyStart = `${prefix}${this.name}.start`;
-      const keyEnd = `${prefix}${this.name}.end`;
-      if (has(query, key)) {
-        this.setValue(query[key]);
-      } else if (has(query, keyStart) && has(query, keyEnd)) {
-        this.setValue([query[keyStart], query[keyEnd]]);
-      }
-    } else {
-      const key = `${prefix}${this.name}`;
-      if (has(query, key)) {
-        if (this.multiValuesOptions) {
-          try {
-            const valueFromJson = JSON.parse(query[key]);
-            this.setValue(isArray(valueFromJson) ? valueFromJson : query[key]);
-          } catch (e) {
-            this.setValue(query[key]);
-          }
-        } else {
-          this.setValue(query[key]);
-        }
-      }
-    }
-  }
-
-  toQueryTextFragment() {
-    if (isDateRangeParameter(this.type)) {
-      return `{{ ${this.name}.start }} {{ ${this.name}.end }}`;
-    }
-    return `{{ ${this.name} }}`;
-  }
-
-  loadDropdownValues() {
-    if (this.parentQueryId) {
-      return Query.associatedDropdown({ queryId: this.parentQueryId, dropdownQueryId: this.queryId }).$promise;
-    }
-
-    return Query.asDropdown({ id: this.queryId }).$promise;
-  }
-}
-
 class Parameters {
   constructor(query, queryString) {
     this.query = query;
@@ -465,7 +72,7 @@ class Parameters {
 
     parameterNames.forEach((param) => {
       if (!has(parametersMap, param)) {
-        this.query.options.parameters.push(new Parameter({
+        this.query.options.parameters.push(Parameter.create({
           title: param,
           name: param,
           type: 'text',
@@ -478,7 +85,7 @@ class Parameters {
     const parameterExists = p => includes(parameterNames, p.name);
     const parameters = this.query.options.parameters;
     this.query.options.parameters = parameters.filter(parameterExists)
-      .map(p => (p instanceof Parameter ? p : new Parameter(p, this.query.id)));
+      .map(p => (p instanceof Parameter ? p : Parameter.create(p, this.query.id)));
   }
 
   initFromQueryString(query) {
@@ -495,7 +102,7 @@ class Parameters {
   add(parameterDef) {
     this.query.options.parameters = this.query.options.parameters
       .filter(p => p.name !== parameterDef.name);
-    const param = new Parameter(parameterDef);
+    const param = Parameter.create(parameterDef);
     this.query.options.parameters.push(param);
     return param;
   }
@@ -508,9 +115,9 @@ class Parameters {
     return !isEmpty(this.get());
   }
 
-  getValues(extra = {}) {
+  getExecutionValues(extra = {}) {
     const params = this.get();
-    return zipObject(map(params, i => i.name), map(params, i => i.getValue(extra)));
+    return zipObject(map(params, i => i.name), map(params, i => i.getExecutionValue(extra)));
   }
 
   hasPendingValues() {
@@ -748,7 +355,7 @@ function QueryResource(
   };
 
   QueryService.prototype.getQueryResult = function getQueryResult(maxAge) {
-    const execute = () => QueryResult.getByQueryId(this.id, this.getParameters().getValues(), maxAge);
+    const execute = () => QueryResult.getByQueryId(this.id, this.getParameters().getExecutionValues(), maxAge);
     return this.prepareQueryResultExecution(execute, maxAge);
   };
 
@@ -758,7 +365,7 @@ function QueryResource(
       return new QueryResultError("Can't execute empty query.");
     }
 
-    const parameters = this.getParameters().getValues({ joinListValues: true });
+    const parameters = this.getParameters().getExecutionValues({ joinListValues: true });
     const execute = () => QueryResult.get(this.data_source_id, queryText, parameters, maxAge, this.id);
     return this.prepareQueryResultExecution(execute, maxAge);
   };