table_reader_macro.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  $Id: table_reader_macro.cpp 47403 2023-03-08 19:36:58Z asztalos $
* ===========================================================================
*
*                            PUBLIC DOMAIN NOTICE
*               National Center for Biotechnology Information
*
*  This software/database is a "United States Government Work" under the
*  terms of the United States Copyright Act.  It was written as part of
*  the author's official duties as a United States Government employee and
*  thus cannot be copyrighted.  This software/database is freely available
*  to the public for use. The National Library of Medicine and the U.S.
*  Government have not placed any restriction on its use or reproduction.
*
*  Although all reasonable efforts have been taken to ensure the accuracy
*  and reliability of the software and data,  the NLM and the U.S.
*  Government do not and cannot warrant the performance or results that
*  may be obtained by using this software or data. The NLM and the U.S.
*  Government disclaim all warranties,  express or implied,  including
*  warranties of performance,  merchantability or fitness for any particular
*  purpose.
*
*  Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Authors:  Andrea Asztalos
*/
 
#include <ncbi_pch.hpp>
#include <objects/general/User_object.hpp>
#include <objects/general/Object_id.hpp>
 
#include <gui/objutils/macro_biodata.hpp>
#include <gui/objutils/macro_fn_where.hpp>
#include <gui/objutils/macro_fn_aecr.hpp>
#include <gui/objutils/macro_fn_entry.hpp>
#include <gui/objutils/macro_fn_pubfields.hpp>
#include <gui/objutils/macro_engine.hpp>
#include <gui/objutils/macro_util.hpp>
#include <gui/objutils/macro_ex.hpp>
#include <gui/widgets/edit/field_type_constants.hpp>
#include <gui/widgets/edit/feature_field_name_panel.hpp>
#include <gui/widgets/edit/generic_report_dlg.hpp> 
#include <gui/widgets/edit/macro_treeitemdata.hpp>
#include <gui/widgets/edit/macro_applytbl_itemdata.hpp>
#include <gui/widgets/edit/macro_panel_args.hpp>
#include <gui/widgets/edit/propagate_descriptors.hpp>
#include <gui/widgets/wx/wx_utils.hpp>
#include <gui/widgets/wx/message_box.hpp>
#include <gui/packages/pkg_sequence_edit/field_choice_panel.hpp>
#include <gui/packages/pkg_sequence_edit/constraint_panel.hpp>
#include <gui/packages/pkg_sequence_edit/table_reader_macro.hpp>
#include <chrono>
 
 
 
BEGIN_NCBI_SCOPE
USING_SCOPE(objects);
 
CTableReaderMacro::TVecMacroNames CTableReaderMacro::CreateMacros(const wxString& filename, 
    CRef<CUser_object> column_properties, const SColumnDelimiters& del_options,
    CConstraintPanel* constraint_panel, bool test)
{
    if (test) {
        m_Filename = ToStdString(filename);
    }
    else {
        auto mapped_path = GetAbsolutePath(filename);
        m_Filename = ToStdString(mapped_path);
    }
    m_ColProperties.Reset(column_properties);
    m_ConstraintPnl = constraint_panel;
 
    LOG_POST(Info << "Column properties:\n" << MSerial_AsnText << m_ColProperties.GetObject());
 
    x_GatherValuesAndMatchField();
    if (m_MatchFieldType == EMacroFieldType::eNotSet) {
        NCBI_THROW(CException, eUnknown, "Table must have an ID column");
    }
 
    TVecMacroNames macros;
    for (auto&& it : m_MacroVec) {
        string script = x_GetMacro(it, del_options);
        if (it.m_CreateProteins) {
            macros.push_back(x_GetCreateProtFeatsMacro());
        }
        macros.push_back(script);
    }
    return macros;
}
 
void CTableReaderMacro::x_GatherValuesAndMatchField()
{
    if (!m_ColProperties->IsSetData())
        return;
 
    m_MacroVec.clear();
    m_MatchField.Reset();
 
    for (auto&& it : m_ColProperties->GetData()) {
        string column = "0";
        if (it->IsSetLabel() && it->GetLabel().IsStr()) {
            column = it->GetLabel().GetStr().substr(string("Column.").length(), NPOS);
        }
        if (column == "0") {
            m_MatchField.Reset();
            break;
        }
 
        if (it->IsSetData() && it->GetData().IsStr()) {
            string col_meta_info = it->GetData().GetStr();
            string skipped = NMItemData::GetPropertyFromInfo(col_meta_info, "skipped");
            if (skipped == "true") {
                continue;
            }
 
            bool match_col = NStr::StringToBool(NMItemData::GetPropertyFromInfo(col_meta_info, "match"));
            string name = NMItemData::GetPropertyFromInfo(col_meta_info, "name");
            string qualifier = NMItemData::GetPropertyFromInfo(col_meta_info, "qualifier");
            string qualifier_type = NMItemData::GetPropertyFromInfo(col_meta_info, "qual_type");
 
            _ASSERT(!name.empty());
            _ASSERT(!qualifier.empty());
            _ASSERT(!qualifier_type.empty());
 
            if (match_col) {
                m_MatchField.m_Column = column;
                m_MatchField.m_GUIName = qualifier;
                m_MatchFieldType = EMacroFieldType::eNotSet;
                m_MatchField.m_MacroName = x_GetIterator(qualifier_type, m_MatchFieldType, qualifier);
                // temporarily store the target for the matching field in the 'm_MacroName' member
                _ASSERT(NStr::StartsWith(name, "match "));
            }
            else {
                EMacroFieldType field_type = EMacroFieldType::eNotSet;
                string iterator = x_GetIterator(qualifier_type, field_type, qualifier, true);
                auto it = find_if(m_MacroVec.begin(), m_MacroVec.end(),
                    [field_type, &iterator](const SOneMacroData& elem){ return elem.m_Fieldtype == field_type; });
 
                if (it != m_MacroVec.end()) {
                    if (it->m_Iterator.empty()) {
                        it->m_Iterator = iterator;
                    }
                    it->m_Values.emplace_back(qualifier, column);
                    it->m_ColumnInfo.push_back(col_meta_info);
                }
                else {
                    SOneMacroData new_data(iterator);
                    new_data.m_Fieldtype = field_type;
                    new_data.m_Values.emplace_back(qualifier, column);
                    new_data.m_ColumnInfo.push_back(col_meta_info);
                    m_MacroVec.push_back(new_data);
                }
            }
        }
    }
}
 
string CTableReaderMacro::x_GetMacro(SOneMacroData& data, const SColumnDelimiters& del_options)
{
    string macro_script = "MACRO TableReaderMacro \"Description\"\n";
    macro_script += "VAR\n";
    bool list_update_mrna = (data.m_Fieldtype == EMacroFieldType::eFeatQualifiers) ||
        (data.m_Fieldtype == EMacroFieldType::eCdsGeneProt);
 
    macro_script += x_GetVariables(del_options, list_update_mrna) + "\n";
    macro_script += "FOR EACH " + data.m_Iterator + "\n";
 
    TStringPairsVector constraints = x_GetStringConstraint(data.m_Iterator);
    x_GetMatchFieldConstraint(data, del_options.m_Del, constraints);
    string do_function = x_GetFunction(data, constraints);
 
    vector<string> pure_constraints;
    pure_constraints.reserve(constraints.size());
    for (auto p : constraints) {
        pure_constraints.push_back(p.second);
    }
    macro_script += "WHERE " + NStr::Join(pure_constraints, " AND ") + "\n";
    macro_script += "DO\n" + do_function + "\nDONE\n";
    macro_script += "---------------------------------------------------\n";
    return macro_script;
}
 
string CTableReaderMacro::x_GetCreateProtFeatsMacro()
{
    string macro_script = "MACRO CreateProtFeats \"Create full length protein features\"\n";
    macro_script += "FOR EACH TSEntry\n";
    macro_script += "DO\n" + macro::CMacroFunction_CreateProteinFeats::GetFuncName() + "();\nDONE\n";
    macro_script += "---------------------------------------------------\n";
    return macro_script;
}
 
string CTableReaderMacro::x_GetVariables(const SColumnDelimiters& del_options, bool list_update_mrna) const
{
    string variables;
    variables += NMacroArgs::kTableName + " = \"" + m_Filename + "\"\n";
    variables += NMacroArgs::kMergeDel + " = " + NStr::BoolToString(del_options.m_Merge_delimiters) + "\n";
    variables += NMacroArgs::kSplitFirst + " = " + NStr::BoolToString(del_options.m_Split_first_col) + "\n";
    variables += NMacroArgs::kConvertMulti + " = " + NStr::BoolToString(del_options.m_Multispace_to_tab) + "\n";
    variables += NMacroArgs::kMergeFirst + " = " + NStr::BoolToString(del_options.m_Merge_first_two_cols) + "\n";
    variables += NMacroArgs::kMultipleSpsOnly + " = " + NStr::BoolToString(del_options.m_Multiple_spaces_only);
    if (list_update_mrna) {
        variables += "\n" + NMacroArgs::kUpdatemRNA + " = false";
    }
 
    return variables;
}
 
string CTableReaderMacro::x_GetIterator(const string& qual_type, EMacroFieldType& field_type, 
    const string& qualifier, bool apply)
{
    if (qual_type.empty())
        return kEmptyStr;
    if (NStr::EqualNocase(qual_type, "taxname") || NStr::StartsWith(qual_type, "Source ")) {
        field_type = EMacroFieldType::eBiosourceAll;
        return macro::CMacroBioData::sm_BioSource;
    }
    else if (NStr::EqualNocase(qual_type, kFieldTypeSeqId)) {
        field_type = EMacroFieldType::eSeqID;
        return kEmptyStr;
    }
    else if (NStr::StartsWith(qual_type, "DBLink")) {
        field_type = EMacroFieldType::eDBLink;
        return macro::CMacroBioData::sm_SeqNa;
    }
    else if (NStr::StartsWith(qual_type, "MolInfo", NStr::eNocase)) {
        field_type = EMacroFieldType::eMolinfo;
        if (apply) {
            return macro::CMacroBioData::sm_Seq;
        }
        else {
            return macro::CMacroBioData::sm_MolInfo;
        }
    }
    else if (NStr::StartsWith(qual_type, "Structured Comment")) {
        field_type = EMacroFieldType::eStructComment;
        return macro::CMacroBioData::sm_StrComm;
    }
    else if (NStr::StartsWith(qual_type, "Pub", NStr::eNocase)) {
        field_type = EMacroFieldType::ePubdesc;
        return macro::CMacroBioData::sm_Pubdesc;
    }
    else if (NStr::StartsWith(qual_type, "Misc ")) {
        field_type = EMacroFieldType::eMiscDescriptors;
        return macro::CMacroBioData::sm_SeqNa;
    }
    else if (NStr::StartsWith(qual_type, "CDS-Gene-Prot", NStr::eNocase)) {
        field_type = EMacroFieldType::eCdsGeneProt;
        CTempString new_target = NMItemData::UpdateTargetForCdsGeneProt(qualifier);
        return new_target;
    }
    else if (NStr::StartsWith(qual_type, "Feature ")) {
        field_type = EMacroFieldType::eFeatQualifiers;
        vector<string> tokens;
        NStr::Split(qualifier, " ", tokens);
        if (tokens.size() == 2) {
            CTempString new_target = NMItemData::UpdateTargetForFeatures(tokens[0], tokens[1]);
            return new_target;
        }
        else {
            return macro::CMacroBioData::sm_SeqFeat;
        }
    }
    else if (NStr::StartsWith(qual_type, "RNA ")) {
        field_type = EMacroFieldType::eRNA;
        string rna_type, ncRNA_class, rna_qual;
        NMItemData::GetRNASpecificFieldsForTableReader(qualifier, rna_type, ncRNA_class, rna_qual);
        CTempString new_target = NMItemData::UpdateTargetForRnas(rna_type);
        return new_target;
    }
    return kEmptyStr;
}
 
void CTableReaderMacro::x_GetMatchFieldConstraint(const SOneMacroData& data, const string& delimiter, TStringPairsVector& constraints)
{
    auto del = delimiter;
    if (del == "\t") del = "\\t";
 
    string constraint;
     
    if (m_MatchFieldType == EMacroFieldType::eFeatQualifiers) {
        vector<string> tokens;
        NStr::Split(m_MatchField.m_GUIName, " ", tokens);
        if (tokens.size() == 2) {
            constraint = CFeatureFieldNamePanel::s_GetMacroFieldName(tokens[0], tokens[1], data.m_Iterator /*, selected_field */);
        }
    }
    else if (m_MatchFieldType == EMacroFieldType::eCdsGeneProt) {
        constraint = CCDSGeneProtFieldNamePanel::s_GetMacroFieldName(m_MatchField.m_GUIName, data.m_Iterator /*, selected_field */);
    }
    else if (m_MatchFieldType == EMacroFieldType::eRNA) {
        string rna_type, ncRNA_class, rna_qual;
        NMItemData::GetRNASpecificFieldsForTableReader(m_MatchField.m_GUIName, rna_type, ncRNA_class, rna_qual);
        constraint = CRNAFieldNamePanel::s_GetMacroFieldName(rna_type, rna_qual, data.m_Iterator /*, selected_field */);
    }
    else if (data.m_Fieldtype != m_MatchFieldType) {
        string path = CMacroEditorContext::GetInstance().GetAsnPathToFieldName(m_MatchField.m_GUIName,
            m_MatchFieldType, data.m_Iterator);
        if (path.find(',') != NPOS) {
            vector<string> tokens;
            NStr::Split(path, ",", tokens);
            path = "\"" + tokens[0] + "\", \"" + tokens[1] + "\"";
        }
        else if (path.find('(') != NPOS) {
            // do nothing
        }
        else {
            path = "\"" + path + "\"";
        }
 
 
        if (m_MatchFieldType == EMacroFieldType::eSeqID) {
            constraint = path;
        }
        else if (m_MatchFieldType == EMacroFieldType::eBiosourceAll) {
 
            if (data.m_Iterator == macro::CMacroBioData::sm_MolInfo) {
                constraint = macro::CMacroFunction_GetSeqdesc::sm_BsrcForMolinfo + string("(") + path + ")";
            }
            else if (data.m_Iterator == macro::CMacroBioData::sm_StrComm ||
                data.m_Iterator == macro::CMacroBioData::sm_Pubdesc) {
                constraint = macro::CMacroFunction_GetSeqdesc::sm_BsrcForSeqdesc + string("(") + path + ")";
            }
            else if (data.m_Iterator == macro::CMacroBioData::sm_Seq ||
                data.m_Iterator == macro::CMacroBioData::sm_SeqNa) {
                constraint = macro::CMacroFunction_GetSeqdesc::sm_BsrcForSeq + string("(") + path + ")";
            }
            else if (CFieldNamePanel::IsFeature(data.m_Iterator)) {
                constraint = macro::CMacroFunction_GetSeqdesc::sm_BsrcForFeat + string("(") + path + ")";
            }
            else if (data.m_Iterator == macro::CMacroBioData::sm_BioSource) {
                constraint = path;
            }
 
            m_MatchField.m_MacroName = constraint;
            m_MatchField.m_UseMacroName = true;
        }
        else if (m_MatchFieldType == EMacroFieldType::eMolinfo) {
            bool is_inst_field = NStr::StartsWith(path, "\"inst.");
 
            if (data.m_Iterator == macro::CMacroBioData::sm_MolInfo) {
                if (is_inst_field) {
                    constraint = CTempString(macro::CMacroFunction_GetSequence::sm_SeqForDescr) + "(" + path + ")";
                }
            }
            else if (data.m_Iterator == macro::CMacroBioData::sm_Seqdesc) {
                if (is_inst_field) {
                    constraint = CTempString(macro::CMacroFunction_GetSequence::sm_SeqForDescr) + "(" + path + ")";
                }
            }
            else if (CFieldNamePanel::IsFeature(data.m_Iterator)) {
                if (is_inst_field) {
                    constraint = CTempString(macro::CMacroFunction_GetSequence::sm_SeqForFeat) + "(" + path + ")";
                }
                else {
                    constraint = CTempString(macro::CMacroFunction_GetSeqdesc::sm_MolinfoForFeat) + "(" + path + ")";
                }
            }
            else if (data.m_Iterator == macro::CMacroBioData::sm_BioSource) {
                if (is_inst_field) {
                    constraint = CTempString(macro::CMacroFunction_GetSequence::sm_SeqForDescr) + "(" + path + ")";
                }
                else {
                    constraint = CTempString(macro::CMacroFunction_GetSeqdesc::sm_MolinfoForBsrc) + "(" + path + ")";
                }
            }
            else if (data.m_Iterator == macro::CMacroBioData::sm_Seq ||
                data.m_Iterator == macro::CMacroBioData::sm_SeqNa ||
                data.m_Iterator == macro::CMacroBioData::sm_SeqAa) {
                constraint = path;
            }
        }
        else if (m_MatchFieldType == EMacroFieldType::eDBLink) {
            // 'path' is not used
            constraint = macro::CMacroFunction_GetDBLink::GetFuncName() + "(\"" + m_MatchField.m_GUIName + "\")";
        }
        else if (m_MatchFieldType == EMacroFieldType::eStructComment) {
            if (NStr::EqualNocase(m_MatchField.m_GUIName, kStructCommDBName)) {
                constraint = macro::CMacroFunction_StructCommDatabase::GetFuncName() + "()";
            }
            else if (NStr::EqualNocase(m_MatchField.m_GUIName, kStructCommFieldName)) {
                constraint = macro::CMacroFunction_StructCommFieldname::GetFuncName() + "()";
            }
            else if (NStr::StartsWith(m_MatchField.m_GUIName, kStructCommFieldValuePair, NStr::eNocase)) {
                string field_name = m_MatchField.m_GUIName.substr(
                    CTempString(kStructCommFieldValuePair).length(), NPOS);
                NStr::TruncateSpacesInPlace(field_name);
 
                constraint = macro::CMacroFunction_StructCommField::GetFuncName();
                constraint += "(\"" + field_name + "\")";
            }
        }
        else if (m_MatchFieldType == EMacroFieldType::ePubdesc) {
            constraint = path;
        }
    }
 
    if (!constraint.empty()) {
        m_MatchField.m_MacroName = constraint;
        m_MatchField.m_UseMacroName = true;
    }
 
    constraints.emplace_back(kEmptyStr, CApplyTableItemData::s_GetMatchFieldConstraint(m_MatchField, del, data.m_Fieldtype, data.m_Iterator));
} 
 
TStringPairsVector CTableReaderMacro::x_GetStringConstraint(const string& target)
{
    TStringPairsVector constraints;
    if (!m_ConstraintPnl)
        return constraints;
 
    string field_in_macro;
    CFieldNamePanel* field_name_panel = m_ConstraintPnl->GetFieldNamePanel();
    if (field_name_panel) {
        string field_name = field_name_panel->GetFieldName(false);
        field_in_macro = field_name_panel->GetMacroFieldName(target);
    }
 
    string str_constraint = m_ConstraintPnl->GetMacroStringConstraint(field_in_macro);
    if (!str_constraint.empty()) {
        constraints.emplace_back(field_in_macro, str_constraint);
    }
    return constraints;
}
    
 
string CTableReaderMacro::x_GetFunction(SOneMacroData& data, TStringPairsVector& constraints)
{
    string function;
    if (data.m_Fieldtype == EMacroFieldType::eBiosourceAll) {
        function = CApplySrcTableTreeItemData::s_GetFunction(data.m_Values, constraints, false, data.m_ColumnInfo);
    }
    else if (data.m_Fieldtype == EMacroFieldType::eDBLink) {
        function = CApplyDBlinkTableTreeItemData::s_GetFunction(data.m_Values, constraints, false, data.m_ColumnInfo);
    }
    else if (data.m_Fieldtype == EMacroFieldType::eStructComment) {
        function = CApplyStrCommTableTreeItemData::s_GetFunction(data.m_Values, constraints, false, data.m_ColumnInfo);
    }
    else if (data.m_Fieldtype == EMacroFieldType::eMolinfo) {
        function = CApplyMolinfoTableTreeItemData::s_GetFunction(data.m_Values, constraints, false, data.m_ColumnInfo);
    }
    else if (data.m_Fieldtype == EMacroFieldType::eMiscDescriptors) {
        function = CApplyMiscTableTreeItemData::s_GetFunction(data.m_Values, constraints, false, data.m_ColumnInfo);
    }
    else if (data.m_Fieldtype == EMacroFieldType::ePubdesc) {
        function = CApplyPubTableTreeItemData::s_GetFunction(data.m_Values, constraints, false, data.m_ColumnInfo);
    }
    else if (data.m_Fieldtype == EMacroFieldType::eCdsGeneProt) {
        string first_field = data.m_Values.front().first;
        string feat_type, feat_qual;
        NMItemData::GetFeatureAndField(first_field, feat_type, feat_qual);
 
        NMItemData::UpdateConstraintsForDualCdsGeneProt(constraints, feat_type);
 
        bool update_mrna = false;
        function = CApplyCDSGeneProtTableTreeItemData::s_GetFunction(data.m_Values, constraints, false,
            data.m_Iterator, update_mrna, data.m_ColumnInfo);
    }
    else if (data.m_Fieldtype == EMacroFieldType::eFeatQualifiers) {
        // the first field's feature type determines the asn selector of the macro
        string first_field = data.m_Values.front().first;
        vector<string> tokens;
        NStr::Split(first_field, " ", tokens);
        if (tokens.size() == 2) {
            NMItemData::UpdateConstraintsForFeatures(constraints, tokens[0]);
        }
        bool update_mrna = false;
        function = CApplyFeatTableTreeItemData::s_GetFunction(data.m_Values, constraints, false, 
            data.m_Iterator, update_mrna, data.m_ColumnInfo);
    }
    else if (data.m_Fieldtype == EMacroFieldType::eRNA) {
        string first_field = data.m_Values.front().first;
        string rna_type, ncRNA_class, rna_qual;
        NMItemData::GetRNASpecificFieldsForTableReader(first_field, rna_type, ncRNA_class, rna_qual);
 
        NMItemData::UpdateConstraintsForRnas(constraints, rna_type, ncRNA_class);
 
        function = CApplyRNATableTreeItemData::s_GetFunction(data.m_Values, constraints, false, 
            rna_type, data.m_ColumnInfo);
    }
 
    if (data.m_Iterator == macro::CMacroBioData::sm_Protein &&
        (data.m_Fieldtype == EMacroFieldType::eCdsGeneProt ||
        data.m_Fieldtype == EMacroFieldType::eFeatQualifiers)) {
        for (auto&& it : data.m_Values) {
            if (NStr::EqualNocase(it.first, "protein name") ||
                NStr::EqualNocase(it.first, "CDS product") ||
                NStr::EqualNocase(it.first, "Protein product") ||
                macro::NMacroUtil::StringsAreEquivalent(it.first, "protein EC number") ||
                macro::NMacroUtil::StringsAreEquivalent(it.first, "CDS EC number")) {
                data.m_CreateProteins = true;
            }
        }
    }
    return function;
}
 
bool CTableReaderMacro::RunMacro(const TVecMacroNames& macros, CSeq_entry_Handle entry, ICommandProccessor* cmd_processor)
{
    if (macros.empty()) {
        LOG_POST(Info << "List of macros generated by Table Reader is empty");
        return false;
    }
 
    CRef<CMacroCmdComposite> macro_cmd(new CMacroCmdComposite("Execute macros for Table Reader"));
    bool status = true;
 
    bool apply_pmid = false;
    for (auto& it : macros) {
        if (it.find(macro::CMacroFunction_SetPubPMID::GetFuncName()) != NPOS)
            apply_pmid = true;
    }
 
    if (apply_pmid) {
        CRef<CCmdComposite> cmd = CPropagateDescriptors::GetPropagateDownCommand(entry);
        if (cmd) {
            cmd->Execute();
            macro_cmd->AddCommand(*cmd);
        }
    }
  
    auto start = chrono::steady_clock::now();
    macro::CMacroEngine macro_engine;
    bool data_updated = false;
    string report_all;
    string ignored_lines;
 
    for (auto&& it : macros) {
        LOG_POST(Info << it);
        CRef<macro::CMacroRep> macro_rep(macro_engine.Parse(it));
        if (!macro_rep) {
            LOG_POST(Info << "Parsing the macro for Table Reader has failed");
            return false;
        }
 
        macro::CMacroBioData bio_data(entry);
        try {
            macro_engine.Exec(*macro_rep, bio_data, macro_cmd, true);
        }
        catch (const macro::CMacroExecException& e) {
            status = false;
            if (e.GetErrCode() == macro::CMacroExecException::eMultipleEntries) {
                // There was a problem and Undo Manager was not involved
                macro_cmd->Execute(); // this call resets state to let Unexecute be run
                macro_cmd->Unexecute();
 
                string msg = e.ReportAll();
                size_t pos = msg.find("'");
                size_t end_pos = msg.find(" ([Error]");
                if (pos != NPOS && end_pos != NPOS) {
                    msg = msg.substr(pos, end_pos - pos);
                }
                CGenericReportDlg* report = new CGenericReportDlg(NULL);
                report->SetTitle(wxT("Duplicate row ids"));
                report->SetText(wxString(msg));
                report->Show(true);
                NCBI_THROW(CException, eInvalid, "Multiple rows apply to the same object. Cannot continue.");
            }
        }
        catch (const CException& err) {
            status = false;
            LOG_POST(Info << "Execution of the macro has failed at " << 
                macro_rep->GetTitle() << " step:\n" << err.ReportAll());
            break;
        }
 
        const auto& macro_stat = macro_engine.GetStatistics();
        const auto& report = macro_stat.GetMacroReport();
        if (!report.GetLog().empty()) {
            report_all += report.GetName() + ":\n" + report.GetLog() + "\n";
        }
        else {
            const auto& logs = macro_stat.GetFunctionsLog();
            if (!logs.empty()) {
                report_all += report.GetName() + ":\n";
            }
            for (const auto& it : logs) {
                report_all += it->Print() + "\n";
            }
        }
 
        if (!report.GetErrorLog().empty()) {
            report_all += "\nERRORS:\n" + report.GetErrorLog();
        }
 
        const auto& unmatched = macro_stat.GetUnmatchedTableEntries();
        if (!unmatched.empty()) {
            _ASSERT(unmatched.size() == 1);
            string temp = unmatched.front().first;
            int count = unmatched.front().second;
 
            size_t nl_pos = temp.find("\n");
            while (nl_pos != NPOS && count > 0) {
                temp = temp.substr(nl_pos + 1);
                nl_pos = temp.find("\n");
                string value = temp.substr(0, nl_pos);
                if (!s_LooksLikeHeader(value) && ignored_lines.find(value) == NPOS) {
                    if (!ignored_lines.empty()) {
                        ignored_lines += "\n";
                    }
                    ignored_lines += value;
                }
                count--;
            }
 
        }
 
        data_updated |= macro_stat.HasDataUpdated();
    }
 
    // 'status' signals only whether the macro was executed successfully or not
    // it does not tell whether there was any actual data update
    if (status) {
        if (apply_pmid) {
            CRef<CCmdComposite> cmd = CPropagateDescriptors::GetPropagateUpCommand(entry);
            if (cmd) {
                cmd->Execute();
                macro_cmd->AddCommand(*cmd);
            }
        }
 
        // Introduce Undo Manager or undo changes in case of error
        cmd_processor->Execute(macro_cmd);
 
        auto stop = chrono::steady_clock::now();
        chrono::duration<double> elapsed = stop - start;
        LOG_POST(Info << "Total time spent on executing the macro is: " << elapsed.count() << " seconds.");
    }
    else {
        // There was a problem and Undo Manager was not involved
        macro_cmd->Execute(); // this call resets state to let Unexecute be run
        macro_cmd->Unexecute();
        
    }
 
    if (!data_updated) {
        NcbiInfoBox("Table was applied successfully. No data change has occurred.");
    }
    else if (!ignored_lines.empty()) {
        NcbiInfoBox("No matches were found for these values present in the table:\n" + ignored_lines);
    }
 
#if _DEBUG
    LOG_POST(Info << report_all);
#endif
    return status;
}
 
bool CTableReaderMacro::s_LooksLikeHeader(const string& value)
{
    if (NStr::EqualNocase(value, "sequence") ||
        NStr::EqualNocase(value, "accession") ||
        macro::NMacroUtil::StringsAreEquivalent(value, "acc. num.") ||
        macro::NMacroUtil::StringsAreEquivalent(value, "acc. num") ||
        macro::NMacroUtil::StringsAreEquivalent(value, "acc num") ||
        macro::NMacroUtil::StringsAreEquivalent(value, "acc num.") ||
        NStr::StartsWith(value, "bankit", NStr::eNocase) ||
        NStr::StartsWith(value, "filename", NStr::eNocase) ||
        macro::NMacroUtil::StringsAreEquivalent(value, "file-id/seq-id") ||
        !CFieldChoicePanel::AutoMatch(value).empty())
        return true;
    return false;
}
 
END_NCBI_SCOPE