Frank
/
fineui
forked from fanruan/fineui
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

KERNEL-14100 refactor: widget/yearquarter、yearquarterinterval es6化

es6
Joker.Wang-王顺 2 years ago
parent
8920b5aff7
commit
176b402e0b
8 changed files with 1255 additions and 871 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 9
      src/widget/index.js
  2. 293
      src/widget/yearquarter/card.dynamic.yearquarter.js
  3. 260
      src/widget/yearquarter/card.static.yearquarter.js
  4. 345
      src/widget/yearquarter/combo.yearquarter.js
  5. 6
      src/widget/yearquarter/index.js
  6. 437
      src/widget/yearquarter/popup.yearquarter.js
  7. 461
      src/widget/yearquarter/trigger.yearquarter.js
  8. 315
      src/widget/yearquarterinterval/yearquarterinterval.js

9
src/widget/index.js
Unescape View File

@ -10,6 +10,7 @@ import * as editor from "./editor";
import * as downList from "./downlist"; import * as downList from "./downlist";
import * as singleSliderItem from "./singleslider"; import * as singleSliderItem from "./singleslider";
import * as intervalSliderItem from "./intervalslider"; import * as intervalSliderItem from "./intervalslider";
import * as yearQuarter from "./yearquarter";
import { SelectTreeCombo } from "./selecttree/selecttree.combo"; import { SelectTreeCombo } from "./selecttree/selecttree.combo";
import { SingleTreeCombo } from "./singletree/singletree.combo"; import { SingleTreeCombo } from "./singletree/singletree.combo";
import { MultiTreeCombo } from "./multitree/multi.tree.combo"; import { MultiTreeCombo } from "./multitree/multi.tree.combo";
@ -17,6 +18,7 @@ import { MultiTreeInsertCombo } from "./multitree/multi.tree.insert.combo";
import { MultiTreeListCombo } from "./multitree/multi.tree.list.combo"; import { MultiTreeListCombo } from "./multitree/multi.tree.list.combo";
import { NumberEditor } from "./numbereditor/number.editor"; import { NumberEditor } from "./numbereditor/number.editor";
import { NumberInterval } from "./numberinterval/numberinterval"; import { NumberInterval } from "./numberinterval/numberinterval";
import { YearQuarterInterval } from "./yearquarterinterval/yearquarterinterval";
import * as multiselect from "./multiselect"; import * as multiselect from "./multiselect";
import * as multiselectlist from "./multiselectlist"; import * as multiselectlist from "./multiselectlist";
import * as multilayerselectree from "./multilayerselecttree"; import * as multilayerselectree from "./multilayerselecttree";
@ -41,6 +43,7 @@ Object.assign(BI, {
...downList, ...downList,
...singleSliderItem, ...singleSliderItem,
...intervalSliderItem, ...intervalSliderItem,
...yearQuarter,
SelectTreeCombo, SelectTreeCombo,
SingleTreeCombo, SingleTreeCombo,
MultiTreeCombo, MultiTreeCombo,
@ -49,6 +52,7 @@ Object.assign(BI, {
NumberEditor, NumberEditor,
NumberInterval, NumberInterval,
YearInterval, YearInterval,
YearQuarterInterval,
...multiselect, ...multiselect,
...multiselectlist, ...multiselectlist,
...multilayerselectree, ...multilayerselectree,
@ -75,7 +79,7 @@ export * from "./multilayersingletree";
export * from "./multilayerselecttree"; export * from "./multilayerselecttree";
export * from "./singleselect"; export * from "./singleselect";
export * from "./multilayerdownlist"; export * from "./multilayerdownlist";
export * from "./multilayersingletree"; export * from "./yearquarter";
export { export {
Collapse, Collapse,
@ -86,5 +90,6 @@ export {
MultiTreeCombo, MultiTreeCombo,
MultiTreeInsertCombo, MultiTreeInsertCombo,
MultiTreeListCombo, MultiTreeListCombo,
YearInterval YearInterval,
YearQuarterInterval
}; };

293
src/widget/yearquarter/card.dynamic.yearquarter.js
Unescape View File

@ -1,166 +1,213 @@
/** import {
* 年季度展示面板 shortcut,
* Widget,
* Created by GUY on 2015/9/2. i18nText,
* @class BI.YearCard bind,
* @extends BI.Trigger VerticalLayout,
*/ parseDateTime,
BI.DynamicYearQuarterCard = BI.inherit(BI.Widget, { extend,
checkDateVoid,
props: { isNotEmptyString,
baseCls: "bi-year-quarter-card" getQuarter
}, } from "@/core";
import { DynamicDateCard, DynamicDateParamItem, DynamicDateHelper } from "../dynamicdate";
render: function () { import { Label, Bubbles } from "@/base";
var self = this;
@shortcut()
export class DynamicYearQuarterCard extends Widget {
static xtype = "bi.dynamic_year_quarter_card";
props = { baseCls: "bi-year-quarter-card" };
static EVENT_CHANGE = "EVENT_CHANGE";
render() {
return { return {
type: "bi.vertical", type: VerticalLayout.xtype,
items: [{ items: [
type: "bi.label", {
text: BI.i18nText("BI-Multi_Date_Relative_Current_Time"), type: Label.xtype,
textAlign: "left", text: i18nText("BI-Multi_Date_Relative_Current_Time"),
height: BI.SIZE_CONSANTS.LIST_ITEM_HEIGHT, textAlign: "left",
}, { height: BI.SIZE_CONSANTS.LIST_ITEM_HEIGHT,
type: "bi.vertical",
ref: function (_ref) {
self.wrapper = _ref;
}, },
items: [{ {
el: { type: VerticalLayout.xtype,
type: "bi.dynamic_date_param_item", ref: _ref => {
validationChecker: BI.bind(self._checkDate, self), this.wrapper = _ref;
ref: function () {
self.year = this;
},
listeners: [{
eventName: "EVENT_CHANGE",
action: function () {
self.fireEvent("EVENT_CHANGE");
}
}, {
eventName: "EVENT_INPUT_CHANGE",
action: function () {
BI.Bubbles.hide("dynamic-year-quarter-error");
}
}]
},
bgap: 10
}, {
type: "bi.dynamic_date_param_item",
dateType: BI.DynamicDateCard.TYPE.QUARTER,
ref: function () {
self.quarter = this;
}, },
listeners: [{ items: [
eventName: "EVENT_CHANGE", {
action: function () { el: {
self.fireEvent("EVENT_CHANGE"); type: DynamicDateParamItem.xtype,
} validationChecker: bind(this._checkDate, this),
}, { ref: _ref => {
eventName: "EVENT_INPUT_CHANGE", this.year = _ref;
action: function () { },
BI.Bubbles.hide("dynamic-year-quarter-error"); listeners: [
{
eventName: "EVENT_CHANGE",
action: () => {
this.fireEvent("EVENT_CHANGE");
},
},
{
eventName: "EVENT_INPUT_CHANGE",
action: () => {
Bubbles.hide(
"dynamic-year-quarter-error"
);
},
}
],
},
bgap: 10,
},
{
type: DynamicDateParamItem.xtype,
dateType: DynamicDateCard.TYPE.QUARTER,
ref: _ref => {
this.quarter = _ref;
},
listeners: [
{
eventName: "EVENT_CHANGE",
action: () => {
this.fireEvent("EVENT_CHANGE");
},
},
{
eventName: "EVENT_INPUT_CHANGE",
action: () => {
Bubbles.hide(
"dynamic-year-quarter-error"
);
},
}
],
} }
}] ],
}] }
}], ],
vgap: 10, vgap: 10,
hgap: 10 hgap: 10,
}; };
}, }
_getErrorText: function () { _getErrorText() {
var o = this.options; const o = this.options;
var start = BI.parseDateTime(o.min, "%Y-%X-%d"); const start = parseDateTime(o.min, "%Y-%X-%d");
var end = BI.parseDateTime(o.max, "%Y-%X-%d"); const end = parseDateTime(o.max, "%Y-%X-%d");
return BI.i18nText("BI-Basic_Year_Quarter_Range_Error",
return i18nText(
"BI-Basic_Year_Quarter_Range_Error",
start.getFullYear(), start.getFullYear(),
BI.getQuarter(start), getQuarter(start),
end.getFullYear(), end.getFullYear(),
BI.getQuarter(end) getQuarter(end)
); );
}, }
_checkDate: function (obj) { _checkDate(obj) {
var o = this.options; const o = this.options;
var date = BI.DynamicDateHelper.getCalculation(BI.extend(this._getValue(), this._digestDateTypeValue(obj))); const date = DynamicDateHelper.getCalculation(
extend(this._getValue(), this._digestDateTypeValue(obj))
);
return !BI.checkDateVoid(date.getFullYear(), date.getMonth() + 1, date.getDate(), o.min, o.max)[0]; return !checkDateVoid(
}, date.getFullYear(),
date.getMonth() + 1,
date.getDate(),
o.min,
o.max
)[0];
}
_digestDateTypeValue: function (value) { _digestDateTypeValue(value) {
var valueMap = {}; const valueMap = {};
switch (value.dateType) { switch (value.dateType) {
case BI.DynamicDateCard.TYPE.YEAR: case DynamicDateCard.TYPE.YEAR:
valueMap.year = (value.offset === 0 ? -value.value : +value.value); valueMap.year =
break; value.offset === 0 ? -value.value : +value.value;
case BI.DynamicDateCard.TYPE.QUARTER: break;
valueMap.quarter = (value.offset === 0 ? -value.value : +value.value); case DynamicDateCard.TYPE.QUARTER:
break; valueMap.quarter =
default: value.offset === 0 ? -value.value : +value.value;
break; break;
default:
break;
} }
return valueMap; return valueMap;
}, }
_createValue: function (type, v) { _createValue(type, v) {
return { return {
dateType: type, dateType: type,
value: Math.abs(v), value: Math.abs(v),
offset: v > 0 ? 1 : 0 offset: v > 0 ? 1 : 0,
}; };
}, }
setMinDate: function(minDate) { setMinDate(minDate) {
if (BI.isNotEmptyString(this.options.min)) { if (isNotEmptyString(this.options.min)) {
this.options.min = minDate; this.options.min = minDate;
} }
}, }
setMaxDate: function (maxDate) { setMaxDate(maxDate) {
if (BI.isNotEmptyString(this.options.max)) { if (isNotEmptyString(this.options.max)) {
this.options.max = maxDate; this.options.max = maxDate;
} }
}, }
setValue: function (v) { setValue(v) {
v = v || {year: 0, quarter: 0}; v = v || { year: 0, quarter: 0 };
this.year.setValue(this._createValue(BI.DynamicDateCard.TYPE.YEAR, v.year)); this.year.setValue(
this.quarter.setValue(this._createValue(BI.DynamicDateCard.TYPE.QUARTER, v.quarter)); this._createValue(DynamicDateCard.TYPE.YEAR, v.year)
}, );
this.quarter.setValue(
this._createValue(DynamicDateCard.TYPE.QUARTER, v.quarter)
);
}
_getValue: function () { _getValue() {
var year = this.year.getValue(); const year = this.year.getValue();
var quarter = this.quarter.getValue(); const quarter = this.quarter.getValue();
return { return {
year: (year.offset === 0 ? -year.value : year.value), year: year.offset === 0 ? -year.value : year.value,
quarter: (quarter.offset === 0 ? -quarter.value : quarter.value) quarter: quarter.offset === 0 ? -quarter.value : quarter.value,
}; };
}, }
getInputValue: function () { getInputValue() {
return this._getValue(); return this._getValue();
}, }
getValue: function () { getValue() {
return this.checkValidation() ? this._getValue() : {}; return this.checkValidation() ? this._getValue() : {};
}, }
checkValidation: function (show) { checkValidation(show) {
var errorText; let errorText;
var yearInvalid = !this.year.checkValidation(); const yearInvalid = !this.year.checkValidation();
var quarterInvalid = !this.quarter.checkValidation(); const quarterInvalid = !this.quarter.checkValidation();
var invalid = yearInvalid || quarterInvalid; let invalid = yearInvalid || quarterInvalid;
if (invalid) { if (invalid) {
errorText = BI.i18nText("BI-Please_Input_Natural_Number"); errorText = i18nText("BI-Please_Input_Natural_Number");
} else { } else {
invalid = !this._checkDate(this._getValue()); invalid = !this._checkDate(this._getValue());
errorText = this._getErrorText(); errorText = this._getErrorText();
} }
invalid && show && BI.Bubbles.show("dynamic-year-quarter-error", errorText, this.wrapper); invalid &&
show &&
Bubbles.show(
"dynamic-year-quarter-error",
errorText,
this.wrapper
);
return !invalid; return !invalid;
}, }
}); }
BI.DynamicYearQuarterCard.EVENT_CHANGE = "EVENT_CHANGE";
BI.shortcut("bi.dynamic_year_quarter_card", BI.DynamicYearQuarterCard);

260
src/widget/yearquarter/card.static.yearquarter.js
Unescape View File

@ -1,152 +1,190 @@
BI.StaticYearQuarterCard = BI.inherit(BI.Widget, { import {
shortcut,
Widget,
map,
extend,
VerticalLayout,
parseDateTime,
parseInt,
each,
checkDateVoid,
getDate,
getQuarterName,
getQuarter
} from "@/core";
import { TextItem, ButtonGroup } from "@/base";
import { YearPicker } from "../date/calendar";
props: { @shortcut()
baseCls: "bi-static-year-quarter-card", export class StaticYearQuarterCard extends Widget {
behaviors: {} static xtype = "bi.static_year_quarter_card";
},
_createQuarter: function () { props = { baseCls: "bi-static-year-quarter-card", behaviors: {} };
var self = this;
var items = [{ static EVENT_CHANGE = "EVENT_CHANGE";
text: BI.getQuarterName(1),
value: 1 _createQuarter() {
}, { const items = [
text: BI.getQuarterName(2), {
value: 2 text: getQuarterName(1),
}, { value: 1,
text: BI.getQuarterName(3), },
value: 3 {
}, { text: getQuarterName(2),
text: BI.getQuarterName(4), value: 2,
value: 4 },
}]; {
return BI.map(items, function (j, item) { text: getQuarterName(3),
return BI.extend(item, { value: 3,
type: "bi.text_item", },
cls: "bi-border-radius bi-list-item-select", {
textAlign: "center", text: getQuarterName(4),
whiteSpace: "nowrap", value: 4,
once: false, }
forceSelected: true, ];
height: BI.SIZE_CONSANTS.TOOL_BAR_HEIGHT,
ref: function (_ref) { return map(items, (j, item) => extend(item, {
self.quarterMap[j + 1] = _ref; type: TextItem.xtype,
} cls: "bi-border-radius bi-list-item-select",
}); textAlign: "center",
}); whiteSpace: "nowrap",
}, once: false,
forceSelected: true,
height: BI.SIZE_CONSANTS.TOOL_BAR_HEIGHT,
ref: _ref => {
this.quarterMap[j + 1] = _ref;
},
}));
}
render: function () { render() {
var self = this, o = this.options; const o = this.options;
this.quarterMap = {}; this.quarterMap = {};
return { return {
type: "bi.vertical", type: VerticalLayout.xtype,
items: [{ items: [
type: "bi.year_picker", {
cls: "bi-split-bottom", type: YearPicker.xtype,
ref: function () { cls: "bi-split-bottom",
self.yearPicker = this; ref: _ref => {
}, this.yearPicker = _ref;
min: o.min,
max: o.max,
behaviors: o.behaviors,
height: 30,
listeners: [{
eventName: BI.YearPicker.EVENT_CHANGE,
action: function () {
var value = this.getValue();
self._checkQuarterStatus(value);
self.setValue({
year: value,
quarter: self.selectedQuarter
});
}
}]
}, {
el: {
type: "bi.button_group",
behaviors: o.behaviors,
ref: function () {
self.quarter = this;
}, },
items: this._createQuarter(), min: o.min,
layouts: [{ max: o.max,
type: "bi.vertical", behaviors: o.behaviors,
vgap: 10, height: 30,
hgap: 12, listeners: [
}], {
value: o.value, eventName: YearPicker.EVENT_CHANGE,
listeners: [{ action: () => {
eventName: BI.ButtonGroup.EVENT_CHANGE, const value = this.yearPicker.getValue();
action: function () { this._checkQuarterStatus(value);
self.selectedYear = self.yearPicker.getValue(); this.setValue({
self.selectedQuarter = this.getValue()[0]; year: value,
self.fireEvent(BI.StaticYearQuarterCard.EVENT_CHANGE); quarter: this.selectedQuarter,
});
},
} }
}] ],
}, },
vgap: 5 {
}] el: {
type: ButtonGroup.xtype,
behaviors: o.behaviors,
ref: _ref => {
this.quarter = _ref;
},
items: this._createQuarter(),
layouts: [
{
type: VerticalLayout.xtype,
vgap: 10,
hgap: 12,
}
],
value: o.value,
listeners: [
{
eventName: ButtonGroup.EVENT_CHANGE,
action: () => {
this.selectedYear =
this.yearPicker.getValue();
this.selectedQuarter = this.quarter.getValue()[0];
this.fireEvent(
StaticYearQuarterCard.EVENT_CHANGE
);
},
}
],
},
vgap: 5,
}
],
}; };
}, }
_checkQuarterStatus: function (year) { _checkQuarterStatus(year) {
var o = this.options; const o = this.options;
var minDate = BI.parseDateTime(o.min, "%Y-%X-%d"), maxDate = BI.parseDateTime(o.max, "%Y-%X-%d"); const minDate = parseDateTime(o.min, "%Y-%X-%d"),
var minYear = minDate.getFullYear(), maxYear = maxDate.getFullYear(); maxDate = parseDateTime(o.max, "%Y-%X-%d");
var minQuarter = 1; var maxQuarter = 4; const minYear = minDate.getFullYear(),
minYear === year && (minQuarter = BI.parseInt(BI.getQuarter(minDate))); maxYear = maxDate.getFullYear();
maxYear === year && (maxQuarter = BI.parseInt(BI.getQuarter(maxDate))); let minQuarter = 1;
var yearInvalid = year < minYear || year > maxYear; let maxQuarter = 4;
BI.each(this.quarterMap, function (quarter, obj) { minYear === year && (minQuarter = parseInt(getQuarter(minDate)));
var quarterInvalid = quarter < minQuarter || quarter > maxQuarter; maxYear === year && (maxQuarter = parseInt(getQuarter(maxDate)));
const yearInvalid = year < minYear || year > maxYear;
each(this.quarterMap, (quarter, obj) => {
const quarterInvalid = quarter < minQuarter || quarter > maxQuarter;
obj.setEnable(!yearInvalid && !quarterInvalid); obj.setEnable(!yearInvalid && !quarterInvalid);
}); });
}, }
setMinDate: function (minDate) { setMinDate(minDate) {
if (this.options.min !== minDate) { if (this.options.min !== minDate) {
this.options.min = minDate; this.options.min = minDate;
this.yearPicker.setMinDate(minDate); this.yearPicker.setMinDate(minDate);
this._checkQuarterStatus(this.selectedYear); this._checkQuarterStatus(this.selectedYear);
} }
}, }
setMaxDate: function (maxDate) { setMaxDate(maxDate) {
if (this.options.max !== maxDate) { if (this.options.max !== maxDate) {
this.options.max = maxDate; this.options.max = maxDate;
this.yearPicker.setMaxDate(maxDate); this.yearPicker.setMaxDate(maxDate);
this._checkQuarterStatus(this.selectedYear); this._checkQuarterStatus(this.selectedYear);
} }
}, }
getValue: function () { getValue() {
return { return {
year: this.selectedYear, year: this.selectedYear,
quarter: this.selectedQuarter quarter: this.selectedQuarter,
}; };
}, }
setValue: function (obj) { setValue(obj) {
var o = this.options; const o = this.options;
var newObj = {}; const newObj = {};
newObj.year = obj.year || 0; newObj.year = obj.year || 0;
newObj.quarter = obj.quarter || 0; newObj.quarter = obj.quarter || 0;
if (newObj.quarter === 0 || newObj.year === 0 || BI.checkDateVoid(newObj.year, newObj.quarter, 1, o.min, o.max)[0]) { if (
var year = newObj.year || BI.getDate().getFullYear(); newObj.quarter === 0 ||
newObj.year === 0 ||
checkDateVoid(newObj.year, newObj.quarter, 1, o.min, o.max)[0]
) {
const year = newObj.year || getDate().getFullYear();
this.selectedYear = year; this.selectedYear = year;
this.selectedQuarter = ""; this.selectedQuarter = "";
this.yearPicker.setValue(year); this.yearPicker.setValue(year);
this.quarter.setValue(); this.quarter.setValue();
} else { } else {
this.selectedYear = BI.parseInt(newObj.year); this.selectedYear = parseInt(newObj.year);
this.selectedQuarter = BI.parseInt(newObj.quarter); this.selectedQuarter = parseInt(newObj.quarter);
this.yearPicker.setValue(this.selectedYear); this.yearPicker.setValue(this.selectedYear);
this.quarter.setValue(this.selectedQuarter); this.quarter.setValue(this.selectedQuarter);
} }
this._checkQuarterStatus(this.selectedYear); this._checkQuarterStatus(this.selectedYear);
} }
}); }
BI.StaticYearQuarterCard.EVENT_CHANGE = "EVENT_CHANGE";
BI.shortcut("bi.static_year_quarter_card", BI.StaticYearQuarterCard);

345
src/widget/yearquarter/combo.yearquarter.js
Unescape View File

@ -1,72 +1,102 @@
BI.DynamicYearQuarterCombo = BI.inherit(BI.Widget, { import {
shortcut,
Widget,
createWidget,
toPix,
isEqual,
isNotEmptyString,
getDate,
AbsoluteLayout,
HorizontalFillLayout,
isNotNull,
isNotEmptyObject,
checkDateVoid,
getQuarter
} from "@/core";
import { DynamicYearQuarterTrigger } from "./trigger.yearquarter";
// TODO:需要等待yearmonth完成才能将BI.DynamicYearMonthTrigger替换
// import { DynamicYearMonthCombo } from "../yearmonth/combo.yearmonth";
import { DynamicYearQuarterPopup } from "./popup.yearquarter";
import { DynamicDateCombo } from "../dynamicdate";
import { Combo, IconButton } from "@/base";
_consts: { @shortcut()
iconWidth: 24 export class DynamicYearQuarterCombo extends Widget {
}, static xtype = "bi.dynamic_year_quarter_combo";
props: {
_consts = { iconWidth: 24 };
props = {
baseCls: "bi-year-quarter-combo", baseCls: "bi-year-quarter-combo",
behaviors: {}, behaviors: {},
minDate: "1900-01-01", // 最小日期 minDate: "1900-01-01",
maxDate: "2099-12-31", // 最大日期 maxDate: "2099-12-31",
height: 24, height: 24,
supportDynamic: true, supportDynamic: true,
isNeedAdjustHeight: false, isNeedAdjustHeight: false,
isNeedAdjustWidth: false isNeedAdjustWidth: false,
}, };
static EVENT_CONFIRM = "EVENT_CONFIRM";
static EVENT_BEFORE_POPUPVIEW = "EVENT_BEFORE_POPUPVIEW";
static EVENT_ERROR = "EVENT_ERROR";
static EVENT_VALID = "EVENT_VALID";
static EVENT_FOCUS = "EVENT_FOCUS";
static Static = 1;
static Dynamic = 2;
_init: function () { _init() {
var self = this, o = this.options; const o = this.options;
BI.DynamicYearQuarterCombo.superclass._init.apply(this, arguments); super._init(...arguments);
this.storeValue = o.value; this.storeValue = o.value;
var border = o.simple ? 1 : 2; const border = o.simple ? 1 : 2;
self.storeTriggerValue = ""; this.storeTriggerValue = "";
this.trigger = BI.createWidget({ this.trigger = createWidget({
type: "bi.dynamic_year_quarter_trigger", type: "bi.dynamic_year_quarter_trigger",
simple: o.simple, simple: o.simple,
min: o.minDate, min: o.minDate,
max: o.maxDate, max: o.maxDate,
height: BI.toPix(o.height, border), height: toPix(o.height, border),
value: o.value || "", value: o.value || "",
watermark: o.watermark, watermark: o.watermark,
}); });
this.trigger.on(BI.DynamicYearQuarterTrigger.EVENT_KEY_DOWN, function () { this.trigger.on(DynamicYearQuarterTrigger.EVENT_KEY_DOWN, () => {
self.combo.isViewVisible() && self.combo.hideView(); this.combo.isViewVisible() && this.combo.hideView();
}); });
this.trigger.on(BI.DynamicYearQuarterTrigger.EVENT_START, function () { this.trigger.on(DynamicYearQuarterTrigger.EVENT_START, () => {
self.combo.isViewVisible() && self.combo.hideView(); this.combo.isViewVisible() && this.combo.hideView();
}); });
this.trigger.on(BI.DynamicYearQuarterTrigger.EVENT_STOP, function () { this.trigger.on(DynamicYearQuarterTrigger.EVENT_STOP, () => {
self.combo.showView(); this.combo.showView();
}); });
this.trigger.on(BI.DynamicYearQuarterTrigger.EVENT_ERROR, function () { this.trigger.on(DynamicYearQuarterTrigger.EVENT_ERROR, () => {
self.combo.isViewVisible() && self.combo.hideView(); this.combo.isViewVisible() && this.combo.hideView();
self.comboWrapper.element.addClass("error"); this.comboWrapper.element.addClass("error");
self.fireEvent(BI.DynamicYearQuarterCombo.EVENT_ERROR); this.fireEvent(DynamicYearQuarterCombo.EVENT_ERROR);
}); });
this.trigger.on(BI.DynamicYearQuarterTrigger.EVENT_VALID, function () { this.trigger.on(DynamicYearQuarterTrigger.EVENT_VALID, () => {
self.comboWrapper.element.removeClass("error"); this.comboWrapper.element.removeClass("error");
self.fireEvent(BI.DynamicYearMonthCombo.EVENT_VALID); this.fireEvent(BI.DynamicYearMonthCombo.EVENT_VALID);
}); });
this.trigger.on(BI.DynamicYearQuarterTrigger.EVENT_CONFIRM, function () { this.trigger.on(DynamicYearQuarterTrigger.EVENT_CONFIRM, () => {
var dateStore = self.storeTriggerValue; const dateStore = this.storeTriggerValue;
var dateObj = self.trigger.getKey(); const dateObj = this.trigger.getKey();
if (BI.isEqual(dateObj, dateStore)) { if (isEqual(dateObj, dateStore)) {
return; return;
} }
if (BI.isNotEmptyString(dateObj) && !BI.isEqual(dateObj, dateStore)) { if (isNotEmptyString(dateObj) && !isEqual(dateObj, dateStore)) {
self.storeValue = self.trigger.getValue(); this.storeValue = this.trigger.getValue();
self.setValue(self.trigger.getValue()); this.setValue(this.trigger.getValue());
} }
self._checkDynamicValue(self.storeValue); this._checkDynamicValue(this.storeValue);
self.fireEvent(BI.DynamicYearQuarterCombo.EVENT_CONFIRM); this.fireEvent(DynamicYearQuarterCombo.EVENT_CONFIRM);
}); });
this.trigger.on(BI.DynamicYearQuarterTrigger.EVENT_FOCUS, function () { this.trigger.on(DynamicYearQuarterTrigger.EVENT_FOCUS, () => {
self.storeTriggerValue = self.trigger.getKey(); this.storeTriggerValue = this.trigger.getKey();
self.fireEvent(BI.DynamicYearQuarterCombo.EVENT_FOCUS); this.fireEvent(DynamicYearQuarterCombo.EVENT_FOCUS);
}); });
this.combo = BI.createWidget({ this.combo = createWidget({
type: "bi.combo", type: Combo.xtype,
container: o.container, container: o.container,
isNeedAdjustHeight: o.isNeedAdjustHeight, isNeedAdjustHeight: o.isNeedAdjustHeight,
isNeedAdjustWidth: o.isNeedAdjustWidth, isNeedAdjustWidth: o.isNeedAdjustWidth,
@ -80,172 +110,185 @@ BI.DynamicYearQuarterCombo = BI.inherit(BI.Widget, {
type: "bi.dynamic_year_quarter_popup", type: "bi.dynamic_year_quarter_popup",
width: o.isNeedAdjustWidth ? o.width : undefined, width: o.isNeedAdjustWidth ? o.width : undefined,
supportDynamic: o.supportDynamic, supportDynamic: o.supportDynamic,
ref: function () { ref: _ref => {
self.popup = this; this.popup = _ref;
}, },
listeners: [ listeners: [
{ {
eventName: BI.DynamicYearQuarterPopup.EVENT_CHANGE, eventName: DynamicYearQuarterPopup.EVENT_CHANGE,
action: function () { action: () => {
self.setValue(self.popup.getValue()); this.setValue(this.popup.getValue());
self.combo.hideView(); this.combo.hideView();
self.fireEvent(BI.DynamicYearQuarterCombo.EVENT_CONFIRM); this.fireEvent(
} DynamicYearQuarterCombo.EVENT_CONFIRM
}, { );
eventName: BI.DynamicYearQuarterPopup.BUTTON_CLEAR_EVENT_CHANGE, },
action: function () { },
self.setValue(); {
self.comboWrapper.element.removeClass("error"); eventName:
self.combo.hideView(); DynamicYearQuarterPopup.BUTTON_CLEAR_EVENT_CHANGE,
self.fireEvent(BI.DynamicYearQuarterCombo.EVENT_CONFIRM); action: () => {
} this.setValue();
}, { this.comboWrapper.element.removeClass("error");
eventName: BI.DynamicYearQuarterPopup.BUTTON_lABEL_EVENT_CHANGE, this.combo.hideView();
action: function () { this.fireEvent(
var date = BI.getDate(); DynamicYearQuarterCombo.EVENT_CONFIRM
self.setValue({ );
},
},
{
eventName:
DynamicYearQuarterPopup.BUTTON_lABEL_EVENT_CHANGE,
action: () => {
const date = getDate();
this.setValue({
type: BI.DynamicYearMonthCombo.Static, type: BI.DynamicYearMonthCombo.Static,
value: { year: date.getFullYear(), quarter: BI.getQuarter(date) } value: {
year: date.getFullYear(),
quarter: getQuarter(date),
},
}); });
self.combo.hideView(); this.combo.hideView();
self.fireEvent(BI.DynamicDateCombo.EVENT_CONFIRM); this.fireEvent(DynamicDateCombo.EVENT_CONFIRM);
} },
}, { },
eventName: BI.DynamicYearQuarterPopup.BUTTON_OK_EVENT_CHANGE, {
action: function () { eventName:
var value = self.popup.getValue(); DynamicYearQuarterPopup.BUTTON_OK_EVENT_CHANGE,
if (self._checkValue(value)) { action: () => {
self.setValue(value); const value = this.popup.getValue();
if (this._checkValue(value)) {
this.setValue(value);
} }
self.combo.hideView(); this.combo.hideView();
self.fireEvent(BI.DynamicDateCombo.EVENT_CONFIRM); this.fireEvent(DynamicDateCombo.EVENT_CONFIRM);
} },
} }
], ],
behaviors: o.behaviors, behaviors: o.behaviors,
min: o.minDate, min: o.minDate,
max: o.maxDate max: o.maxDate,
}, },
value: o.value || "" value: o.value || "",
} },
}); });
this.combo.on(BI.Combo.EVENT_BEFORE_POPUPVIEW, function () { this.combo.on(Combo.EVENT_BEFORE_POPUPVIEW, () => {
self.popup.setMinDate(o.minDate); this.popup.setMinDate(o.minDate);
self.popup.setMaxDate(o.maxDate); this.popup.setMaxDate(o.maxDate);
self.popup.setValue(self.storeValue); this.popup.setValue(this.storeValue);
self.fireEvent(BI.DynamicYearQuarterCombo.EVENT_BEFORE_POPUPVIEW); this.fireEvent(DynamicYearQuarterCombo.EVENT_BEFORE_POPUPVIEW);
}); });
BI.createWidget({ createWidget({
type: "bi.absolute", type: AbsoluteLayout.xtype,
element: this, element: this,
items: [ items: [
{ {
el: { el: {
type: "bi.horizontal_fill", type: HorizontalFillLayout.xtype,
columnSize: ["", "fill"], columnSize: ["", "fill"],
cls: (o.simple ? "bi-border-bottom" : "bi-border bi-border-radius") + " bi-focus-shadow", cls:
ref: function () { `${o.simple
self.comboWrapper = this; ? "bi-border-bottom"
: "bi-border bi-border-radius"
} bi-focus-shadow`,
ref: _ref => {
this.comboWrapper = _ref;
}, },
items: [ items: [
{ {
el: { el: {
type: "bi.icon_button", type: IconButton.xtype,
cls: "bi-trigger-icon-button date-change-h-font", cls: "bi-trigger-icon-button date-change-h-font",
width: this._consts.iconWidth, width: this._consts.iconWidth,
height: BI.toPix(o.height, border), height: toPix(o.height, border),
ref: function () { ref: _ref => {
self.changeIcon = this; this.changeIcon = _ref;
} },
} },
}, this.combo },
] this.combo
],
}, },
top: 0, top: 0,
left: 0, left: 0,
right: 0, right: 0,
bottom: 0 bottom: 0,
} }
] ],
}); });
this._checkDynamicValue(o.value); this._checkDynamicValue(o.value);
}, }
_checkDynamicValue: function (v) { _checkDynamicValue(v) {
var type = null; let type = null;
if (BI.isNotNull(v)) { if (isNotNull(v)) {
type = v.type; type = v.type;
} }
switch (type) { switch (type) {
case BI.DynamicYearQuarterCombo.Dynamic: case DynamicYearQuarterCombo.Dynamic:
this.changeIcon.setVisible(true); this.changeIcon.setVisible(true);
break; break;
default: default:
this.changeIcon.setVisible(false); this.changeIcon.setVisible(false);
break; break;
} }
}, }
_checkValue: function (v) { _checkValue(v) {
var o = this.options; const o = this.options;
let value;
switch (v.type) { switch (v.type) {
case BI.DynamicDateCombo.Dynamic: case DynamicDateCombo.Dynamic:
return BI.isNotEmptyObject(v.value); return isNotEmptyObject(v.value);
case BI.DynamicDateCombo.Static: case DynamicDateCombo.Static:
var value = v.value || {}; value = v.value || {};
return !BI.checkDateVoid(value.year, (value.quarter - 1) * 3 + 1, 1, o.minDate, o.maxDate)[0]; return !checkDateVoid(
default: value.year,
return true; (value.quarter - 1) * 3 + 1,
1,
o.minDate,
o.maxDate
)[0];
default:
return true;
} }
}, }
setMinDate: function (minDate) { setMinDate(minDate) {
var o = this.options; const o = this.options;
o.minDate = minDate; o.minDate = minDate;
this.trigger.setMinDate(minDate); this.trigger.setMinDate(minDate);
this.popup && this.popup.setMinDate(minDate); this.popup && this.popup.setMinDate(minDate);
}, }
setMaxDate: function (maxDate) { setMaxDate(maxDate) {
var o = this.options; const o = this.options;
o.maxDate = maxDate; o.maxDate = maxDate;
this.trigger.setMaxDate(maxDate); this.trigger.setMaxDate(maxDate);
this.popup && this.popup.setMaxDate(maxDate); this.popup && this.popup.setMaxDate(maxDate);
}, }
hideView: function () { hideView() {
this.combo.hideView(); this.combo.hideView();
}, }
getKey: function () { getKey() {
return this.trigger.getKey(); return this.trigger.getKey();
}, }
setValue: function (v) { setValue(v) {
this.storeValue = v; this.storeValue = v;
this.trigger.setValue(v); this.trigger.setValue(v);
this._checkDynamicValue(v); this._checkDynamicValue(v);
}, }
getValue: function () { getValue() {
return this.storeValue; return this.storeValue;
}, }
isStateValid: function () { isStateValid() {
return this.trigger.isStateValid(); return this.trigger.isStateValid();
} }
}
});
BI.DynamicYearQuarterCombo.EVENT_CONFIRM = "EVENT_CONFIRM";
BI.DynamicYearQuarterCombo.EVENT_BEFORE_POPUPVIEW = "EVENT_BEFORE_POPUPVIEW";
BI.DynamicYearQuarterCombo.EVENT_ERROR = "EVENT_ERROR";
BI.DynamicYearQuarterCombo.EVENT_VALID = "EVENT_VALID";
BI.DynamicYearQuarterCombo.EVENT_FOCUS = "EVENT_FOCUS";
BI.shortcut("bi.dynamic_year_quarter_combo", BI.DynamicYearQuarterCombo);
BI.extend(BI.DynamicYearQuarterCombo, {
Static: 1,
Dynamic: 2
});

6
src/widget/yearquarter/index.js
Unescape View File

@ -0,0 +1,6 @@
export { DynamicYearQuarterCard } from "./card.dynamic.yearquarter";
export { StaticYearQuarterCard } from "./card.static.yearquarter";
export { DynamicYearQuarterCombo } from "./combo.yearquarter";
export { DynamicYearQuarterPopup } from "./popup.yearquarter";
export { DynamicYearQuarterTrigger } from "./trigger.yearquarter";

437
src/widget/yearquarter/popup.yearquarter.js
Unescape View File

@ -1,235 +1,328 @@
BI.DynamicYearQuarterPopup = BI.inherit(BI.Widget, { import {
constants: { shortcut,
tabHeight: 40, Widget,
buttonHeight: 24 toPix,
}, i18nText,
VerticalLayout,
GridLayout,
print,
getDate,
checkDateVoid,
createItems,
getQuarter
} from "@/core";
import { DynamicYearQuarterCombo } from "./combo.yearquarter";
import { TextButton, Tab } from "@/base";
import { DynamicDateCombo, DynamicDatePopup, DynamicDateHelper } from "../dynamicdate";
// TODO:需要等待year完成才能将BI.DynamicYearCard替换
// import { DynamicYearCard } from "../year/card.dynamic.year";
import { LinearSegment } from "@/case";
import { DynamicYearQuarterCard } from "./card.dynamic.yearquarter";
import { StaticYearQuarterCard } from "./card.static.yearquarter";
props: { @shortcut()
export class DynamicYearQuarterPopup extends Widget {
static xtype = "bi.dynamic_year_quarter_popup";
constants = { tabHeight: 40, buttonHeight: 24 };
props = {
baseCls: "bi-year-quarter-popup", baseCls: "bi-year-quarter-popup",
behaviors: {}, behaviors: {},
min: "1900-01-01", // 最小日期 min: "1900-01-01",
max: "2099-12-31", // 最大日期, max: "2099-12-31",
width: 180, width: 180,
supportDynamic: true, supportDynamic: true,
}, };
static BUTTON_CLEAR_EVENT_CHANGE = "BUTTON_CLEAR_EVENT_CHANGE";
static BUTTON_lABEL_EVENT_CHANGE = "BUTTON_lABEL_EVENT_CHANGE";
static BUTTON_OK_EVENT_CHANGE = "BUTTON_OK_EVENT_CHANGE";
static EVENT_CHANGE = "EVENT_CHANGE";
render: function () { render() {
var self = this, opts = this.options, c = this.constants; this.storeValue = { type: DynamicYearQuarterCombo.Static };
this.storeValue = {type: BI.DynamicYearQuarterCombo.Static};
return { return {
type: "bi.vertical", type: VerticalLayout.xtype,
items: [{ items: [
el: this._getTabJson() {
}, { el: this._getTabJson(),
el: {
type: "bi.grid",
items: [[{
type: "bi.text_button",
cls: "bi-split-top bi-high-light",
shadow: true,
textHeight: BI.toPix(BI.SIZE_CONSANTS.TOOL_BAR_HEIGHT, 1),
text: BI.i18nText("BI-Basic_Clear"),
listeners: [{
eventName: BI.TextButton.EVENT_CHANGE,
action: function () {
self.fireEvent(BI.DynamicYearQuarterPopup.BUTTON_CLEAR_EVENT_CHANGE);
}
}]
}, {
type: "bi.text_button",
cls: "bi-split-left bi-split-right bi-high-light bi-split-top",
textHeight: BI.toPix(BI.SIZE_CONSANTS.TOOL_BAR_HEIGHT, 1),
shadow: true,
text: BI.i18nText("BI-Basic_Current_Quarter"),
disabled: this._checkTodayValid(),
ref: function () {
self.textButton = this;
},
listeners: [{
eventName: BI.TextButton.EVENT_CHANGE,
action: function () {
self.fireEvent(BI.DynamicYearQuarterPopup.BUTTON_lABEL_EVENT_CHANGE);
}
}]
}, {
type: "bi.text_button",
cls: "bi-split-top bi-high-light",
shadow: true,
textHeight: BI.toPix(BI.SIZE_CONSANTS.TOOL_BAR_HEIGHT, 1),
text: BI.i18nText("BI-Basic_OK"),
listeners: [{
eventName: BI.TextButton.EVENT_CHANGE,
action: function () {
var type = self.dateTab.getSelect();
if (type === BI.DynamicDateCombo.Dynamic) {
self.dynamicPane.checkValidation(true) && self.fireEvent(BI.DynamicDatePopup.BUTTON_OK_EVENT_CHANGE);
} else {
self.fireEvent(BI.DynamicYearQuarterPopup.BUTTON_OK_EVENT_CHANGE);
}
}
}]
}]],
height: BI.SIZE_CONSANTS.TOOL_BAR_HEIGHT
}, },
}] {
el: {
type: GridLayout.xtype,
items: [
[
{
type: TextButton.xtype,
cls: "bi-split-top bi-high-light",
shadow: true,
textHeight: toPix(
BI.SIZE_CONSANTS.TOOL_BAR_HEIGHT,
1
),
text: i18nText("BI-Basic_Clear"),
listeners: [
{
eventName: TextButton.EVENT_CHANGE,
action: () => {
this.fireEvent(
DynamicYearQuarterPopup.BUTTON_CLEAR_EVENT_CHANGE
);
},
}
],
},
{
type: TextButton.xtype,
cls: "bi-split-left bi-split-right bi-high-light bi-split-top",
textHeight: toPix(
BI.SIZE_CONSANTS.TOOL_BAR_HEIGHT,
1
),
shadow: true,
text: i18nText("BI-Basic_Current_Quarter"),
disabled: this._checkTodayValid(),
ref: _ref => {
this.textButton = _ref;
},
listeners: [
{
eventName: TextButton.EVENT_CHANGE,
action: () => {
this.fireEvent(
DynamicYearQuarterPopup.BUTTON_lABEL_EVENT_CHANGE
);
},
}
],
},
{
type: TextButton.xtype,
cls: "bi-split-top bi-high-light",
shadow: true,
textHeight: toPix(
BI.SIZE_CONSANTS.TOOL_BAR_HEIGHT,
1
),
text: i18nText("BI-Basic_OK"),
listeners: [
{
eventName: TextButton.EVENT_CHANGE,
action: () => {
const type =
this.dateTab.getSelect();
if (
type ===
DynamicDateCombo.Dynamic
) {
this.dynamicPane.checkValidation(
true
) &&
this.fireEvent(
DynamicDatePopup.BUTTON_OK_EVENT_CHANGE
);
} else {
this.fireEvent(DynamicYearQuarterPopup
.BUTTON_OK_EVENT_CHANGE
);
}
},
}
],
}
]
],
height: BI.SIZE_CONSANTS.TOOL_BAR_HEIGHT,
},
}
],
}; };
}, }
_setInnerValue: function () { _setInnerValue() {
if (this.dateTab.getSelect() === BI.DynamicYearQuarterCombo.Static) { if (this.dateTab.getSelect() === DynamicYearQuarterCombo.Static) {
this.textButton.setValue(BI.i18nText("BI-Basic_Current_Quarter")); this.textButton.setValue(i18nText("BI-Basic_Current_Quarter"));
this.textButton.setEnable(!this._checkTodayValid()); this.textButton.setEnable(!this._checkTodayValid());
} else { } else {
var date = BI.DynamicDateHelper.getCalculation(this.dynamicPane.getInputValue()); let date = DynamicDateHelper.getCalculation(
date = BI.print(date, "%Y-%Q"); this.dynamicPane.getInputValue()
);
date = print(date, "%Y-%Q");
this.textButton.setValue(date); this.textButton.setValue(date);
this.textButton.setEnable(false); this.textButton.setEnable(false);
} }
}, }
_checkTodayValid: function () { _checkTodayValid() {
var o = this.options; const o = this.options;
var today = BI.getDate(); const today = getDate();
return !!BI.checkDateVoid(today.getFullYear(), today.getMonth() + 1, today.getDate(), o.min, o.max)[0];
}, return !!checkDateVoid(
today.getFullYear(),
today.getMonth() + 1,
today.getDate(),
o.min,
o.max
)[0];
}
_getTabJson: function () { _getTabJson() {
var self = this, o = this.options; const o = this.options;
return { return {
type: "bi.tab", type: Tab.xtype,
logic: { logic: {
dynamic: true dynamic: true,
}, },
ref: function () { ref: _ref => {
self.dateTab = this; this.dateTab = _ref;
}, },
tab: { tab: {
type: "bi.linear_segment", type: LinearSegment.xtype,
cls: "bi-split-bottom", cls: "bi-split-bottom",
invisible: !o.supportDynamic, invisible: !o.supportDynamic,
height: this.constants.tabHeight, height: this.constants.tabHeight,
items: BI.createItems([{ items: createItems(
text: BI.i18nText("BI-Basic_Year_Quarter"), [
value: BI.DynamicYearQuarterCombo.Static {
}, { text: i18nText("BI-Basic_Year_Quarter"),
text: BI.i18nText("BI-Basic_Dynamic_Title"), value: DynamicYearQuarterCombo.Static,
value: BI.DynamicYearQuarterCombo.Dynamic },
}], { {
textAlign: "center" text: i18nText("BI-Basic_Dynamic_Title"),
}) value: DynamicYearQuarterCombo.Dynamic,
}
],
{
textAlign: "center",
}
),
}, },
cardCreator: function (v) { cardCreator: v => {
switch (v) { switch (v) {
case BI.DynamicYearQuarterCombo.Dynamic: case DynamicYearQuarterCombo.Dynamic:
return { return {
type: "bi.dynamic_year_quarter_card", type: DynamicYearQuarterCard.xtype,
cls: "dynamic-year-quarter-pane", cls: "dynamic-year-quarter-pane",
min: self.options.min, min: this.options.min,
max: self.options.max, max: this.options.max,
listeners: [{ listeners: [
{
eventName: "EVENT_CHANGE", eventName: "EVENT_CHANGE",
action: function () { action: () => {
self._setInnerValue(self.year, v); this._setInnerValue(this.year, v);
} },
}],
ref: function () {
self.dynamicPane = this;
} }
}; ],
case BI.DynamicYearQuarterCombo.Static: ref: _ref => {
default: this.dynamicPane = _ref;
return { },
type: "bi.static_year_quarter_card", };
behaviors: o.behaviors, case DynamicYearQuarterCombo.Static:
min: self.options.min, default:
max: self.options.max, return {
listeners: [{ type: StaticYearQuarterCard.xtype,
behaviors: o.behaviors,
min: this.options.min,
max: this.options.max,
listeners: [
{
eventName: BI.DynamicYearCard.EVENT_CHANGE, eventName: BI.DynamicYearCard.EVENT_CHANGE,
action: function () { action: () => {
self.fireEvent(BI.DynamicYearQuarterPopup.EVENT_CHANGE); this.fireEvent(
} DynamicYearQuarterPopup.EVENT_CHANGE
}], );
ref: function () { },
self.year = this;
} }
}; ],
ref: _ref => {
this.year = _ref;
},
};
} }
}, },
listeners: [{ listeners: [
eventName: BI.Tab.EVENT_CHANGE, {
action: function () { eventName: Tab.EVENT_CHANGE,
var v = self.dateTab.getSelect(); action: () => {
switch (v) { const v = this.dateTab.getSelect();
case BI.DynamicYearQuarterCombo.Static: let date;
var date = BI.DynamicDateHelper.getCalculation(self.dynamicPane.getValue()); switch (v) {
self.year.setValue({year: date.getFullYear(), quarter: BI.getQuarter(date)}); case DynamicYearQuarterCombo.Static:
self._setInnerValue(); date = DynamicDateHelper.getCalculation(
this.dynamicPane.getValue()
);
this.year.setValue({
year: date.getFullYear(),
quarter: getQuarter(date),
});
this._setInnerValue();
break; break;
case BI.DynamicYearQuarterCombo.Dynamic: case DynamicYearQuarterCombo.Dynamic:
default: default:
if(self.storeValue && self.storeValue.type === BI.DynamicYearQuarterCombo.Dynamic) { if (
self.dynamicPane.setValue(self.storeValue.value); this.storeValue &&
}else{ this.storeValue.type ===
self.dynamicPane.setValue({ DynamicYearQuarterCombo.Dynamic
year: 0 ) {
this.dynamicPane.setValue(
this.storeValue.value
);
} else {
this.dynamicPane.setValue({
year: 0,
}); });
} }
self._setInnerValue(); this._setInnerValue();
break; break;
} }
},
} }
}] ],
}; };
}, }
setMinDate: function (minDate) { setMinDate(minDate) {
if (this.options.min !== minDate) { if (this.options.min !== minDate) {
this.options.min = minDate; this.options.min = minDate;
this.year && this.year.setMinDate(minDate); this.year && this.year.setMinDate(minDate);
this.dynamicPane && this.dynamicPane.setMinDate(minDate); this.dynamicPane && this.dynamicPane.setMinDate(minDate);
} }
}, }
setMaxDate: function (maxDate) { setMaxDate(maxDate) {
if (this.options.max !== maxDate) { if (this.options.max !== maxDate) {
this.options.max = maxDate; this.options.max = maxDate;
this.year && this.year.setMaxDate(maxDate); this.year && this.year.setMaxDate(maxDate);
this.dynamicPane && this.dynamicPane.setMaxDate(maxDate); this.dynamicPane && this.dynamicPane.setMaxDate(maxDate);
} }
}, }
setValue: function (v) { setValue(v) {
this.storeValue = v; this.storeValue = v;
var self = this;
var type, value;
v = v || {}; v = v || {};
type = v.type || BI.DynamicDateCombo.Static; const type = v.type || DynamicDateCombo.Static;
value = v.value || v; const value = v.value || v;
this.dateTab.setSelect(type); this.dateTab.setSelect(type);
switch (type) { switch (type) {
case BI.DynamicDateCombo.Dynamic: case DynamicDateCombo.Dynamic:
this.dynamicPane.setValue(value); this.dynamicPane.setValue(value);
self._setInnerValue(); this._setInnerValue();
break; break;
case BI.DynamicDateCombo.Static: case DynamicDateCombo.Static:
default: default:
this.year.setValue(value); this.year.setValue(value);
this.textButton.setValue(BI.i18nText("BI-Basic_Current_Quarter")); this.textButton.setValue(i18nText("BI-Basic_Current_Quarter"));
this.textButton.setEnable(!this._checkTodayValid()); this.textButton.setEnable(!this._checkTodayValid());
break; break;
} }
}, }
getValue: function () { getValue() {
return { return {
type: this.dateTab.getSelect(), type: this.dateTab.getSelect(),
value: this.dateTab.getValue() value: this.dateTab.getValue(),
}; };
} }
}
});
BI.DynamicYearQuarterPopup.BUTTON_CLEAR_EVENT_CHANGE = "BUTTON_CLEAR_EVENT_CHANGE";
BI.DynamicYearQuarterPopup.BUTTON_lABEL_EVENT_CHANGE = "BUTTON_lABEL_EVENT_CHANGE";
BI.DynamicYearQuarterPopup.BUTTON_OK_EVENT_CHANGE = "BUTTON_OK_EVENT_CHANGE";
BI.DynamicYearQuarterPopup.EVENT_CHANGE = "EVENT_CHANGE";
BI.shortcut("bi.dynamic_year_quarter_popup", BI.DynamicYearQuarterPopup);

461
src/widget/yearquarter/trigger.yearquarter.js
Unescape View File

@ -1,277 +1,374 @@
BI.DynamicYearQuarterTrigger = BI.inherit(BI.Trigger, { import {
_const: { shortcut,
hgap: 4, i18nText,
vgap: 2, createWidget,
iconWidth: 24 HTapeLayout,
}, CenterLayout,
HorizontalFillLayout,
isEmptyString,
parseDateTime,
isPositiveInteger,
checkDateVoid,
isNotEmptyString,
isNotNull,
print,
checkDateLegal,
isNull,
parseInt,
getDate,
getQuarter
} from "@/core";
import { Trigger, TextButton } from "@/base";
import { TriggerIconButton, SignEditor } from "@/case";
import { DynamicDateHelper } from "../dynamicdate";
// TODO:需要等待yearmonth完成才能将BI.DynamicYearMonthTrigger替换
// import { DynamicYearMonthTrigger } from "../yearmonth/trigger.yearmonth";
import { DynamicYearQuarterCombo } from "./combo.yearquarter";
props: () => ({ @shortcut()
extraCls: "bi-year-quarter-trigger", export class DynamicYearQuarterTrigger extends Trigger {
min: "1900-01-01", // 最小日期 static xtype = "bi.dynamic_year_quarter_trigger";
max: "2099-12-31", // 最大日期
height: 24,
watermark: {
year: BI.i18nText("BI-Basic_Unrestricted"),
quarter: BI.i18nText("BI-Basic_Unrestricted"),
},
}),
_init: function () { _const = { hgap: 4, vgap: 2, iconWidth: 24 };
BI.DynamicYearQuarterTrigger.superclass._init.apply(this, arguments);
var o = this.options; static EVENT_FOCUS = "EVENT_FOCUS";
static EVENT_ERROR = "EVENT_ERROR";
static EVENT_START = "EVENT_START";
static EVENT_CONFIRM = "EVENT_CONFIRM";
static EVENT_STOP = "EVENT_STOP";
static EVENT_KEY_DOWN = "EVENT_KEY_DOWN";
static EVENT_VALID = "EVENT_VALID";
props() {
return {
extraCls: "bi-year-quarter-trigger",
min: "1900-01-01", // 最小日期
max: "2099-12-31", // 最大日期
height: 24,
watermark: {
year: i18nText("BI-Basic_Unrestricted"),
quarter: i18nText("BI-Basic_Unrestricted"),
},
};
}
_init() {
super._init(...arguments);
const o = this.options;
this.yearEditor = this._createEditor(true); this.yearEditor = this._createEditor(true);
this.quarterEditor = this._createEditor(false); this.quarterEditor = this._createEditor(false);
// 暂时的解决方法 // 暂时的解决方法
var height = o.height + 2; // const height = o.height + 2;
BI.createWidget({ createWidget({
element: this, element: this,
type: "bi.htape", type: HTapeLayout.xtype,
items: [{ items: [
type: "bi.center", {
items: [{ type: CenterLayout.xtype,
type: "bi.horizontal_fill", items: [
columnSize: ["fill", ""], {
items: [this.yearEditor, { type: HorizontalFillLayout.xtype,
el: { columnSize: ["fill", ""],
type: "bi.text_button", items: [
text: BI.i18nText("BI-Multi_Date_Year"), this.yearEditor,
}, {
}] el: {
}, { type: TextButton.xtype,
type: "bi.horizontal_fill", text: i18nText("BI-Multi_Date_Year"),
columnSize: ["fill", ""], },
items: [this.quarterEditor, { }
el: { ],
type: "bi.text_button",
text: BI.i18nText("BI-Multi_Date_Quarter"),
}, },
}] {
}] type: HorizontalFillLayout.xtype,
}, { columnSize: ["fill", ""],
el: { items: [
type: "bi.trigger_icon_button", this.quarterEditor,
width: this._const.iconWidth, {
el: {
type: TextButton.xtype,
text: i18nText("BI-Multi_Date_Quarter"),
},
}
],
}
],
}, },
width: this._const.iconWidth, {
}] el: {
type: TriggerIconButton.xtype,
width: this._const.iconWidth,
},
width: this._const.iconWidth,
}
],
}); });
this.setValue(o.value); this.setValue(o.value);
}, }
_createEditor: function (isYear) { _createEditor(isYear) {
var self = this, o = this.options, c = this._const; const o = this.options,
var editor = BI.createWidget({ c = this._const;
type: "bi.sign_editor", const editor = createWidget({
type: SignEditor.xtype,
simple: o.simple, simple: o.simple,
height: o.height, height: o.height,
validationChecker: function (v) { validationChecker: v => {
if(isYear) { if (isYear) {
var month = self.quarterEditor.getValue(); let month = this.quarterEditor.getValue();
if(BI.isEmptyString(month)) { if (isEmptyString(month)) {
month = parseInt(v, 10) === BI.parseDateTime(o.min, "%Y-%X-%d").getFullYear() ? BI.parseDateTime(o.min, "%Y-%X-%d").getMonth() + 1 : 1; month =
parseInt(v, 10) ===
parseDateTime(o.min, "%Y-%X-%d").getFullYear()
? parseDateTime(o.min, "%Y-%X-%d").getMonth() +
1
: 1;
} else { } else {
month = (parseInt(month, 10) - 1) * 3 + 1; month = (parseInt(month, 10) - 1) * 3 + 1;
} }
return v === "" || (BI.isPositiveInteger(v) && !BI.checkDateVoid(v, month, 1, o.min, o.max)[0]);
return (
v === "" ||
(isPositiveInteger(v) &&
!checkDateVoid(v, month, 1, o.min, o.max)[0])
);
} }
var year = self.yearEditor.getValue(); const year = this.yearEditor.getValue();
return v === "" || ((BI.isPositiveInteger(v) && v >= 1 && v <= 4) && (BI.isEmptyString(year) ? true : !BI.checkDateVoid(self.yearEditor.getValue(), (v - 1) * 3 + 1, 1, o.min, o.max)[0])); return (
}, v === "" ||
quitChecker: function () { (isPositiveInteger(v) &&
return false; v >= 1 &&
v <= 4 &&
(isEmptyString(year)
? true
: !checkDateVoid(
this.yearEditor.getValue(),
(v - 1) * 3 + 1,
1,
o.min,
o.max
)[0]))
);
}, },
errorText: function (v) { quitChecker: () => false,
var year = isYear ? v : self.yearEditor.getValue(); errorText: v => {
var quarter = isYear ? self.quarterEditor.getValue() : v; const year = isYear ? v : this.yearEditor.getValue();
if (!BI.isPositiveInteger(year) || !BI.isPositiveInteger(quarter) || quarter > 4) { const quarter = isYear ? this.quarterEditor.getValue() : v;
return BI.i18nText("BI-Year_Trigger_Invalid_Text"); if (
!isPositiveInteger(year) ||
!isPositiveInteger(quarter) ||
quarter > 4
) {
return i18nText("BI-Year_Trigger_Invalid_Text");
} }
var start = BI.parseDateTime(o.min, "%Y-%X-%d"); const start = parseDateTime(o.min, "%Y-%X-%d");
var end = BI.parseDateTime(o.max, "%Y-%X-%d"); const end = parseDateTime(o.max, "%Y-%X-%d");
return BI.i18nText("BI-Basic_Year_Quarter_Range_Error", return i18nText(
"BI-Basic_Year_Quarter_Range_Error",
start.getFullYear(), start.getFullYear(),
BI.getQuarter(start), getQuarter(start),
end.getFullYear(), end.getFullYear(),
BI.getQuarter(end) getQuarter(end)
); );
}, },
watermark: isYear ? o.watermark?.year : o.watermark?.quarter, watermark: isYear ? o.watermark?.year : o.watermark?.quarter,
hgap: c.hgap, hgap: c.hgap,
vgap: c.vgap, vgap: c.vgap,
allowBlank: true allowBlank: true,
}); });
editor.on(BI.SignEditor.EVENT_KEY_DOWN, function () { editor.on(SignEditor.EVENT_KEY_DOWN, () => {
self.fireEvent(BI.DynamicYearQuarterTrigger.EVENT_KEY_DOWN); this.fireEvent(DynamicYearQuarterTrigger.EVENT_KEY_DOWN);
}); });
editor.on(BI.SignEditor.EVENT_FOCUS, function () { editor.on(SignEditor.EVENT_FOCUS, () => {
self.fireEvent(BI.DynamicYearQuarterTrigger.EVENT_FOCUS); this.fireEvent(DynamicYearQuarterTrigger.EVENT_FOCUS);
}); });
editor.on(BI.SignEditor.EVENT_STOP, function () { editor.on(SignEditor.EVENT_STOP, () => {
self.fireEvent(BI.DynamicYearQuarterTrigger.EVENT_STOP); this.fireEvent(DynamicYearQuarterTrigger.EVENT_STOP);
}); });
editor.on(BI.SignEditor.EVENT_CONFIRM, function () { editor.on(SignEditor.EVENT_CONFIRM, () => {
self._doEditorConfirm(editor); this._doEditorConfirm(editor);
self.fireEvent(BI.DynamicYearQuarterTrigger.EVENT_CONFIRM); this.fireEvent(DynamicYearQuarterTrigger.EVENT_CONFIRM);
}); });
editor.on(BI.SignEditor.EVENT_SPACE, function () { editor.on(SignEditor.EVENT_SPACE, () => {
if (editor.isValid()) { if (editor.isValid()) {
editor.blur(); editor.blur();
} }
}); });
editor.on(BI.SignEditor.EVENT_START, function () { editor.on(SignEditor.EVENT_START, () => {
self.fireEvent(BI.DynamicYearQuarterTrigger.EVENT_START); this.fireEvent(DynamicYearQuarterTrigger.EVENT_START);
}); });
editor.on(BI.SignEditor.EVENT_ERROR, function () { editor.on(SignEditor.EVENT_ERROR, () => {
self.fireEvent(BI.DynamicYearQuarterTrigger.EVENT_ERROR); this.fireEvent(DynamicYearQuarterTrigger.EVENT_ERROR);
}); });
editor.on(BI.SignEditor.EVENT_VALID, function () { editor.on(SignEditor.EVENT_VALID, () => {
var year = self.yearEditor.getValue(); const year = this.yearEditor.getValue();
var quarter = self.quarterEditor.getValue(); const quarter = this.quarterEditor.getValue();
if(BI.isNotEmptyString(year) && BI.isNotEmptyString(quarter)) { if (isNotEmptyString(year) && isNotEmptyString(quarter)) {
if(BI.isPositiveInteger(year) && quarter >= 1 && quarter <= 4 && !BI.checkDateVoid(year, (quarter - 1) * 3 + 1, 1, o.min, o.max)[0]) { if (
self.fireEvent(BI.DynamicYearMonthTrigger.EVENT_VALID); isPositiveInteger(year) &&
quarter >= 1 &&
quarter <= 4 &&
!checkDateVoid(
year,
(quarter - 1) * 3 + 1,
1,
o.min,
o.max
)[0]
) {
this.fireEvent(BI.DynamicYearMonthTrigger.EVENT_VALID);
} }
} }
}); });
editor.on(BI.SignEditor.EVENT_CHANGE, function () { editor.on(SignEditor.EVENT_CHANGE, () => {
if(isYear) { if (isYear) {
self._autoSwitch(editor); this._autoSwitch(editor);
} }
}); });
return editor; return editor;
}, }
_doEditorConfirm: function (editor) { _doEditorConfirm(editor) {
var value = editor.getValue(); const value = editor.getValue();
if (BI.isNotNull(value)) { if (isNotNull(value)) {
editor.setValue(value); editor.setValue(value);
} }
var quarterValue = this.quarterEditor.getValue(); const quarterValue = this.quarterEditor.getValue();
this.storeValue = { this.storeValue = {
type: BI.DynamicYearQuarterCombo.Static, type: DynamicYearQuarterCombo.Static,
value: { value: {
year: this.yearEditor.getValue(), year: this.yearEditor.getValue(),
quarter: BI.isEmptyString(this.quarterEditor.getValue()) ? "" : quarterValue quarter: isEmptyString(this.quarterEditor.getValue())
} ? ""
: quarterValue,
},
}; };
this.setTitle(this._getStaticTitle(this.storeValue.value)); this.setTitle(this._getStaticTitle(this.storeValue.value));
}, }
_yearCheck: function (v) { _yearCheck(v) {
var date = BI.print(BI.parseDateTime(v, "%Y-%X-%d"), "%Y-%X-%d"); const date = print(parseDateTime(v, "%Y-%X-%d"), "%Y-%X-%d");
return BI.print(BI.parseDateTime(v, "%Y"), "%Y") === v && date >= this.options.min && date <= this.options.max;
}, return (
print(parseDateTime(v, "%Y"), "%Y") === v &&
date >= this.options.min &&
date <= this.options.max
);
}
_autoSwitch: function (editor) { _autoSwitch(editor) {
var v = editor.getValue(); const v = editor.getValue();
if (BI.isNotEmptyString(v) && BI.checkDateLegal(v)) { if (isNotEmptyString(v) && checkDateLegal(v)) {
if (v.length === 4 && this._yearCheck(v)) { if (v.length === 4 && this._yearCheck(v)) {
this._doEditorConfirm(editor); this._doEditorConfirm(editor);
this.fireEvent(BI.DynamicYearQuarterTrigger.EVENT_CONFIRM); this.fireEvent(DynamicYearQuarterTrigger.EVENT_CONFIRM);
this.quarterEditor.focus(); this.quarterEditor.focus();
} }
} }
}, }
_getStaticTitle: function (value) { _getStaticTitle(value) {
value = value || {}; value = value || {};
var hasYear = !(BI.isNull(value.year) || BI.isEmptyString(value.year)); const hasYear = !(isNull(value.year) || isEmptyString(value.year));
var hasMonth = !(BI.isNull(value.quarter) || BI.isEmptyString(value.quarter)); const hasMonth = !(isNull(value.quarter) || isEmptyString(value.quarter));
switch ((hasYear << 1) | hasMonth) { switch ((hasYear << 1) | hasMonth) {
// !hasYear && !hasMonth // !hasYear && !hasMonth
case 0: case 0:
return ""; return "";
// !hasYear && hasMonth // !hasYear && hasMonth
case 1: case 1:
return value.quarter; return value.quarter;
// hasYear && !hasMonth // hasYear && !hasMonth
case 2: case 2:
return value.year; return value.year;
// hasYear && hasMonth // hasYear && hasMonth
case 3: case 3:
default: default:
return value.year + "-" + value.quarter; return `${value.year}-${value.quarter}`;
} }
}, }
_getText: function (obj) { _getText(obj) {
var value = ""; let value = "";
if(BI.isNotNull(obj.year) && BI.parseInt(obj.year) !== 0) { if (isNotNull(obj.year) && parseInt(obj.year) !== 0) {
value += Math.abs(obj.year) + BI.i18nText("BI-Basic_Year") + (obj.year < 0 ? BI.i18nText("BI-Basic_Front") : BI.i18nText("BI-Basic_Behind")); value +=
Math.abs(obj.year) +
i18nText("BI-Basic_Year") +
(obj.year < 0
? i18nText("BI-Basic_Front")
: i18nText("BI-Basic_Behind"));
} }
if(BI.isNotNull(obj.quarter) && BI.parseInt(obj.quarter) !== 0) { if (isNotNull(obj.quarter) && parseInt(obj.quarter) !== 0) {
value += Math.abs(obj.quarter) + BI.i18nText("BI-Basic_Single_Quarter") + (obj.quarter < 0 ? BI.i18nText("BI-Basic_Front") : BI.i18nText("BI-Basic_Behind")); value +=
Math.abs(obj.quarter) +
i18nText("BI-Basic_Single_Quarter") +
(obj.quarter < 0
? i18nText("BI-Basic_Front")
: i18nText("BI-Basic_Behind"));
} }
return value; return value;
}, }
_setInnerValue: function (date, text) { _setInnerValue(date, text) {
var dateStr = BI.print(date, "%Y-%Q"); const dateStr = print(date, "%Y-%Q");
this.yearEditor.setValue(date.getFullYear()); this.yearEditor.setValue(date.getFullYear());
this.quarterEditor.setValue(BI.getQuarter(date)); this.quarterEditor.setValue(getQuarter(date));
this.setTitle(BI.isEmptyString(text) ? dateStr : (text + ":" + dateStr)); this.setTitle(isEmptyString(text) ? dateStr : `${text}:${dateStr}`);
}, }
setMinDate: function (minDate) { setMinDate(minDate) {
if (BI.isNotEmptyString(this.options.min)) { if (isNotEmptyString(this.options.min)) {
this.options.min = minDate; this.options.min = minDate;
} }
}, }
setMaxDate: function (maxDate) { setMaxDate(maxDate) {
if (BI.isNotEmptyString(this.options.max)) { if (isNotEmptyString(this.options.max)) {
this.options.max = maxDate; this.options.max = maxDate;
} }
}, }
setValue: function (v) { setValue(v) {
var type, value; let type, value, text, quarter;
var date = BI.getDate(); let date = getDate();
this.storeValue = v; this.storeValue = v;
if (BI.isNotNull(v)) { if (isNotNull(v)) {
type = v.type || BI.DynamicYearQuarterCombo.Static; type = v.type || DynamicYearQuarterCombo.Static;
value = v.value || v; value = v.value || v;
} }
switch (type) { switch (type) {
case BI.DynamicYearQuarterCombo.Dynamic: case DynamicYearQuarterCombo.Dynamic:
var text = this._getText(value); text = this._getText(value);
date = BI.DynamicDateHelper.getCalculation(value); date = DynamicDateHelper.getCalculation(value);
this._setInnerValue(date, text); this._setInnerValue(date, text);
break; break;
case BI.DynamicYearQuarterCombo.Static: case DynamicYearQuarterCombo.Static:
default: default:
value = value || {}; value = value || {};
var quarter = BI.isNull(value.quarter) ? null : value.quarter; quarter = isNull(value.quarter) ? null : value.quarter;
this.yearEditor.setValue(value.year); this.yearEditor.setValue(value.year);
this.quarterEditor.setValue(quarter); this.quarterEditor.setValue(quarter);
this.setTitle(this._getStaticTitle(value)); this.setTitle(this._getStaticTitle(value));
break; break;
} }
}, }
getValue: function () { getValue() {
return this.storeValue; return this.storeValue;
}, }
getKey: function () { getKey() {
return this.yearEditor.getValue() + "-" + this.quarterEditor.getValue(); return `${this.yearEditor.getValue()}-${this.quarterEditor.getValue()}`;
}, }
isStateValid: function () { isStateValid() {
return this.yearEditor.isValid() && this.quarterEditor.isValid(); return this.yearEditor.isValid() && this.quarterEditor.isValid();
} }
}); }
BI.DynamicYearQuarterTrigger.EVENT_FOCUS = "EVENT_FOCUS";
BI.DynamicYearQuarterTrigger.EVENT_ERROR = "EVENT_ERROR";
BI.DynamicYearQuarterTrigger.EVENT_START = "EVENT_START";
BI.DynamicYearQuarterTrigger.EVENT_CONFIRM = "EVENT_CONFIRM";
BI.DynamicYearQuarterTrigger.EVENT_STOP = "EVENT_STOP";
BI.DynamicYearQuarterTrigger.EVENT_KEY_DOWN = "EVENT_KEY_DOWN";
BI.DynamicYearQuarterTrigger.EVENT_VALID = "EVENT_VALID";
BI.shortcut("bi.dynamic_year_quarter_trigger", BI.DynamicYearQuarterTrigger);

315
src/widget/yearquarterinterval/yearquarterinterval.js
Unescape View File

@ -1,193 +1,248 @@
/** import {
* @author windy shortcut,
* @version 2.0 HorizontalFillLayout,
* Created by windy on 2021/1/25 createWidget,
*/ i18nText,
BI.YearQuarterInterval = BI.inherit(BI.Single, { print,
constants: { parseDateTime,
checkDateVoid,
isNotNull,
checkDateLegal
} from "@/core";
import { Single, Label, Bubbles } from "@/base";
import { DynamicYearQuarterCombo } from "../yearquarter";
@shortcut()
export class YearQuarterInterval extends Single {
static xtype = "bi.year_quarter_interval";
constants = {
height: 24, height: 24,
width: 25, width: 25,
lgap: 15, lgap: 15,
offset: -15, offset: -15,
timeErrorCls: "time-error" timeErrorCls: "time-error",
}, };
props = {
props: {
extraCls: "bi-year-quarter-interval", extraCls: "bi-year-quarter-interval",
minDate: "1900-01-01", minDate: "1900-01-01",
maxDate: "2099-12-31", maxDate: "2099-12-31",
supportDynamic: true, supportDynamic: true,
}, };
static EVENT_VALID = "EVENT_VALID";
static EVENT_ERROR = "EVENT_ERROR";
static EVENT_CHANGE = "EVENT_CHANGE";
static EVENT_BEFORE_POPUPVIEW = "EVENT_BEFORE_POPUPVIEW";
render: function () { render() {
var self = this, o = this.options; const o = this.options;
o.value = o.value || {}; o.value = o.value || {};
this.left = this._createCombo(o.value.start, o.watermark?.start); this.left = this._createCombo(o.value.start, o.watermark?.start);
this.right = this._createCombo(o.value.end, o.watermark?.end); this.right = this._createCombo(o.value.end, o.watermark?.end);
return { return {
type: "bi.horizontal_fill", type: HorizontalFillLayout.xtype,
columnSize: ["fill", "", "fill"], columnSize: ["fill", "", "fill"],
items: [{ items: [
el: self.left {
}, { el: this.left,
el: { },
type: "bi.label", {
height: o.height, el: {
hgap: 5, type: Label.xtype,
text: "-", height: o.height,
ref: function (_ref) { hgap: 5,
self.label = _ref; text: "-",
} ref: _ref => {
this.label = _ref;
},
},
},
{
el: this.right,
} }
}, { ],
el: self.right
}]
}; };
}, }
_createCombo: function (v, watermark) { _createCombo(v, watermark) {
var self = this, o = this.options; const o = this.options;
var combo = BI.createWidget({ const combo = createWidget({
type: "bi.dynamic_year_quarter_combo", type: DynamicYearQuarterCombo.xtype,
supportDynamic: o.supportDynamic, supportDynamic: o.supportDynamic,
minDate: o.minDate, minDate: o.minDate,
maxDate: o.maxDate, maxDate: o.maxDate,
behaviors: o.behaviors, behaviors: o.behaviors,
value: v, value: v,
height: o.height, height: o.height,
watermark: watermark, watermark,
listeners: [{ listeners: [
eventName: BI.DynamicYearQuarterCombo.EVENT_BEFORE_POPUPVIEW, {
action: function () { eventName: DynamicYearQuarterCombo.EVENT_BEFORE_POPUPVIEW,
self.fireEvent(BI.YearQuarterInterval.EVENT_BEFORE_POPUPVIEW); action: () => {
this.fireEvent(
YearQuarterInterval.EVENT_BEFORE_POPUPVIEW
);
},
} }
}] ],
}); });
combo.on(BI.DynamicYearQuarterCombo.EVENT_ERROR, function () { combo.on(DynamicYearQuarterCombo.EVENT_ERROR, () => {
self._clearTitle(); this._clearTitle();
BI.Bubbles.hide("error"); Bubbles.hide("error");
self.element.removeClass(self.constants.timeErrorCls); this.element.removeClass(this.constants.timeErrorCls);
self.fireEvent(BI.YearQuarterInterval.EVENT_ERROR); this.fireEvent(YearQuarterInterval.EVENT_ERROR);
}); });
combo.on(BI.DynamicYearQuarterCombo.EVENT_VALID, function () { combo.on(DynamicYearQuarterCombo.EVENT_VALID, () => {
self._checkValid(); this._checkValid();
}); });
combo.on(BI.DynamicYearQuarterCombo.EVENT_FOCUS, function () { combo.on(DynamicYearQuarterCombo.EVENT_FOCUS, () => {
self._checkValid(); this._checkValid();
}); });
combo.on(BI.DynamicYearQuarterCombo.EVENT_CONFIRM, function () { combo.on(DynamicYearQuarterCombo.EVENT_CONFIRM, () => {
BI.Bubbles.hide("error"); Bubbles.hide("error");
var smallDate = self.left.getKey(), bigDate = self.right.getKey(); const smallDate = this.left.getKey(),
if (self.left.isStateValid() && self.right.isStateValid() && self._check(smallDate, bigDate) && self._compare(smallDate, bigDate)) { bigDate = this.right.getKey();
self._setTitle(BI.i18nText("BI-Time_Interval_Error_Text")); if (
self.element.addClass(self.constants.timeErrorCls); this.left.isStateValid() &&
self.fireEvent(BI.YearQuarterInterval.EVENT_ERROR); this.right.isStateValid() &&
}else{ this._check(smallDate, bigDate) &&
self._clearTitle(); this._compare(smallDate, bigDate)
self.element.removeClass(self.constants.timeErrorCls); ) {
self.fireEvent(BI.YearQuarterInterval.EVENT_CHANGE); this._setTitle(i18nText("BI-Time_Interval_Error_Text"));
this.element.addClass(this.constants.timeErrorCls);
this.fireEvent(YearQuarterInterval.EVENT_ERROR);
} else {
this._clearTitle();
this.element.removeClass(this.constants.timeErrorCls);
this.fireEvent(YearQuarterInterval.EVENT_CHANGE);
} }
}); });
return combo; return combo;
}, }
_dateCheck: function (date) {
return BI.print(BI.parseDateTime(date, "%Y-%Q"), "%Y-%Q") === date || BI.print(BI.parseDateTime(date, "%Y-%q"), "%Y-%q") === date;
},
_dateCheck(date) {
return (
print(parseDateTime(date, "%Y-%Q"), "%Y-%Q") === date ||
print(parseDateTime(date, "%Y-%q"), "%Y-%q") === date
);
}
// 判是否在最大最小之间 _checkVoid(obj) {
_checkVoid: function (obj) { const o = this.options;
var o = this.options;
return !BI.checkDateVoid(obj.year, (obj.quarter - 1) * 3 + 1, 1, o.minDate, o.maxDate)[0]; return !checkDateVoid(
}, obj.year,
(obj.quarter - 1) * 3 + 1,
1,
o.minDate,
o.maxDate
)[0];
}
// 判格式合法 _check(smallDate, bigDate) {
_check: function (smallDate, bigDate) { const smallObj = smallDate.match(/\d+/g),
var smallObj = smallDate.match(/\d+/g), bigObj = bigDate.match(/\d+/g); bigObj = bigDate.match(/\d+/g);
var smallDate4Check = ""; let smallDate4Check = "";
if (BI.isNotNull(smallObj)) { if (isNotNull(smallObj)) {
smallDate4Check = (smallObj[0] || "") + "-" + (smallObj[1] || 1); smallDate4Check = `${smallObj[0] || ""}-${smallObj[1] || 1}`;
} }
var bigDate4Check = ""; let bigDate4Check = "";
if (BI.isNotNull(bigObj)) { if (isNotNull(bigObj)) {
bigDate4Check = (bigObj[0] || "") + "-" + (bigObj[1] || 1); bigDate4Check = `${bigObj[0] || ""}-${bigObj[1] || 1}`;
} }
return this._dateCheck(smallDate4Check) && BI.checkDateLegal(smallDate4Check) && this._checkVoid({ return (
year: smallObj[0], this._dateCheck(smallDate4Check) &&
quarter: smallObj[1] || 1 checkDateLegal(smallDate4Check) &&
}) && this._dateCheck(bigDate4Check) && BI.checkDateLegal(bigDate4Check) && this._checkVoid({ this._checkVoid({
year: bigObj[0], year: smallObj[0],
quarter: bigObj[1] || 1 quarter: smallObj[1] || 1,
}); }) &&
}, this._dateCheck(bigDate4Check) &&
checkDateLegal(bigDate4Check) &&
_compare: function (smallDate, bigDate) { this._checkVoid({
smallDate = BI.print(BI.parseDateTime(smallDate, "%Y-%Q"), "%Y-%Q"); year: bigObj[0],
bigDate = BI.print(BI.parseDateTime(bigDate, "%Y-%Q"), "%Y-%Q"); quarter: bigObj[1] || 1,
return BI.isNotNull(smallDate) && BI.isNotNull(bigDate) && smallDate > bigDate; })
}, );
_setTitle: function (v) { }
_compare(smallDate, bigDate) {
smallDate = print(parseDateTime(smallDate, "%Y-%Q"), "%Y-%Q");
bigDate = print(parseDateTime(bigDate, "%Y-%Q"), "%Y-%Q");
return (
isNotNull(smallDate) && isNotNull(bigDate) && smallDate > bigDate
);
}
_setTitle(v) {
this.setTitle(v); this.setTitle(v);
}, }
_clearTitle: function () {
_clearTitle() {
this.setTitle(""); this.setTitle("");
}, }
_checkValid: function () {
var self = this; _checkValid() {
Bubbles.hide("error");
BI.Bubbles.hide("error"); const smallDate = this.left.getKey(),
var smallDate = self.left.getKey(), bigDate = self.right.getKey(); bigDate = this.right.getKey();
if (self.left.isValid() && self.right.isValid() && self._check(smallDate, bigDate) && self._compare(smallDate, bigDate)) { if (
self._setTitle(BI.i18nText("BI-Time_Interval_Error_Text")); this.left.isValid() &&
self.element.addClass(self.constants.timeErrorCls); this.right.isValid() &&
BI.Bubbles.show("error", BI.i18nText("BI-Time_Interval_Error_Text"), self, { this._check(smallDate, bigDate) &&
offsetStyle: "center" this._compare(smallDate, bigDate)
}); ) {
self.fireEvent(BI.YearQuarterInterval.EVENT_ERROR); this._setTitle(i18nText("BI-Time_Interval_Error_Text"));
this.element.addClass(this.constants.timeErrorCls);
Bubbles.show(
"error",
i18nText("BI-Time_Interval_Error_Text"),
this,
{
offsetStyle: "center",
}
);
this.fireEvent(YearQuarterInterval.EVENT_ERROR);
} else { } else {
self._clearTitle(); this._clearTitle();
self.element.removeClass(self.constants.timeErrorCls); this.element.removeClass(this.constants.timeErrorCls);
} }
}, }
setMinDate: function (minDate) { setMinDate(minDate) {
var o = this.options; const o = this.options;
o.minDate = minDate; o.minDate = minDate;
this.left.setMinDate(minDate); this.left.setMinDate(minDate);
this.right.setMinDate(minDate); this.right.setMinDate(minDate);
}, }
setMaxDate: function (maxDate) { setMaxDate(maxDate) {
var o = this.options; const o = this.options;
o.maxDate = maxDate; o.maxDate = maxDate;
this.left.setMaxDate(maxDate); this.left.setMaxDate(maxDate);
this.right.setMaxDate(maxDate); this.right.setMaxDate(maxDate);
}, }
setValue: function (date) { setValue(date) {
date = date || {}; date = date || {};
this.left.setValue(date.start); this.left.setValue(date.start);
this.right.setValue(date.end); this.right.setValue(date.end);
this._checkValid(); this._checkValid();
},
getValue: function () {
return {start: this.left.getValue(), end: this.right.getValue()};
} }
});
BI.YearQuarterInterval.EVENT_VALID = "EVENT_VALID"; getValue() {
BI.YearQuarterInterval.EVENT_ERROR = "EVENT_ERROR"; return { start: this.left.getValue(), end: this.right.getValue() };
BI.YearQuarterInterval.EVENT_CHANGE = "EVENT_CHANGE"; }
BI.YearQuarterInterval.EVENT_BEFORE_POPUPVIEW = "EVENT_BEFORE_POPUPVIEW"; }
BI.shortcut("bi.year_quarter_interval", BI.YearQuarterInterval);

Write Preview
Loading…
Cancel
Save