public class RepairEditor extends AbstractEditor<RepairProxy, RepairEditor, RepairRequestFactory> {


    public interface RepairDriver extends RequestFactoryEditorDriver<RepairProxy, RepairEditor> {}

    protected BoxLayoutContainer.BoxLayoutData repairLineFieldData = new BoxLayoutContainer.BoxLayoutData(new Margins(5, 10, 5, 10));
    protected BoxLayoutContainer.BoxLayoutData repairLineLabelData = new BoxLayoutContainer.BoxLayoutData(new Margins(5, 30, 5, 10));
    protected VerticalLayoutContainer.VerticalLayoutData repairVerticalData = new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(5, 5, 5, 5));

    TabPanel repairTabPanel;
    /*InfoTabPanel block begin*/
    VerticalLayoutContainer defectsTabPanel;

    VerticalLayoutContainer infoTabPanel;
    VerticalLayoutContainer documentsLayoutContainer;

    HBoxLayoutContainer vu53Container;
    HBoxLayoutContainer listCompletionContainer;


    CarProperties carProps = GWT.create(CarProperties.class);
    TransportRateProperties cargoEtsngProps = GWT.create(TransportRateProperties.class);
    RepairTypeProperties repairTypeProps = GWT.create(RepairTypeProperties.class);
    RailwayProperties railwayProps = GWT.create(RailwayProperties.class);
    DepotProperties depotProps = GWT.create(DepotProperties.class);
    RepairDocumentProperties repairDocumentProps = GWT.create(RepairDocumentProperties.class);
    CompletionRecordProperties completionRecordProperties = GWT.create(CompletionRecordProperties.class);
    PaymentProperties paymentProperties = GWT.create(PaymentProperties.class);

    UploadComponent uploadComponent;
    ListStore<CarProxy> carStore = new ListStore<>(carProps.key());
    ListStore<TransportRateProxy> cargoEtsngStore = new ListStore<>(cargoEtsngProps.key());
    ListStore<RepairTypeProxy> repairTypeStore = new ListStore<>(repairTypeProps.key());
    ListStore<RailwayProxy> railwayStore = new ListStore<>(railwayProps.key());
    ListStore<DepotProxy> depotStore = new ListStore<>(depotProps.key());
    ModelKeyProvider completionKeyProvider = new ModelKeyProvider<CompletionRecordProxy>() {
        @Override
        public String getKey(CompletionRecordProxy item) {
            return getCompletionRecordProxyKey(item.getTitle(), item.getNumber(), item.getDocument());
        }
    };
    ListStore<CompletionRecordProxy> completionRecordProxyListStore = new ListStore<CompletionRecordProxy>(completionKeyProvider);

    Map<Long, RepairDocTypePanel> repairDocTypePanels = new HashMap<>();

    ListStore<Boolean> carLoadedStore = new ListStore<Boolean>(new ModelKeyProvider<Boolean>() {
        @Override
        public String getKey(Boolean item) {
            return item == null || !item ? Boolean.FALSE.toString() : Boolean.TRUE.toString();
        }
    });

    RepairDefectPartsFieldSet partsFieldSet;

    @Path("loadDate")
    DateField loadDate = new DateField(dateTimeProperty);
    @Path("car")
    ComboBox<CarProxy> cars = new ComboBox<>(carStore, carProps.label());
    @Path("loaded")
    ComboBox<Boolean> carLoaded = new ComboBox<>(carLoadedStore,  new LabelProvider<Boolean>() {
        @Override
        public String getLabel(Boolean item) {
            return item == null || !item ? "Порожний" : "Груженый";
        }
    });

    @Path("mileage")
    FloatField mileage  = new FloatField();

    @Path("cargoEtsng")
    ComboBox<TransportRateProxy> cargoEtsng = new ComboBox<>(cargoEtsngStore, cargoEtsngProps.label());
    @Path("repairType")
    ComboBox<RepairTypeProxy> repairTypes = new ComboBox<>(repairTypeStore, repairTypeProps.label());

    @Path("repairStation")
    ComboBox<RailwayProxy> repairStation = new ComboBox<>(new ListStore<RailwayProxy>(railwayProps.key()), railwayProps.label());
    @Path("uncoupleStation")
    ComboBox<RailwayProxy> uncoupleStation = new ComboBox<>(new ListStore<RailwayProxy>(railwayProps.key()), railwayProps.label());
    @Path("currentStation")
    ComboBox<RailwayProxy> currentStation = new ComboBox<>(new ListStore<RailwayProxy>(railwayProps.key()), railwayProps.label());
    @Path("depot")
    ComboBox<DepotProxy> depot = new ComboBox<>(depotStore, depotProps.label());

    @Path("defect1")
    TextField defect1 = new TextField();
    @Path("defect2")
    TextField defect2 = new TextField();
    @Path("defectType1")
    SimpleComboBox<String> defectType1 = new SimpleComboBox<>(new StringLabelProvider<String>());
    @Path("defectType2")
    SimpleComboBox<String> defectType2 = new SimpleComboBox<>(new StringLabelProvider<String>());
    @Path("defectType3")
    SimpleComboBox<String> defectType3 = new SimpleComboBox<>(new StringLabelProvider<String>());

    @Path("vu23Date")
    DateField vu23Date = new DateField(dateTimeProperty);
    @Path("startDate")
    DateField startDate = new DateField(dateTimeProperty);
    @Path("endDate")
    DateField endDate = new DateField(dateTimeProperty);


    @Path("vu23Vu36Days")
    FloatField vu23Vu36Days  = new FloatField();
    @Path("repairDays")
    FloatField repairDays  = new FloatField();
    @Path("downtimeOnStation")
    FloatField downtimeOnStation  = new FloatField();

    @Path("provisionalInvoiceNumber")
    TextField provisionalInvoiceNumber =  new TextField();
    @Path("provisionalInvoiceDate")
    DateField provisionalInvoiceDate= new DateField(dateTimeProperty);
    @Path("provisionalInvoiceAmount")
    FloatField provisionalInvoiceAmount = new FloatField();
    @Path("defectsAbout")
    TextArea defectsAbout = new TextArea();



    @Path("repairDocuments")
    ListStoreEditor<RepairDocumentProxy> repairDocuments;

    @Path("attachments")
    ListStoreEditor<AttachmentProxy> attachments;

    @Path("completionList")
    ListStoreEditor<CompletionRecordProxy> completionList;

    @Path("repairDefects")
    ListStoreEditor<RepairDefectProxy> repairDefects;

    @Path("payments")
    ListStoreEditor<PaymentProxy> payments;

    @Ignore
    TextLabel carFactory = new TextLabel();
    @Ignore
    TextLabel claimCarFactory = new TextLabel();

    @Ignore
    TextLabel carType = new TextLabel();
    @Ignore
    TextLabel carOwner = new TextLabel();
    @Ignore
    TextLabel carBuildingDate = new TextLabel();

    //@Ignore
    //TextLabel carNextRepairDate = new TextLabel();
    @Path("plannedRepairDate")
    DateField carNextRepairDate= new LocalDateField();

    @Ignore
    TextLabel railRoad = new TextLabel();

    @Ignore
    TextLabel repairDebit = new TextLabel();
    @Ignore
    TextLabel repairCredit = new TextLabel();

    @Ignore
    TextLabel repairPaymentDebit = new TextLabel();
    @Ignore
    TextLabel repairPaymentCredit = new TextLabel();


    @Ignore
    TextLabel defectsRepairSum = new TextLabel();
    @Ignore
    TextLabel defectsWorkSum = new TextLabel();
    @Ignore
    TextLabel defectsTotalSumWithoutTaxes = new TextLabel();
    @Ignore
    TextLabel defectsTotalSumTaxes = new TextLabel();
    @Ignore
    TextLabel defectsTotalSumWithTaxes = new TextLabel();
    @Ignore
    TextLabel defectsTotalSaveSum = new TextLabel();

    @Ignore
    ListStoreEditor<CompletionRecordProxy> completionRecordVu53FirstStoreEditor;
    @Ignore
    ListStoreEditor<CompletionRecordProxy> completionRecordVu53LastStoreEditor;
    @Ignore
    ListStoreEditor<CompletionRecordProxy> completionRecordListCompletionAutoStoreEditor;
    @Ignore
    ListStoreEditor<CompletionRecordProxy> completionRecordListCompletion2FieldsStoreEditor;
    @Ignore
    ListStoreEditor<CompletionRecordProxy> completionRecordListCompletion4FieldsMainStoreEditor;
    @Ignore
    ListStoreEditor<CompletionRecordProxy> completionRecordListCompletion4FieldsLeftStoreEditor;
    @Ignore
    ListStoreEditor<CompletionRecordProxy> completionRecordListCompletion4FieldsRightStoreEditor;

    @Ignore
    ListStoreEditor<CompletionRecordProxy> completionRecordPartWheelsStoreEditor;
    @Ignore
    ListStoreEditor<CompletionRecordProxy> completionRecordPartFrameStoreEditor;
    @Ignore
    ListStoreEditor<CompletionRecordProxy> completionRecordPartBeamStoreEditor;

    HBoxLayoutContainer mxLabelContainer = new HBoxLayoutContainer();
    /*InfoTabPanel block end*/


    private List<Grid> gridsForRefresh = new ArrayList<>();
    private List<CheckBox> yokeCheckBoxesForRefresh = new ArrayList<>();
    private List<CheckBox> brakeEquipmentCheckBoxesForRefresh = new ArrayList<>();
    private List<VerticalLayoutContainer> planRepairTabs = new ArrayList<>();
    private List<VerticalLayoutContainer> currentRepairTabs = new ArrayList<>();


    ListStore<PaymentProxy> freePayments =  new ListStore<PaymentProxy>(paymentProperties.key());


    @Ignore
    final TextField paymentNumber = new TextField();
    @Ignore
    final DateField paymentLoadDate = new DateField(dateTimeProperty);
    @Ignore
    final NumberField<Float> paymentAmount = new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor());
    @Ignore
    final TextArea paymentDetails = new TextArea();
    @Ignore
    final TextButton paymentButton = new TextButton("Прикрепить");
    @Ignore
    final TextField invoiceNumber = new TextField();
    @Ignore
    final DateField invoiceLoadDate = new DateField(dateTimeProperty);
    @Ignore
    final NumberField<Float> invoiceAmount = new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor());
    @Ignore
    final TextLabel vu25TextField = new TextLabel();
    @Ignore
    final TextLabel vu41TextField = new TextLabel();
    @Ignore
    final TextField lesserTextField = new TextField();
    private RepairClaimProxy repairClaimProxy = null;

    private Grid<PaymentProxy> paymentGrid;

    Map<ListStore<CompletionRecordProxy>, List<CompletionChecker>> completionCheckerList = new HashMap<>();
    public RepairEditor() {
        initEditor();

    }

    @Override
    protected void initRequestFactory() {
        service = GWT.create(RepairRequestFactory.class);
        driver = GWT.create(RepairDriver.class);
        service.initialize(new SimpleEventBus(), transport);
        driver.initialize(service, this);
    }

    @Override
    protected void initUI() {
        fieldsPanel.setHeight(675);
        fieldsPanel.setWidth(1000);


        repairTabPanel = new TabPanel();
        infoTabPanel = new VerticalLayoutContainer();
        fillInfoTabPanel(infoTabPanel);
        infoTabPanel.setTitle("Основная информация");
        repairTabPanel.add(infoTabPanel, infoTabPanel.getTitle());

        VerticalLayoutContainer paymentTabPanel = new VerticalLayoutContainer();
        fillPaymentsTabPanel(paymentTabPanel);
        paymentTabPanel.setTitle("Платежное поручение");
        planRepairTabs.add(paymentTabPanel);
        currentRepairTabs.add(paymentTabPanel);


        VerticalLayoutContainer documentsTabPanel = new VerticalLayoutContainer();
        fillDocumentsTabPanel(documentsTabPanel);
        documentsTabPanel.setTitle("Документы");
        planRepairTabs.add(documentsTabPanel);
        currentRepairTabs.add(documentsTabPanel);

        defectsTabPanel = new VerticalLayoutContainer();
        fillDefectsTabPanel(defectsTabPanel);
        defectsTabPanel.setTitle("Неисправности");
        planRepairTabs.add(defectsTabPanel);
        currentRepairTabs.add(defectsTabPanel);

        VerticalLayoutContainer completionTabPanel = new VerticalLayoutContainer();
        fillCompletionTabPanel(completionTabPanel);
        completionTabPanel.setTitle("Информация о комплектации");
        planRepairTabs.add(completionTabPanel);



        VerticalLayoutContainer claimsTabPanel = new VerticalLayoutContainer();
        fillClaimTabPanel(claimsTabPanel);
        claimsTabPanel.setTitle("Претензии");
        currentRepairTabs.add(claimsTabPanel);





        addWidget(repairTabPanel);
    }

    protected void fillCompletionTabPanel(InsertResizeContainer container){
        completionRecordPartWheelsStoreEditor  = new ListStoreEditor<CompletionRecordProxy>(new ListStore<CompletionRecordProxy>(completionKeyProvider));
        completionRecordPartBeamStoreEditor  = new ListStoreEditor<CompletionRecordProxy>(new ListStore<CompletionRecordProxy>(completionKeyProvider));
        completionRecordPartFrameStoreEditor  = new ListStoreEditor<CompletionRecordProxy>(new ListStore<CompletionRecordProxy>(completionKeyProvider));

        FieldSet wheelFieldSet = new FieldSet();
        wheelFieldSet.setHeadingText("Колёсные пары");
        wheelFieldSet.setCollapsible(false);
        wheelFieldSet.setLayoutData(repairVerticalData);
        container.add(wheelFieldSet);

        ColumnConfig<CompletionRecordProxy, ?> ccTitle = new ColumnConfig<CompletionRecordProxy, String>(new ValueProvider<CompletionRecordProxy, String>() {
            @Override
            public String getValue(CompletionRecordProxy object) {
                String title = object.getTitle();
                if (!"Другое".equals(title)) title += " " + object.getNumber();
                return title;
            }

            @Override
            public void setValue(CompletionRecordProxy object, String value) {}

            @Override
            public String getPath() {return null;}
        }, 140, "Наименование");

        ColumnConfig<CompletionRecordProxy, Float> ccLeftFlange = new ColumnConfig<CompletionRecordProxy, Float>(completionRecordProperties.flangeWidthLeft(), 120, "Толщина гребня");
        ccLeftFlange.setHeader(getMultiLineHeader("Толщина гребня","Левая КП"));
        ColumnConfig<CompletionRecordProxy, Float> ccRightFlange = new ColumnConfig<CompletionRecordProxy, Float>(completionRecordProperties.flangeWidthRight(), 120, "Толщина гребня");
        ccRightFlange.setHeader(getMultiLineHeader("Толщина гребня","Правая КП"));
        ColumnConfig<CompletionRecordProxy, Float> ccLeftRim = new ColumnConfig<CompletionRecordProxy, Float>(completionRecordProperties.rimWidthLeft(), 120, "Толщина обода");
        ccLeftRim.setHeader(getMultiLineHeader("Толщина обода","Левая КП"));
        ColumnConfig<CompletionRecordProxy, Float> ccRightRim = new ColumnConfig<CompletionRecordProxy, Float>(completionRecordProperties.rimWidthRight(), 120, "Толщина обода");
        ccRightRim.setHeader(getMultiLineHeader("Толщина обода","Правая КП"));
        ColumnConfig<CompletionRecordProxy, Long> ccNumber = new ColumnConfig<CompletionRecordProxy, Long>(completionRecordProperties.numberNew(), 120, "Номер");
        ColumnConfig<CompletionRecordProxy, Integer> ccCode = new ColumnConfig<CompletionRecordProxy, Integer>(completionRecordProperties.codeNew(), 120, "Код изготовителя");
        ColumnConfig<CompletionRecordProxy, Integer> ccYear = new ColumnConfig<CompletionRecordProxy, Integer>(completionRecordProperties.yearNew(), 120, "Год изготовления");

        final List<ColumnConfig<CompletionRecordProxy, ?>> listWheelCC = new ArrayList<>();

        listWheelCC.add(ccTitle);
        listWheelCC.add(ccRightRim);
        listWheelCC.add(ccLeftRim);
        listWheelCC.add(ccRightFlange);
        listWheelCC.add(ccLeftFlange);
        listWheelCC.add(ccNumber);
        listWheelCC.add(ccCode);
        listWheelCC.add(ccYear);


        Grid gridWheel = new Grid<CompletionRecordProxy>(completionRecordPartWheelsStoreEditor.getStore(), new ColumnModel<CompletionRecordProxy>(listWheelCC));
        completionRecordPartWheelsStoreEditor.getStore().setAutoCommit(true);
        GroupingView<CompletionRecordProxy> listWheelView = new GroupingView<CompletionRecordProxy>();
        listWheelView.setAutoFill(false);
        listWheelView.setColumnLines(true);
        listWheelView.setSortingEnabled(false);
        listWheelView.setEnableGroupingMenu(false);
        listWheelView.setEnableNoGroups(false);
        listWheelView.setShowGroupedColumn(false);
        listWheelView.setForceFit(false);
        gridWheel.setView(listWheelView);

        final GridInlineEditing<CompletionRecordProxy> listWheelFieldsEditing = new GridInlineEditing<CompletionRecordProxy>(gridWheel);
        List<CompletionChecker> wheelCheckers = new ArrayList<CompletionChecker>();
        listWheelFieldsEditing.addEditor(ccRightRim, new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor()));
        wheelCheckers.add(new CompletionRimRightChecker());
        listWheelFieldsEditing.addEditor(ccLeftRim, new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor()));
        wheelCheckers.add(new CompletionRimLeftChecker());
        listWheelFieldsEditing.addEditor(ccRightFlange, new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor()));
        wheelCheckers.add(new CompletionFlangeRightChecker());
        listWheelFieldsEditing.addEditor(ccLeftFlange, new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor()));
        wheelCheckers.add(new CompletionFlangeLeftChecker());
        listWheelFieldsEditing.addEditor(ccNumber, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999999999l), new NumberPropertyEditor.LongPropertyEditor()));
        wheelCheckers.add(new CompletionNumberNewChecker());
        listWheelFieldsEditing.addEditor(ccCode, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        wheelCheckers.add(new CompletionCodeNewChecker());
        listWheelFieldsEditing.addEditor(ccYear, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        wheelCheckers.add(new CompletionYearNewChecker());
        completionCheckerList.put(completionRecordPartWheelsStoreEditor.getStore(), wheelCheckers);
        listWheelFieldsEditing.setRevertInvalid(true);
        listWheelFieldsEditing.addStartEditHandler(new StartEditEvent.StartEditHandler<CompletionRecordProxy>() {
            @Override
            public void onStartEdit(StartEditEvent<CompletionRecordProxy> completionRecordProxyStartEditEvent) {
                for (ColumnConfig cc : completionRecordProxyStartEditEvent.getSource().getEditableGrid().getColumnModel().getColumns()) {
                    Field field = completionRecordProxyStartEditEvent.getSource().getEditor(cc);
                    if (field != null && field instanceof NumberField ) {
                        if (!((NumberField)field).isCurrentValid()) ((NumberField)field).setText("");
                    }
                }
            }
        });
        listWheelFieldsEditing.addCompleteEditHandler(new CompleteEditEvent.CompleteEditHandler<CompletionRecordProxy>() {
            @Override
            public void onCompleteEdit(CompleteEditEvent<CompletionRecordProxy> event) {
                CompletionRecordProxy cpr = completionRecordPartWheelsStoreEditor.getStore().get(event.getEditCell().getRow());
                if (!completionList.getStore().getAll().contains(cpr)) completionList.getStore().add(cpr);
                refreshGrids();
            }
        });
        wheelFieldSet.add(gridWheel);


        FieldSet frameFieldSet = new FieldSet();
        frameFieldSet.setHeadingText("Боковые рамы");
        frameFieldSet.setCollapsible(false);
        frameFieldSet.setLayoutData(repairVerticalData);
        container.add(frameFieldSet);

        List<ColumnConfig<CompletionRecordProxy, ?>> listFrameCC = new ArrayList<>();
        listFrameCC.add(ccTitle);
        listFrameCC.add(ccNumber);
        listFrameCC.add(ccCode);
        listFrameCC.add(ccYear);


        Grid gridFrame = new Grid<CompletionRecordProxy>(completionRecordPartFrameStoreEditor.getStore(), new ColumnModel<CompletionRecordProxy>(listFrameCC));
        completionRecordPartFrameStoreEditor.getStore().setAutoCommit(true);
        GroupingView<CompletionRecordProxy> listFrameView = new GroupingView<CompletionRecordProxy>();
        listFrameView.setAutoFill(false);
        listFrameView.setColumnLines(true);
        listFrameView.setSortingEnabled(false);
        listFrameView.setEnableGroupingMenu(false);
        listFrameView.setEnableNoGroups(false);
        listFrameView.setShowGroupedColumn(false);
        listFrameView.setForceFit(false);
        gridFrame.setView(listFrameView);
        final GridInlineEditing<CompletionRecordProxy> listFrameFieldsEditing = new GridInlineEditing<CompletionRecordProxy>(gridFrame);
        List<CompletionChecker> frameCheckers = new ArrayList<CompletionChecker>();
        listFrameFieldsEditing.addEditor(ccNumber, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999999999l), new NumberPropertyEditor.LongPropertyEditor()));
        frameCheckers.add(new CompletionNumberNewChecker());
        listFrameFieldsEditing.addEditor(ccCode, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        frameCheckers.add(new CompletionCodeNewChecker());
        listFrameFieldsEditing.addEditor(ccYear, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        frameCheckers.add(new CompletionYearNewChecker());
        completionCheckerList.put(completionRecordPartFrameStoreEditor.getStore(), frameCheckers);
        listFrameFieldsEditing.setRevertInvalid(true);
        listFrameFieldsEditing.addStartEditHandler(new StartEditEvent.StartEditHandler<CompletionRecordProxy>() {
            @Override
            public void onStartEdit(StartEditEvent<CompletionRecordProxy> completionRecordProxyStartEditEvent) {
                for (ColumnConfig cc : completionRecordProxyStartEditEvent.getSource().getEditableGrid().getColumnModel().getColumns()) {
                    Field field = completionRecordProxyStartEditEvent.getSource().getEditor(cc);
                    if (field != null && field instanceof NumberField ) {
                        if (!((NumberField)field).isCurrentValid()) ((NumberField)field).setText("");
                    }
                }
            }
        });
        listFrameFieldsEditing.addCompleteEditHandler(new CompleteEditEvent.CompleteEditHandler<CompletionRecordProxy>() {
            @Override
            public void onCompleteEdit(CompleteEditEvent<CompletionRecordProxy> event) {
                CompletionRecordProxy cpr = completionRecordPartFrameStoreEditor.getStore().get(event.getEditCell().getRow());
                if(!completionList.getStore().getAll().contains(cpr)) completionList.getStore().add(cpr);
                refreshGrids();
                //listFrameFieldsEditing.clearEditors();
            }
        });
        frameFieldSet.add(gridFrame);


        FieldSet beamFieldSet = new FieldSet();
        beamFieldSet.setHeadingText("Надрессорные балки");
        beamFieldSet.setCollapsible(false);
        beamFieldSet.setLayoutData(repairVerticalData);
        container.add(beamFieldSet);


        List<ColumnConfig<CompletionRecordProxy, ?>> listBeamCC = new ArrayList<>();
        listBeamCC.add(ccTitle);
        listBeamCC.add(ccNumber);
        listBeamCC.add(ccCode);
        listBeamCC.add(ccYear);


        Grid gridBeam = new Grid<CompletionRecordProxy>(completionRecordPartBeamStoreEditor.getStore(), new ColumnModel<CompletionRecordProxy>(listBeamCC));
        completionRecordPartFrameStoreEditor.getStore().setAutoCommit(true);
        GroupingView<CompletionRecordProxy> listBeamView = new GroupingView<CompletionRecordProxy>();
        listBeamView.setAutoFill(false);
        listBeamView.setColumnLines(true);
        listBeamView.setSortingEnabled(false);
        listBeamView.setEnableGroupingMenu(false);
        listBeamView.setEnableNoGroups(false);
        listBeamView.setShowGroupedColumn(false);
        listBeamView.setForceFit(false);
        gridBeam.setView(listBeamView);
        final GridInlineEditing<CompletionRecordProxy> listBeamFieldsEditing = new GridInlineEditing<CompletionRecordProxy>(gridBeam);
        List<CompletionChecker> beamCheckers = new ArrayList<CompletionChecker>();
        listBeamFieldsEditing.addEditor(ccNumber, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999999999l), new NumberPropertyEditor.LongPropertyEditor()));
        beamCheckers.add(new CompletionNumberNewChecker());
        listBeamFieldsEditing.addEditor(ccCode, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        beamCheckers.add(new CompletionCodeNewChecker());
        listBeamFieldsEditing.addEditor(ccYear, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        beamCheckers.add(new CompletionYearNewChecker());
        completionCheckerList.put(completionRecordPartBeamStoreEditor.getStore(), beamCheckers);
        listBeamFieldsEditing.setRevertInvalid(true);
        listBeamFieldsEditing.addCompleteEditHandler(new CompleteEditEvent.CompleteEditHandler<CompletionRecordProxy>() {
            @Override
            public void onCompleteEdit(CompleteEditEvent<CompletionRecordProxy> event) {
                CompletionRecordProxy cpr = completionRecordPartBeamStoreEditor.getStore().get(event.getEditCell().getRow());
                if(!completionList.getStore().getAll().contains(cpr)) completionList.getStore().add(cpr);
                refreshGrids();
                //listBeamFieldsEditing.clearEditors();
            }
        });
        listBeamFieldsEditing.addStartEditHandler(new StartEditEvent.StartEditHandler<CompletionRecordProxy>() {
            @Override
            public void onStartEdit(StartEditEvent<CompletionRecordProxy> completionRecordProxyStartEditEvent) {
                for (ColumnConfig cc : completionRecordProxyStartEditEvent.getSource().getEditableGrid().getColumnModel().getColumns()) {
                    Field field = completionRecordProxyStartEditEvent.getSource().getEditor(cc);
                    if (field != null && field instanceof NumberField ) {
                        if (!((NumberField)field).isCurrentValid()) ((NumberField)field).setText("");
                    }
                }
            }
        });
        beamFieldSet.add(gridBeam);


    }

    protected void fillClaimTabPanel(InsertResizeContainer container){

        FieldSet claimFieldSet = new FieldSet();
        claimFieldSet.setHeadingText("Информация о претензии");
        claimFieldSet.setCollapsible(true);
        claimFieldSet.setLayoutData(repairVerticalData);
        VerticalLayoutContainer claimContainer = new VerticalLayoutContainer();
        claimFieldSet.add(claimContainer);

        HBoxLayoutContainer horizontalLayoutContainerContractFirstLine =  new HBoxLayoutContainer();
        claimContainer.add(horizontalLayoutContainerContractFirstLine);

        horizontalLayoutContainerContractFirstLine.add(createFieldLabel(vu41TextField, "Перевыставление счета при наличии ВУ-41", repairLineFieldData), repairLineFieldData);
        horizontalLayoutContainerContractFirstLine.add(createFieldLabel(vu25TextField, "Перевыставление счета при наличии ВУ-25", repairLineFieldData), repairLineFieldData);

        HBoxLayoutContainer horizontalLayoutContainerContractSecondLine =  new HBoxLayoutContainer();
        claimContainer.add(horizontalLayoutContainerContractSecondLine);


        horizontalLayoutContainerContractSecondLine.add(createFieldLabel(claimCarFactory, "Завод-изготовитель", repairLineFieldData), repairLineFieldData);
        horizontalLayoutContainerContractSecondLine.add(createFieldLabel(lesserTextField, "Арендодатель", repairLineFieldData), repairLineFieldData);
    }


    protected void fillInfoTabPanel(InsertResizeContainer container){
        loadDate.setReadOnly(true);
        HBoxLayoutContainer horizontalLayoutContainerHeader =  new HBoxLayoutContainer();
        horizontalLayoutContainerHeader.setPadding(new Padding(5));
        horizontalLayoutContainerHeader.setHBoxLayoutAlign(HBoxLayoutContainer.HBoxLayoutAlign.STRETCHMAX);
        container.add(horizontalLayoutContainerHeader);
        horizontalLayoutContainerHeader.add(createFieldLabelAutoWidth(loadDate, "Дата внесения в реестр", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerHeader.add(createFieldLabelAutoWidth(repairDebit, "Дебет", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerHeader.add(createFieldLabelAutoWidth(repairCredit, "Кредит", repairLineFieldData), repairLineLabelData);

        VerticalLayoutContainer verticalLayoutContainer =  new VerticalLayoutContainer();

        container.add(verticalLayoutContainer);
        FieldSet carFieldSet = new FieldSet();
        carFieldSet.setHeadingText("Информация о вагоне");
        carFieldSet.setCollapsible(true);
        carFieldSet.setLayoutData(repairVerticalData);
        verticalLayoutContainer.add(carFieldSet);

        VerticalLayoutContainer contractContainer = new VerticalLayoutContainer();
        carFieldSet.add(contractContainer);

        HBoxLayoutContainer horizontalLayoutContainerContractFirstLine =  new HBoxLayoutContainer();
        contractContainer.add(horizontalLayoutContainerContractFirstLine);
        HBoxLayoutContainer horizontalLayoutContainerContractSecondLine =  new HBoxLayoutContainer();
        contractContainer.add(horizontalLayoutContainerContractSecondLine);

        cars.setAllowBlank(false);
        cars.setTriggerAction(ComboBoxCell.TriggerAction.ALL);
        cars.setMinListWidth(250);
        carStore.addSortInfo(new Store.StoreSortInfo<CarProxy>(carProps.number(), SortDir.ASC));
        cars.addSelectionHandler(new SelectionHandler<CarProxy>() {
            @Override
            public void onSelection(SelectionEvent<CarProxy> event) {
                fillCarFields(event.getSelectedItem());
            }
        });

        carLoaded.setAllowBlank(false);
        carLoaded.setTriggerAction(ComboBoxCell.TriggerAction.ALL);
        carLoaded.addSelectionHandler(new SelectionHandler<Boolean>() {
            @Override
            public void onSelection(SelectionEvent<Boolean> event) {
                enableCargoField(event.getSelectedItem());
            }
        });

        cargoEtsng.setTriggerAction(ComboBoxCell.TriggerAction.ALL);
        cargoEtsngStore.addSortInfo(new Store.StoreSortInfo<TransportRateProxy>(cargoEtsngProps.title(), SortDir.ASC));
        cargoEtsng.setMinListWidth(250);

        repairTypes.setAllowBlank(false);
        repairTypes.setForceSelection(true);
        repairTypes.setTriggerAction(ComboBoxCell.TriggerAction.ALL);
        repairTypeStore.addSortInfo(new Store.StoreSortInfo<RepairTypeProxy>(repairTypeProps.title(), SortDir.ASC));
        repairTypes.setWidth(350);
        repairTypes.addSelectionHandler(new SelectionHandler<RepairTypeProxy>() {
            @Override
            public void onSelection(SelectionEvent<RepairTypeProxy> event) {
                hideNotUsingDocuments(event.getSelectedItem().getPlanned());
                updateRepairTabsHeaders(event.getSelectedItem().getPlanned());
                changeRepairTabs(event.getSelectedItem().getPlanned());
                partsFieldSet.setRepairType(event.getSelectedItem().getPlanned());
            }
        });

        defect1.setWidth(350);
        defect2.setWidth(350);

        defectType1.setTriggerAction(ComboBoxCell.TriggerAction.ALL);
        defectType2.setTriggerAction(ComboBoxCell.TriggerAction.ALL);
        defectType3.setTriggerAction(ComboBoxCell.TriggerAction.ALL);

        carStore.addSortInfo(new Store.StoreSortInfo<CarProxy>(carProps.number(), SortDir.ASC));

        railwayStore.addSortInfo(new Store.StoreSortInfo<RailwayProxy>(railwayProps.title(), SortDir.ASC));
        repairStation.setTriggerAction(ComboBoxCell.TriggerAction.ALL);
        uncoupleStation.setAllowBlank(false);
        uncoupleStation.setTriggerAction(ComboBoxCell.TriggerAction.ALL);
        currentStation.setAllowBlank(false);
        currentStation.setTriggerAction(ComboBoxCell.TriggerAction.ALL);
        currentStation.addSelectionHandler(new SelectionHandler<RailwayProxy>() {
            @Override
            public void onSelection(SelectionEvent<RailwayProxy> event) {
                fillCurrentStationFields(event.getSelectedItem());
            }
        });

        depotStore.addSortInfo(new Store.StoreSortInfo<DepotProxy>(depotProps.title(), SortDir.ASC));
        depot.setAllowBlank(false);
        depot.setTriggerAction(ComboBoxCell.TriggerAction.ALL);

        horizontalLayoutContainerContractFirstLine.add(createTopFieldLabel(cars, "Номер вагона", repairLineFieldData), repairLineLabelData);

        horizontalLayoutContainerContractFirstLine.add(createTopFieldLabel(carFactory, "Завод-изготовитель", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerContractFirstLine.add(createTopFieldLabel(carType, "Род вагона", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerContractFirstLine.add(createTopFieldLabel(carOwner, "Собственник", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerContractFirstLine.add(createTopFieldLabel(carBuildingDate, "Дата постройки", repairLineFieldData), repairLineLabelData);


        horizontalLayoutContainerContractSecondLine.add(createTopFieldLabel(carLoaded, "Загруженность", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerContractSecondLine.add(createTopFieldLabel(mileage, "Остат. пробег", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerContractSecondLine.add(createTopFieldLabel(cargoEtsng, "Груз ЕТСНГ", repairLineFieldData), repairLineLabelData);

        FieldSet fileFieldSet = new FieldSet();
        //fileFieldSet.setHeadingText("Информация из файла по ремонту");
        fileFieldSet.setHeadingText("Информация по ремонту");
        fileFieldSet.setCollapsible(true);
        fileFieldSet.setLayoutData(repairVerticalData);
        verticalLayoutContainer.add(fileFieldSet);

        VerticalLayoutContainer fileContainer = new VerticalLayoutContainer();
        fileFieldSet.add(fileContainer);



        FieldSet fileRepairFieldSet = new FieldSet();
        fileRepairFieldSet.setHeadingText("Ремонт");
        fileRepairFieldSet.setCollapsible(true);
        fileRepairFieldSet.setLayoutData(verticalData);
        fileContainer.add(fileRepairFieldSet);

        VerticalLayoutContainer fileRepairContainer = new VerticalLayoutContainer();
        fileRepairFieldSet.add(fileRepairContainer);

        HBoxLayoutContainer horizontalLayoutContainerFileFirstLine =  new HBoxLayoutContainer();
        fileRepairContainer.add(horizontalLayoutContainerFileFirstLine);
        HBoxLayoutContainer horizontalLayoutContainerFileSecondLine =  new HBoxLayoutContainer();
        fileRepairContainer.add(horizontalLayoutContainerFileSecondLine);
        HBoxLayoutContainer horizontalLayoutContainerFileThirdLine =  new HBoxLayoutContainer();
        fileRepairContainer.add(horizontalLayoutContainerFileThirdLine);
        HBoxLayoutContainer horizontalLayoutContainerFileForthLine =  new HBoxLayoutContainer();
        fileRepairContainer.add(horizontalLayoutContainerFileForthLine);

        horizontalLayoutContainerFileFirstLine.add(createFieldLabel(repairTypes, "Вид ремонта", repairLineFieldData, 150), repairLineFieldData);

        horizontalLayoutContainerFileSecondLine.add(createFieldLabel(defectType1, "Тип неисправности 1", repairLineFieldData, 150), repairLineFieldData);
        horizontalLayoutContainerFileSecondLine.add(createFieldLabelAutoWidth(defect1, "Неисправность 1", repairLineFieldData), repairLineFieldData);

        horizontalLayoutContainerFileThirdLine.add(createFieldLabel(defectType2, "Тип неисправности 2", repairLineFieldData, 150), repairLineFieldData);
        horizontalLayoutContainerFileThirdLine.add(createFieldLabelAutoWidth(defect2, "Неисправность 2", repairLineFieldData), repairLineFieldData);

        horizontalLayoutContainerFileForthLine.add(createFieldLabel(defectType3, "Тип неисправности 3", repairLineFieldData, 150), repairLineFieldData);

        FieldSet fileStationsDepotFieldSet = new FieldSet();
        fileStationsDepotFieldSet.setHeadingText("Станции и Депо");
        fileStationsDepotFieldSet.setCollapsible(true);
        fileStationsDepotFieldSet.setLayoutData(verticalData);
        fileContainer.add(fileStationsDepotFieldSet);

        VerticalLayoutContainer fileStationsContainer = new VerticalLayoutContainer();
        fileStationsDepotFieldSet.add(fileStationsContainer);
        HBoxLayoutContainer horizontalLayoutContainerFileStationsLine =  new HBoxLayoutContainer();
        fileStationsContainer.add(horizontalLayoutContainerFileStationsLine);

        horizontalLayoutContainerFileStationsLine.add(createTopFieldLabel(repairStation, "Станция ремонта", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerFileStationsLine.add(createTopFieldLabel(uncoupleStation, "Станция отцепки", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerFileStationsLine.add(createTopFieldLabel(currentStation, "Станция нахождения", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerFileStationsLine.add(createTopFieldLabel(railRoad, "Дорога", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerFileStationsLine.add(createTopFieldLabel(depot, "Депо", repairLineFieldData), repairLineLabelData);

        FieldSet fileDatesFieldSet = new FieldSet();
        fileDatesFieldSet.setHeadingText("Временные параметры и даты");
        fileDatesFieldSet.setCollapsible(true);
        fileDatesFieldSet.setLayoutData(verticalData);
        fileContainer.add(fileDatesFieldSet);

        VerticalLayoutContainer fileDatesContainer = new VerticalLayoutContainer();
        fileDatesFieldSet.add(fileDatesContainer);

        HBoxLayoutContainer horizontalLayoutContainerFileDatesFirstLine =  new HBoxLayoutContainer();
        fileDatesContainer.add(horizontalLayoutContainerFileDatesFirstLine);

        HBoxLayoutContainer horizontalLayoutContainerFileDatesSecondLine =  new HBoxLayoutContainer();
        fileDatesContainer.add(horizontalLayoutContainerFileDatesSecondLine);

        vu23Date.setAllowBlank(false);

        //this.editedEntity
        Validator<Date> dateValidator = new Validator<Date>() {
            @Override
            public List<EditorError> validate(Editor<Date> editor, Date value) {
                List<EditorError> errors = new ArrayList<>();
                if(startDate.getValue() == null && endDate.getValue() == null) {
                    return null;
                }
                if(startDate.getValue() == null && endDate.getValue() != null) {
                    errors.add(new SimpleEditorError(startDate, value, "Дата начала ремонта должна быть указана"));
                    return errors;
                }
                if(startDate.getValue().compareTo(endDate.getValue()) > 0) {
                    errors.add(new SimpleEditorError(editor, value, "Дата окончания ремонта не может быть раньше даты начала ремонта"));
                    return errors;
                }
                return null;
            }
        };
        startDate.addValidator(dateValidator);
        endDate.addValidator(dateValidator);
        horizontalLayoutContainerFileDatesFirstLine.add(createTopFieldLabel(vu23Date, "Дата ВУ-23", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerFileDatesFirstLine.add(createTopFieldLabel(startDate, "Начало ремонта", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerFileDatesFirstLine.add(createTopFieldLabel(endDate, "Конец ремонта", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerFileDatesFirstLine.add(createTopFieldLabel(vu23Vu36Days, "От ВУ-23 до ВУ-36 (в сутках)", repairLineFieldData), repairLineLabelData);

        horizontalLayoutContainerFileDatesSecondLine.add(createTopFieldLabel(repairDays, "Суток в ремонте", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerFileDatesSecondLine.add(createTopFieldLabel(downtimeOnStation, "Простой на ст. ремонта", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerFileDatesSecondLine.add(createTopFieldLabel(carNextRepairDate, "Дата планового ремонта по паспорту", repairLineFieldData), repairLineLabelData);

        // not editable because the date is stored and edited at Cars
        carNextRepairDate.setReadOnly(true);
    }

    protected void fillDocumentsTabPanel(InsertResizeContainer container){

        FieldSet provisionalInvoiceFieldSet = new FieldSet();
        provisionalInvoiceFieldSet.setHeadingText("Счет предварительный");
        provisionalInvoiceFieldSet.setCollapsible(false);
        provisionalInvoiceFieldSet.setLayoutData(repairVerticalData);
        container.add(provisionalInvoiceFieldSet);

        VerticalLayoutContainer provisionalInvoiceContainer = new VerticalLayoutContainer();
        provisionalInvoiceFieldSet.add(provisionalInvoiceContainer);

        HBoxLayoutContainer horizontalLayoutContainerProvisionalInvoiceLine =  new HBoxLayoutContainer();
        provisionalInvoiceContainer.add(horizontalLayoutContainerProvisionalInvoiceLine);

        horizontalLayoutContainerProvisionalInvoiceLine.add(createFieldLabelAutoWidth(provisionalInvoiceNumber, "Номер", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerProvisionalInvoiceLine.add(createFieldLabelAutoWidth(provisionalInvoiceDate, "Дата", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerProvisionalInvoiceLine.add(createFieldLabelAutoWidth(provisionalInvoiceAmount, "Сумма", repairLineFieldData), repairLineLabelData);
        provisionalInvoiceAmount.addValueChangeHandler(new ValueChangeHandler<Float>() {
            @Override
            public void onValueChange(ValueChangeEvent<Float> event) {
                recalculateDefectReadOnlyDocumentFields();
            }
        });

        vu53Container = new HBoxLayoutContainer();
        vu53Container.add(getVu53Panel(), new BoxLayoutContainer.BoxLayoutData(new Margins(10)));

        listCompletionContainer = new HBoxLayoutContainer();
        listCompletionContainer.add(getListCompletionPanel(), new BoxLayoutContainer.BoxLayoutData(new Margins(10)));


        FieldSet documentsFieldSet = new FieldSet();
        documentsFieldSet.setHeadingText("Документы");
        documentsFieldSet.setCollapsible(false);
        documentsFieldSet.setLayoutData(repairVerticalData);
        container.add(documentsFieldSet);

        HBoxLayoutContainer documentsWithAttachmentsLayoutContainer = new HBoxLayoutContainer();

        VerticalLayoutContainer documentsCommonLayoutContainer = new VerticalLayoutContainer();
        documentsCommonLayoutContainer.setWidth(750);
        HBoxLayoutContainer documentsHeaderLayoutContainer = new HBoxLayoutContainer();
        documentsHeaderLayoutContainer.setPadding(new Padding(5));
        documentsHeaderLayoutContainer.setHBoxLayoutAlign(HBoxLayoutContainer.HBoxLayoutAlign.TOP);

        documentsLayoutContainer = new VerticalLayoutContainer();
        documentsLayoutContainer.setScrollMode(ScrollSupport.ScrollMode.AUTOY);
        documentsLayoutContainer.setHeight(450);

        documentsWithAttachmentsLayoutContainer.add(documentsCommonLayoutContainer);
        uploadComponent = new UploadComponent("repair-attachments", "Список файлов", 200, 505){
            @Override
            protected void sendRequestForAttachment(String guid, Receiver<AttachmentProxy> receiver){
                service.attachments().findByGuid(guid).fire(receiver);
            }
            @Override
            protected AttachmentProxy openAttachmentForEdit(AttachmentProxy ap){
                return context.edit(ap);
            }
        };
        documentsWithAttachmentsLayoutContainer.add(uploadComponent, new BoxLayoutContainer.BoxLayoutData(new Margins(0, 0, 0, 10)));
        documentsWithAttachmentsLayoutContainer.add(uploadComponent.getUploader());
        attachments = uploadComponent.getAttachmentStoreEditor();

        documentsFieldSet.add(documentsWithAttachmentsLayoutContainer);
        int commonLabelWidth = 100;
        BoxLayoutContainer.BoxLayoutData boxLayoutRight10 = new BoxLayoutContainer.BoxLayoutData(new Margins(0, 5, 0, 0));
        documentsHeaderLayoutContainer.add(createLabelCenterTextAlign("Наименование документа", 135), boxLayoutRight10);
        documentsHeaderLayoutContainer.add(createLabelCenterTextAlign("Наличие", 50), boxLayoutRight10);
        documentsHeaderLayoutContainer.add(createLabelCenterTextAlign("Дата поступления электронной версии", commonLabelWidth), boxLayoutRight10);
        documentsHeaderLayoutContainer.add(createLabelCenterTextAlign("Дата поступления оригинала", commonLabelWidth), boxLayoutRight10);
        documentsHeaderLayoutContainer.add(createLabelCenterTextAlign("Сумма", commonLabelWidth), boxLayoutRight10);
        documentsHeaderLayoutContainer.add(createLabelCenterTextAlign("Номер документа", commonLabelWidth), boxLayoutRight10);
        documentsHeaderLayoutContainer.add(createLabelCenterTextAlign("Дата документа", commonLabelWidth));
        documentsHeaderLayoutContainer.setBorders(true);
        documentsCommonLayoutContainer.add(documentsHeaderLayoutContainer);
        documentsCommonLayoutContainer.add(documentsLayoutContainer);

        repairDocuments  = new ListStoreEditor<RepairDocumentProxy>(new ListStore<>(repairDocumentProps.key()));
        completionList  = new ListStoreEditor<CompletionRecordProxy>(new ListStore<CompletionRecordProxy>(completionKeyProvider));
        completionRecordProxyListStore.setAutoCommit(true);
    }



    protected void fillPaymentsTabPanel(InsertResizeContainer container){

        payments = new ListStoreEditor<PaymentProxy>(new ListStore<PaymentProxy>(paymentProperties.key()));


        FieldSet financeFieldSet = new FieldSet();
        financeFieldSet.setHeadingText("Расчёт с депо");
        financeFieldSet.setCollapsible(false);
        financeFieldSet.setLayoutData(repairVerticalData);
        container.add(financeFieldSet);

        HBoxLayoutContainer horizontalLayoutContainerHeader =  new HBoxLayoutContainer();
        horizontalLayoutContainerHeader.setPadding(new Padding(5));
        horizontalLayoutContainerHeader.setHBoxLayoutAlign(HBoxLayoutContainer.HBoxLayoutAlign.STRETCHMAX);
        financeFieldSet.add(horizontalLayoutContainerHeader);
        horizontalLayoutContainerHeader.add(createFieldLabelAutoWidth(repairPaymentDebit, "Дебет", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerHeader.add(createFieldLabelAutoWidth(repairPaymentCredit, "Кредит", repairLineFieldData), repairLineLabelData);


        FieldSet paymentSection = new FieldSet();
        paymentSection.setHeadingText("Прикрепление платёжного поручения");
        paymentSection.setCollapsible(false);
        paymentSection.setLayoutData(repairVerticalData);
        container.add(paymentSection);

        HBoxLayoutContainer horizontalLayoutContainerMain =  new HBoxLayoutContainer();
        horizontalLayoutContainerMain.setPadding(new Padding(5));
        horizontalLayoutContainerMain.setHBoxLayoutAlign(HBoxLayoutContainer.HBoxLayoutAlign.STRETCH);
        paymentSection.add(horizontalLayoutContainerMain);
        RequestFactoryProxy<FilterPagingLoadConfig, List<PaymentProxy>> paymentRequestFactoryProxy =
                new RequestFactoryProxy<FilterPagingLoadConfig, List<PaymentProxy>>() {

                    @Override
                    public void load(FilterPagingLoadConfig loadConfig, Receiver<? super List<PaymentProxy>> receiver) {
                        service.paymentTools().openList().fire(receiver);
                    }
                };
        ListLoader paymentLoader = new ListLoader<FilterPagingLoadConfig, ListLoadResult<PaymentProxy>>(paymentRequestFactoryProxy, new ListReader<PaymentProxy>()){
            @Override
            protected FilterPagingLoadConfig newLoadConfig() {
                return new FilterPagingLoadConfigBean();
            }
        };




        paymentGrid = new Grid(freePayments, getPaymentColumnModel());

        paymentLoader.setRemoteSort(true);
        paymentLoader.addLoadHandler(new LoadResultListStoreBinding(paymentGrid.getStore()));

        paymentGrid.setLoader(paymentLoader);

        paymentGrid.setBorders(true);
        paymentGrid.setWidth(400);
        paymentGrid.setHeight(500);

        LiveGridView<PaymentProxy> paymentLiveGridView = new LiveGridView<PaymentProxy>(){
            @Override
            public void refresh(boolean headerToo) {
                preventScrollToTopOnRefresh = true;
                super.refresh(headerToo);
            }
        };
        paymentLiveGridView.setPrefetchFactor(.6);
        paymentLiveGridView.setCacheSize(300);
        paymentLiveGridView.setForceFit(false);
        paymentGrid.setView(paymentLiveGridView);

        paymentGrid.getView().setAutoFill(true);
        paymentGrid.setLoadMask(false);

        horizontalLayoutContainerMain.add(paymentGrid);
        FieldSet paymentDescriptionSection = new FieldSet();
        paymentDescriptionSection.setHeadingText("Платёжное поручение");
        paymentDescriptionSection.setCollapsible(false);
        paymentDescriptionSection.setLayoutData(repairVerticalData);
        paymentDescriptionSection.setWidth(250);
        paymentDescriptionSection.setHeight(500);
        horizontalLayoutContainerMain.add(paymentDescriptionSection, new BoxLayoutContainer.BoxLayoutData(new Margins(5,5,5,5)));

        VerticalLayoutContainer paymentDescriptionContainer = new VerticalLayoutContainer();
        paymentDescriptionSection.add(paymentDescriptionContainer);


        paymentDescriptionContainer.add(createFieldLabel(paymentNumber, "Номер", repairVerticalData, 60));
        paymentDescriptionContainer.add(createFieldLabel(paymentLoadDate, "Дата", repairVerticalData, 60));
        paymentDescriptionContainer.add(createFieldLabel(paymentAmount, "Сумма", repairVerticalData, 60));
        paymentDescriptionContainer.add(createTopFieldLabel(paymentDetails, "Назначение", repairVerticalData));

        paymentDescriptionContainer.add(paymentButton, new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(100,5,5,100)));

        paymentGrid.getSelectionModel().setSelectionMode(Style.SelectionMode.SINGLE);
        paymentGrid.addRowClickHandler(new RowClickEvent.RowClickHandler() {
            @Override
            public void onRowClick(RowClickEvent rowClickEvent) {
                PaymentProxy proxy = paymentGrid.getSelectionModel().getSelectedItem();
                paymentButton.setText(payments.getStore().findModelWithKey(paymentProperties.key().getKey(proxy)) != null ? "Открепить" : "Прикрепить");
                paymentNumber.setValue(proxy.getNumber());
                paymentLoadDate.setValue(proxy.getLoadDate());
                paymentAmount.setValue(proxy.getAmount());
                paymentDetails.setValue(proxy.getDetails());
            }
        });

        paymentButton.addSelectHandler(new SelectEvent.SelectHandler() {
            @Override
            public void onSelect(SelectEvent selectEvent) {
                PaymentProxy proxy = paymentGrid.getSelectionModel().getSelectedItem();
                if (proxy != null){
                    PaymentProxy realProxy =  payments.getStore().findModelWithKey(paymentProperties.key().getKey(proxy));
                    if (realProxy != null) payments.getStore().remove(realProxy);
                    else {
                        payments.getStore().add(context.edit(proxy));
                    }
                    paymentButton.setText(payments.getStore().findModelWithKey(paymentProperties.key().getKey(proxy)) != null ? "Открепить" : "Прикрепить");
                }
            }
        });

        FieldSet invoiceDescriptionSection = new FieldSet();
        invoiceDescriptionSection.setHeadingText("Счёт-фактура");
        invoiceDescriptionSection.setCollapsible(false);
        invoiceDescriptionSection.setLayoutData(repairVerticalData);
        invoiceDescriptionSection.setWidth(250);
        invoiceDescriptionSection.setHeight(500);
        horizontalLayoutContainerMain.add(invoiceDescriptionSection, new BoxLayoutContainer.BoxLayoutData(new Margins(5,5,5,5)));
        VerticalLayoutContainer invoiceDescriptionContainer = new VerticalLayoutContainer();
        invoiceDescriptionSection.add(invoiceDescriptionContainer);

        invoiceDescriptionContainer.add(createFieldLabel(invoiceNumber, "Номер", repairVerticalData, 60));
        invoiceDescriptionContainer.add(createFieldLabel(invoiceLoadDate, "Дата", repairVerticalData, 60));
        invoiceDescriptionContainer.add(createFieldLabel(invoiceAmount, "Сумма", repairVerticalData, 60));
    }


    private ColumnModel<PaymentProxy> getPaymentColumnModel(){
        List<ColumnConfig<PaymentProxy, ?>> list = new ArrayList<ColumnConfig<PaymentProxy, ?>>();
        list.add(new ColumnConfig<PaymentProxy, String>(paymentProperties.number(), 80, "№"));

        list.add(getDateColumnConfig(paymentProperties.loadDate(), 80, "Дата"));
        list.add(new ColumnConfig<PaymentProxy, Float>(paymentProperties.amount(),80,"Сумма"));
        list.add(getPaymentRepairCarNumber(paymentProperties.repairs()));

        return new ColumnModel<PaymentProxy>(list);
    }

    protected void fillDefectsTabPanel(InsertResizeContainer container){
        VerticalLayoutContainer verticalLayoutContainer =  new VerticalLayoutContainer();
        container.add(verticalLayoutContainer);
        partsFieldSet = new RepairDefectPartsFieldSet(975, 370){
            @Override
            protected void onChangeValues(){
                recalculateDefectReadOnlyOtherFields();
            }
        };
        partsFieldSet.setCollapsible(false);
        partsFieldSet.setLayoutData(repairVerticalData);
        repairDefects = partsFieldSet.getDefectStoreEditor();
        FieldSet header = new FieldSet();
        header.setHeadingText("Затраты по ремонту");
        header.setCollapsible(false);
        header.setLayoutData(repairVerticalData);

        HBoxLayoutContainer horizontalLayoutContainerHeader =  new HBoxLayoutContainer();
        horizontalLayoutContainerHeader.setPadding(new Padding(5));
        horizontalLayoutContainerHeader.setHBoxLayoutAlign(HBoxLayoutContainer.HBoxLayoutAlign.STRETCHMAX);
        header.add(horizontalLayoutContainerHeader);

        horizontalLayoutContainerHeader.add(createFieldLabelAutoWidth(defectsRepairSum, "Сумма ремонта", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerHeader.add(createFieldLabelAutoWidth(defectsWorkSum, "Стоимость работ", repairLineFieldData), repairLineLabelData);

        FieldSet footer = new FieldSet();
        footer.setHeadingText("Итого");
        footer.setCollapsible(false);
        footer.setLayoutData(repairVerticalData);

        HBoxLayoutContainer horizontalLayoutContainerOuterFooter =  new HBoxLayoutContainer();
        horizontalLayoutContainerOuterFooter.setPadding(new Padding(5));
        horizontalLayoutContainerOuterFooter.setHBoxLayoutAlign(HBoxLayoutContainer.HBoxLayoutAlign.STRETCHMAX);

        VerticalLayoutContainer verticalLayoutFooterContainer =  new VerticalLayoutContainer();
        horizontalLayoutContainerOuterFooter.add(verticalLayoutFooterContainer);

        HBoxLayoutContainer horizontalLayoutContainerFooter =  new HBoxLayoutContainer();
        horizontalLayoutContainerFooter.setPadding(new Padding(5));
        horizontalLayoutContainerFooter.setHBoxLayoutAlign(HBoxLayoutContainer.HBoxLayoutAlign.STRETCHMAX);
        verticalLayoutFooterContainer.add(horizontalLayoutContainerFooter);

        HBoxLayoutContainer horizontalLayoutContainerSubFooter =  new HBoxLayoutContainer();
        horizontalLayoutContainerSubFooter.setPadding(new Padding(5));
        horizontalLayoutContainerSubFooter.setHBoxLayoutAlign(HBoxLayoutContainer.HBoxLayoutAlign.STRETCHMAX);
        verticalLayoutFooterContainer.add(horizontalLayoutContainerSubFooter);

        footer.add(horizontalLayoutContainerOuterFooter);

        defectsAbout.setWidth(200);
        defectsAbout.setHeight(65);
        horizontalLayoutContainerFooter.add(createFieldLabel(defectsTotalSumWithoutTaxes, "Итого, без НДС", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerFooter.add(createFieldLabel(defectsTotalSumTaxes, "Итого, 18%", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerSubFooter.add(createFieldLabel(defectsTotalSumWithTaxes, "Итого, с НДС", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerSubFooter.add(createFieldLabel(defectsTotalSaveSum, "Экономия", repairLineFieldData), repairLineLabelData);
        horizontalLayoutContainerOuterFooter.add(createFieldLabel(defectsAbout, "Примечание", repairLineFieldData), repairLineLabelData);
        verticalLayoutContainer.add(header);
        verticalLayoutContainer.add(partsFieldSet);
        verticalLayoutContainer.add(footer);
    }

    private Label createLabelCenterTextAlign(String text, int width){
        return createLabelText(text, width, HasHorizontalAlignment.ALIGN_CENTER);
    }

    private Label createLabelText(String text, int width, HasHorizontalAlignment.HorizontalAlignmentConstant horizontalAlignment){
        Label label = new Label(text);
        label.setWidth(width + "px");
        label.setHorizontalAlignment(horizontalAlignment);
        return label;
    }

    @Override
    protected void receiveData() {
        service.cars().list().fire(new Receiver<List<CarProxy>>() {
            @Override
            public void onSuccess(List<CarProxy> response) {
                carStore.replaceAll(response);
            }
        });

        cargoEtsngStore.replaceAll(Injector.INSTANCE.transportRates());

        carLoadedStore.clear();
        carLoadedStore.addAll(java.util.Arrays.asList(new Boolean[]{false, true}));
        service.repairTypes().list().fire(new Receiver<List<RepairTypeProxy>>() {
            @Override
            public void onSuccess(List<RepairTypeProxy> response) {
                repairTypeStore.replaceAll(response);
            }
        });
        railwayStore.replaceAll(Injector.INSTANCE.railways());

        service.depots().list().fire(new Receiver<List<DepotProxy>>() {
            @Override
            public void onSuccess(List<DepotProxy> response) {
                depotStore.replaceAll(response);
            }
        });
        defectType1.clear();
        defectType2.clear();
        defectType3.clear();
        defectType1.add(ResourceList.getDefectTypes());
        defectType2.add(ResourceList.getDefectTypes());
        defectType3.add(ResourceList.getDefectTypes());

        service.repairDocumentTypes().orderedList().fire(new Receiver<List<RepairDocumentTypeProxy>>() {
            @Override
            public void onSuccess(List<RepairDocumentTypeProxy> response) {
                fillMxLabelContainer();
                fillDocumentTypes(response);
            }
        });

        service.repairDefectTypes().orderedList().fire(new Receiver<List<RepairDefectTypeProxy>>() {
            @Override
            public void onSuccess(List<RepairDefectTypeProxy> response) {
                partsFieldSet.fillRepairDefectTypeStore(response);
            }
        });

        service.repairDefectUnits().orderedList().fire(new Receiver<List<RepairDefectUnitProxy >> () {
            @Override
            public void onSuccess(List<RepairDefectUnitProxy> response) {
                partsFieldSet.fillRepairDefectUnitStore(response);
            }
        });

    }

    @Override
    public void initValidators() {

    }

    @Override
    protected void initHandlers() {
        this.addBeforeSaveEventHandler(new BeforeSaveHandler() {
            @Override
            public void beforeSave(BeforeSaveEvent event) {
                repairDocuments.flush();
                completionList.flush();
                attachments.flush();
                repairDefects.flush();
                payments.flush();
            }
        });
    }

    @Override
    public void clear() {
        uploadComponent.getUploader().clear();
    }

    @Override
    public void edit(RepairProxy element) {
        super.edit(element);
        //TODO: add logic for checking rights on editing repairs
        //infoTabPanel.setEnabled(false);
        refreshTabPanel();
        partsFieldSet.reinitContext(context);

        if (element != null) {
            fillCarFields(element.getCar());
            enableCargoField(element.getLoaded());
            fillCurrentStationFields(element.getCurrentStation());
            fillDebitCreditFields(element.getRepairDocuments(), element.getPayments());
            final boolean planned = element.getRepairType().getPlanned();
            hideNotUsingDocuments(planned);
            repairTypeStore.removeFilters();
            repairTypeStore.addFilter(new Store.StoreFilter<RepairTypeProxy>() {
                @Override
                public boolean select(Store<RepairTypeProxy> store, RepairTypeProxy parent, RepairTypeProxy item) {
                    return item.getPlanned() == planned;
                }
            });
            setDocuments(true);
            refillCompletionStores(true);
            refreshAttachments(element.getAttachments());
            updateRepairTabsHeaders(planned);
            changeRepairTabs(planned);
            partsFieldSet.setRepairType(planned);
            partsFieldSet.resetFields(element.getRepairDefects());
        } else {
            partsFieldSet.resetFields();
        }
        refreshGrids();
        refreshCheckBoxes();
        refreshStores();
        recalculateDefectReadOnlyFields();
        refillPayments();
        refillClaims();
    }

    @Override
    public RepairProxy create() {
        RepairProxy result = super.create();
        infoTabPanel.setEnabled(true);
        fillCarFields(context.create(CarProxy.class));
        fillCurrentStationFields(context.create(RailwayProxy.class));
        setDocuments(false);
        refillCompletionStores(false);
        refreshAttachments(null);
        repairTypeStore.removeFilters();
        refreshTabPanel();
        refreshGrids();
        refreshCheckBoxes();
        partsFieldSet.reinitContext(context);
        partsFieldSet.resetFields();
        refreshStores();
        recalculateDefectReadOnlyFields();
        refillPayments();
        refillClaims();
        fillDebitCreditFields(null, null);
        return result;
    }

    private void refillPayments(){
        paymentGrid.getLoader().load();
    }

    private void refillClaims(){
        lesserTextField.clear();
        if (editedEntity != null && editedEntity.getRepairClaim() != null){
            RepairClaimProxy claim = editedEntity.getRepairClaim();
            repairClaimProxy = context.edit(claim);
            if (claim.getLessor() != null) lesserTextField.setValue(claim.getLessor());
        } repairClaimProxy = context.create(RepairClaimProxy.class);
        lesserTextField.addValueChangeHandler(new ValueChangeHandler<String>() {
            @Override
            public void onValueChange(ValueChangeEvent<String> event) {
                repairClaimProxy.setLessor(event.getValue());
            }
        });
    }


    private void refreshTabPanel(){
        repairTabPanel.setActiveWidget(infoTabPanel);
        while (repairTabPanel.getWidgetCount()>1){
            repairTabPanel.remove(repairTabPanel.getWidgetCount()-1);
        }
    }

    private void changeRepairTabs(boolean planned){
        repairTabPanel.setActiveWidget(infoTabPanel);
        while (repairTabPanel.getWidgetCount()>1){
            repairTabPanel.remove(repairTabPanel.getWidgetCount()-1);
        }
        for (VerticalLayoutContainer container : planned ? planRepairTabs : currentRepairTabs)
            repairTabPanel.add(container, container.getTitle());
    }

    private void updateRepairTabsHeaders(boolean planned){
        defectsTabPanel.setTitle(planned ? "Данные по ремонтным частям без НДС 18%" : "Неисправности");
        defectsTabPanel.forceLayout();
    }

    private String getCompletionRecordProxyKey(String title, Integer number, Boolean isDocument) {
        return title + number + isDocument;
    }

    private void fillCarFields(CarProxy car){
        carFactory.setValue(car.getCarFactoryTitle());
        claimCarFactory.setValue(car.getCarFactoryTitle());
        if (car.getCarType() !=null) {
            carType.setValue(car.getCarType().getTitle());
        }
        else {
            carType.setValue(null);
            //carType.clear();
        }
        carOwner.setValue(car.getCarOwnerTitle());
        if (car.getBuildingDate() != null) carBuildingDate.setValue(dateTimeProperty.getFormat().format(car.getBuildingDate()));
        if (car.getNextRepairDate() != null) carBuildingDate.setValue(dateTimeProperty.getFormat().format(car.getNextRepairDate()));
        if(car.getBuildingDate() == null && car.getNextRepairDate() == null) {
            carBuildingDate.setValue(null);
            //carBuildingDate.clear();
        }
    }

    private void enableCargoField(Boolean flag){
        if (flag != null && flag){
            cargoEtsng.setEnabled(true);
        } else {
            cargoEtsng.setEnabled(false);
            cargoEtsng.setValue(null);
        }
    }

    private void fillCurrentStationFields(RailwayProxy railway){
        if (railway != null && railway.getRailroad() != null && railway.getRailroad().getTitle() != null) {
            railRoad.setValue(railway.getRailroad().getTitle());
        }
        else {
            railRoad.setValue(null);
            //railRoad.clear();
        }
    }

    private void fillDebitCreditFields(List<RepairDocumentProxy> docList, List<PaymentProxy> payList){
        Float debit = null;
        Float credit = null;
        if (docList != null){
            for (RepairDocumentProxy document: docList){
                Float value = document.getAmount();
                if (value != null){
                    if ("Счет-фактура".equals(document.getRepairDocumentType().getTitle())){
                        debit = debit == null? value : debit + value;
                    }
                }

            }

        }
        if (payList != null){
            for (PaymentProxy payment: payList){
                Float value = payment.getAmount();
                if (value != null){
                    credit = credit == null? value : credit + value;
                }

            }

        }
        repairDebit.setValue(debit == null? "Нет" : Float.toString((credit == null? debit : debit - credit)));
        repairCredit.setValue(credit == null? "Нет" : Float.toString((debit == null? credit : credit - debit)));
        repairPaymentDebit.setValue(debit == null? "Нет" : Float.toString((credit == null? debit : debit - credit)));
        repairPaymentCredit.setValue(credit == null? "Нет" : Float.toString((debit == null? credit : credit - debit)));
    }

    @Override
    protected FieldLabel createFieldLabel(Widget field, String label, MarginData marginData){
        FieldLabel fieldLabel = new FieldLabel(field, label);
        fieldLabel.setLayoutData(marginData);
        return fieldLabel;
    }

    protected FieldLabel createFieldLabelAutoWidth(Widget field, String label, MarginData marginData){
        FieldLabel fieldLabel = new FieldLabel(field, label);
        fieldLabel.setLayoutData(marginData);
        if (label != null) fieldLabel.setLabelWidth((int) Math.max(Math.ceil(label.length() * 7.5), 25));
        return fieldLabel;
    }

    protected FieldLabel createFieldLabel(Widget field, String label, MarginData marginData, int width){
        FieldLabel fieldLabel = new FieldLabel(field, label);
        fieldLabel.setLayoutData(marginData);
        fieldLabel.setLabelWidth(width);
        return fieldLabel;
    }

    private void fillDocumentTypes(List<RepairDocumentTypeProxy>list){
        documentsLayoutContainer.clear();
        VerticalLayoutContainer.VerticalLayoutData verticalLayoutData = new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(5, 0, 5, 0));
        repairDocTypePanels.clear();
        for (RepairDocumentTypeProxy documentTypeProxy : list){
            RepairDocTypePanel panel = new RepairDocTypePanel(documentTypeProxy);
            repairDocTypePanels.put(documentTypeProxy.getId(), panel);
            if (documentTypeProxy.getTypeID() == 4){
                documentsLayoutContainer.add(mxLabelContainer, verticalLayoutData);
            }
            documentsLayoutContainer.add(panel, verticalLayoutData);
            if (documentTypeProxy.getTypeID() == 5){
                documentsLayoutContainer.add(vu53Container);
                vu53Container.hide();
            }
            if (documentTypeProxy.getTypeID() == 6){
                documentsLayoutContainer.add(listCompletionContainer);
                listCompletionContainer.hide();
            }

        }
    }

    private void hideNotUsingDocuments(boolean isPlannedReport){
        vu53Container.hide();
        listCompletionContainer.hide();
        mxLabelContainer.hide();
        for (RepairDocTypePanel panel : repairDocTypePanels.values()){
            panel.setVisible((!isPlannedReport && panel.isCurrent()) || (isPlannedReport && panel.isPlanned()));
            if (panel.getTypeId() == 4) mxLabelContainer.setVisible(isPlannedReport);
            panel.forceLayout();
        }
    }

    private void setDocuments(boolean checkEntity){
        for (RepairDocTypePanel panel : repairDocTypePanels.values()) panel.resetDocument(null);
        if (checkEntity){
        int size = repairDocuments.getStore().size();
            for (int i = 0; i < size; i++){
                RepairDocumentProxy document = repairDocuments.getStore().get(i);
                repairDocTypePanels.get(document.getRepairDocumentType().getId()).resetDocument(document);
            }
        }
    }

    private void refillCompletionStores(boolean checkEntity){
        completionRecordProxyListStore.clear();
        if (checkEntity){
            int size = completionList.getStore().size();
            for (int i = 0; i < size; i++){
                completionRecordProxyListStore.add(completionList.getStore().get(i));
            }
        }
        refillVu53Stores();
        refillListCompletionStores();
        refillPanelCompletionStores();
    }

    private void refillVu53Stores(){
        ListStore<CompletionRecordProxy> completionRecordVu53FirstStore = completionRecordVu53FirstStoreEditor.getStore();
        ListStore<CompletionRecordProxy> completionRecordVu53LastStore = completionRecordVu53LastStoreEditor.getStore();
        completionRecordVu53FirstStore.clear();
        completionRecordVu53LastStore.clear();

        completionRecordVu53FirstStore.addAll(getSeveralNewCompletionRecords("Колёсная пара", 4));
        completionRecordVu53FirstStore.addAll(getSeveralNewCompletionRecords("Боковая рама", 4));
        completionRecordVu53FirstStore.addAll(getSeveralNewCompletionRecords("Надрессорная балка", 2));
        completionRecordVu53FirstStore.addAll(getSeveralNewCompletionRecords("Автосцепка", 2));

        completionRecordVu53LastStore.addAll(getSeveralNewCompletionRecords("Поглощающий аппарат", 2));
        completionRecordVu53LastStore.addAll(getSeveralNewCompletionRecords("Другое", 1));


    }

    private void refillListCompletionStores(){
        ListStore<CompletionRecordProxy> completionRecordAutoStore = completionRecordListCompletionAutoStoreEditor.getStore();
        ListStore<CompletionRecordProxy> completionRecord2FieldsStoreEditor = completionRecordListCompletion2FieldsStoreEditor.getStore();
        ListStore<CompletionRecordProxy> completionRecord4FieldsMainStoreEditor = completionRecordListCompletion4FieldsMainStoreEditor.getStore();
        ListStore<CompletionRecordProxy> completionRecord4FieldsLeftStoreEditor = completionRecordListCompletion4FieldsLeftStoreEditor.getStore();
        ListStore<CompletionRecordProxy> completionRecord4FieldsRightStoreEditor = completionRecordListCompletion4FieldsRightStoreEditor.getStore();

        completionRecordAutoStore.clear();
        completionRecord2FieldsStoreEditor.clear();
        completionRecord4FieldsMainStoreEditor.clear();
        completionRecord4FieldsLeftStoreEditor.clear();
        completionRecord4FieldsRightStoreEditor.clear();

        completionRecordAutoStore.addAll(getSeveralNewCompletionRecords("Автосцепка", 2));

        getSeveralNewCompletionRecords("Тяговые хомуты", 1);

        completionRecord2FieldsStoreEditor.addAll(getSeveralNewCompletionRecords("Поглощающий аппарат", 2));
        completionRecord2FieldsStoreEditor.addAll(getSeveralNewCompletionRecords("Тележка", 2));

        completionRecord4FieldsMainStoreEditor.addAll(getSeveralNewCompletionRecords("Боковая рама", 4));
        completionRecord4FieldsMainStoreEditor.addAll(getSeveralNewCompletionRecords("Надрессорная балка", 2));
        completionRecord4FieldsMainStoreEditor.addAll(getSeveralNewCompletionRecords("Колёсная пара", 4));
        completionRecord4FieldsLeftStoreEditor.addAll(getSeveralNewCompletionRecords("Колёсная пара", 4));
        completionRecord4FieldsRightStoreEditor.addAll(getSeveralNewCompletionRecords("Колёсная пара", 4));

        getSeveralNewCompletionRecords("Тормозное оборудование", 1);
    }

    private void refillPanelCompletionStores(){
        ListStore<CompletionRecordProxy> wheels = completionRecordPartWheelsStoreEditor.getStore();
        ListStore<CompletionRecordProxy> beam = completionRecordPartBeamStoreEditor.getStore();
        ListStore<CompletionRecordProxy> frame = completionRecordPartFrameStoreEditor.getStore();

        wheels.clear();
        beam.clear();
        frame.clear();

        wheels.addAll(getSeveralNewCompletionRecords("Колёсная пара", 4, false));
        frame.addAll(getSeveralNewCompletionRecords("Боковая рама", 4, false));
        beam.addAll(getSeveralNewCompletionRecords("Надрессорная балка", 2, false));
    }


    public List<CompletionRecordProxy> getSeveralNewCompletionRecords(String title, int count){
        return getSeveralNewCompletionRecords(title, count, true);
    }
    public List<CompletionRecordProxy> getSeveralNewCompletionRecords(String title, int count, boolean isDocument){
        List<CompletionRecordProxy> list = new ArrayList<>();
        for (int i = 1; i<= count; i++){
            CompletionRecordProxy cpr = completionRecordProxyListStore.findModelWithKey(getCompletionRecordProxyKey(title, i, isDocument));
            if (cpr == null){
                cpr = context.create(CompletionRecordProxy.class);
                cpr.setTitle(title);
                cpr.setNumber(i);
                cpr.setDocument(isDocument);
                completionRecordProxyListStore.add(cpr);
            }
            list.add(cpr);
        }
        return list;
    }

    private SafeHtml getMultiLineHeader(String... headers){
        SafeHtmlBuilder shb = new SafeHtmlBuilder();
        StringBuilder sb = new StringBuilder("");
        for (String s : headers){
            sb.append('\n').append(s);
        }
        shb.appendEscapedLines(sb.delete(0, 1).toString());
        return shb.toSafeHtml();
    }


    private Widget getVu53Panel(){

        completionRecordVu53FirstStoreEditor  = new ListStoreEditor<CompletionRecordProxy>(new ListStore<CompletionRecordProxy>(completionKeyProvider));
        completionRecordVu53LastStoreEditor  = new ListStoreEditor<CompletionRecordProxy>(new ListStore<CompletionRecordProxy>(completionKeyProvider));
        VerticalLayoutContainer vlc = new VerticalLayoutContainer();
        ContentPanel panel = new ContentPanel();
        panel.setHeadingText("Акт замены запчастей ВУ-53");
        panel.setWidth(650);
        panel.setPosition(50, -1);
        GroupingView<CompletionRecordProxy> vu53FirstView = new GroupingView<CompletionRecordProxy>();
        GroupingView<CompletionRecordProxy> vu53LastView = new GroupingView<CompletionRecordProxy>();



        ColumnConfig<CompletionRecordProxy, String> ccVu53Grouping = new ColumnConfig<CompletionRecordProxy, String>(new ValueProvider<CompletionRecordProxy, String>() {
            @Override
            public String getValue(CompletionRecordProxy object) {
                return ResourceList.getCompletionGroups().get(object.getTitle());
            }
            @Override
            public void setValue(CompletionRecordProxy object, String value) {}
            @Override
            public String getPath() {return "";}
        });

        ColumnConfig<CompletionRecordProxy, String> ccVu53Grouping2 = new ColumnConfig<CompletionRecordProxy, String>(new ValueProvider<CompletionRecordProxy, String>() {
            @Override
            public String getValue(CompletionRecordProxy object) {
                return ResourceList.getCompletionGroups().get(object.getTitle());
            }
            @Override
            public void setValue(CompletionRecordProxy object, String value) {}
            @Override
            public String getPath() {return "";}
        });


        Comparator comparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return ResourceList.getVu53GroupsNo().get(o1).compareTo(ResourceList.getVu53GroupsNo().get(o2));
            }
        };
        ccVu53Grouping.setComparator(comparator);
        ccVu53Grouping2.setComparator(comparator);


        ColumnConfig<CompletionRecordProxy, ?> ccVu53Title = new ColumnConfig<CompletionRecordProxy, String>(new ValueProvider<CompletionRecordProxy, String>() {
            @Override
            public String getValue(CompletionRecordProxy object) {
                String title = object.getTitle();
                if (!"Другое".equals(title)) title += " " + object.getNumber();
                return title;
            }

            @Override
            public void setValue(CompletionRecordProxy object, String value) {}

            @Override
            public String getPath() {return null;}
        }, 140, "Наименование");


        ColumnConfig<CompletionRecordProxy, Long> ccVu53numberOld = new ColumnConfig<CompletionRecordProxy, Long>(completionRecordProperties.numberOld(), 80);
        ccVu53numberOld.setHeader(getMultiLineHeader("Снято", "Номер"));
        ColumnConfig<CompletionRecordProxy, Integer> ccVu53codeOld = new ColumnConfig<CompletionRecordProxy, Integer>(completionRecordProperties.codeOld(), 80);
        ccVu53codeOld.setHeader(getMultiLineHeader("Снято", "Код", "изготовителя"));
        ColumnConfig<CompletionRecordProxy, Integer> ccVu53yearOld = new ColumnConfig<CompletionRecordProxy, Integer>(completionRecordProperties.yearOld(), 80);
        ccVu53yearOld.setHeader(getMultiLineHeader("Снято", "Год", "изготовления"));
        ColumnConfig<CompletionRecordProxy, Long> ccVu53numberNew = new ColumnConfig<CompletionRecordProxy, Long>(completionRecordProperties.numberNew(), 80);
        ccVu53numberNew.setHeader(getMultiLineHeader("Установлено", "Номер"));
        ColumnConfig<CompletionRecordProxy, Integer> ccVu53codeNew = new ColumnConfig<CompletionRecordProxy, Integer>(completionRecordProperties.codeNew(), 80);
        ccVu53codeNew.setHeader(getMultiLineHeader("Установлено", "Код", "изготовителя"));
        ColumnConfig<CompletionRecordProxy, Integer> ccVu53yearNew = new ColumnConfig<CompletionRecordProxy, Integer>(completionRecordProperties.yearNew(), 80);
        ccVu53yearNew.setHeader(getMultiLineHeader("Установлено", "Год", "изготовления"));

        ColumnConfig<CompletionRecordProxy, String> ccVu53textOld = new ColumnConfig<CompletionRecordProxy, String>(completionRecordProperties.textOld(), 240);
        ccVu53textOld.setHeader("Снято");
        ColumnConfig<CompletionRecordProxy, String> ccVu53textNew = new ColumnConfig<CompletionRecordProxy, String>(completionRecordProperties.textNew(), 240);
        ccVu53textNew.setHeader("Установлено");



        List<ColumnConfig<CompletionRecordProxy, ?>> vu53firstCC = new ArrayList<>();
        vu53firstCC.add(ccVu53Grouping);
        vu53firstCC.add(ccVu53Title);
        vu53firstCC.add(ccVu53numberOld);
        vu53firstCC.add(ccVu53codeOld);
        vu53firstCC.add(ccVu53yearOld);
        vu53firstCC.add(ccVu53numberNew);
        vu53firstCC.add(ccVu53codeNew);
        vu53firstCC.add(ccVu53yearNew);

        List<ColumnConfig<CompletionRecordProxy, ?>> vu53lastCC = new ArrayList<>();
        vu53lastCC.add(ccVu53Grouping2);
        vu53lastCC.add(ccVu53Title);
        vu53lastCC.add(ccVu53textOld);
        vu53lastCC.add(ccVu53textNew);

        Grid gridVu53First = new Grid<CompletionRecordProxy>(completionRecordVu53FirstStoreEditor.getStore(), new ColumnModel<CompletionRecordProxy>(vu53firstCC));
        vu53FirstView.setAutoFill(false);
        vu53FirstView.setColumnLines(true);
        vu53FirstView.setSortingEnabled(false);
        vu53FirstView.setEnableGroupingMenu(false);
        vu53FirstView.setEnableNoGroups(false);
        vu53FirstView.setShowGroupedColumn(false);
        vu53FirstView.setForceFit(false);
        gridVu53First.setView(vu53FirstView);
        vu53FirstView.groupBy(ccVu53Grouping);
        completionRecordVu53FirstStoreEditor.getStore().setAutoCommit(true);
        gridsForRefresh.add(gridVu53First);

        Grid gridVu53Last = new Grid<CompletionRecordProxy>(completionRecordVu53LastStoreEditor.getStore(), new ColumnModel<CompletionRecordProxy>(vu53lastCC));
        vu53LastView.setAutoFill(false);
        vu53LastView.setColumnLines(true);
        vu53LastView.setSortingEnabled(false);
        vu53LastView.setEnableGroupingMenu(false);
        vu53LastView.setEnableNoGroups(false);
        vu53LastView.setShowGroupedColumn(false);
        vu53LastView.setForceFit(false);
        gridVu53Last.setView(vu53LastView);
        vu53LastView.groupBy(ccVu53Grouping2);
        completionRecordVu53LastStoreEditor.getStore().setAutoCommit(true);
        gridsForRefresh.add(gridVu53Last);

        final GridInlineEditing<CompletionRecordProxy> firstEditing = new GridInlineEditing<CompletionRecordProxy>(gridVu53First);
        List<CompletionChecker> firstList = new ArrayList<>();
        firstEditing.addEditor(ccVu53numberOld, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999999999l), new NumberPropertyEditor.LongPropertyEditor()));
        firstList.add(new CompletionNumberOldChecker());
        firstEditing.addEditor(ccVu53codeOld, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        firstList.add(new CompletionCodeOldChecker());
        firstEditing.addEditor(ccVu53yearOld, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        firstList.add(new CompletionYearOldChecker());
        firstEditing.addEditor(ccVu53numberNew, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999999999l), new NumberPropertyEditor.LongPropertyEditor()));
        firstList.add(new CompletionNumberNewChecker());
        firstEditing.addEditor(ccVu53codeNew, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        firstList.add(new CompletionCodeNewChecker());
        firstEditing.addEditor(ccVu53yearNew, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        firstList.add(new CompletionYearNewChecker());
        completionCheckerList.put(completionRecordVu53FirstStoreEditor.getStore(), firstList);

        firstEditing.setRevertInvalid(true);
        firstEditing.addCompleteEditHandler(new CompleteEditEvent.CompleteEditHandler<CompletionRecordProxy>() {
            @Override
            public void onCompleteEdit(CompleteEditEvent<CompletionRecordProxy> event) {
                CompletionRecordProxy cpr = completionRecordVu53FirstStoreEditor.getStore().get(event.getEditCell().getRow());
                if(!completionList.getStore().getAll().contains(cpr)) completionList.getStore().add(cpr);
                refreshGrids();
            }
        });
        firstEditing.addStartEditHandler(new StartEditEvent.StartEditHandler<CompletionRecordProxy>() {
            @Override
            public void onStartEdit(StartEditEvent<CompletionRecordProxy> completionRecordProxyStartEditEvent) {
                for (ColumnConfig cc : completionRecordProxyStartEditEvent.getSource().getEditableGrid().getColumnModel().getColumns()) {
                    Field field = completionRecordProxyStartEditEvent.getSource().getEditor(cc);
                    if (field != null && field instanceof NumberField ) {
                        if (!((NumberField)field).isCurrentValid()) ((NumberField)field).setText("");
                    }
                }
            }
        });
        final GridInlineEditing<CompletionRecordProxy> lastEditing = new GridInlineEditing<CompletionRecordProxy>(gridVu53Last);
        List<CompletionChecker> lastList = new ArrayList<>();
        TextField textField = new TextField();
        textField.addValidator(new MaxLengthValidator(30));
        textField.setAutoValidate(true);
        lastEditing.addEditor(ccVu53textOld, textField);
        textField = new TextField();
        textField.addValidator(new MaxLengthValidator(30));
        textField.setAutoValidate(true);
        lastList.add(new CompletionTextOldChecker());
        lastEditing.addEditor(ccVu53textNew, textField);
        lastList.add(new CompletionTextNewChecker());
        completionCheckerList.put(completionRecordVu53LastStoreEditor.getStore(), firstList);

        lastEditing.setRevertInvalid(true);
        lastEditing.addCompleteEditHandler(new CompleteEditEvent.CompleteEditHandler<CompletionRecordProxy>() {
            @Override
            public void onCompleteEdit(CompleteEditEvent<CompletionRecordProxy> event) {
                CompletionRecordProxy cpr = completionRecordVu53LastStoreEditor.getStore().get(event.getEditCell().getRow());
                if (!completionList.getStore().getAll().contains(cpr)) completionList.getStore().add(cpr);
                refreshGrids();
            }
        });

        vlc.add(gridVu53First, new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(5, 5, 5, 5)));
        vlc.add(gridVu53Last, new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(5, 5, 5, 5)));
        panel.add(vlc);
        return panel;
    }


    private Widget getListCompletionPanel(){
        completionRecordListCompletionAutoStoreEditor  = new ListStoreEditor<CompletionRecordProxy>(new ListStore<CompletionRecordProxy>(completionKeyProvider));
        completionRecordListCompletion2FieldsStoreEditor  = new ListStoreEditor<CompletionRecordProxy>(new ListStore<CompletionRecordProxy>(completionKeyProvider));
        completionRecordListCompletion4FieldsMainStoreEditor  = new ListStoreEditor<CompletionRecordProxy>(new ListStore<CompletionRecordProxy>(completionKeyProvider));
        completionRecordListCompletion4FieldsLeftStoreEditor  = new ListStoreEditor<CompletionRecordProxy>(new ListStore<CompletionRecordProxy>(completionKeyProvider));
        completionRecordListCompletion4FieldsRightStoreEditor  = new ListStoreEditor<CompletionRecordProxy>(new ListStore<CompletionRecordProxy>(completionKeyProvider));


        VerticalLayoutContainer vlc = new VerticalLayoutContainer();
        ContentPanel panel = new ContentPanel();
        panel.setHeadingText("Лист комплектации");
        panel.setWidth(650);
        panel.setPosition(50, -1);

        ColumnConfig<CompletionRecordProxy, Long> ccNumber = new ColumnConfig<CompletionRecordProxy, Long>(completionRecordProperties.numberNew(), 120, "Номер");
        ColumnConfig<CompletionRecordProxy, Integer> ccCode = new ColumnConfig<CompletionRecordProxy, Integer>(completionRecordProperties.codeNew(), 120, "Код изготовителя");
        ColumnConfig<CompletionRecordProxy, Integer> ccYear = new ColumnConfig<CompletionRecordProxy, Integer>(completionRecordProperties.yearNew(), 120, "Год изготовления");
        ColumnConfig<CompletionRecordProxy, String> ccKind = new ColumnConfig<CompletionRecordProxy, String>(completionRecordProperties.textNew(), 120, "Марка");
        ColumnConfig<CompletionRecordProxy, String> ccModel = new ColumnConfig<CompletionRecordProxy, String>(completionRecordProperties.textNew(), 480, "Модель");
        ColumnConfig<CompletionRecordProxy, Float> ccLeftFlange = new ColumnConfig<CompletionRecordProxy, Float>(completionRecordProperties.flangeWidthLeft(), 120, "Толщина гребня");
        ColumnConfig<CompletionRecordProxy, Float> ccRightFlange = new ColumnConfig<CompletionRecordProxy, Float>(completionRecordProperties.flangeWidthRight(), 120, "Толщина гребня");
        ColumnConfig<CompletionRecordProxy, Float> ccLeftRim = new ColumnConfig<CompletionRecordProxy, Float>(completionRecordProperties.rimWidthLeft(), 120, "Толщина обода");
        ColumnConfig<CompletionRecordProxy, Float> ccRightRim = new ColumnConfig<CompletionRecordProxy, Float>(completionRecordProperties.rimWidthRight(), 120, "Толщина обода");
        ColumnConfig<CompletionRecordProxy, Float> ccLeftRolled = new ColumnConfig<CompletionRecordProxy, Float>(completionRecordProperties.rolledLeft(), 120, "Прокат");
        ColumnConfig<CompletionRecordProxy, Float> ccRightRolled = new ColumnConfig<CompletionRecordProxy, Float>(completionRecordProperties.rolledRight(), 120, "Прокат");

        Comparator comparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return ResourceList.getListCompletionNo().get(o1).compareTo(ResourceList.getListCompletionNo().get(o2));
            }
        };

        ColumnConfig<CompletionRecordProxy, String> ccListGrouping = new ColumnConfig<CompletionRecordProxy, String>(new ValueProvider<CompletionRecordProxy, String>() {
            @Override
            public String getValue(CompletionRecordProxy object) {
                return ResourceList.getCompletionGroups().get(object.getTitle());
            }
            @Override
            public void setValue(CompletionRecordProxy object, String value) {}
            @Override
            public String getPath() {return "";}
        });

        ColumnConfig<CompletionRecordProxy, String> ccListGrouping2 = new ColumnConfig<CompletionRecordProxy, String>(new ValueProvider<CompletionRecordProxy, String>() {
            @Override
            public String getValue(CompletionRecordProxy object) {
                return ResourceList.getCompletionGroups().get(object.getTitle());
            }
            @Override
            public void setValue(CompletionRecordProxy object, String value) {}
            @Override
            public String getPath() {return "";}
        });


        ColumnConfig<CompletionRecordProxy, String> ccListGrouping3 = new ColumnConfig<CompletionRecordProxy, String>(new ValueProvider<CompletionRecordProxy, String>() {
            @Override
            public String getValue(CompletionRecordProxy object) {
                return ResourceList.getCompletionGroups().get(object.getTitle());
            }
            @Override
            public void setValue(CompletionRecordProxy object, String value) {}
            @Override
            public String getPath() {return "";}
        });


        ColumnConfig<CompletionRecordProxy, String> ccLeftGrouping = new ColumnConfig<CompletionRecordProxy, String>(new ValueProvider<CompletionRecordProxy, String>() {
            @Override
            public String getValue(CompletionRecordProxy object) {
                return "Геометрические размеры, Левое колесо";
            }
            @Override
            public void setValue(CompletionRecordProxy object, String value) {}
            @Override
            public String getPath() {return "";}
        });
        ColumnConfig<CompletionRecordProxy, String> ccRightGrouping = new ColumnConfig<CompletionRecordProxy, String>(new ValueProvider<CompletionRecordProxy, String>() {
            @Override
            public String getValue(CompletionRecordProxy object) {
                return "Геометрические размеры, Правое колесо";
            }
            @Override
            public void setValue(CompletionRecordProxy object, String value) {}
            @Override
            public String getPath() {return "";}
        });

        ccListGrouping.setComparator(comparator);
        ccListGrouping2.setComparator(comparator);
        ccListGrouping3.setComparator(comparator);

        ColumnConfig<CompletionRecordProxy, ?> ccTitle = new ColumnConfig<CompletionRecordProxy, String>(new ValueProvider<CompletionRecordProxy, String>() {
            @Override
            public String getValue(CompletionRecordProxy object) {
                String title = object.getTitle();
                if (!"Другое".equals(title)) title += " " + object.getNumber();
                return title;
            }

            @Override
            public void setValue(CompletionRecordProxy object, String value) {}

            @Override
            public String getPath() {return null;}
        }, 140, "Наименование");

        ColumnConfig<CompletionRecordProxy, Integer> ccRealNumber = new ColumnConfig<CompletionRecordProxy, Integer>(completionRecordProperties.number());

        List<ColumnConfig<CompletionRecordProxy, ?>> listAutoCC = new ArrayList<>();
        listAutoCC.add(ccListGrouping);
        listAutoCC.add(ccTitle);
        listAutoCC.add(ccNumber);
        listAutoCC.add(ccCode);
        listAutoCC.add(ccYear);
        listAutoCC.add(ccKind);

        List<ColumnConfig<CompletionRecordProxy, ?>> list2FieldsCC = new ArrayList<>();
        list2FieldsCC.add(ccListGrouping2);
        list2FieldsCC.add(ccTitle);
        list2FieldsCC.add(ccModel);

        List<ColumnConfig<CompletionRecordProxy, ?>> list4FieldsCC = new ArrayList<>();
        list4FieldsCC.add(ccListGrouping3);
        list4FieldsCC.add(ccTitle);
        list4FieldsCC.add(ccNumber);
        list4FieldsCC.add(ccCode);
        list4FieldsCC.add(ccYear);

        List<ColumnConfig<CompletionRecordProxy, ?>> list4FieldsLeftCC = new ArrayList<>();
        list4FieldsLeftCC.add(ccLeftGrouping);
        list4FieldsLeftCC.add(ccRealNumber);
        list4FieldsLeftCC.add(ccLeftRim);
        list4FieldsLeftCC.add(ccLeftFlange);
        list4FieldsLeftCC.add(ccLeftRolled);

        List<ColumnConfig<CompletionRecordProxy, ?>> list4FieldsRightCC = new ArrayList<>();
        list4FieldsRightCC.add(ccRightGrouping);
        list4FieldsRightCC.add(ccRealNumber);
        list4FieldsRightCC.add(ccRightRim);
        list4FieldsRightCC.add(ccRightFlange);
        list4FieldsRightCC.add(ccRightRolled);

        Grid gridListAuto = new Grid<CompletionRecordProxy>(completionRecordListCompletionAutoStoreEditor.getStore(), new ColumnModel<CompletionRecordProxy>(listAutoCC));
        gridListAuto.setTitle("Автосцепное оборудование");
        completionRecordListCompletionAutoStoreEditor.getStore().setAutoCommit(true);
        GroupingView<CompletionRecordProxy> autoFieldsView = new GroupingView<CompletionRecordProxy>();
        autoFieldsView.setAutoFill(false);
        autoFieldsView.setColumnLines(true);
        autoFieldsView.setSortingEnabled(false);
        autoFieldsView.setEnableGroupingMenu(false);
        autoFieldsView.setEnableNoGroups(false);
        autoFieldsView.setShowGroupedColumn(false);
        autoFieldsView.setForceFit(false);
        gridListAuto.setView(autoFieldsView);
        autoFieldsView.groupBy(ccListGrouping);
        final GridInlineEditing<CompletionRecordProxy> autoEditing = new GridInlineEditing<CompletionRecordProxy>(gridListAuto);
        List<CompletionChecker> autoList = new ArrayList<>();
        autoEditing.addEditor(ccNumber, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999999999l), new NumberPropertyEditor.LongPropertyEditor()));
        autoList.add(new CompletionNumberNewChecker());
        autoEditing.addEditor(ccCode, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        autoList.add(new CompletionCodeNewChecker());
        autoEditing.addEditor(ccYear, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        autoList.add(new CompletionYearNewChecker());
        TextField textField = new TextField();
        textField.addValidator(new MaxLengthValidator(20));
        textField.setAutoValidate(true);
        autoEditing.addEditor(ccKind, textField);
        autoList.add(new CompletionTextNewChecker());
        autoEditing.setRevertInvalid(true);
        completionCheckerList.put(completionRecordListCompletionAutoStoreEditor.getStore(), autoList);
        autoEditing.addCompleteEditHandler(new CompleteEditEvent.CompleteEditHandler<CompletionRecordProxy>() {
            @Override
            public void onCompleteEdit(CompleteEditEvent<CompletionRecordProxy> event) {
                CompletionRecordProxy cpr = completionRecordListCompletionAutoStoreEditor.getStore().get(event.getEditCell().getRow());
                if(!completionList.getStore().getAll().contains(cpr)) completionList.getStore().add(cpr);
                refreshGrids();
            }
        });
        autoEditing.addStartEditHandler(new StartEditEvent.StartEditHandler<CompletionRecordProxy>() {
            @Override
            public void onStartEdit(StartEditEvent<CompletionRecordProxy> completionRecordProxyStartEditEvent) {
                for (ColumnConfig cc : completionRecordProxyStartEditEvent.getSource().getEditableGrid().getColumnModel().getColumns()) {
                    Field field = completionRecordProxyStartEditEvent.getSource().getEditor(cc);
                    if (field != null && field instanceof NumberField ) {
                        if (!((NumberField)field).isCurrentValid()) ((NumberField)field).setText("");
                    }
                }
            }
        });
        gridsForRefresh.add(gridListAuto);

        FieldSet yokeFieldSet = new FieldSet();
        yokeFieldSet.setHeadingText("Тяговый хомут");
        yokeFieldSet.setCollapsible(false);

        yokeFieldSet.add(getYokeContainer());

        Grid gridList2Fields = new Grid<CompletionRecordProxy>(completionRecordListCompletion2FieldsStoreEditor.getStore(), new ColumnModel<CompletionRecordProxy>(list2FieldsCC));
        completionRecordListCompletion2FieldsStoreEditor.getStore().setAutoCommit(true);
        GroupingView<CompletionRecordProxy> list2FieldsView = new GroupingView<CompletionRecordProxy>();
        list2FieldsView.setAutoFill(false);
        list2FieldsView.setColumnLines(true);
        list2FieldsView.setSortingEnabled(false);
        list2FieldsView.setEnableGroupingMenu(false);
        list2FieldsView.setEnableNoGroups(false);
        list2FieldsView.setShowGroupedColumn(false);
        list2FieldsView.setForceFit(false);
        gridList2Fields.setView(list2FieldsView);
        list2FieldsView.groupBy(ccListGrouping2);
        final GridInlineEditing<CompletionRecordProxy> list2FieldsEditing = new GridInlineEditing<CompletionRecordProxy>(gridList2Fields);
        textField = new TextField();
        textField.addValidator(new MaxLengthValidator(30));
        textField.setAutoValidate(true);

        list2FieldsEditing.addEditor(ccModel, textField);
        completionCheckerList.put(completionRecordListCompletion2FieldsStoreEditor.getStore(), new ArrayList<CompletionChecker>(Arrays.asList(new CompletionTextNewChecker())));
        list2FieldsEditing.setRevertInvalid(true);
        list2FieldsEditing.addCompleteEditHandler(new CompleteEditEvent.CompleteEditHandler<CompletionRecordProxy>() {
            @Override
            public void onCompleteEdit(CompleteEditEvent<CompletionRecordProxy> event) {
                CompletionRecordProxy cpr = completionRecordListCompletion2FieldsStoreEditor.getStore().get(event.getEditCell().getRow());
                if(!completionList.getStore().getAll().contains(cpr)) completionList.getStore().add(cpr);
                refreshGrids();
            }
        });

        gridsForRefresh.add(gridList2Fields);

        Grid gridList4Fields = new Grid<CompletionRecordProxy>(completionRecordListCompletion4FieldsMainStoreEditor.getStore(), new ColumnModel<CompletionRecordProxy>(list4FieldsCC));
        completionRecordListCompletion4FieldsMainStoreEditor.getStore().setAutoCommit(true);
        GroupingView<CompletionRecordProxy> list4FieldsView = new GroupingView<CompletionRecordProxy>();
        list4FieldsView.setAutoFill(false);
        list4FieldsView.setColumnLines(true);
        list4FieldsView.setSortingEnabled(false);
        list4FieldsView.setEnableGroupingMenu(false);
        list4FieldsView.setEnableNoGroups(false);
        list4FieldsView.setShowGroupedColumn(false);
        list4FieldsView.setForceFit(false);
        gridList4Fields.setView(list4FieldsView);
        list4FieldsView.groupBy(ccListGrouping3);
        final GridInlineEditing<CompletionRecordProxy> list4FieldsEditing = new GridInlineEditing<CompletionRecordProxy>(gridList4Fields);
        List<CompletionChecker> fields4List = new ArrayList<>();

        list4FieldsEditing.addEditor(ccNumber, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999999999l), new NumberPropertyEditor.LongPropertyEditor()));
        fields4List.add(new CompletionNumberNewChecker());
        list4FieldsEditing.addEditor(ccCode, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        fields4List.add(new CompletionCodeNewChecker());
        list4FieldsEditing.addEditor(ccYear, getCompletionNumberFieldForEditor(new MaxNumberValidator(9999), new NumberPropertyEditor.IntegerPropertyEditor()));
        fields4List.add(new CompletionYearNewChecker());
        completionCheckerList.put(completionRecordListCompletion4FieldsMainStoreEditor.getStore(), fields4List);

        list4FieldsEditing.setRevertInvalid(true);
        list4FieldsEditing.addCompleteEditHandler(new CompleteEditEvent.CompleteEditHandler<CompletionRecordProxy>() {
            @Override
            public void onCompleteEdit(CompleteEditEvent<CompletionRecordProxy> event) {
                CompletionRecordProxy cpr = completionRecordListCompletion4FieldsMainStoreEditor.getStore().get(event.getEditCell().getRow());
                if(!completionList.getStore().getAll().contains(cpr)) completionList.getStore().add(cpr);
                refreshGrids();
            }
        });
        list4FieldsEditing.addStartEditHandler(new StartEditEvent.StartEditHandler<CompletionRecordProxy>() {
            @Override
            public void onStartEdit(StartEditEvent<CompletionRecordProxy> completionRecordProxyStartEditEvent) {
                for (ColumnConfig cc : completionRecordProxyStartEditEvent.getSource().getEditableGrid().getColumnModel().getColumns()) {
                    Field field = completionRecordProxyStartEditEvent.getSource().getEditor(cc);
                    if (field != null && field instanceof NumberField ) {
                        if (!((NumberField)field).isCurrentValid()) ((NumberField)field).setText("");
                    }
                }
            }
        });
        gridsForRefresh.add(gridList4Fields);

        Grid gridListLeft = new Grid<CompletionRecordProxy>(completionRecordListCompletion4FieldsLeftStoreEditor.getStore(), new ColumnModel<CompletionRecordProxy>(list4FieldsLeftCC));
        completionRecordListCompletion4FieldsLeftStoreEditor.getStore().setAutoCommit(true);
        GroupingView<CompletionRecordProxy> leftFieldsView = new GroupingView<CompletionRecordProxy>();
        leftFieldsView.setAutoFill(false);
        leftFieldsView.setColumnLines(true);
        leftFieldsView.setSortingEnabled(false);
        leftFieldsView.setEnableGroupingMenu(false);
        leftFieldsView.setEnableNoGroups(false);
        leftFieldsView.setShowGroupedColumn(false);
        leftFieldsView.setForceFit(false);
        gridListLeft.setView(leftFieldsView);
        leftFieldsView.groupBy(ccLeftGrouping);

        final GridInlineEditing<CompletionRecordProxy> leftEditing = new GridInlineEditing<CompletionRecordProxy>(gridListLeft);
        List<CompletionChecker> leftList = new ArrayList<>();
        leftEditing.addEditor(ccLeftRim, new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor()));
        leftList.add(new CompletionRimLeftChecker());
        leftEditing.addEditor(ccLeftFlange, new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor()));
        leftList.add(new CompletionFlangeLeftChecker());
        leftEditing.addEditor(ccLeftRolled, new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor()));
        leftList.add(new CompletionRolledLeftChecker());

        completionCheckerList.put(completionRecordListCompletion4FieldsLeftStoreEditor.getStore(), leftList);
        leftEditing.setRevertInvalid(true);
        leftEditing.addCompleteEditHandler(new CompleteEditEvent.CompleteEditHandler<CompletionRecordProxy>() {
            @Override
            public void onCompleteEdit(CompleteEditEvent<CompletionRecordProxy> event) {
                CompletionRecordProxy cpr = completionRecordListCompletion4FieldsLeftStoreEditor.getStore().get(event.getEditCell().getRow());
                if(!completionList.getStore().getAll().contains(cpr)) completionList.getStore().add(cpr);
                refreshGrids();
            }
        });
        gridsForRefresh.add(gridListLeft);

        Grid gridListRight = new Grid<CompletionRecordProxy>(completionRecordListCompletion4FieldsLeftStoreEditor.getStore(), new ColumnModel<CompletionRecordProxy>(list4FieldsRightCC));
        completionRecordListCompletion4FieldsLeftStoreEditor.getStore().setAutoCommit(true);
        GroupingView<CompletionRecordProxy> rightFieldsView = new GroupingView<CompletionRecordProxy>();
        rightFieldsView.setAutoFill(false);
        rightFieldsView.setColumnLines(true);
        rightFieldsView.setSortingEnabled(false);
        rightFieldsView.setEnableGroupingMenu(false);
        rightFieldsView.setEnableNoGroups(false);
        rightFieldsView.setShowGroupedColumn(false);
        rightFieldsView.setForceFit(false);
        gridListRight.setView(rightFieldsView);
        rightFieldsView.groupBy(ccRightGrouping);
        final GridInlineEditing<CompletionRecordProxy> rightEditing = new GridInlineEditing<CompletionRecordProxy>(gridListRight);
        List<CompletionChecker> rightList = new ArrayList<>();

        rightEditing.addEditor(ccRightRim, new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor()));
        leftList.add(new CompletionRimRightChecker());
        rightEditing.addEditor(ccRightFlange, new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor()));
        leftList.add(new CompletionFlangeRightChecker());
        rightEditing.addEditor(ccRightRolled, new NumberField<Float>(new NumberPropertyEditor.FloatPropertyEditor()));
        leftList.add(new CompletionRolledRightChecker());

        completionCheckerList.put(completionRecordListCompletion4FieldsLeftStoreEditor.getStore(), rightList);

        rightEditing.setRevertInvalid(true);
        rightEditing.addCompleteEditHandler(new CompleteEditEvent.CompleteEditHandler<CompletionRecordProxy>() {
            @Override
            public void onCompleteEdit(CompleteEditEvent<CompletionRecordProxy> event) {
                CompletionRecordProxy cpr = completionRecordListCompletion4FieldsRightStoreEditor.getStore().get(event.getEditCell().getRow());
                if (!completionList.getStore().getAll().contains(cpr)) completionList.getStore().add(cpr);
                refreshGrids();
            }
        });
        gridsForRefresh.add(gridListRight);

        FieldSet brakeEquipmentSet = new FieldSet();
        brakeEquipmentSet.setHeadingText("Тормозное оборудование");
        brakeEquipmentSet.setCollapsible(false);
        brakeEquipmentSet.add(getBrakeEquipmentContainer());





        vlc.add(gridListAuto, new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(5, 5, 5, 5)));
        vlc.add(yokeFieldSet, new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(5, 5, 5, 5)));
        vlc.add(gridList2Fields, new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(5, 5, 5, 5)));
        vlc.add(gridList4Fields, new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(5, 5, 5, 5)));
        vlc.add(gridListLeft, new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(5, 5, 5, 5)));
        vlc.add(gridListRight, new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(5, 5, 5, 5)));
        vlc.add(brakeEquipmentSet, new VerticalLayoutContainer.VerticalLayoutData(-1d, -1d, new Margins(5, 5, 5, 5)));
        refreshGrids();
        panel.add(vlc);
        return panel;
    }

    private HBoxLayoutContainer getBrakeEquipmentContainer(){
        brakeEquipmentCheckBoxesForRefresh.clear();
        String brakeEquipmentKey = getCompletionRecordProxyKey("Тормозное оборудование", 1, true);
        HBoxLayoutContainer brakeEquipmentContainer = new HBoxLayoutContainer();
        brakeEquipmentContainer.setPadding(new Padding(5));
        brakeEquipmentContainer.setHBoxLayoutAlign(HBoxLayoutContainer.HBoxLayoutAlign.MIDDLE);
        brakeEquipmentContainer.setPack(BoxLayoutContainer.BoxLayoutPack.CENTER);
        BoxLayoutContainer.BoxLayoutData tbLayoutData = new BoxLayoutContainer.BoxLayoutData(new Margins(5, 0, 5, 0));
        BoxLayoutContainer.BoxLayoutData layoutData = new BoxLayoutContainer.BoxLayoutData(new Margins(5, 5, 5, 5));
        for (byte b = 0; b < 6; b++ ){
            brakeEquipmentCheckBoxesForRefresh.add(getCompletionCheckBox(b, brakeEquipmentKey));
            brakeEquipmentCheckBoxesForRefresh.get(b).setLayoutData(tbLayoutData);
            brakeEquipmentContainer.add(createFieldLabelAutoWidth(brakeEquipmentCheckBoxesForRefresh.get(b), ResourceList.getBreakEquipment().get(b), layoutData));
        }
        return brakeEquipmentContainer;
    }

    private HBoxLayoutContainer getYokeContainer(){
        yokeCheckBoxesForRefresh.clear();
        String yokeKey = getCompletionRecordProxyKey("Тяговые хомуты", 1, true);
        BoxLayoutContainer.BoxLayoutData yokeLayoutData = new BoxLayoutContainer.BoxLayoutData(new Margins(0, 50, 0, 10));
        HBoxLayoutContainer yokeContainer = new HBoxLayoutContainer();
        yokeContainer.setPadding(new Padding(5));
        yokeContainer.setHBoxLayoutAlign(HBoxLayoutContainer.HBoxLayoutAlign.MIDDLE);
        yokeContainer.setPack(BoxLayoutContainer.BoxLayoutPack.CENTER);
        for (byte b = 0; b < 2; b++ ){
            yokeCheckBoxesForRefresh.add(getCompletionCheckBox(b, yokeKey));
            yokeCheckBoxesForRefresh.get(b).setLayoutData(new BoxLayoutContainer.BoxLayoutData(new Margins(5, 5, 5, 5)) );
            yokeContainer.add(createFieldLabel(yokeCheckBoxesForRefresh.get(b), "Тяговый хомут " + (b + 1), repairLineFieldData), yokeLayoutData);
        }
        return yokeContainer;
    }

    private CheckBox getCompletionCheckBox(final byte position, final String key){
        CheckBox checkBox = new CheckBox();
        checkBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
            @Override
            public void onValueChange(ValueChangeEvent<Boolean> event) {
                CompletionRecordProxy cpr = completionRecordProxyListStore.findModelWithKey(key);
                setNumberCheckBoxValue(cpr, position, event.getValue());
            }
        });
        return checkBox;
    }

    private void refreshGrids(){
        if (gridsForRefresh != null){
            for(Grid grid : gridsForRefresh){
                grid.getView().refresh(false);
            }
        }
    }
    private void refreshCheckBoxes(){
        if (yokeCheckBoxesForRefresh != null){
            for(byte i = 0; i < yokeCheckBoxesForRefresh.size(); i++){
                yokeCheckBoxesForRefresh.get(i).setValue(getCheckBoxValue(i, getCompletionRecordProxyKey("Тяговые хомуты", 1, true)));
            }
        }

        if (brakeEquipmentCheckBoxesForRefresh != null){
            for(byte i = 0; i < brakeEquipmentCheckBoxesForRefresh.size(); i++){
                brakeEquipmentCheckBoxesForRefresh.get(i).setValue(getCheckBoxValue(i, getCompletionRecordProxyKey("Тормозное оборудование", 1, true)));
            }
        }
    }

    private void refreshStores(){
        currentStation.getStore().replaceAll(railwayStore.getAll());
        repairStation.getStore().replaceAll(railwayStore.getAll());
        uncoupleStation.getStore().replaceAll(railwayStore.getAll());
    }

    private Boolean getCheckBoxValue(byte checkboxNumber, String key){
        CompletionRecordProxy cpr = completionRecordProxyListStore.findModelWithKey(key);
        if (cpr == null || cpr.getNumberNew() == null) return null;
        return checkMultiBooleanNumber(cpr.getNumberNew(), checkboxNumber);
    }

    private void setNumberCheckBoxValue(CompletionRecordProxy cpr, byte checkboxNumber, Boolean value){
        if (cpr == null) return;
        if (cpr.getNumberNew() == null) cpr.setNumberNew(0l);
        boolean _value = value == null ? false : value;
        cpr.setNumberNew(getMultiBooleanNumber(cpr.getNumberNew(), checkboxNumber, _value));

        if(!completionList.getStore().getAll().contains(cpr)) completionList.getStore().add(cpr);
    }


    private boolean checkMultiBooleanNumber(long number, byte place){
        int b = 1<<place;
        return b == (number & b);
    }

    private long getMultiBooleanNumber(long number, byte place, boolean value){
        int b = 1 << place;
        return value ? number | b : number ^ b;
    }


    public void fillMxLabelContainer(){
        mxLabelContainer =  new HBoxLayoutContainer();
        FlowPanel fp = new FlowPanel();
        fp.setWidth("150px");
        mxLabelContainer.add(fp);

        fp = new FlowPanel();
        fp.setWidth("55px");
        mxLabelContainer.add(fp);

        fp = new FlowPanel();
        fp.setWidth("105px");
        mxLabelContainer.add(fp);

        fp = new FlowPanel();
        fp.setWidth("105px");
        mxLabelContainer.add(fp);

        fp = new FlowPanel();
        fp.setWidth("105px");
        mxLabelContainer.add(fp);

        fp = new FlowPanel();
        fp.setWidth("105px");
        fp.add(new Label("Масса в тоннах"));
        mxLabelContainer.add(fp);
    }

    private void refreshAttachments(List<AttachmentProxy> list){
        AttachmentProxy ap = context.create(AttachmentProxy.class);
        uploadComponent.refresh(ap, list);
    }

    private void recalculateDefectReadOnlyDocumentFields(){
        Float repairSum = null;
        Float goods = null;
        Float finalInvoice = null;
        if (repairDocuments != null && repairDocuments.getStore() != null){
            for (RepairDocumentProxy document : repairDocuments.getStore().getAll()){
                if (document.getRepairDocumentType().getTitle().equals("Калькуляция РДВ")){
                    repairSum = document.getAmount();
                } else if (document.getRepairDocumentType().getTitle().equals("Акт ПП товарно-материальных ценностей")){
                    goods = document.getAmount();
                } else if (document.getRepairDocumentType().getTitle().equals("Счет окончательный")){
                    finalInvoice = document.getAmount();
                }
                if (repairSum != null && goods != null && finalInvoice != null) break;
            }
        }
        if (repairSum != null && goods != null) repairSum -= goods;
        if (repairSum == null) defectsRepairSum.setValue(null);//defectsRepairSum.clear();
        else defectsRepairSum.setValue(Float.toString(repairSum));

        partsFieldSet.setRepairSum(repairSum);

        if (provisionalInvoiceAmount.getValue() == null || finalInvoice == null) defectsTotalSaveSum.setValue(null);//defectsTotalSaveSum.clear();
        else defectsTotalSaveSum.setValue(Float.toString(provisionalInvoiceAmount.getValue() - finalInvoice));
    }

    private void recalculateDefectReadOnlyOtherFields(){

        Float repairSum = defectsRepairSum.getValue() == null ? null : Float.parseFloat(defectsRepairSum.getValue());
        Float defectsSum = null;

        if (repairSum != null && repairDefects != null && repairDefects.getStore() != null){
            for (RepairDefectProxy defect : repairDefects.getStore().getAll()){
                if (defect.getCost() != null){
                    defectsSum = defectsSum == null ? defect.getCost() : defectsSum + defect.getCost();
                }
            }
        }

        if (repairSum == null) {
            defectsWorkSum.setValue(null);
            defectsTotalSumWithoutTaxes.setValue(null);
            defectsTotalSumTaxes.setValue(null);
            defectsTotalSumWithTaxes.setValue(null);
//            defectsWorkSum.clear();
//            defectsTotalSumWithoutTaxes.clear();
//            defectsTotalSumTaxes.clear();
//            defectsTotalSumWithTaxes.clear();
        }
        else {
            defectsWorkSum.setValue(Float.toString(defectsSum == null ? repairSum : repairSum - defectsSum));
            defectsTotalSumWithoutTaxes.setValue(Float.toString(repairSum));
            defectsTotalSumTaxes.setValue(Float.toString(repairSum * 0.18f));
            defectsTotalSumWithTaxes.setValue(Float.toString(repairSum * 1.18f));
        }
    }

    private void recalculateDefectReadOnlyFields(){
        recalculateDefectReadOnlyDocumentFields();
        recalculateDefectReadOnlyOtherFields();
    }

    private class RepairDocTypePanel extends HBoxLayoutContainer {
        private RepairDocumentTypeProxy repairDocumentType;

        private RepairDocumentProxy document;
        private CheckBox checkBox = new CheckBox();
        private Boolean planned;
        private Long excludeID;

        private DateField original =  new DateField(dateTimeProperty);
        private DateField electronic =  new DateField(dateTimeProperty);
        private TextField number = new TextField();
        private FloatField amount = new FloatField();
        private FloatField weight = new FloatField();
        private DateField date =  new DateField(dateTimeProperty);

        private com.sencha.gxt.widget.core.client.button.ToggleButton button =
                new com.sencha.gxt.widget.core.client.button.ToggleButton("Показать");

        public int getTypeId(){
            return repairDocumentType.getTypeID();
        }
        public RepairDocumentProxy getDocument(){
            if (document == null && context != null) {
                document = context.create(RepairDocumentProxy.class);
                document.setGuid(Long.toString((new Date()).getTime()));
                document.setRepairDocumentType(repairDocumentType);
            }
            return document;
        }

        public void resetDocument(RepairDocumentProxy document){
            button.setValue(false);
            button.setText("Показать");
            if (document != null) {
                enableFields(true);
                this.document = document;
                original.setValue(document.getDocumentOriginalDate());
                original.setAllowBlank(document != null && document.getDocumentElectronicDate() != null);
                electronic.setValue(document.getDocumentElectronicDate());
                electronic.setAllowBlank(document != null && document.getDocumentOriginalDate() != null);
                number.setValue(document.getNumber());
                amount.setValue(document.getAmount());
                weight.setValue(document.getWeight());
                date.setValue(document.getDocumentDate());
                checkBox.setValue(true);

                if (document.getRepairDocumentType().getTitle().equals("Счет-фактура")) {
                    if (document.getNumber() != null) invoiceNumber.setValue(document.getNumber());
                    else invoiceNumber.clear();
                    if (document.getDocumentDate() != null) invoiceLoadDate.setValue(document.getDocumentDate());
                    else invoiceLoadDate.clear();
                    if (document.getAmount() != null) invoiceAmount.setValue(document.getAmount());
                    else invoiceAmount.clear();
                } else if (document.getRepairDocumentType().getTitle().equals("ВУ-41")){
                    if (document.getAmount() != null) vu41TextField.setValue(Float.toString(document.getAmount()));
                    else vu41TextField.clear();
                } else if (document.getRepairDocumentType().getTitle().equals("Акт повреждения вагона ВУ-25")){
                    if (document.getAmount() != null) vu25TextField.setValue(Float.toString(document.getAmount()));
                    else vu25TextField.clear();
                }
            } else {
                this.document = null;
                original.clear();
                electronic.clear();
                number.clear();
                amount.clear();
                weight.clear();
                date.clear();
                checkBox.clear();
                enableFields(false);
           }
        }

        public boolean isCurrent(){
            return planned == null || !planned;
        }

        public boolean isPlanned(){
            return planned == null || planned;
        }

        public RepairDocTypePanel(RepairDocumentTypeProxy documentType){
            repairDocumentType = documentType;
            planned = documentType.getIsPlanned();
            excludeID = documentType.getExcludeId();
            FlowPanel labelPanel = new FlowPanel();
            Label label = new Label(documentType.getTitle());
            FlowPanel checkPanel = new FlowPanel();
            FlowPanel originalPanel = new FlowPanel();
            FlowPanel electronicPanel = new FlowPanel();
            FlowPanel amountPanel = new FlowPanel();
            FlowPanel datePanel = new FlowPanel();

            original.setEnabled(false);
            original.setAllowBlank(getDocument() != null && getDocument().getDocumentElectronicDate() != null);
            original.addValueChangeHandler(new ValueChangeHandler<Date>() {
                @Override
                public void onValueChange(ValueChangeEvent<Date> event) {
                    getDocument().setDocumentOriginalDate(event.getValue());
                    electronic.setAllowBlank(event.getValue() != null);
                    electronic.clearInvalid();
                }
            });

            electronic.setEnabled(false);
            electronic.setAllowBlank(getDocument() != null && getDocument().getDocumentOriginalDate() != null);
            FlowPanel numberPanel = new FlowPanel();
            electronic.addValueChangeHandler(new ValueChangeHandler<Date>() {
                @Override
                public void onValueChange(ValueChangeEvent<Date> event) {
                    getDocument().setDocumentElectronicDate(event.getValue());
                    original.setAllowBlank(event.getValue() != null);
                    original.clearInvalid();
                }
            });
            number.setEnabled(false);
            number.setAllowBlank(false);
            number.addValueChangeHandler(new ValueChangeHandler<String>() {
                @Override
                public void onValueChange(ValueChangeEvent<String> event) {
                    getDocument().setNumber(event.getValue());
                }
            });

            amount.setEnabled(false);
            amount.setAllowBlank(false);
            amount.addValueChangeHandler(new ValueChangeHandler<Float>() {
                @Override
                public void onValueChange(ValueChangeEvent<Float> event) {
                    getDocument().setAmount(event.getValue());
                    recalculateDefectReadOnlyFields();
                }
            });
            date.setAllowBlank(false);
            date.setEnabled(false);
            date.addValueChangeHandler(new ValueChangeHandler<Date>() {
                @Override
                public void onValueChange(ValueChangeEvent<Date> event) {
                    getDocument().setDocumentDate(event.getValue());
                }
            });
            weight.setAllowBlank(false);
            weight.setEnabled(false);
            weight.addValueChangeHandler(new ValueChangeHandler<Float>() {
                @Override
                public void onValueChange(ValueChangeEvent<Float> event) {
                    getDocument().setWeight(event.getValue());
                }
            });


            button.setWidth("100px");
            button.setEnabled(false);
            labelPanel.setWidth("150px");
            checkPanel.setWidth("55px");
            original.setWidth(100);
            originalPanel.setWidth("105px");
            electronic.setWidth(100);
            electronicPanel.setWidth("105px");
            number.setWidth(100);
            numberPanel.setWidth("105px");
            date.setWidth(100);
            datePanel.setWidth("105px");
            amount.setWidth(100);
            amountPanel.setWidth("105px");
            weight.setWidth(100);
            labelPanel.add(label);
            checkPanel.add(checkBox);
            originalPanel.add(original);
            electronicPanel.add(electronic);
            if (documentType.getTypeID()<7){
                if (documentType.getTypeID() > 4 ) {
                    amountPanel.add(button);
                    if (documentType.getTypeID() == 5) {
                        button.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
                            @Override
                            public void onValueChange(ValueChangeEvent<Boolean> event) {
                                if (event.getValue()) {
                                    vu53Container.show();
                                    button.setText("Скрыть");
                                } else {
                                    vu53Container.hide();
                                    button.setText("Показать");
                                }
                            }
                        });
                    } else if (documentType.getTypeID() == 6) {
                        button.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
                            @Override
                            public void onValueChange(ValueChangeEvent<Boolean> event) {
                                if (event.getValue()) {
                                    listCompletionContainer.show();
                                    button.setText("Скрыть");
                                } else {
                                    listCompletionContainer.hide();
                                    button.setText("Показать");
                                }
                            }
                        });
                    }
                }
                else {
                    amountPanel.add(amount);
                    if (documentType.getTitle().equals("ВУ-41")){
                        amount.addValueChangeHandler(new ValueChangeHandler<Float>() {
                            @Override
                            public void onValueChange(ValueChangeEvent<Float> event) {
                                vu41TextField.setValue(Float.toString(event.getValue()));
                            }
                        });
                    } else if (documentType.getTitle().equals("Акт повреждения вагона ВУ-25")){
                        amount.addValueChangeHandler(new ValueChangeHandler<Float>() {
                            @Override
                            public void onValueChange(ValueChangeEvent<Float> event) {
                                vu25TextField.setValue(Float.toString(event.getValue()));
                            }
                        });
                    }

                    if (documentType.getTypeID() > 2){
                        numberPanel.add(weight);
                    }
                    else if (documentType.getTypeID() == 1) {
                        numberPanel.add(number);
                        datePanel.add(date);
                        if (documentType.getTitle().equals("Счет-фактура")) {
                            amount.addValueChangeHandler(new ValueChangeHandler<Float>() {
                                @Override
                                public void onValueChange(ValueChangeEvent<Float> event) {
                                    fillDebitCreditFields(repairDocuments.getStore().getAll(), payments.getStore().getAll());
                                    invoiceAmount.setValue(event.getValue());
                                }
                            });
                            date.addValueChangeHandler(new ValueChangeHandler<Date>() {
                                @Override
                                public void onValueChange(ValueChangeEvent<Date> event) {
                                    invoiceLoadDate.setValue(event.getValue());
                                }
                            });
                            number.addValueChangeHandler(new ValueChangeHandler<String>() {
                                @Override
                                public void onValueChange(ValueChangeEvent<String> event) {
                                    invoiceNumber.setValue(event.getValue());
                                }
                            });
                        }
                    }
                }
            }
            add(labelPanel);
            add(checkPanel);
            add(electronicPanel);
            add(originalPanel);
            add(amountPanel);
            add(numberPanel);
            add(datePanel);


            checkBox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
                @Override
                public void onValueChange(ValueChangeEvent<Boolean> event) {
                    enableFields(event.getValue());
                    if (event.getValue()){
                        repairDocuments.getStore().add(getDocument());
                    } else {
                        repairDocuments.getStore().remove(getDocument());
                        recalculateDefectReadOnlyFields();
                        original.clearInvalid();
                        electronic.clearInvalid();
                        number.clearInvalid();
                        amount.clearInvalid();
                        weight.clearInvalid();
                        date.clearInvalid();
                    }
                }
            });

        }

        private void enableFields(boolean enable){
            date.setEnabled(enable);
            number.setEnabled(enable);
            amount.setEnabled(enable);
            weight.setEnabled(enable);
            original.setEnabled(enable);
            electronic.setEnabled(enable);
            button.setEnabled(enable);
            if (excludeID != null) repairDocTypePanels.get(excludeID).setEnabled(!enable);
        }

        public boolean hasErrors(){
            boolean result = false;
            if (checkBox.getValue()){
                result |= !(original.getParent() == null || original.isCurrentValid());
                result |= !(electronic.getParent() == null || electronic.isCurrentValid());
                result |= !(number.getParent() == null || number.isCurrentValid());
                result |= !(amount.getParent() == null || amount.isCurrentValid());
                result |= !(weight.getParent() == null || weight.isCurrentValid());
                result |= !(date.getParent() == null || date.isCurrentValid());
            }
            return result;
        }
    }

    private SummaryColumnConfig getDateColumnConfig(ValueProvider valueProvider, int size, String columnHeader){
        SummaryColumnConfig columnConfig = new SummaryColumnConfig<RepairProxy, Date>(valueProvider, size, columnHeader);
        columnConfig.setCell(dateCell);
        columnConfig.setAlignment(HasHorizontalAlignment.ALIGN_CENTER);
        return columnConfig;
    }

    private SummaryColumnConfig<PaymentProxy, ?> getPaymentRepairCarNumber(ValueProvider valueProvider){

        Cell nc =  new AbstractCell<List<RepairProxy>>() {
            @Override
            public void render(Context context, List<RepairProxy> value, SafeHtmlBuilder sb) {
                String number = null;
                for (RepairProxy repairProxy: value){
                    if (number == null) number = repairProxy.getCar().getNumber();
                    else number += ", " + repairProxy.getCar().getNumber();
                }
                if (number != null) sb.appendEscapedLines(number);
            }
        };

        SummaryColumnConfig<PaymentProxy, ?> columnConfigNumber = new SummaryColumnConfig(valueProvider,100, "Оплаченные вагоны");
        columnConfigNumber.setSortable(false);
        columnConfigNumber.setCell(nc);
        return columnConfigNumber;
    }

    private NumberField getCompletionNumberFieldForEditor(AbstractValidator validator, NumberPropertyEditor propertyEditor){
        final NumberField numberField = new NumberField(propertyEditor);
        numberField.addValidator(validator);
        numberField.setAutoValidate(true);
        return numberField;
    }

    @Override
    public boolean isValid() {
        driver.flush();
        boolean result = driver.hasErrors();
        result |= partsFieldSet.hasErrors();
        for (RepairDocTypePanel panel : repairDocTypePanels.values()) result |= panel.hasErrors();
        for (ListStore<CompletionRecordProxy> listStore : completionCheckerList.keySet()){
            if (result) break;
            List<CompletionChecker> list = completionCheckerList.get(listStore);
            if (list.size() >0)
            {
                for (CompletionRecordProxy proxy :listStore.getAll()){
                    if (result) break;
                    boolean firstIsNull = list.get(0).check(proxy);
                    for (CompletionChecker checker : list){
                        if (checker.check(proxy) != firstIsNull){
                            result = true;
                            break;
                        }
                    }
                }
            }
        }
        return !result;
    }



    // Class to provide common/simple errors from custom validators
    private class SimpleEditorError extends MockEditorError {
        Editor<?> editor;
        String message;
        Object value;

        public SimpleEditorError(Editor<?> editor, Object value, String message) {
            super();
            this.editor = editor;
            this.value = value;
            this.message = message;
        }

        @Override
        public Editor<?> getEditor() {
            return editor;
        }

        @Override
        public String getMessage() {
            return message;
        }

        @Override
        public Object getValue() {
            return value;
        }

        @Override
        public boolean isConsumed() {
            return true;
        }
    }
// ----------------------------------------
}