@@ -2615,38 +3182,301 @@ function addFilterRow() {
$newRow.find('.filter-field').html($firstFilterSelect.html());
$filters.append($newRow);
+
+ // Добавляем обработчик изменения поля фильтра
+ $newRow.find('.filter-field').on('change', function() {
+ const fieldname = $(this).val();
+ const fieldInfo = getFieldInfo(fieldname);
+ updateFilterValueField($(this).closest('.filter-row'), fieldInfo);
+ });
}
-// Функция для валидации формы
-function validateUniversalFieldForm() {
- const $modal = $("#universal_fields_modal");
+function getFieldInfo(fieldname) {
+ if (!window.docFields || !fieldname) return null;
+
+ return window.docFields.find(field => field.fieldname === fieldname);
+}
+
+function updateFilterValueField($filterRow, fieldInfo) {
+ const $valueContainer = $filterRow.find('.filter-value-container');
+ const $operator = $filterRow.find('.filter-operator');
+
+ console.log("⚙️ updateFilterValueField вызван для поля:", fieldInfo);
+
+ // Если информация о поле отсутствует, возвращаем обычное текстовое поле
+ if (!fieldInfo) {
+ console.log("❌ Отсутствует информация о поле, использую текстовое поле");
+ $valueContainer.html('
');
+ return;
+ }
+
+ console.log("🔍 Определение типа ввода для поля типа:", fieldInfo.fieldtype);
+
+ // В зависимости от типа поля создаем соответствующий элемент ввода
+ switch (fieldInfo.fieldtype) {
+ case 'Date':
+ console.log("🔍 Обрабатываю поле типа Date");
+ // Получаем target_doctype из основной формы
+ const target_doctype = cur_frm.doc.target_doctype;
+ console.log("🔹 Target DocType для полей даты:", target_doctype);
+
+ if (target_doctype) {
+ // Загружаем поля целевого DocType
+ frappe.model.with_doctype(target_doctype, function() {
+ const targetMeta = frappe.get_meta(target_doctype);
+ if (targetMeta) {
+ // Фильтруем поля даты и специальные поля ay/il
+ const targetDateFields = targetMeta.fields.filter(field =>
+ field.fieldtype === 'Date' ||
+ field.fieldname === 'ay' ||
+ field.fieldname === 'il'
+ );
+ console.log("🔹 Найденные поля Date и ay/il в target_doctype:", targetDateFields);
+
+ // Проверяем, есть ли специальные поля ay и il одновременно
+ const hasAyField = targetDateFields.some(field => field.fieldname === 'ay');
+ const hasIlField = targetDateFields.some(field => field.fieldname === 'il');
+
+ if (targetDateFields.length > 0) {
+ console.log("✅ Создаю селект с полями даты из target_doctype");
+ // Создаем селект с опциями из полей с датой
+ let selectHtml = '
';
+
+ $valueContainer.html(selectHtml);
+
+ // Добавляем обработчик для опции "Указать дату..."
+ $valueContainer.find('.filter-value').on('change', function() {
+ const selectedValue = $(this).val();
+ console.log("🔄 Изменение значения поля даты:", selectedValue);
+
+ if (selectedValue === 'custom') {
+ console.log("🔄 Переключение на ручной ввод даты");
+ $valueContainer.html('
');
+ }
+ else if (selectedValue === 'doc.ay') {
+ console.log("🔄 Выбрано специальное поле месяца (Ay)");
+ // Помечаем в data-атрибуте, что это специальное поле ay
+ $(this).attr('data-is-special-ay-field', 'true');
+ }
+ });
+ } else {
+ console.log("⚠️ Не найдено полей с типом Date в target_doctype, использую стандартный ввод даты");
+ $valueContainer.html('
');
+ }
+ } else {
+ console.log("⚠️ Не удалось получить метаданные target_doctype, использую стандартный ввод даты");
+ $valueContainer.html('
');
+ }
+ });
+ } else {
+ console.log("⚠️ target_doctype не указан, использую стандартный ввод даты");
+ $valueContainer.html('
');
+ }
+ break;
+
+ case 'Datetime':
+ console.log("🔍 Обрабатываю поле типа Datetime");
+ $valueContainer.html('
');
+ break;
+
+ case 'Select':
+ console.log("🔍 Обрабатываю поле типа Select с опциями:", fieldInfo.options);
+ if (fieldInfo.options) {
+ let selectHtml = '
';
+ $valueContainer.html(selectHtml);
+ } else {
+ $valueContainer.html('
');
+ }
+ break;
+
+ case 'Link':
+ console.log("🔍 Обрабатываю поле типа Link с целью:", fieldInfo.options);
+ if (fieldInfo.options) {
+ const targetDoctype = fieldInfo.options;
+ $valueContainer.html(`
+
+
+
+
+ `);
+
+ // Инициализация автодополнения для Link полей
+ initLinkAutocomplete($valueContainer.find('.filter-value'));
+ } else {
+ $valueContainer.html('
');
+ }
+ break;
+
+ case 'Check':
+ console.log("🔍 Обрабатываю поле типа Check");
+ $valueContainer.html(`
+
+ `);
+ break;
+
+ case 'Int':
+ console.log("🔍 Обрабатываю поле типа Int");
+ $valueContainer.html('
');
+ break;
+
+ case 'Float':
+ case 'Currency':
+ console.log("🔍 Обрабатываю числовое поле типа:", fieldInfo.fieldtype);
+ $valueContainer.html('
');
+ break;
+
+ default:
+ console.log("🔍 Обрабатываю поле с типом по умолчанию:", fieldInfo.fieldtype);
+ $valueContainer.html('
');
+ }
+
+ // Обновляем доступные операторы в зависимости от типа поля
+ updateOperators($operator, fieldInfo.fieldtype);
+}
+
+function initLinkAutocomplete($input) {
+ const targetDoctype = $input.data('link-target');
+ if (!targetDoctype) return;
+
+ $input.on('focus', function() {
+ if (!$input.data('initialized')) {
+ $input.data('initialized', true);
+
+ // Загружаем значения из целевого DocType
+ frappe.call({
+ method: "frappe.desk.search.search_link",
+ args: {
+ doctype: targetDoctype,
+ txt: ""
+ },
+ callback: function(r) {
+ if (r.results && r.results.length) {
+ window.linkOptions = r.results.map(item => item.value);
+ }
+ }
+ });
+ }
+ });
+
+ $input.on('input', function() {
+ const searchTerm = $(this).val().toLowerCase();
+ const $dropdown = $(this).siblings('.link-dropdown');
+
+ if (!window.linkOptions || searchTerm.length < 1) {
+ $dropdown.hide();
+ return;
+ }
+
+ // Фильтруем значения по поисковому запросу
+ const filteredOptions = window.linkOptions.filter(
+ option => option.toLowerCase().includes(searchTerm)
+ );
+
+ // Отображаем результаты в выпадающем списке
+ if (filteredOptions.length > 0) {
+ $dropdown.empty();
+ filteredOptions.forEach(option => {
+ $dropdown.append(`
${option}`);
+ });
+ $dropdown.show();
+ } else {
+ $dropdown.hide();
+ }
+ });
+
+ // Обработчик выбора значения из выпадающего списка
+ $(document).on('click', '.link-item', function() {
+ const selectedValue = $(this).text();
+ $(this).closest('.awesomplete').find('.filter-value').val(selectedValue);
+ $(this).closest('.link-dropdown').hide();
+ });
+}
+
+function updateOperators($operator, fieldtype) {
+ $operator.empty();
+
+ // Базовые операторы для всех типов
+ $operator.append('
');
+ $operator.append('
');
+
+ // Дополнительные операторы в зависимости от типа
+ if (['Int', 'Float', 'Currency', 'Date', 'Datetime'].includes(fieldtype)) {
+ $operator.append('
');
+ $operator.append('
');
+ $operator.append('
');
+ $operator.append('
');
+ }
+
+ if (['Data', 'Text', 'Small Text', 'Link', 'Select'].includes(fieldtype)) {
+ $operator.append('
');
+ $operator.append('
');
+ }
+
+ if (['Link', 'Select'].includes(fieldtype)) {
+ $operator.append('
');
+ $operator.append('
');
+ }
+}
+
+function validateUniversalFieldForm($modal) {
const name = $modal.find('#universal_field_name').val().trim();
const doctype = $modal.find('#universal_field_doctype').val();
const fieldname = $modal.find('#universal_field_fieldname').val();
+ // Проверяем, что все обязательные поля заполнены
const isValid = name && doctype && fieldname;
$modal.find('.save-universal-field').prop('disabled', !isValid);
}
-// Функция для сохранения универсального поля
-function saveUniversalField(frm) {
- const $modal = $("#universal_fields_modal");
- const fieldId = $modal.data('editing-field-id') || frappe.utils.get_random(10);
+function saveUniversalField(frm, values, fieldId = null) {
+ const newFieldId = fieldId || frappe.utils.get_random(10);
- const name = $modal.find('#universal_field_name').val().trim();
- const doctype = $modal.find('#universal_field_doctype').val();
- const fieldname = $modal.find('#universal_field_fieldname').val();
- const fieldtype = $modal.find(`#universal_field_fieldname option[value="${fieldname}"]`).data('fieldtype');
-
- // ... остальной код сбора данных ...
-
- // Сохраняем в storage
try {
let universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
// Проверяем, не существует ли уже поле с таким именем (кроме текущего редактируемого)
const existingField = Object.keys(universalFields).find(key =>
- key !== fieldId && universalFields[key].name === name
+ key !== newFieldId && universalFields[key].name === values.name
);
if (existingField) {
@@ -2658,65 +3488,130 @@ function saveUniversalField(frm) {
return;
}
- universalFields[fieldId] = universalField;
+ // Получаем тип поля
+ let fieldtype = '';
+ if (values.doctype && values.fieldname) {
+ const meta = frappe.get_meta(values.doctype);
+ if (meta) {
+ const field = meta.fields.find(f => f.fieldname === values.fieldname);
+ if (field) {
+ fieldtype = field.fieldtype;
+ }
+ }
+ }
+
+ // Проверяем фильтры на наличие специальных полей ay/il
+ if (values.filters && Array.isArray(values.filters)) {
+ values.filters.forEach(filter => {
+ if (typeof filter.value === 'string' && filter.value === 'doc.ay') {
+ filter.__is_special_ay_field = true;
+ console.log("🔹 Обнаружен фильтр с использованием специального поля ay:", filter);
+ }
+ });
+ }
+
+ // Создаем объект универсального поля
+ universalFields[newFieldId] = {
+ name: values.name,
+ doctype: values.doctype,
+ fieldname: values.fieldname,
+ fieldtype: fieldtype,
+ filters: values.filters || []
+ };
+
frm.set_value("universal_fields_storage", JSON.stringify(universalFields));
- // ... остальной код ...
+ frappe.show_alert({
+ message: __('Универсальное поле сохранено'),
+ indicator: 'green'
+ });
+
+ renderUniversalFields(frm);
} catch (error) {
- // ... обработка ошибок ...
+ console.error("Ошибка при сохранении универсального поля:", error);
+ frappe.msgprint({
+ title: __('Ошибка'),
+ message: __('Не удалось сохранить универсальное поле.'),
+ indicator: 'red'
+ });
}
}
-// Функция для заполнения формы при редактировании
-function fillFormForEditing(frm, fieldId) {
+function fillFormForEditing(frm, fieldId, $modal) {
try {
const universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
const field = universalFields[fieldId];
if (!field) {
- console.error("Поле не найдено:", fieldId);
return;
}
- const $modal = $("#universal_fields_modal");
-
// Заполняем базовые поля
$modal.find('#universal_field_name').val(field.name);
$modal.find('#universal_field_doctype').val(field.doctype);
// Загружаем поля выбранного DocType и затем выбираем нужное поле
- loadDoctypeFields(field.doctype).then(() => {
- $modal.find('#universal_field_fieldname').val(field.fieldname);
- $modal.find('.universal-fields-container').show();
- $modal.find('.universal-filter-container').show();
+ loadDoctypeFields(field.doctype);
+
+ // Настраиваем обработчик для загрузки полей doctype
+ const loadFieldsWatcher = setInterval(function() {
+ const $fieldnameSelect = $modal.find('#universal_field_fieldname');
- // Очищаем существующие фильтры
- $modal.find('.universal-filters').empty();
-
- // Добавляем сохраненные фильтры
- if (field.filters && field.filters.length > 0) {
- field.filters.forEach(filter => {
- addFilterRow();
- const $lastRow = $modal.find('.filter-row').last();
- $lastRow.find('.filter-field').val(filter.field);
- $lastRow.find('.filter-operator').val(filter.operator);
- $lastRow.find('.filter-value').val(filter.value);
- });
- } else {
- // Добавляем пустую строку фильтра, если нет сохраненных
- addFilterRow();
+ if ($fieldnameSelect.find('option').length > 1) {
+ clearInterval(loadFieldsWatcher);
+
+ $fieldnameSelect.val(field.fieldname);
+ $modal.find('.universal-fields-container').show();
+ $modal.find('.universal-filter-container').show();
+
+ // Очищаем существующие фильтры
+ $modal.find('.universal-filters').empty();
+
+ // Добавляем сохраненные фильтры
+ if (field.filters && field.filters.length > 0) {
+ field.filters.forEach((filter, index) => {
+ // Добавляем новую строку фильтра
+ if (index > 0) {
+ addFilterRow($modal);
+ }
+
+ const $filterRow = $modal.find('.filter-row').eq(index);
+
+ // Устанавливаем значения фильтра с небольшой задержкой для загрузки полей
+ setTimeout(() => {
+ const $fieldSelect = $filterRow.find('.filter-field');
+ $fieldSelect.val(filter.field);
+
+ // Обновляем поле значения в зависимости от типа поля
+ const fieldInfo = getFieldInfo(filter.field);
+ if (fieldInfo) {
+ updateFilterValueField($filterRow, fieldInfo);
+
+ // Устанавливаем оператор и значение
+ $filterRow.find('.filter-operator').val(filter.operator);
+ $filterRow.find('.filter-value').val(filter.value);
+ }
+ }, 200);
+ });
+ } else {
+ // Добавляем пустую строку фильтра, если нет сохраненных
+ addFilterRow($modal);
+ }
+
+ // Валидируем форму
+ validateUniversalFieldForm($modal);
}
-
- // Валидируем форму
- validateUniversalFieldForm();
- });
+ }, 100);
+
+ // Ограничиваем время ожидания 5 секундами
+ setTimeout(function() {
+ clearInterval(loadFieldsWatcher);
+ }, 5000);
} catch (error) {
- console.error("Ошибка при заполнении формы:", error);
}
}
-// Функция для удаления универсального поля
function deleteUniversalField(frm, fieldId) {
frappe.confirm(
'Вы уверены, что хотите удалить это универсальное поле?',
@@ -2734,7 +3629,6 @@ function deleteUniversalField(frm, fieldId) {
indicator: 'green'
});
} catch (error) {
- console.error("Ошибка при удалении универсального поля:", error);
frappe.msgprint({
title: __('Ошибка'),
message: __('Не удалось удалить универсальное поле.'),
@@ -2745,18 +3639,18 @@ function deleteUniversalField(frm, fieldId) {
);
}
-// Функция для редактирования универсального поля
function editUniversalField(frm, fieldId) {
openUniversalFieldModal(frm, fieldId);
}
-// Исправленная функция transform_expression
-function transform_expression(expression, for_child_table = false, table_name = null, universalFields = {}) {
+// Функция для преобразования выражений формул
+function transform_expression(expression, for_child_table = false, table_name = null) {
console.log("🔄 Исходная формула:", expression, "для табличной части:", for_child_table, "таблица:", table_name);
let transformed = expression;
- // Обрабатываем универсальные поля
+ // Обработка универсальных полей
+ const universalFields = JSON.parse(cur_frm.doc.universal_fields_storage || "{}");
Object.keys(universalFields).forEach(fieldId => {
const field = universalFields[fieldId];
if (!field || !field.name) return;
@@ -2765,15 +3659,335 @@ function transform_expression(expression, for_child_table = false, table_name =
transformed = transformed.replace(pattern, `(frm.doc.__universalFields && frm.doc.__universalFields["${fieldId}"] || 0)`);
});
- // Функция суммирования по табличной части - обрабатываем ее первой
- transformed = transformed.replace(/sum\((\w+)[_]?(\w+)\)/g, (match, tbl, fld) => {
- // Проверяем, содержит ли таблица подчеркивание или нет
- return `(frm.doc["${tbl}"] && frm.doc["${tbl}"].reduce((sum, row) => sum + (parseFloat(row["${fld}"]) || 0), 0) || 0)`;
+ // Получаем список табличных частей из DOM или из предопределенного списка
+ const tablePrefixes = getTablePrefixes();
+
+ // Функция суммирования по табличной части - обрабатываем первой
+ tablePrefixes.forEach(tablePrefix => {
+ const pattern = new RegExp(`sum\\(${tablePrefix}_([^)]+)\\)`, 'g');
+ transformed = transformed.replace(pattern, (match, fieldName) => {
+ return `(frm.doc["${tablePrefix}"] && frm.doc["${tablePrefix}"].reduce((sum, row) => sum + (parseFloat(row["${fieldName}"]) || 0), 0) || 0)`;
+ });
+
+ // Проверяем использование val() для табличных полей (должны использоваться sum())
+ const valTablePattern = new RegExp(`val\\(${tablePrefix}_([^)]+)\\)`, 'g');
+ transformed = transformed.replace(valTablePattern, (match, fieldName) => {
+ console.warn(`⚠️ Использование val() для табличного поля. Заменено на sum(): ${match}`);
+ return `(frm.doc["${tablePrefix}"] && frm.doc["${tablePrefix}"].reduce((sum, row) => sum + (parseFloat(row["${fieldName}"]) || 0), 0) || 0)`;
+ });
});
- // Остальная часть функции без изменений...
- // ...
+ // Если мы трансформируем выражение для табличной части
+ if (for_child_table) {
+ // Заменяем val() на row[] для всех полей внутри табличной части
+ transformed = transformed.replace(/val\(([^)]+)\)/g, (match, field) => {
+ // Проверяем, если имя поля содержит префикс таблицы
+ if (field.startsWith(table_name + '_')) {
+ // Извлекаем имя поля без префикса
+ const actualFieldName = field.substring(table_name.length + 1);
+ return `row["${actualFieldName}"]`;
+ }
+ // Если поле не из текущей таблицы, используем frm.doc
+ return `frm.doc["${field}"]`;
+ });
+
+ // Обрабатываем row() как обычно для табличной части
+ transformed = transformed.replace(/row\(([^)]+)\)/g, (match, field) => {
+ return `row["${field}"]`;
+ });
+ } else {
+ // Стандартная замена для обычных полей
+ transformed = transformed.replace(/val\(([^)]+)\)/g, (match, field) => {
+ return `frm.doc["${field}"]`;
+ });
+
+ // Предупреждение, если row() используется вне таблицы
+ transformed = transformed.replace(/row\(([^)]+)\)/g, (match, field) => {
+ console.warn("⚠️ Функция row() используется вне контекста табличной части");
+ return `0 /* ERROR: row() вне табличной части */`;
+ });
+ }
+
+ // Обработка процентов
+ transformed = transformed.replace(/(frm\.doc\["[^"]+"\]|\d+|row\["[^"]+"\])\s*([+\-])\s*(\d+(\.\d+)?)%/g, (match, base, operator, percent) => {
+ console.log("✅ Обнаружен процент в выражении:", match);
+ return `${base} ${operator} ((${base} * ${percent}) / 100)`;
+ });
console.log("🔄 Трансформированная формула:", transformed);
return transformed;
+}
+
+// Вспомогательная функция для получения доступных префиксов таблиц
+function getTablePrefixes() {
+ // Предопределенный список известных префиксов таблиц
+ const knownPrefixes = ["items", "taxes", "packed_items", "payments", "advances", "timesheets", "payment_schedule", "sales_team", "aksiz_test_table"];
+
+ // Добавляем дополнительные префиксы из текущего DOM, если доступно
+ try {
+ // Ищем таблицы в DOM
+ let domPrefixes = [];
+ $("div.form-section div.form-section-title").each(function() {
+ const sectionTitle = $(this).text().trim();
+ if (sectionTitle && sectionTitle !== "Основные поля") {
+ // Преобразуем название секции в возможный префикс таблицы
+ // Например: "Items (items)" -> "items"
+ const match = sectionTitle.match(/\(([^)]+)\)/);
+ if (match) {
+ domPrefixes.push(match[1]);
+ } else {
+ // Иначе используем название секции, преобразованное в нижний регистр без пробелов
+ domPrefixes.push(sectionTitle.toLowerCase().replace(/\s+/g, '_'));
+ }
+ }
+ });
+
+ // Объединяем найденные префиксы с известными
+ return [...new Set([...knownPrefixes, ...domPrefixes])];
+ } catch (e) {
+ console.warn("⚠️ Ошибка при получении префиксов таблиц из DOM:", e);
+ return knownPrefixes;
+ }
+}
+
+function renderUniversalFields(frm) {
+ const $container = $(frm.wrapper).find('.universal-fields-list');
+ $container.empty();
+
+ try {
+ const universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
+
+ if (Object.keys(universalFields).length === 0) {
+ $container.append('
Нет универсальных полей. Нажмите "Добавить поле" для создания.
');
+ return;
+ }
+
+ Object.keys(universalFields).forEach(fieldId => {
+ const field = universalFields[fieldId];
+
+ const $fieldButton = $(`
+
+
+
+
+
+
+
+ `);
+
+ // Показываем/скрываем кнопки действий при наведении
+ $fieldButton.hover(
+ function() { $(this).find('.field-actions').show(); },
+ function() { $(this).find('.field-actions').hide(); }
+ );
+
+ $container.append($fieldButton);
+ });
+
+ // Инициализируем drag-n-drop для универсальных полей
+ $container.find('.universal-field-btn').each(function() {
+ $(this).attr('draggable', 'true');
+
+ $(this).off('dragstart').on('dragstart', function(e) {
+ const fieldId = $(this).data('field-id');
+ const universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
+ const field = universalFields[fieldId];
+
+ e.originalEvent.dataTransfer.setData('text/plain', JSON.stringify({
+ type: 'universal-field',
+ fieldId: fieldId,
+ name: field.name
+ }));
+ });
+ });
+ } catch (error) {
+ $container.append('
Ошибка при загрузке универсальных полей.
');
+ }
+}
+
+function delete_client_script_for_doctype(doctype) {
+ if (!doctype) {
+ return;
+ }
+
+ frappe.call({
+ method: "frappe.client.get_list",
+ args: {
+ doctype: "Client Script",
+ filters: { dt: doctype },
+ fields: ["name"]
+ },
+ callback: function(r) {
+ if (r.message && r.message.length > 0) {
+ const script_names = r.message.map(script => script.name);
+
+ // Удаляем каждый найденный скрипт
+ script_names.forEach(script_name => {
+ frappe.call({
+ method: "frappe.client.delete",
+ args: {
+ doctype: "Client Script",
+ name: script_name
+ },
+ callback: function(response) {
+ if (response.exc) {
+ } else {
+ }
+ }
+ });
+ });
+ } else {
+ }
+ }
+ });
+}
+
+// Функция для обработки изменения поля в таблице фильтров
+function setupFilterRowHandlers(d) {
+ // Обработчик изменения поля в фильтре
+ d.fields_dict.filters.grid.get_visible_rows().forEach(row => {
+ setupFilterFieldHandler(d, row);
+ });
+}
+
+// Функция для настройки обработчика изменения поля в строке фильтра
+function setupFilterFieldHandler(d, row) {
+ if (!row.doc || row.doc.__processed) return;
+
+ // Отмечаем строку как обработанную
+ row.doc.__processed = true;
+
+ // Находим селект поля и добавляем обработчик
+ $(row.wrapper).find('select[data-fieldname="field"]').on('change', function() {
+ const fieldname = $(this).val();
+ changeFilterValueFieldType(d, row, fieldname);
+ });
+
+ // Обрабатываем текущее значение, если оно уже установлено
+ if (row.doc.field) {
+ changeFilterValueFieldType(d, row, row.doc.field);
+ }
+}
+
+// Функция для изменения типа поля значения в зависимости от выбранного поля
+function changeFilterValueType(grid_row, fieldInfo) {
+ if (!grid_row || !fieldInfo) return;
+
+ // Получаем текущее значение
+ const currentValue = grid_row.doc.value;
+
+ // Определяем новый тип поля в зависимости от типа выбранного поля
+ let fieldtype = 'Data';
+ let options = '';
+
+ switch (fieldInfo.fieldtype) {
+ case 'Select':
+ fieldtype = 'Select';
+ options = fieldInfo.options;
+ break;
+
+ case 'Link':
+ fieldtype = 'Link';
+ options = fieldInfo.options;
+ break;
+
+ case 'Check':
+ fieldtype = 'Check';
+ break;
+
+ case 'Date':
+ fieldtype = 'Date';
+ break;
+
+ case 'Datetime':
+ fieldtype = 'Datetime';
+ break;
+
+ case 'Int':
+ case 'Float':
+ case 'Currency':
+ fieldtype = 'Float';
+ break;
+
+ default:
+ fieldtype = 'Data';
+ }
+
+ // Обновляем определение поля значения
+ grid_row.grid.meta.fields.forEach(field => {
+ if (field.fieldname === 'value') {
+ field.fieldtype = fieldtype;
+ field.options = options;
+ }
+ });
+
+ // Обновляем колонку значений для текущего DocType
+ grid_row.grid.grid_rows.forEach(row => {
+ // Получаем контрол поля значения
+ const value_field = row.columns_list.find(col => col.df.fieldname === 'value');
+ if (value_field) {
+ // Пересоздаем контрол
+ value_field.df.fieldtype = fieldtype;
+ value_field.df.options = options;
+ row.refresh_field('value');
+ }
+ });
+
+ // Устанавливаем значение обратно
+ if (currentValue) {
+ grid_row.doc.value = currentValue;
+ }
+}
+
+function processAzerbayjanDateField(docValues) {
+ // Словарь для сопоставления названий месяцев с их номерами
+ const monthNames = {
+ "Yanvar": 1,
+ "Fevral": 2,
+ "Mart": 3,
+ "Aprel": 4,
+ "May": 5,
+ "İyun": 6,
+ "İyul": 7,
+ "Avqust": 8,
+ "Sentyabr": 9,
+ "Oktyabr": 10,
+ "Noyabr": 11,
+ "Dekabr": 12
+ };
+
+ // Проверяем, есть ли у нас значения ay и il
+ if (docValues && docValues.ay && monthNames[docValues.ay]) {
+ // Получаем номер месяца
+ const monthNum = monthNames[docValues.ay];
+
+ // Получаем год из поля il или используем текущий год
+ let year = docValues.il || new Date().getFullYear();
+ console.log(`🔹 Обработка специальных полей: ay=${docValues.ay} (${monthNum}), il=${year}`);
+
+ // Определяем первый день месяца (1-е число)
+ const firstDay = new Date(year, monthNum - 1, 1);
+
+ // Последний день месяца (получаем последнее число месяца)
+ const lastDay = new Date(year, monthNum, 0);
+
+ // Форматируем даты в формате YYYY-MM-DD
+ const firstDayStr = `${year}.${String(monthNum).padStart(2, '0')}.01`;
+ const lastDayStr = `${year}.${String(monthNum).padStart(2, '0')}.${String(lastDay.getDate()).padStart(2, '0')}`;
+
+ console.log(`🔹 Диапазон дат для ${docValues.ay} ${year}: ${firstDayStr} - ${lastDayStr}`);
+
+ // Возвращаем объект с диапазоном дат
+ return {
+ start: firstDayStr,
+ end: lastDayStr
+ };
+ }
+
+ // Если это не специальное поле или значение не распознано, возвращаем null
+ return null;
}
\ No newline at end of file
diff --git a/formula_editor/hooks.py b/formula_editor/hooks.py
index f4ab3c9..2e500b6 100644
--- a/formula_editor/hooks.py
+++ b/formula_editor/hooks.py
@@ -140,13 +140,11 @@ app_license = "unlicense"
# ---------------
# Hook on document methods and events
-# doc_events = {
-# "*": {
-# "on_update": "method",
-# "on_cancel": "method",
-# "on_trash": "method"
-# }
-# }
+doc_events = {
+ "Formula Editor": {
+ "on_trash": "formula_editor.api.on_trash"
+ }
+}
# Scheduled Tasks
# ---------------