CalcResponse CalcDB::removeCalc(const std::string& keyword)
{
if(!_db)
return CALC_RESPONSE_NODB;
CalcResponse ret = CALC_RESPONSE_NOCALC;
// First we need to know the calc exists.
std::string response;
if(getCalc(keyword, response) == CALC_RESPONSE_NOCALC)
return ret;
std::string query = "DELETE FROM calcs WHERE keyword = ?";
sqlite3_stmt* stmt = 0;
if(sqlite3_prepare_v2(_db, query.c_str(), query.size(), &stmt, 0) == SQLITE_OK)
{
sqlite3_bind_text(stmt, 1, keyword.c_str(), keyword.size(), SQLITE_STATIC);
if(sqlite3_step(stmt) == SQLITE_DONE)
{
ret = CALC_RESPONSE_OK;
}
}
else
{
std::cerr << "Error with query: " << query << std::endl;
}
return ret;
}
CalcResponse CalcDB::getLatestVersionNumber(const std::string& keyword, int& version)
{
if(!_db)
return CALC_RESPONSE_NODB;
std::string response;
if(getCalc(keyword, response) == CALC_RESPONSE_NOCALC)
return CALC_RESPONSE_NOCALC;
std::string query = "SELECT MAX(version) FROM calcs WHERE keyword = ?";
sqlite3_stmt* stmt = 0;
if(sqlite3_prepare_v2(_db, query.c_str(), query.size(), &stmt, 0) == SQLITE_OK)
{
sqlite3_bind_text(stmt, 1, keyword.c_str(), keyword.size(), SQLITE_STATIC);
if(sqlite3_step(stmt) == SQLITE_ROW)
{
version = sqlite3_column_int(stmt, 0);
}
}
else
{
std::cerr << "Error with query: " << query << std::endl;
}
sqlite3_finalize(stmt);
return CALC_RESPONSE_VERSIONOK;
}
CalcResponse CalcDB::makeCalc(const std::string& keyword, const std::string& newcalc, const std::string& author)
{
if(!_db)
return CALC_RESPONSE_NODB;
std::string response;
if(getCalc(keyword, response) == CALC_RESPONSE_OK)
return CALC_RESPONSE_CALCALREADYEXISTS;
CalcResponse ret = CALC_RESPONSE_CALCALREADYEXISTS;
std::string calc = newcalc;
calc = MiscStringHelpers::trim(calc);
std::string query = "INSERT INTO calcs (calc, keyword, author, version, added) VALUES (?,?,?,'0', strftime(\"%Y-%m-%d %H:%M:%S\",\"now\"))";
sqlite3_stmt* stmt = 0;
if(sqlite3_prepare_v2(_db, query.c_str(), query.size(), &stmt, 0) == SQLITE_OK)
{
sqlite3_bind_text(stmt, 1, calc.c_str(), calc.size(), SQLITE_STATIC);
sqlite3_bind_text(stmt, 2, keyword.c_str(), keyword.size(), SQLITE_STATIC);
sqlite3_bind_text(stmt, 3, author.c_str(), author.size(), SQLITE_STATIC);
int step = sqlite3_step(stmt);
if(step == SQLITE_DONE)
{
ret = CALC_RESPONSE_CALCCHANGED;
}
else if(step == SQLITE_BUSY)
{
ret = CALC_RESPONSE_DBBUSY;
}
}
else
{
std::cerr << "Error with query: " << query << std::endl;
}
sqlite3_finalize(stmt);
return ret;
}
int CFormulaNode::RunCalc()
{
if( !getCalc() )
{
if( getCalcButtonID().length() )
setMissButton();
return 0;
}
if( !getCalc()->isPositionRunExist() ) return 0;
QVector<RealFde> frames_ltrb;
frames_ltrb.fill( 0.0, 4 * GetChildCount() );
QVector<RealFde> frames_margin_ltrb;
frames_margin_ltrb.fill( 0.0, 4 * GetChildCount() );
QVector<RealFde> primitive_ltrb;
primitive_ltrb.fill( 0.0, 4 * GetChildCount() );
long i;
CNode *pCurNode = GetFirstChild();
if( pCurNode->GetType() != NODE_FRAME ) return 0;
for( i = 0; i < GetChildCount() && pCurNode; pCurNode = pCurNode->GetNext(), i++ )
{
frames_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Left ] = pCurNode->GetPosition().x();
frames_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Top ] = pCurNode->GetPosition().y();
frames_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Right ] = pCurNode->GetPosition().x() + pCurNode->GetSize().width();
frames_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Bottom ] = pCurNode->GetPosition().y() + pCurNode->GetSize().height();
frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Left ] = ((CFrameNode*) pCurNode)->getLeftIndent();
frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Top ] = ((CFrameNode*) pCurNode)->getTopIndent();
frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Right ] = ((CFrameNode*) pCurNode)->getRightIndent();
frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Bottom ] = ((CFrameNode*) pCurNode)->getBottomIndent();
}
for( i = 0; i < getGraphPrimNumber(); i++ )
{
primitive_ltrb.push_back( getGraphPrimitivePositionCoord( i, 0 ) );
primitive_ltrb.push_back( getGraphPrimitivePositionCoord( i, 1 ) );
primitive_ltrb.push_back( getGraphPrimitivePositionCoord( i, 2 ) );
primitive_ltrb.push_back( getGraphPrimitivePositionCoord( i, 3 ) );
}
UseBtnCalc_InitByThisSize( *getCalc() );
int ret = getCalc()->PositionRun( frames_ltrb, frames_margin_ltrb, primitive_ltrb );
// reset parent margins
UseBtnCalc_ChangeThisMargin( *getCalc() );
for( i = 0; i < getGraphPrimNumber(); i++ )
{
if( getCalc()->isFormulaTypeGraphics( i ) )
{
setGraphPrimitivePositionCoord(
i, SVG_NodeTemplate_Parameter_Left,
primitive_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Left ] );
setGraphPrimitivePositionCoord(
i, SVG_NodeTemplate_Parameter_Top,
primitive_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Top ] );
setGraphPrimitivePositionCoord(
i, SVG_NodeTemplate_Parameter_Right,
primitive_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Right ] );
setGraphPrimitivePositionCoord(
i, SVG_NodeTemplate_Parameter_Bottom,
primitive_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Bottom ] );
}
}
if( ret )
{
pCurNode = GetFirstChild();
i = 0;
while( pCurNode )
{
((CFrameNode*) pCurNode)->setLeftIndent( frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Left ] );
((CFrameNode*) pCurNode)->setTopIndent( frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Top ] );
((CFrameNode*) pCurNode)->setRightIndent( frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Right ] );
((CFrameNode*) pCurNode)->setBottomIndent( frames_margin_ltrb[ i * 4 + SVG_NodeTemplate_Parameter_Bottom ] );
pCurNode = pCurNode->GetNext();
i++;
}
RecalculateSizeChild();
}
return ret;
}
QString CPlaneText::to_mathml__get_attribute_str( QString& _tag, QString& _body, int *isDefaultMMLChanged )
{
if( isDefaultMMLChanged ) *isDefaultMMLChanged = 0;
QString new_attr = _T(""), tmp = _T("");
struct HMathMLAttr mml_attr( _tag, _body );
HMathOpAttr *opinfo = ::mml_is_token_op_tag( _tag ) ? ::getOperatorEntryByMML( _body ) : 0;
if( opinfo ) mml_attr.setMODefault( *opinfo );
struct HMathMLAttr mml_attr_by_this_node( getMathMLAttr() );
FS_LogFont_Color current_lfs;
long st = (getFStyle() == FSTYLE_NONE ? FSTYLE_DEFAULT : getFStyle());
int wouldChangeStyle = 0;//!::isMathMLStylePriority() && ::wouldChangeStyleOnMathStyleAutodetect( this );
if( st == FSTYLE_OTHER_STYLE )
{
if( isDefaultMMLChanged ) *isDefaultMMLChanged = 1;
current_lfs = getOtherStyleFont();
}
else
{
current_lfs = ::getCurrentFormulatorStyle().getFontStyle( st );
if( !::isMathMLStylePriority() )
{
FXmlBtn *btn = getCalc();
if( btn )
{
if( btn->getTextStyle() != st )
wouldChangeStyle = 1;
}
else
{
std::vector<QString> dest_str;
std::vector<long> dest_style;
::getMathMLChar2Style( dest_str, dest_style, _body, _tag, __GLOBAL_WORK_MODE );
if( dest_style.size() > 1 )
wouldChangeStyle = 1;
else if( dest_style.size() == 1 && dest_style.at(0) != st )
wouldChangeStyle = 1;
}
}
}
int ret;
FS_LogFont_Color def_lfs;
ret = ::mml_mathvariant2font( ::isMathMLStylePriority(), st, ::getCurrentFormulatorStyle().getAllFontStyles(), mml_attr, def_lfs );
if( ret == -1 ||
def_lfs.m_name != current_lfs.m_name ||
def_lfs.m_isFixed != current_lfs.m_isFixed ||
//def_lfs.m_hint != current_lfs.m_hint ||
def_lfs.m_isBold != current_lfs.m_isBold ||
def_lfs.m_isItalic != current_lfs.m_isItalic ||
wouldChangeStyle )
{
tmp = _T("");
::mml_getStyle2TextAttrFont( tmp, current_lfs, _tag, _body, getMathMLAttr(), (st == FSTYLE_OTHER_STYLE) || wouldChangeStyle );
new_attr += tmp;
}
QColor default_color = ::isMathMLStylePriority() ? QColor( 0, 0, 0 ) : ::getCurrentFormulatorStyle().getFontStyle( st ).m_color;
ret = ::mml_mathcolor2color( mml_attr.getFilteredAttr( FBL_ATTR_mathcolor ), def_lfs.m_color, default_color );
if( ret == 0 || def_lfs.m_color != current_lfs.m_color )
{
tmp = _T("");
::mml_getStyle2TextAttrColor( tmp, current_lfs.m_color, _tag, _body );
new_attr += tmp;
if( isDefaultMMLChanged ) *isDefaultMMLChanged = 1;
}
if( mml_attr_by_this_node.getFilteredAttr( FBL_ATTR_mathbackground, tmp ) == 0 )
{
new_attr += MAKE_MATHML_ATTR( FBL_ATTR_mathbackground, tmp );
if( isDefaultMMLChanged ) *isDefaultMMLChanged = 1;
}
if( getTextKeglSize() != ::getKegl( GetLevel() ) )
{
tmp = _T("");
RealFde kegl = getTextKeglSize();
if( kegl == ::getCurrentFormulatorStyle().getKegl( FTEXT_HEIGHT_CHILD1 ) )
tmp = MAKE_MATHML_ATTR( FBL_ATTR_mathsize, FBL_VAL_small );
else if( kegl == ::getCurrentFormulatorStyle().getKegl( FTEXT_HEIGHT_FRAME ) )
tmp = MAKE_MATHML_ATTR( FBL_ATTR_mathsize, FBL_VAL_normal );
else if( kegl == ::getCurrentFormulatorStyle().getKegl( FTEXT_HEIGHT_LARGEOP ) )
tmp = MAKE_MATHML_ATTR( FBL_ATTR_mathsize, FBL_VAL_big );
else
::mml_getStyle2TextPointSize( tmp, kegl, _tag, _body );
new_attr += tmp;
if( isDefaultMMLChanged ) *isDefaultMMLChanged = 1;
}
tmp = _T("");
if( mml_attr_by_this_node.getChangedAttr_2_String( ::getCurrentFormulatorStyle().getUnit2PX(), tmp, mml_attr, _tag ) )
{
}
return new_attr + tmp;
}
void CalcFrame::calc()
{
auto milkReception = m_mainWindow->database()->milkReception();
if (!milkReception) {
Utils::Main::showMsgIfDbNotChoosed(this);
return;
}
refreshTableWidgetCalc();
DataWorker dw(m_mainWindow->database());
try {
dw.loadMilkReceptions(getWhereQuery());
} catch (const QString &err) {
QMessageBox::critical(this, tr("Расчеты"), tr("Произошла ошибка во время подгрузки данных: ") + err);
}
if (dw.getMilkReceptions().empty()) {
QMessageBox::information(this, tr("Расчеты"), tr("Отсутствуют данные для расчетов"));
return;
}
const auto settings = m_mainWindow->getSettings();
const auto deliverers = dw.getDeliverers().values();
const auto itemsCount = dw.getMilkReceptions().size() + deliverers.size() + 1; // FIXME
ui->tableWidgetCalc->setRowCount(itemsCount);
int row = 0;
TableWidgetItemBuilder itemBuilder;
CalculatedItem::Data allResult;
const Settings::Calc settingsCalc = settings->getCalc();
const char f = 'f';
const Settings::Column nameCol = settingsCalc.columns[toInt(Columns::Name)],
mpNameCol = settingsCalc.columns[toInt(Columns::MilkPointName)],
dateCol = settingsCalc.columns[toInt(Columns::Date)],
priceCol = settingsCalc.columns[toInt(Columns::PriceLiter)],
litersCol = settingsCalc.columns[toInt(Columns::Liters)],
fatCol = settingsCalc.columns[toInt(Columns::Fat)],
proteinCol = settingsCalc.columns[toInt(Columns::Protein)],
fatUnitsCol = settingsCalc.columns[toInt(Columns::FatUnits)],
rankWeightCol = settingsCalc.columns[toInt(Columns::RankWeight)],
payCol = settingsCalc.columns[toInt(Columns::PayWithOutPrem)],
premiumCol = settingsCalc.columns[toInt(Columns::Premium)],
sumCol = settingsCalc.columns[toInt(Columns::Sum)];
const auto dateFromat = settingsCalc.dateFormat;
auto addCalcItems = [&](const QString &name, const QString &milkPoint,
const QString &delivDate, const CalculatedItem::Data &calcItem)
{
int c = 0;
if (nameCol.isShow)
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setText(name)->get());
if (mpNameCol.isShow)
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setText(milkPoint)->get());
if (dateCol.isShow)
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setText(delivDate)->get());
if (priceCol.isShow) {
const QString priceValue = calcItem.price <= .0 ? "-" : QString::number(calcItem.price, f, priceCol.prec);
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setText(priceValue)->get());
}
if (litersCol.isShow)
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setNum(calcItem.liters, f, litersCol.prec)->get());
if (fatCol.isShow)
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setNum(calcItem.fat, f, fatCol.prec)->get());
if (proteinCol.isShow)
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setNum(calcItem.protein, f, proteinCol.prec)->get());
if (fatUnitsCol.isShow)
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setNum(calcItem.fatUnits, f, fatUnitsCol.prec)->get());
if (rankWeightCol.isShow)
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setNum(calcItem.rankWeight, f, rankWeightCol.prec)->get());
if (payCol.isShow)
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setNum(calcItem.paymentWithOutPremium, f, payCol.prec)->get());
if (premiumCol.isShow)
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setNum(calcItem.premiumForFat, f, premiumCol.prec)->get());
if (sumCol.isShow) {
ui->tableWidgetCalc->setItem(row, c++, itemBuilder.setNum(calcItem.sum, f, sumCol.prec)->get());
}
};
for (const auto &deliverer: deliverers) {
CalculatedItem::Data delivererResult;
itemBuilder.setBackColor(settingsCalc.textBackColor);
itemBuilder.setFont(settingsCalc.textFont);
for (const auto &milkReception: deliverer->milkReceptions()) {
const auto mr = milkReception.data();
const CalculatedItem::Data calcItem = mr->getCalculations().data();
addCalcItems(deliverer->name(), mr->milkPoint().data()->name(),
mr->deliveryDate().toString(dateFromat), calcItem);
delivererResult += calcItem;
++row;
}
itemBuilder.setBackColor(settingsCalc.delivResultColor);
itemBuilder.setFont(settingsCalc.delivResultFont);
addCalcItems(deliverer->name(), "-", "-", delivererResult);
allResult += delivererResult;
++row;
}
itemBuilder.setBackColor(settingsCalc.allResultColor);
itemBuilder.setFont(settingsCalc.allResultFont);
addCalcItems("Итого", "-", "-", allResult);
}
