core-cde
Version:
575 lines • 20.2 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DataColumnRemovedArg = exports.DataColumnAddedArg = exports.DataRowRemovedArg = exports.DataRowAddedArg = exports.DataTable = void 0;
const tslib_1 = require("tslib");
const StateChanger_module_1 = require("../../stateChanger/StateChanger.module");
const Events_module_1 = require("../../events/Events.module");
const DM = (0, tslib_1.__importStar)(require("../Data.module"));
class DataTable {
/**
* Конструктор. Не предназначен для использования внешним кодом.
* Следует использовать DataTable.createNew(), DataSet.addTable()
*/
constructor() {
this._sheetId = -1;
this._onDataRowAdded = new Events_module_1.EventDispatcher();
this._onDataRowRemoved = new Events_module_1.EventDispatcher();
this._onDataColumnAdded = new Events_module_1.EventDispatcher();
this._onDataColumnRemoved = new Events_module_1.EventDispatcher();
this.id = StateChanger_module_1.UUID.get();
this._hashCode = ++DataTable._hashCounter;
this._columns = new DM.DataColumnCollection(this);
this._rows = new DM.DataRowCollection(this);
}
get hashCode() {
return this._hashCode;
}
get onDataRowAdded() {
return this._onDataRowAdded;
}
get onDataRowRemoved() {
return this._onDataRowRemoved;
}
get onDataColumnAdded() {
return this._onDataColumnAdded;
}
get onDataColumnRemoved() {
return this._onDataColumnRemoved;
}
static createNew(dataSet, uniqueName, id) {
const res = new DataTable();
res.id = id;
res._uniqueName = uniqueName;
res.setDataSet(dataSet);
return res;
}
static fromJSON(json) {
if (typeof json === 'string') {
return DataTable.fromJSON(JSON.parse(json));
}
else {
const columns = DM.DataColumnCollection.fromJSON(json.columns);
const rows = DM.DataRowCollection.fromJSON(json.rows, columns);
const uniqueName = json.uniqueName;
const dataTable = new DataTable();
const assign = Object.assign(dataTable, null, {
_columns: columns,
_rows: rows,
_uniqueName: uniqueName,
id: json.id
});
assign._columns._table = assign;
assign._rows._table = assign;
for (let i = 0; i < assign._rows.count; i++) {
assign._rows.get(i)._table = assign;
}
return assign;
}
}
toJSON() {
return Object.assign({}, null, {
rows: this._rows.toJSON(),
columns: this._columns.toJSON(),
uniqueName: this._uniqueName,
id: this.id
});
}
onDataSetValuesUpdated(e) {
try {
const vals = new Array();
// tslint:disable-next-line: prefer-for-of
for (let i = 0; i < e.values.length; i++) {
const item = e.values[i];
if (item.sheet === this._sheetId) {
vals.push(item);
}
}
if (vals.length === 0) {
return;
}
// tslint:disable-next-line: prefer-for-of
for (let i = 0; i < vals.length; i++) {
const row = vals[i].row;
const col = vals[i].col;
if (this._rows.get(row).sheetItems === undefined) {
let ff = 0;
ff++;
}
this._rows.get(row).sheetItems[col] = vals[i].newValue;
}
}
catch (err) {
console.log(err);
}
}
/**
* Возвращает объект набора данных, к которому принадлежит таблица
*/
get dataSet() {
return this._ds;
}
/**
* Возвращает уникальное имя таблицы
*/
get uniqueName() {
return this._uniqueName;
}
/**
* Задает уникальное имя таблицы
*/
set uniqueName(value) {
if (typeof value === 'undefined' || value === null) {
throw new Error('Имя таблицы должно быть определено');
}
if (this._uniqueName !== value) {
if (this._ds !== null) {
const t = this._ds.getTableByName(value);
if (t !== undefined && t !== this) {
throw new Error(`Таблица с именем ${value} уже существует`);
}
}
this._uniqueName = value;
if (this._ds !== null) {
this._ds.hf.renameSheet(this.sheetId, value);
}
}
}
/**
* Задает значение идентификатора листа в HyperFormula
*/
get sheetId() {
return this._sheetId;
}
/**
* Возвращает значение идентификатора листа в HyperFormula
*/
set sheetId(value) {
if (this._sheetId !== value) {
this._sheetId = value;
}
}
// TODO удалить, заглушка
get columns() {
return this._columns.toArray();
}
get columnCollection() {
return this._columns;
}
get rowCollection() {
return this._rows;
}
/**
* Возвращает количество колонок
*/
get columnsCount() {
return this._columns.count;
}
/**
* Возвращает объект колонки
* @param index Индекс колонки
*/
getColumnByIndex(index) {
return this._columns.get(index);
}
/**
* Возвращает колонку по имени. Если не найдено - возвращает undefined
*/
getColumnByName(columnName) {
return this._columns.getByName(columnName);
}
/**
* Вставляет колонку в таблицу в указанной позиции
* @param index Индекс по которому будет вставлена колонка
* @param columnName Имя колонки
* @param dataType Тип данных. По умолчанию - string
*/
insertColumn(index, columnName, dataType = DM.DataType.String, values) {
const column = DM.DataColumn.createNew(columnName, dataType);
this._columns.insert(index, column);
if (values !== undefined && values !== null) {
this._ds.hf.batch(() => {
for (let i = 0; i < values.length; i++) {
this.setCellValue(i, index, values[i]);
}
});
}
this.raiseDataColumnAdded(column);
return column;
}
/**
* Добавляет колонку в таблицу
* @param columnName Имя колонки
* @param dataType Тип данных. По умолчанию - string
*/
addColumn(columnName, dataType = DM.DataType.String) {
const column = DM.DataColumn.createNew(columnName, dataType);
this._columns.add(column);
this.raiseDataColumnAdded(column);
return column;
}
changeTypeColumn(column, type) {
if (typeof column === 'string') {
column = this._columns.getByName(column);
}
if (typeof column === 'number') {
column = this._columns.get(column);
}
column.dataType = type;
switch (type) {
case DM.DataType.Select: {
this._columns.set(column.index, Object.assign(new DM.DataColumnSelect(), column));
break;
}
default:
this._columns.set(column.index, Object.assign(new DM.DataColumn(), column));
}
return this._columns.get(column.index);
}
/**
* Удаляет колонку и возвращает количество удаленных колонок
*/
removeColumn(column) {
const index = this._columns.getOrdinal(column.name);
if (index === -1) {
return 0;
}
this.dataSet.hf.removeColumns(this._sheetId, [index, 1]);
const res = this._columns.remove(column);
if (res > 0) {
this.raiseDataColumnRemoved(column);
}
return res;
}
/**
* Удаляет колонку по индексу и возвращает количество удаленных колонок
*/
removeColumnByIndex(index) {
const column = this._columns.get(index);
if (typeof column === 'undefined') {
return 0;
}
return this.removeColumn(column);
}
/**
* Удаляет колонку по имени и возвращает количество удаленных колонок
*/
removeColumnByName(columnName) {
const column = this._columns.getByName(columnName);
if (typeof column === 'undefined') {
return 0;
}
return this.removeColumn(column);
}
/**
* Возвращает индекс колонки по имени. Если не найдено - возвращает -1
*/
getColumnOrdinal(columnName) {
return this._columns.getOrdinal(columnName);
}
/**
* Возвращает количество строк в таблице
*/
get rowCount() {
return this._rows.count;
}
/**
* Удаляет все строки таблицы
*/
removeAllRows() {
this._rows.clear();
if (!this.isDataSetEmpty()) {
this.dataSet.hf.setSheetContent(this._uniqueName, []);
}
this.raiseDataRowRemoved(undefined);
}
/**
* Не предназначен для использования внешним кодом
*/
addRowsItem(index) {
for (let i = 0; i < this._rows.count; i++) {
const row = this._rows.get(i);
row.items.splice(index, 0, undefined);
row.sheetItems.splice(index, 0, undefined);
}
}
/**
* Не предназначен для использования внешним кодом
*/
removeRowsItem(index) {
for (let i = 0; i < this._rows.count; i++) {
const row = this._rows.get(i);
row.items.splice(index, 1);
row.sheetItems.splice(index, 1);
}
}
getCellAddress(row, col) {
return { sheet: this.sheetId, row, col };
}
/**
* Возвращает оригинальные значения колонки по индексу. Если не найдено - undefined
*/
getColumnValues(col) {
const column = this._columns.get(col);
if (column === undefined) {
return undefined;
}
const res = new Array();
for (let i = 0; i < this._rows.count; i++) {
res.push({
guidColumn: column.id,
value: this.getRowValues(i)[col],
guidRow: this._rows.get(i).id
});
}
return res;
}
/**
* Возвращает оригинальные значения строки по индексу. Если не найдено - undefined
*/
getRowValues(row) {
const dataRow = this._rows.get(row);
if (dataRow === undefined) {
return undefined;
}
const res = new Array();
for (let i = 0; i < this._columns.count; i++) {
res.push(dataRow.items[i]);
}
return res;
}
getRowValuesTest(row) {
const dataRow = this._rows.get(row);
if (dataRow === undefined) {
return undefined;
}
const res = new Array();
for (let i = 0; i < this._columns.count; i++) {
res.push({
guidColumn: this._columns.get(i).id,
guidRow: dataRow.id,
value: dataRow.items[i]
});
}
return res;
}
/**
* Возвращает значение формулы в ячейке
* @param row индекс строки
* @param col индекс колонки
*/
getCellFormula(row, col) {
return this._ds.hf.getCellFormula(this.getCellAddress(row, col));
}
/**
* Возвращает рассчитанное значение ячейки
* @param row Индекс строки
* @param col Индекс колонки
*/
getCellValue(row, col) {
return this._ds.hf.getCellValue(this.getCellAddress(row, col));
}
/**
* Задает оригинальное значение ячейки
* @param row Индекс строки
* @param col Индекс колонки
* @param value Значение
*/
setCellValue(row, col, value) {
const r = this._rows.get(row);
r.items[col] = value;
r.state = DM.DataRowState.Modified;
if (!this.isDataSetEmpty()) {
this.dataSet.hf.setCellContents({ sheet: this._sheetId, col, row }, [[value]]);
}
}
assignDataRowsToSheet() {
var _a;
if (!this.dataSet) {
return;
}
if (!this.dataSet.hf.isItPossibleToSetCellContents({ sheet: this.sheetId, row: 0, col: 0 })) {
// таблица еще не помещена в HF
return;
}
const values = [];
this.dataSet.hf.suspendEvaluation();
try {
for (let i = 0; i < ((_a = this._rows) === null || _a === void 0 ? void 0 : _a.count); i++) {
values.push(this._rows.get(i).items);
}
this.dataSet.hf.setSheetContent(this.uniqueName, values);
}
finally {
this.dataSet.hf.resumeEvaluation();
}
}
refreshAfterRestore() {
var _a;
if (!this.dataSet) {
return;
}
this.sheetId = this.dataSet.hf.getSheetId(this.uniqueName);
for (let i = 0; i < ((_a = this._rows) === null || _a === void 0 ? void 0 : _a.count); i++) {
this._rows.get(i).sheetItems = this.dataSet.hf.getRangeValues({ sheet: this._sheetId, col: 0, row: i }, this._columns.count, 1)[0];
}
}
getRowIndex(row) {
return this._rows.indexOf(row);
}
/**
* Возвращает коллекцию записей таблицы
*/
getRowCollection() {
return this._rows;
}
/**
* Возвращает расчитанные значения строки по индексу. Если не найдено - undefined
* @param index Индект строки
*/
getRowSheetValues(index) {
const row = this._rows.get(index);
if (row !== undefined) {
return row.sheetItems;
}
return undefined;
}
/**
* Добавить новую запись
*/
addRow(values) {
const res = DM.DataRow.createNew(this, values);
this._rows.add(res);
this.addRowToHyperformula(res, this._rows.count - 1);
this.raiseDataRowAdded(res);
return res;
}
/**
* Вставляет новую запись по указанному индексу
*/
insertRow(index, values) {
const res = DM.DataRow.createNew(this, values);
this._rows.insert(index, res);
this.addRowToHyperformula(res, index);
this.raiseDataRowAdded(res);
return res;
}
addRowToHyperformulaShadow(row, index) {
if (!this.isDataSetEmpty()) {
const address = { sheet: this._sheetId, col: 0, row: index };
const rowValues = this.getRowValues(index);
this.dataSet.hf.addRows(this._sheetId, [index, 1]);
this.dataSet.hf.setCellContents(address, [rowValues]);
}
}
addRowToHyperformula(row, index) {
if (!this.isDataSetEmpty()) {
this.addRowToHyperformulaShadow(row, index);
row.sheetItems = this.dataSet.hf.getRangeValues({ sheet: this._sheetId, col: 0, row: index }, this._columns.count, 1)[0];
}
}
/**
* Удалить запись
*/
removeRow(index) {
const row = this._rows.get(index);
if (row !== undefined) {
const res = this._rows.remove(row);
if (!this.isDataSetEmpty()) {
this.dataSet.hf.removeRows(this._sheetId, [index, 1]);
}
this.raiseDataRowRemoved(row);
return res;
}
return 0;
}
/**
* Возвращает рассчитанные значения таблицы
*/
getSheetValues() {
const res = new Array();
for (let i = 0; i < this._rows.count; i++) {
res.push(this._rows.get(i).sheetItems);
}
return res;
}
/**
* Задает DataSet для таблицы
*/
setDataSet(dataSet) {
if (!dataSet && this._ds) {
this._ds.onValuesUpdated.unregister(this, this.onDataSetValuesUpdated);
}
this._ds = dataSet;
if (this._ds) {
this._ds.onValuesUpdated.register(this, this.onDataSetValuesUpdated);
}
this.assignDataRowsToSheet();
}
/**
* Получить новое имя для колонки
* @param indexColumn Index колонки
* @returns Имя колонки
*/
generationColumnName(indexColumn) {
const colName = `Колонка ${++indexColumn}`;
if (this.getColumnByName(colName)) {
return this.generationColumnName(indexColumn);
}
return colName;
}
// ==== PRIVATE ====
throwIfDataSetIsNull() {
if (this.isDataSetEmpty()) {
throw Error(`Таблица ${this._uniqueName} не содержится в DataSet`);
}
}
isDataSetEmpty() {
if (this._ds === undefined || this._ds === null) {
return true;
}
return false;
}
raiseDataRowAdded(row) {
this.onDataRowAdded.dispatch(new DataRowAddedArg(this, row));
}
raiseDataRowRemoved(row) {
this.onDataRowRemoved.dispatch(new DataRowRemovedArg(this, row));
}
raiseDataColumnAdded(column) {
this.onDataColumnAdded.dispatch(new DataColumnAddedArg(this, column));
}
raiseDataColumnRemoved(column) {
this.onDataColumnRemoved.dispatch(new DataColumnRemovedArg(this, column));
}
}
exports.DataTable = DataTable;
DataTable._hashCounter = 0;
class DataRowAddedArg {
constructor(sender, row) {
this.sender = sender;
this.row = row;
}
}
exports.DataRowAddedArg = DataRowAddedArg;
class DataRowRemovedArg {
constructor(sender, row) {
this.sender = sender;
this.row = row;
}
}
exports.DataRowRemovedArg = DataRowRemovedArg;
class DataColumnAddedArg {
constructor(sender, column) {
this.sender = sender;
this.column = column;
}
}
exports.DataColumnAddedArg = DataColumnAddedArg;
class DataColumnRemovedArg {
constructor(sender, column) {
this.sender = sender;
this.column = column;
}
}
exports.DataColumnRemovedArg = DataColumnRemovedArg;
//# sourceMappingURL=DataTable.js.map