Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

привет

  1. User

    привет

  2. Assistant

    Привет! Как я могу помочь тебе сегодня?

  3. User

    надо дописать код к проекту на flask, но он не влазит в 128к, как мне передать тебе сведения о нём?

  4. Assistant

    Ты можешь передать сведения о проекте по частям. Опиши, пожалуйста, основную структуру проекта, какие функции или маршруты тебе нужно реализовать, а также сообщи о любых проблемах, с которыми столкнулся. Можно также поделиться ключевыми фрагментами кода, которые требуют доработки, и я постараюсь помочь!

  5. User

    Если ты не уверен, то задавай уточняющие вопросы по ходу нашего диалога. Вот некоторые его части.

    app/models.py

    from app import db

    class Events(db.Model): tablename = 'events' event_id = db.Column(db.Integer, primary_key=True) event_name = db.Column(db.String(127)) event_time = db.Column(db.DateTime)

    def __repr__(self):
        return f'<Event {self.event_name}>'
    

    class UESTable(db.Model): tablename = 'ues_table' ues_id = db.Column(db.Integer, primary_key=True) ues_name = db.Column(db.String(31), nullable=True, unique=True)

    def __repr__(self):
        return f'<UES {self.ues_name}>'
    

    class DescriptionTable(db.Model): tablename = 'descriptiontbl' description_id = db.Column(db.Integer, primary_key=True) description_text = db.Column(db.String(255), unique=True)

    def __repr__(self):
        return f'<Description {self.description_id}>'
    

    class KomplektTable(db.Model): tablename = 'komplekttbl' komplekt_id = db.Column(db.Integer, primary_key=True) komplekt_text = db.Column(db.String(255), unique=True)

    def __repr__(self):
        return f'<Komplekt {self.komplekt_id}>'
    

    class OsnovanieTable(db.Model): tablename = 'osnovanietbl' osnovanie_id = db.Column(db.Integer, primary_key=True) osnovanie_txt = db.Column(db.String(255), unique=True)

    def __repr__(self):
        return f'<Osnovanie {self.osnovanie_id}>'
    

    class Landocs(db.Model): tablename = 'landocs' doc_id = db.Column(db.Integer, primary_key=True) doc_name = db.Column(db.String(255), nullable=False, unique=True) doc_date = db.Column(db.Date, nullable=False) doc_description = db.Column(db.Text)

    hardware = db.relationship('Hardware', backref='landoc', lazy=True)
    
    def __repr__(self):
        return f'<Landoc {self.doc_name}>'
    

    class StateHW(db.Model): tablename = 'statehw' statehw_id = db.Column(db.Integer, primary_key=True) statehw_name = db.Column(db.String(31), nullable=False, unique=True)

    def __repr__(self):
        return f'<StateHW {self.statehw_name}>'
    

    class ChekedHW(db.Model): tablename = 'chekedhw' chekedhw_id = db.Column(db.Integer, primary_key=True) statehw_id = db.Column(db.Integer, db.ForeignKey('statehw.statehw_id')) date_checked_akt = db.Column(db.Date) date_checked_os = db.Column(db.Date) doc_id = db.Column(db.Integer, db.ForeignKey('landocs.doc_id'))

    state = db.relationship('StateHW', backref='cheked_hw')
    doc = db.relationship('Landocs', backref='cheked_hw')
    
    hardware = db.relationship('Hardware', backref='cheked_hw', uselist=False)
    
    def __repr__(self):
        return f'<ChekedHW {self.chekedhw_id}>'
    

    class Hardware(db.Model): tablename = 'hardware' hw_id = db.Column(db.Integer, primary_key=True) duplicate_hw_id = db.Column(db.Integer, db.ForeignKey('hardware.hw_id')) doc_id = db.Column(db.Integer, db.ForeignKey('landocs.doc_id')) no = db.Column(db.Integer) name_txt = db.Column(db.Text, nullable=False) name = db.Column(db.Text, nullable=False) inv = db.Column(db.String(31), nullable=False, unique=True) sn = db.Column(db.String(64)) mac = db.Column(db.String(31)) kud = db.Column(db.String(31)) boxid = db.Column(db.String(31)) number_akt = db.Column(db.Integer) date_akt = db.Column(db.Date) quantity = db.Column(db.Integer) shifr_time = db.Column(db.Integer) shifr_amo = db.Column(db.Integer) date_build = db.Column(db.Date) date_input = db.Column(db.Date) date_buh = db.Column(db.Date) date_nouse = db.Column(db.Date) first_price = db.Column(db.Float) first_price_date = db.Column(db.Date) last_price = db.Column(db.Float) last_price_date = db.Column(db.Date) srok = db.Column(db.Integer) ues_description = db.Column(db.String(31)) komplekt_id = db.Column(db.Integer, db.ForeignKey('komplekttbl.komplekt_id')) osnovanie_id = db.Column(db.Integer, db.ForeignKey('osnovanietbl.osnovanie_id')) description_id = db.Column(db.Integer, db.ForeignKey('descriptiontbl.description_id')) ues_id = db.Column(db.Integer, db.ForeignKey('ues_table.ues_id')) chekedhw_id = db.Column(db.Integer, db.ForeignKey('chekedhw.chekedhw_id')) os_id = db.Column(db.Integer, db.ForeignKey('os.os_id')) akt_id = db.Column(db.Integer, db.ForeignKey('akt.akt_id')) asudoolink_id = db.Column(db.Integer, db.ForeignKey('asudoolink.asudoolink_id')) event_id = db.Column(db.Integer, db.ForeignKey('events.event_id'))

    duplicate_hw = db.relationship('Hardware', remote_side=[hw_id])
    komplekt = db.relationship('KomplektTable', backref='hardware')
    osnovanie = db.relationship('OsnovanieTable', backref='hardware')
    description = db.relationship('DescriptionTable', backref='hardware')
    ues = db.relationship('UESTable', backref='hardware')
    os = db.relationship('OS', backref='hardware')
    akt = db.relationship('Akt', backref='hardware')
    event = db.relationship('Events', backref='hardware')
    
    def __repr__(self):
        return f'<Hardware inv={self.inv}>'
    

    class OS(db.Model): tablename = 'os' os_id = db.Column(db.Integer, primary_key=True) inv = db.Column(db.String(31), unique=True) name = db.Column(db.String(255)) passport_number = db.Column(db.String(31)) reg_number = db.Column(db.String(31)) zn = db.Column(db.String(127)) nn = db.Column(db.String(31)) date_warranty = db.Column(db.Date) date_production = db.Column(db.Date) date_expluatation = db.Column(db.Date) date_input = db.Column(db.Date) date_output = db.Column(db.Date) date_trash = db.Column(db.Date) quantity = db.Column(db.Integer) model = db.Column(db.String(31)) made_by = db.Column(db.String(31)) code_party = db.Column(db.String(31)) period = db.Column(db.String(31)) dop_inv = db.Column(db.String(31)) record_number = db.Column(db.String(31)) filial_number = db.Column(db.String(31)) description = db.Column(db.String(31)) groups = db.Column(db.String(31)) type_doc = db.Column(db.String(31)) ed_izm = db.Column(db.String(31)) group_os = db.Column(db.String(127)) vid_os = db.Column(db.String(127)) podrazdelenie = db.Column(db.String(127)) mol = db.Column(db.String(127)) code_norma_amort = db.Column(db.String(31)) norma_amort = db.Column(db.String(31)) uses_os = db.Column(db.String(127)) price = db.Column(db.Float) summ_amort = db.Column(db.String(31)) amort_otch_period = db.Column(db.String(31)) price_input = db.Column(db.String(31)) iznos_input = db.Column(db.String(31)) fix_summ_amort = db.Column(db.String(31)) srok_polezn_use = db.Column(db.String(31)) valute = db.Column(db.String(31)) metod_nach_amort = db.Column(db.String(255)) tho_amort = db.Column(db.String(255)) type_object = db.Column(db.String(255)) code_group_okof = db.Column(db.String(31)) name_group_okof = db.Column(db.String(31)) popravka_koef = db.Column(db.String(31)) last_price = db.Column(db.Float) event_id = db.Column(db.Integer, db.ForeignKey('events.event_id'))

    event = db.relationship('Events', backref='oses')
    
    def __repr__(self):
        return f'<OS inv={self.inv}>'
    

    class Akt(db.Model): tablename = 'akt' akt_id = db.Column(db.Integer, primary_key=True) number_akt = db.Column(db.Integer) date_akt = db.Column(db.Date) name_hw = db.Column(db.String(127)) type_hw = db.Column(db.String(127)) zn = db.Column(db.String(127)) inv = db.Column(db.String(31)) ues_id = db.Column(db.Integer, db.ForeignKey('ues_table.ues_id')) condition = db.Column(db.String(127)) issue = db.Column(db.String(127)) conclusion = db.Column(db.String(255)) non_compliance = db.Column(db.String(255)) description = db.Column(db.Text) employee = db.Column(db.String(255)) #pdf = db.Column(db.LargeBinary) image_name = db.Column(db.String(255)) # поле для имени файла изображения event_id = db.Column(db.Integer, db.ForeignKey('events.event_id'))

    ues = db.relationship('UESTable', backref='akts')
    event = db.relationship('Events', backref='akts')
    
    def __repr__(self):
        return f'<Akt number={self.number_akt}>'
    

    class Asudoo(db.Model): tablename = 'asudoo' asudoo_id = db.Column(db.Integer, primary_key=True) branch_name_id = db.Column(db.Integer, db.ForeignKey('branch_name_table.branch_name_id'), nullable=False) rues_name_id = db.Column(db.Integer, db.ForeignKey('rues_name_table.rues_name_id'), nullable=False) ceh_name_id = db.Column(db.Integer, db.ForeignKey('ceh_name_table.ceh_name_id'), nullable=False) equipment_type_name_id = db.Column(db.Integer, db.ForeignKey('equipment_type_name_table.equipment_type_name_id')) equipment_name = db.Column(db.Text) mac = db.Column(db.String(127)) inventory_number = db.Column(db.String(127)) serial_number = db.Column(db.String(255)) last_updated = db.Column(db.Date) cost = db.Column(db.String(31)) chip_id = db.Column(db.String(127)) document_date = db.Column(db.Date) status = db.Column(db.String(127)) contractnum = db.Column(db.String(31)) ttn_number = db.Column(db.String(127)) ttn_date = db.Column(db.Date) number_part = db.Column(db.String(127)) equipment_code = db.Column(db.String(127))

    branch = db.relationship('BranchNameTable', backref='asudoo')
    rues = db.relationship('RuesNameTable', backref='asudoo')
    ceh = db.relationship('CehNameTable', backref='asudoo')
    equipment_type = db.relationship('EquipmentTypeNameTable', backref='asudoo')
    
    def __repr__(self):
        return f'<Asudoo inventory_number={self.inventory_number}>'
    

    class BranchNameTable(db.Model): tablename = 'branch_name_table' branch_name_id = db.Column(db.Integer, primary_key=True) branch_name = db.Column(db.String(127), nullable=False, unique=True)

    def __repr__(self):
        return f'<Branch {self.branch_name}>'
    

    class RuesNameTable(db.Model): tablename = 'rues_name_table' rues_name_id = db.Column(db.Integer, primary_key=True) rues_name = db.Column(db.String(127), nullable=False, unique=True)

    def __repr__(self):
        return f'<RUES {self.rues_name}>'
    

    class CehNameTable(db.Model): tablename = 'ceh_name_table' ceh_name_id = db.Column(db.Integer, primary_key=True) ceh_name = db.Column(db.String(127), nullable=False, unique=True)

    def __repr__(self):
        return f'<Ceh {self.ceh_name}>'
    

    class EquipmentTypeNameTable(db.Model): tablename = 'equipment_type_name_table' equipment_type_name_id = db.Column(db.Integer, primary_key=True) equipment_type_name = db.Column(db.String(127), nullable=False, unique=True)

    def __repr__(self):
        return f'<EquipmentType {self.equipment_type_name}>'
    

    class AsudooLink(db.Model): tablename = 'asudoolink' asudoolink_id = db.Column(db.Integer, primary_key=True) asudoo_id = db.Column(db.Integer, db.ForeignKey('asudoo.asudoo_id')) mac = db.Column(db.String(255)) sn = db.Column(db.String(255)) doc_description = db.Column(db.Text)

    asudoo = db.relationship('Asudoo', backref='asudoo_links')
    hardware = db.relationship('Hardware', backref='asudoo_link')
    
    def __repr__(self):
        return f'<AsudooLink id={self.asudoolink_id}>'
    

    app/init.py

    from flask import Flask, render_template from config import Config from flask_sqlalchemy import SQLAlchemy from flask_marshmallow import Marshmallow # Добавляем импорт Marshmallow from flask_migrate import Migrate from flask_session import Session
    from flask import send_from_directory import os from app.logging_config import setup_logger from app.utils import parse_date

    db = SQLAlchemy() migrate = Migrate() ma = Marshmallow() # Создаем экземпляр Marshmallow

    Создадим объект Session (из Flask-Session):

    sess = Session()

    #app.config['UPLOAD_FOLDER'] = Config.UPLOAD_FOLDER

    def format_datetime(value, format='%Y-%m-%d'): if value is None or value == '': return '' if isinstance(value, str): value = parse_date(value) if value is None: return '' return value.strftime(format)

    def create_app(): app = Flask(name) app.config.from_object(Config)

    db.init_app(app)
    migrate.init_app(app, db)
    ma.init_app(app)  # Инициализируем Marshmallow с приложением
    
    # ВАЖНО: указываем, что SQLAlchemy для сессий это наш db
    # т.е. SESSION_SQLALCHEMY = db (из Config)
    app.config['SESSION_SQLALCHEMY'] = db
    
    # Инициализируем Flask-Session:
    sess.init_app(app)
    
    # Настройка логгера
    setup_logger(app)
    
    # Регистрируем фильтр 'strftime'
    app.jinja_env.filters['strftime'] = format_datetime
    
    
    
    # Регистрируем Blueprint'ы
    from app.blueprints import register_blueprints
    register_blueprints(app)
    
    # Главная страница
    @app.route("/")
    def index():
        return render_template("index.html")
    
    # Сервис для предоставления доступа к папке uploads
    @app.route('/uploads/<path:filename>')
    def uploaded_file(filename):
        return send_from_directory(os.path.join(app.root_path, 'uploads'), filename)
    
    return app
    

    app/blueprints/hardware_bp.py

    from flask import ( Blueprint, request, render_template, redirect, url_for, flash, session ) from app.models import ( db, Landocs, Hardware, OS, Akt, DescriptionTable, KomplektTable, OsnovanieTable, UESTable ) from app.loaders.hardware_loader import ( parse_xlsx_for_hardware_data, parse_docx_for_hardware_data ) from config import Config import os import datetime import json import logging from flask_wtf import FlaskForm from wtforms import StringField, SubmitField, SelectMultipleField from wtforms.validators import DataRequired from app.utils import get_or_create, parse_date, parse_int, parse_float

    class ComparisonForm(FlaskForm): submit = SubmitField('Применить')

    hardware_bp = Blueprint("hardware_bp", name, template_folder="../../templates")

    Создаем логгер

    logger = logging.getLogger(name) logger.setLevel(logging.DEBUG) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter)

    class ComparisonForm2(FlaskForm): fields_select = SelectMultipleField( 'Выберите сравниваемые поля', choices=[ ('quantity', 'Количество'), ('shifr_time', 'Шифр времени'), ('date_build', 'Дата постройки'), ('first_price', 'Первая цена'), ('last_price', 'Последняя цена'), ('srok', 'Срок') ], validators=[DataRequired()] ) submit = SubmitField('Применить')

    def allowed_file(filename): return "." in filename and filename.rsplit(".", 1)[1].lower() in Config.ALLOWED_EXTENSIONS

    def parse_date_from_string(date_str): """ Преобразует строку даты в объект datetime.date. """ if not date_str or date_str in ('', 'None'): return None try: # Попробуем начать с формата ISO, который использовался при сериализации дат #return datetime.fromisoformat(date_str).date() return datetime.datetime.fromisoformat(date_str) except ValueError: # Если не получилось, попробуем другие форматы date_formats = [ "%Y-%m-%d", # Формат ISO "%d.%m.%Y", "%d/%m/%Y", "%Y/%m/%d", "%Y-%m-%d", "%d-%m-%Y", "%d.%m.%y", "%Y", # Только год "%m.%Y", # Месяц и год "%m/%Y", "%Y-%m", "%Y/%m", ] for fmt in date_formats: try: #return datetime.strptime(date_str, fmt).date() return datetime.strptime(date_str, fmt) except ValueError: continue return None

    @hardware_bp.route("/upload_hardware", methods=["GET", "POST"]) def upload_hardware(): if request.method == "POST": # Check if this is the confirmation step #logger.debug(f"[DEBUG] request.form: {request.form}") if 'confirm' in request.form: # Получаем сериализованные данные из сессии parsed_data_json = session.get('parsed_hardware')

            if not parsed_data_json:
                flash("Нет данных для подтверждения.")
                return redirect(url_for("hardware_bp.upload_hardware"))
            
            # Парсим JSON-строку в список словарей (Десериализуем данные)
            parsed_data = json.loads(parsed_data_json)
            for entry in parsed_data:
                # Добавляем поля с None, если они отсутствуют
            
                required_fields = ['no', 'inv','name_txt', 'name', 'quantity', 'sn', 'mac', 'kud', 'boxid', 'shifr_time', 
                                'shifr_amo', 'date_build', 'date_input', 'date_buh', 'date_nouse', 'number_akt', 'date_akt',
                                'first_price', 'last_price', 'srok', 'komplekt_text', 'osnovanie_text', 
                                'description_text', 'ues_description']
                for field in required_fields:
                    entry.setdefault(field, None)
             
            parsed_data = json.loads(parsed_data_json)
    
            # Преобразуем строки дат обратно в объекты datetime.date
            for entry in parsed_data:
                #entry['date_build'] = parse_date_from_string(entry.get('date_build'))
                #entry['date_input'] = parse_date_from_string(entry.get('date_input'))
                #entry['date_buh'] = parse_date_from_string(entry.get('date_buh'))
                #entry['date_nouse'] = parse_date_from_string(entry.get('date_nouse'))
                entry['date_build'] = parse_date(entry.get('date_build'))
                entry['date_input'] = parse_date(entry.get('date_input'))
                entry['date_buh'] = parse_date(entry.get('date_buh'))
                entry['date_nouse'] = parse_date(entry.get('date_nouse'))
                entry['date_akt'] = parse_date(entry.get('date_akt'))
            accept_entries = request.form.getlist('accept')
            for idx, entry in enumerate(parsed_data):
                if str(idx) in accept_entries:
                    # Получаем обновлённые 'sn', 'mac', 'kud', 'boxid' из формы
                    sn_key = f'sn_{idx}'
                    mac_key = f'mac_{idx}'
                    kud_key = f'kud_{idx}'
                    boxid_key = f'boxid_{idx}'
    
                    sn_value = request.form.get(sn_key, entry.get('sn'))
                    mac_value = request.form.get(mac_key, entry.get('mac'))
                    kud_value = request.form.get(kud_key, entry.get('kud'))
                    boxid_value = request.form.get(boxid_key, entry.get('boxid'))
                    # Обновляем значения в entry
                    entry['sn'] = sn_value
                    entry['mac'] = mac_value
                    entry['kud'] = kud_value
                    entry['boxid'] = boxid_value
    
                    # Проверяем, есть ли уже такое оборудование в базе
                    #existing_hw = Hardware.query.filter_by(inv=entry.get("inv")).first()
                    #if existing_hw:
                    #    flash(f"Запись с inv={entry.get('inv')} уже существует. Пропущено сохранение.")
                    #    continue
    
                    # Save this entry to the database
                    try:
                        # Получаем или создаем связанные записи
                        # Получаем или создаем связанные записи KomplektTable
                        komplekt_text = entry.get("komplekt_text")
                        komplekt = None
                        if komplekt_text:
                            komplekt = get_or_create(db.session, KomplektTable, komplekt_text=komplekt_text)
                        # Получаем или создаем связанные записи OsnovanieTable
                        osnovanie_text = entry.get("osnovanie_text")
                        osnovanie = None
                        if osnovanie_text:
                            osnovanie = get_or_create(db.session, OsnovanieTable, osnovanie_txt=osnovanie_text)
                        # Получаем или создаем связанные записи DescriptionTable
                        description_text = entry.get("description_text")
                        description = None
                        if description_text:
                            description = get_or_create(db.session, DescriptionTable, description_text=description_text)
                        # Получаем или создаем связанные записи UESTable
                        ues_description = entry.get("ues_description")
                        ues = None
                        if ues_description:
                            ues = get_or_create(db.session, UESTable, ues_name=ues_description)
    
    
                        # Создаем объект Hardware
                        hardware = Hardware(
                            doc_id=entry.get("doc_id"),
                            no=entry.get("no"),
                            name_txt=entry.get("name_txt"),
                            name=entry.get("name"),
                            inv=entry.get("inv"),
                            quantity=entry.get("quantity"),
                            shifr_time=entry.get("shifr_time"),
                            shifr_amo=entry.get("shifr_amo"),
                            date_build=entry.get("date_build"),
                            date_input=entry.get("date_input"),
                            date_buh=entry.get("date_buh"),
                            date_nouse=entry.get("date_nouse"),
                            first_price=entry.get("first_price"),
                            last_price=entry.get("last_price"),
                            srok=entry.get("srok"),
                            komplekt_id=komplekt.komplekt_id if komplekt else None,
                            osnovanie_id=osnovanie.osnovanie_id if osnovanie else None,
                            description_id=description.description_id if description else None,
                            ues_id=ues.ues_id if ues else None,
                            ues_description=entry.get("ues_description"),
                            sn=entry.get("sn"),
                            mac=entry.get("mac"),
                            kud=entry.get("kud"),
                            boxid=entry.get("boxid"),
                            number_akt=entry.get("number_akt"),
                            date_akt=entry.get("date_akt")
                        )
                        db.session.add(hardware)
                    except Exception as e:
                        db.session.rollback()
                        flash(f"Ошибка при сохранении записи inv={entry.get('inv')}: {e}")
    
            try:
                db.session.commit()
                flash("Выбранные данные успешно сохранены.")
                session.pop('parsed_hardware', None)
                return redirect(url_for("hardware_bp.upload_hardware"))
            except Exception as e:
                db.session.rollback()
                flash(f"Ошибка при сохранении данных: {e}")
                return redirect(url_for("hardware_bp.upload_hardware"))
    
        # Handle initial file upload and parsing
        file_xlsx = request.files.get("file_xlsx")
        file_docx = request.files.get("file_docx")
        doc_name = request.form.get("doc_name")
        doc_date = request.form.get("doc_date")
        doc_description = request.form.get("doc_description")
    
        # Validate document information
        if not doc_name or not doc_date:
            flash("Название и дата документа обязательны.")
            return redirect(url_for("hardware_bp.upload_hardware"))
    
        try:
            doc_date_parsed = datetime.datetime.strptime(doc_date, '%Y-%m-%d').date()
        except ValueError:
            flash("Неверный формат даты документа. Используйте YYYY-MM-DD.")
            return redirect(url_for("hardware_bp.upload_hardware"))
    
        # Проверка/создание LANDOCS
        landoc = Landocs.query.filter_by(doc_name=doc_name, doc_date=doc_date_parsed).first()
        if landoc:
            doc_id = landoc.doc_id
            flash(f"Документ уже существует, используем doc_id={doc_id}")
        else:
            landoc = Landocs(doc_name=doc_name, doc_date=doc_date_parsed, doc_description=doc_description)
            db.session.add(landoc)
            db.session.commit()
            doc_id = landoc.doc_id
            flash(f"Создан новый документ doc_id={doc_id}")
    
        # Parse XLSX and DOCX files
        parsed_hardware = []
    
        if file_xlsx and allowed_file(file_xlsx.filename):
            filename_xlsx = file_xlsx.filename
            path_xlsx = os.path.join(Config.UPLOAD_FOLDER, filename_xlsx)
            file_xlsx.save(path_xlsx)
            parsed_xlsx = parse_xlsx_for_hardware_data(path_xlsx, doc_id)
            parsed_hardware.extend(parsed_xlsx)
            flash("Файл XLSX обработан")
    
        if file_docx and allowed_file(file_docx.filename):
            filename_docx = file_docx.filename
            path_docx = os.path.join(Config.UPLOAD_FOLDER, filename_docx)
            file_docx.save(path_docx)
            parsed_docx = parse_docx_for_hardware_data(path_docx, doc_id)
            # Merge parsed_docx into parsed_hardware based on 'inv'
            for docx_entry in parsed_docx:
                matched = False
                for hw_entry in parsed_hardware:
                    if hw_entry['inv'] == docx_entry['inv']:
                        hw_entry['description_text'] = (hw_entry.get('description_text') or "") + "\n" + docx_entry.get('description_text', '')
                        matched = True
                        break
                if not matched:
                    # If no matching inv in XLSX, add as new entry
                    parsed_hardware.append({
                        "doc_id": doc_id,
                        "no": None,
                        "name": None,
                        "inv": docx_entry['inv'],
                        "quantity": None,
                        "shifr_time": None,
                        "shifr_amo": None,
                        "date_build": None,
                        "date_input": None,
                        "date_buh": None,
                        "date_nouse": None,
                        "first_price": None,
                        "last_price": None,
                        "srok": None,
                        "komplekt_text": None,
                        "osnovanie_text": None,
                        "description_text": docx_entry.get('description_text', ''),
                        "ues_text": None,
                        "sn": None,
                        "mac": None,
                        "kud": None
                    })
            flash("Файл DOCX обработан")
    
        if not parsed_hardware:
            flash("Не найдено данных для обработки.")
            return redirect(url_for("hardware_bp.upload_hardware"))
        #print(parsed_hardware)
        # Store parsed data in session (as JSON)
        session['parsed_hardware'] = json.dumps(parsed_hardware, default=str)
        logging.debug(f'[DEBUG] xlsx session[parsed_hardware] {parsed_hardware}')
        return render_template("confirm_hardware.html", hardware_list=parsed_hardware)
    
    else:
        # GET request: Render the upload form with existing document names
        doc_names = [doc.doc_name for doc in Landocs.query.distinct(Landocs.doc_name).all()]
        logging.debug(f'[DEBUG]Render the upload form with existing document names {doc_names}')
        return render_template("upload_hardware.html", doc_names=doc_names)
    

    @hardware_bp.route("/hardware_assoc", methods=["GET", "POST"]) def hardware_assoc(): """ Страница выбора документа и отображения привязанного к нему списка Hardware. Вверху: выпадающий список doc_name (doc_date). Кнопка "Выбрать" -> фильтрация hardware по doc_id. Кнопки "Связать данные из ОС" и "Связать данные с Актами". Предупреждение о несохранённых данных можно сделать на фронте (onbeforeunload). """ # Получаем все документы (Landocs) чтобы отобразить в выпадающем списке docs = Landocs.query.order_by(Landocs.doc_date.desc()).all()

    selected_doc_id = None
    hardware_list = []
    if request.method == 'POST':
        # Получаем doc_id из формы
        selected_doc_id = request.form.get('doc_id')
        if selected_doc_id:
            # Преобразуем в int
            try:
                doc_id_int = int(selected_doc_id)
                # Загружаем hardware
                hardware_list = Hardware.query.filter_by(doc_id=doc_id_int).all()
            except ValueError:
                flash("Некорректный doc_id", "danger")
    return render_template(
        "hw_assoc_select.html",
        docs=docs,
        selected_doc_id=selected_doc_id,
        hardware_list=hardware_list
    )
    

    def to_dict(obj, exclude=None): if exclude is None: exclude = [] return {col.name: getattr(obj, col.name) for col in obj.table.columns if col.name not in exclude}

    @hardware_bp.route("/hardware_assoc/os/int:doc_id", methods=["GET", "POST"]) def hardware_assoc_os(doc_id): doc = Landocs.query.get_or_404(doc_id) form = ComparisonForm()

    hw_list = Hardware.query.filter_by(doc_id=doc_id).all()
    os_list = OS.query.filter(OS.inv.in_([hw.inv for hw in hw_list])).all()
    
    os_dict = {os.inv: os for os in os_list}
    table_rows = []
    
    # Создаем строки таблицы
    for hw in hw_list:
        os_ = os_dict.get(hw.inv)
        table_rows.append({
            'hw': hw,
            'os': os_
        })
    
    # Обработка формы для обновления данных
    if form.validate_on_submit():
        selected_fields = json.loads(request.form.get('fields_select', '[]'))
        
        for hw in hw_list:
            prefix = f"hw_{hw.hw_id}"
            for field in selected_fields:
                new_value = request.form.get(f"{prefix}_{field}")
                if field == 'quantity':
                    hw.quantity = parse_int(new_value)
                elif field == 'shifr_time':
                    hw.shifr_time = parse_int(new_value)
                elif field == 'date_build':
                    hw.date_build = parse_date(new_value)
                elif field == 'date_input':
                    hw.date_input = parse_date(new_value)
                elif field == 'first_price':
                    hw.first_price = parse_float(new_value)
                elif field == 'last_price':
                    hw.last_price = parse_float(new_value)
                elif field == 'srok':
                    hw.srok = parse_float(new_value)
    
        try:
            db.session.commit()
            flash("Изменения Hardware успешно сохранены.", "success")
        except Exception as e:
            db.session.rollback()
            flash(f"Ошибка при сохранении: {e}", "danger")
        return redirect(url_for("hardware_bp.hardware_assoc_os", doc_id=doc_id))
    
    
    
    return render_template("hw_assoc_os.html", doc=doc, table_rows=table_rows, form=form)
    

    Асинхронная обработка обновлений через AJAX (например, при нажатии на кнопку)

    @hardware_bp.route('/update-hw-field', methods=['POST']) def update_hw_field(): data = request.get_json() # Получаем данные из запроса print(data) hw_id = data.get('hwId') field = data.get('field') value = data.get('value') hw = Hardware.query.filter_by(inv=hw_id).first() if hw: # Обновляем поле в HW, в зависимости от типа if field == 'name': hw.name = value elif field == 'sn': hw.sn = value elif field == 'quantity': hw.quantity = parse_int(value) elif field == 'shifr_time': hw.shifr_time = parse_int(value) elif field == 'shifr_amo': hw.shifr_amo = parse_int(value) elif field == 'price': hw.price = parse_float(value) elif field == 'last_price': hw.last_price = parse_float(value) elif field == 'date_build': hw.date_build = parse_date(value) elif field == 'date_input': hw.date_input = parse_date(value) elif field == 'date_buh': hw.date_buh = parse_date(value) elif field == 'srok': hw.srok = parse_float(value) try: db.session.commit() return jsonify({'success': True}), 200 except Exception as e: db.session.rollback() return jsonify({'success': False, 'error': str(e)}), 500 else: return jsonify({'success': False, 'error': 'HW not found'}), 404

    #@hardware_bp.route("/hardware_assoc/os/int:doc_id", methods=["GET", "POST"]) def hardware_assoc_os3(doc_id): doc = Landocs.query.get_or_404(doc_id) hw_list = Hardware.query.filter_by(doc_id=doc_id).all() table_rows = []

    for hw in hw_list:
        os_ = OS.query.filter_by(inv=hw.inv).first()
        table_rows.append({
            'hw': hw,
            'os': os_
        })
    
    if request.method == "POST":
        for hw in hw_list:
            prefix = f"hw_{hw.hw_id}"
            new_quantity = request.form.get(f"{prefix}_quantity")
            new_shifr_time = request.form.get(f"{prefix}_shifr_time")
            new_date_build = request.form.get(f"{prefix}_date_build")
    
            hw.quantity = parse_int(new_quantity)
            hw.shifr_time = parse_int(new_shifr_time)
            hw.date_build = parse_date(new_date_build)
            # Обратите внимание на поля, которые нужно обрабатывать.
    
        try:
            db.session.commit()
            flash("Изменения Hardware успешно сохранены.", "success")
        except Exception as e:
            db.session.rollback()
            flash(f"Ошибка при сохранении: {e}", "danger")
        return redirect(url_for("hardware_bp.hardware_assoc_os", doc_id=doc_id))
    
    return render_template("hw_assoc_os.html", doc=doc, table_rows=table_rows)
    

    #@hardware_bp.route("/hardware_assoc/os/int:doc_id", methods=["GET", "POST"]) def hardware_assoc_os2(doc_id): """ Страница "Сопоставление данных с ОС". Вверху: Документ: "doc_name от doc_date" Ниже: таблица сопоставления Hardware ↔ OS, поля (inv, quantity, shifr_time → code_norma_amort, ...) При несовпадении подсвечивать красным. Можно редактировать Hardware-поля. Кнопка "Заполнить из ОС" (на каждой строке) - перенести данные OS в Hardware (только в виде form на странице, до "Применить"). Кнопка "Применить" -> сохраняем изменения в БД. """ doc = Landocs.query.get_or_404(doc_id) # Загружаем hardware hw_list = Hardware.query.filter_by(doc_id=doc_id).all()

    # Готовим данные для отображения (список словарей {hw:..., os:...})
    table_rows = []
    for hw in hw_list:
        os_ = OS.query.filter_by(inv=hw.inv).first()
        table_rows.append({
            'hw': hw,
            'os': os_
        })
    
    if request.method == "POST":
        # Если нажали "Применить" (или какая-то форма):
        # Будем считывать поля из request.form и сохранять в Hardware
        for hw in hw_list:
            prefix = f"hw_{hw.hw_id}"
            # Пример: quantity -> request.form.get(f"{prefix}_quantity")
            new_quantity = request.form.get(f"{prefix}_quantity")
            new_shifr_time = request.form.get(f"{prefix}_shifr_time")
            new_date_build = request.form.get(f"{prefix}_date_build")
            # ... и т.д.
    
            # Преобразование
            hw.quantity = parse_int(new_quantity)
            hw.shifr_time = parse_int(new_shifr_time)
            hw.date_build = parse_date(new_date_build)
            # Дополнительно поля first_price, last_price, srok и т.д.
            # (Смотрите ниже, какие поля сопоставлялись.)
    
        try:
            db.session.commit()
            flash("Изменения Hardware успешно сохранены.", "success")
        except Exception as e:
            db.session.rollback()
            flash(f"Ошибка при сохранении: {e}", "danger")
        return redirect(url_for("hardware_bp.hardware_assoc_os", doc_id=doc_id))
    
    # GET-запрос: просто отображаем страницу
    return render_template(
        "hw_assoc_os.html",
        doc=doc,
        table_rows=table_rows
    )
    

    @hardware_bp.route("/hardware_assoc/akt/int:doc_id", methods=["GET"]) def hardware_assoc_akt(doc_id): """ Страница "Сопоставление данных с Актами". Выводим список HW, показываем какие Akt к ним привязаны, и т.д. При клике - уходим на "Просмотр данных HW и AKT" """ doc = Landocs.query.get_or_404(doc_id) hw_list = Hardware.query.filter_by(doc_id=doc_id).all() # Для каждого hardware – найдём связанный акт # (hw.akt, если есть) return render_template( "hw_assoc_akt.html", doc=doc, hw_list=hw_list )

    def link_hardware_with_akt(inv: str, akt_id: int): """ Сопоставляет Hardware с Akt по инвентарному номеру. Если запись найдена, обновляет связь hardware.akt_id. """ hw = Hardware.query.filter_by(inv=inv).first() if hw: hw.akt_id = akt_id return hw return None

    @hardware_bp.route("/hardware_assoc/akt/view/int:hw_id", methods=["GET", "POST"]) def hardware_akt_view(hw_id): """ Логика: 1. Если hardware.akt_id отсутствует, пытаемся найти акт по hardware.number_akt в таблице AKT. 2. Если акт не найден, остаёмся на текущей странице и выводим сообщение. 3. Если акт найден или уже сопоставлен, переходим на страницу сверки AKT и hardware. """ hw = Hardware.query.get_or_404(hw_id) # Получаем запись Hardware

    #akt = Akt.query.get_or_404(hw.akt_id)
    
    if not hw.akt_id:
        # Пытаемся найти акт по номеру из hardware.number_akt
        akt = Akt.query.filter_by(number_akt=hw.number_akt).first()
        if not akt:
            # Акт не найден, остаёмся на текущей странице
            flash(f"Акт с номером {hw.number_akt} не найден.", "warning")
            return redirect(url_for("hardware_bp.hardware_assoc_akt", doc_id=hw.doc_id))
        
        # Акт найден, связываем его с hardware
        hw.akt_id = akt.akt_id
        try:
            db.session.commit()
            flash(f"Hardware с инвентарным номером {hw.inv} связан с актом {akt.number_akt}.", "success")
        except Exception as e:
            db.session.rollback()
            flash(f"Ошибка сохранения: {e}", "danger")
            return redirect(url_for("hardware_bp.hardware_assoc_akt", doc_id=hw.doc_id))
    akt = Akt.query.get_or_404(hw.akt_id)
    if request.method == "POST":
        #print(request.form) 
        # Обновляем ChekedHW (date_checked_akt)
        if not hw.chekedhw_id:
            # Создаём
            from app.models import ChekedHW
            chekedhw = ChekedHW(doc_id=hw.doc_id)
            db.session.add(chekedhw)
            db.session.flush()
            hw.chekedhw_id = chekedhw.chekedhw_id
        else:
            chekedhw = hw.chekedhw
    
        chekedhw.date_checked_akt = datetime.date.today()
            
        try:
            db.session.commit()
            flash("Данные сохранены, привязка HW ↔ Akt выполнена. Проверка (akt) обновлена.", "success")
        except Exception as e:
            db.session.rollback()
            flash(f"Ошибка сохранения: {e}", "danger")
            return redirect(url_for("hardware_bp.hardware_akt_view", hw_id=hw_id))
                            
        #return redirect(url_for("hardware_bp.hardware_akt_view", hw_id=hw_id))
        # --- Переходим к следующему hardware ---
        next_hw = Hardware.query.filter(
            Hardware.doc_id == hw.doc_id,
            Hardware.hw_id > hw.hw_id
        ).order_by(Hardware.hw_id).first()
    
        if next_hw:
            return redirect(url_for("hardware_bp.hardware_akt_view", hw_id=next_hw.hw_id))
        else:
            flash("Это была последняя запись. Возвращаемся к списку.", "info")
            return redirect(url_for("hardware_bp.hardware_assoc_akt", doc_id=hw.doc_id))
        # Если akt_id уже есть или успешно найден, переходим на страницу сверки
    #return redirect(url_for("hardware_bp.akt_hardware_check", hw_id=hw.hw_id))
    return render_template("hw_view_akt.html", hw=hw, akt=akt)
    

    #@hardware_bp.route("/hardware_assoc/akt/view/int:hw_id", methods=["GET", "POST"]) def hardware_akt_view2(hw_id): """ Просмотр/редактирование данных Hardware и Akt. - Отображаем картинку акта (akt.image_name) если есть - Поля из hardware (inv, name, type_hw (если нужно), ...) - Поля из akt (number_akt, date_akt, name_hw, type_hw, ...) - При POST: сохраняем, привязываем hardware.akt_id, обновляем ChekedHW(date_checked_akt) и переходим к следующей записи hardware (с тем же doc_id). """

    hw = Hardware.query.get_or_404(hw_id)
    
    hw = Hardware.query.filter_by(inv=inv).first()
    if hw:
        hw.akt_id = akt_id
    
    #number_akt
    akt = hw.number_akt  # Связанный акт, если есть
    inv = hw.inv  # Связанный акт, если есть
    akt_id = hw.akt_id  # Связанный акт, если есть
    
    if not akt_id:
        akt.inv = request.form.get("akt_inv")
        # Выполняем сопоставление
        linked_hw = link_hardware_with_akt(inv=inv, akt_id=akt.akt_id)
        
        flash("Акт не найден для данного Hardware.", "warning")
        # Можно либо перенаправить, либо дать редактировать новый акт
        return redirect(url_for("hardware_bp.hardware_assoc_akt", doc_id=hw.doc_id))
    # Если акта нет, вы можете либо:
    # 1) Создавать новый акт здесь, если хотите.
    # 2) Или дать пользователю возможность "выбрать акт" из списка.  
    # Для примера: создадим пустой объект, если None:
    #if not akt:
        #akt = Akt()
        # (но в БД ещё не добавляем, пока пользователь не сохранит)
    
    
    if request.method == "POST":
        # Сохраняем поля из формы
        # --- Hardware поля ---
        hw.name = request.form.get("hw_name")
        hw.inv = request.form.get("hw_inv")  # если хотите дать редактировать
        hw.quantity = parse_int(request.form.get("hw_quantity"))
        # hw.type_hw = request.form.get("hw_type")  # если нужно
        # ... и т.д.
        # --- Akt поля ---
        akt.number_akt = parse_int(request.form.get("akt_number"))
        date_akt_str = request.form.get("akt_date")
        if date_akt_str:
            akt.date_akt = datetime.datetime.strptime(date_akt_str, '%Y-%m-%d').date()
        
        akt.inv = request.form.get("akt_inv")
        akt.name_hw = request.form.get("akt_name_hw")
        akt.type_hw = request.form.get("akt_type_hw")
        # Если есть поля, как zn, condition, etc.
        # akt.zn = request.form.get("akt_zn")
        # ...
        
        # Привязываем акт к Hardware, если ещё не привязан
        if not hw.akt_id:
            # Сначала сохраним сам Akt, чтобы получить akt_id
            if not akt.akt_id:
                db.session.add(akt)
                db.session.flush()  # Получаем akt_id без commit
            hw.akt_id = akt.akt_id
        # Обновляем ChekedHW (date_checked_akt)
        if not hw.chekedhw_id:
            # Создаём
            from app.models import ChekedHW
            chekedhw = ChekedHW(doc_id=hw.doc_id)
            db.session.add(chekedhw)
            db.session.flush()
            hw.chekedhw_id = chekedhw.chekedhw_id
        else:
            chekedhw = hw.chekedhw
    
        chekedhw.date_checked_akt = datetime.date.today()
            
        try:
            db.session.commit()
            flash("Данные сохранены, привязка HW ↔ Akt выполнена. Проверка (akt) обновлена.", "success")
        except Exception as e:
            db.session.rollback()
            flash(f"Ошибка сохранения: {e}", "danger")
            return redirect(url_for("hardware_bp.hardware_akt_view", hw_id=hw_id))
                            
        #return redirect(url_for("hardware_bp.hardware_akt_view", hw_id=hw_id))
        # --- Переходим к следующему hardware ---
        next_hw = Hardware.query.filter(
            Hardware.doc_id == hw.doc_id,
            Hardware.hw_id > hw.hw_id
        ).order_by(Hardware.hw_id).first()
    
        if next_hw:
            return redirect(url_for("hardware_bp.hardware_akt_view", hw_id=next_hw.hw_id))
        else:
            flash("Это была последняя запись. Возвращаемся к списку.", "info")
            return redirect(url_for("hardware_bp.hardware_assoc_akt", doc_id=hw.doc_id))
    
    # GET: отобразить страницу
    return render_template("hw_view_akt.html", hw=hw, akt=akt)
    
  6. Assistant

    Спасибо за предоставление информации о проекте! У тебя есть достаточно большой код, достаточно сложная структура с множеством классов и маршрутов. Можешь уточнить, что именно ты собираешься добавить или исправить? Какие функции или маршруты нужно реализовать? Или есть конкретные проблемы, с которыми ты сталкиваешься и которые нужно решить?

  7. User

    мне нужно создать страницу для редактирования данных в таблице hardware

  8. Assistant

    Хорошо! Давай добавим страницу для редактирования данных в таблице Hardware. Мы создадим новый маршрут, который будет обрабатывать запрос на редактирование, и соответствующий шаблон для этой страницы.

    1. Создание маршрута для редактирования:

    Добавь следующий маршрут в твой hardware_bp.py:

    @hardware_bp.route("/edit_hardware/<int:hw_id>", methods=["GET", "POST"])
    def edit_hardware(hw_id):
        hardware_item = Hardware.query.get_or_404(hw_id)
        
        if request.method == "POST":
            # Получаем данные из формы
            hardware_item.name = request.form.get("name")
            hardware_item.inv = request.form.get("inv")
            hardware_item.quantity = parse_int(request.form.get("quantity"))
            hardware_item.sn = request.form.get("sn")
            hardware_item.mac = request.form.get("mac")
            # Здесь добавьте остальные поля, которые хотите редактировать
    
            try:
                db.session.commit()
                flash("Запись успешно обновлена!", "success")
                return redirect(url_for("hardware_bp.hardware_assoc", doc_id=hardware_item.doc_id))
            except Exception as e:
                db.session.rollback()
                flash(f"Ошибка при обновлении записи: {e}", "danger")
    
        return render_template("edit_hardware.html", hardware=hardware_item)
    
    1. Создание шаблона для редактирования:

    Создай файл edit_hardware.html в папке шаблонов. Пример простого шаблона для редактирования:

    {% extends "base.html" %}
    {% block content %}
    <h2>Редактирование оборудования</h2>
    <form method="POST">
        <div class="form-group">
            <label for="name">Название:</label>
            <input type="text" class="form-control" id="name" name="name" value="{{ hardware.name }}" required>
        </div>
    
        <div class="form-group">
            <label for="inv">Инвентарный номер:</label>
            <input type="text" class="form-control" id="inv" name="inv" value="{{ hardware.inv }}" required>
        </div>
    
        <div class="form-group">
            <label for="quantity">Количество:</label>
            <input type="number" class="form-control" id="quantity" name="quantity" value="{{ hardware.quantity }}" required>
        </div>
    
        <div class="form-group">
            <label for="sn">Серийный номер:</label>
            <input type="text" class="form-control" id="sn" name="sn" value="{{ hardware.sn }}">
        </div>
    
        <div class="form-group">
            <label for="mac">MAC адрес:</label>
            <input type="text" class="form-control" id="mac" name="mac" value="{{ hardware.mac }}">
        </div>
    
        <!-- Здесь добавьте остальные поля, которые хотите редактировать -->
    
        <button type="submit" class="btn btn-primary">Сохранить изменения</button>
    </form>
    <a href="{{ url_for('hardware_bp.hardware_assoc', doc_id=hardware.doc_id) }}" class="btn btn-secondary">Отменить</a>
    {% endblock %}
    
    1. Обновление ссылки на редактирование:

    Теперь, когда у тебя будет список оборудования (например, на странице hardware_assoc), добавь ссылку для редактирования каждой записи:

    <a href="{{ url_for('hardware_bp.edit_hardware', hw_id=hardware.hw_id) }}" class="btn btn-warning">Редактировать</a>
    

    Теперь у вас есть базовая страница для редактирования данных в таблице Hardware. Проверяй, работает ли всё так, как задумано, и сообщай, если будут нужны уточнения или изменения!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.