double getLineNetTotal(DataRow row)
{
double tot = getLineRealTotal(row);
double perc = (double)ToolCell.isNull(row[TableSTLINE.DISCPER], (double)0.0);
return(tot * (100 - perc) / 100);
}
static double getStockDocLineAmount(DataRow docLine)
{
double amount = 0;
ConstBool isCancelled = (ConstBool)(short)ToolCell.isNull(docLine[TableSTLINE.CANCELLED], (short)ConstBool.yes);
ConstLineType lineType = (ConstLineType)(short)ToolCell.isNull(docLine[TableSTLINE.LINETYPE], (short)ConstLineType.undef);
if (isCancelled == ConstBool.not && (lineType == ConstLineType.material || lineType == ConstLineType.promotion))
{
amount = (double)ToolCell.isNull(docLine[TableSTLINE.AMOUNT], 0.0);
ConstIOCode ioCode = (ConstIOCode)(short)ToolCell.isNull(docLine[TableSTLINE.IOCODE], (short)0);
switch (ioCode)
{
case ConstIOCode.input:
case ConstIOCode.inputFromWarehouse:
amount = +amount;
break;
case ConstIOCode.output:
case ConstIOCode.outputFromWarehouse:
amount = -amount;
break;
default:
amount = 0;
break;
}
}
return(amount);
}
void refreshVal(double pValue, double pCf, string pCol, bool pReverse)
{
if (_blockPoint.block())
{
try
{
if (pCf < ConstValues.minPositive)
{
pCf = 1.0;
}
DataRow rowMain = ToolRow.getFirstRealRow(_tableSchema);
double mCf = (double)rowMain[TableDUMMY.CONVFACT];
double mAmount = pValue * (pReverse ? (mCf / pCf) : (pCf / mCf));
foreach (DataRow curRow in _tableSchema.Rows)
{
double curCf = (double)curRow[TableDUMMY.CONVFACT];
if (curCf < ConstValues.minPositive)
{
curCf = 1.0;
}
ToolCell.set(curRow, pCol, mAmount * (pReverse ? (curCf / mCf) : (mCf / curCf)));
}
}
finally
{
_blockPoint.unblock();
}
}
}
protected override void prepareBeforeUpdate(DataSet pData)
{
DataSet dataSet = (DataSet)pData;
DataTable tab;
DataRow row;
tab = dataSet.Tables[TableKSLINES.TABLE];
for (int i = 0; i < tab.Rows.Count; ++i)
{
row = tab.Rows[i];
if (row.RowState != DataRowState.Deleted)
{
if (row.RowState == DataRowState.Added)
{
docId = row[TableKSLINES.LOGICALREF];
ToolCell.set(row, TableKSLINES.FICHENO, getDocNr());
}
else
{
docId = row[TableKSLINES.LOGICALREF];
}
ToolCell.set(row, TableKSLINES.TRCODE, docTrCode);
ToolCell.set(row, TableKSLINES.SIGN, docSign);
}
}
}
protected bool startSave()
{
try
{
FinishDataEditing();
if (_checkLevel)
{
DataRow row = ToolRow.getFirstRealRow(_tableSchema);
double amount = (double)ToolCell.isNull(row[TableDUMMY.AMOUNT], 0.0);
double onhand = (double)ToolCell.isNull(_curMatRecord[TableDUMMY.ONHAND], 0.0);
if ((amount - onhand) > ConstValues.minPositive)
{
ToolMsg.show(this, MessageCollection.T_MSG_INVALID_QUANTITY, null);
return(false);
}
}
DataRow _rowActiveUnit = this.BindingContext.getBindingItemRecord(cUnit);
//
if (_rowActiveUnit != null)
{
switch (handler.converCol(handler.column))
{
case TableDUMMY.AMOUNT:
ToolCell.set(handler.row, TableSTLINE.AMOUNT, ToolRow.getFirstRealRow(_tableSchema)[TableDUMMY.AMOUNT]);
//
if (_rowActiveUnit != null)
{
ToolCell.set(handler.row, TableSTLINE.UNIT, _rowActiveUnit[TableDUMMY.UNIT]);
ToolCell.set(handler.row, TableSTLINE.UNITREF, _rowActiveUnit[TableDUMMY.UNITREF]);
ToolCell.set(handler.row, TableSTLINE.UINFO1, _rowActiveUnit[TableDUMMY.UNITCF01]);
ToolCell.set(handler.row, TableSTLINE.UINFO2, _rowActiveUnit[TableDUMMY.UNITCF02]);
}
//
return(true);
case TableDUMMY.PRICE:
ToolCell.set(handler.row, TableSTLINE.PRICE, ToolRow.getFirstRealRow(_tableSchema)[TableDUMMY.PRICE]);
return(true);
case TableDUMMY.DISCPER:
ToolCell.set(handler.row, TableSTLINE.DISCPER, ToolRow.getFirstRealRow(_tableSchema)[TableDUMMY.DISCPER]);
return(true);
case TableDUMMY.TOTAL:
ToolCell.set(handler.row, TableSTLINE.TOTAL, ToolRow.getFirstRealRow(_tableSchema)[TableDUMMY.TOTAL]);
return(true);
}
}
}
catch (Exception exc)
{
ToolMobile.setException(exc);
}
return(false);
}
protected virtual void tableSTLINEColumnChanged(object sender, DataColumnChangeEventArgs e)
{
DataTable tab = (DataTable)sender;
DataSet dataSet = tab.DataSet;
if (e.Row.RowState != DataRowState.Detached)
{
switch (e.Column.ColumnName)
{
case TableSTLINE.LINETYPE:
ToolCell.set(e.Row, TableSTLINE.DISCPER, (double)(ToolStockLine.isLinePromotion(e.Row) ? 100 : 0));
break;
case TableSTLINE.DISCPER:
if (ToolStockLine.isLinePromotion(e.Row))
{
ToolCell.set(e.Row, TableSTLINE.DISCPER, (double)100);
}
break;
case TableSTLINE.AMOUNT:
case TableSTLINE.PRICE:
case TableSTLINE.TOTAL:
break;
}
}
}
protected void table_DistributeValues(DataRow[] topRows, DataRow[] subRows)
{
object topTotal = topOperDef;
for (int i = 0; i < topRows.Length; ++i)
{
evalOnTopAny.setVarAll(ToolRow.copyRowToArr(columnsVars, topRows[i]));
object tmpRes = evalOnTopAny.getResult();
evalOnTopAnyResult.setVarAll(new object[] { topTotal, tmpRes });
topTotal = evalOnTopAnyResult.getResult();
}
for (int i = 0; i < subRows.Length; ++i)
{
object[] vals;
object tmp;
DataRow row = subRows[i];
string oldest = toucher.getOldest(columnsCalc, row);
IEvaluator eval = evalOnSubCalc[Array.IndexOf <string>(columnsCalc, oldest)];
vals = ToolRow.copyRowToArr(columnsVars, row);
vals = ToolArray.resize <object>(vals, vals.Length + 1);
vals[vals.Length - 1] = topTotal;
eval.setVarAll(vals);
tmp = eval.getResult();
ToolCell.set(row, oldest, tmp);
vals = ToolRow.copyRowToArr(columnsVars, row);
vals = ToolArray.resize <object>(vals, vals.Length + 1);
vals[vals.Length - 1] = topTotal;
evalOnSubCorrect.setVarAll(vals);
topTotal = evalOnSubCorrect.getResult();
}
}
public void fillTree(object[][] arrGroups)
{
//object[]{object[]{1,2,3},object[]{5,6},object[]{6,9}}
this.RootNode.Clear();
foreach (object[] arr in arrGroups)
{
Node curNode = this.RootNode;
for (int i = 0; i < Math.Min(2, arr.Length); ++i)
{
string item = ToolCell.isNull(arr[i], string.Empty).ToString();
Node res_ = curNode.Search(item); // Find(curCollect, item.ToString(), false);
if (res_ != null)
{
curNode = res_;
}
else
{
curNode = curNode.Add(new Node(item, item));
curNode.Tag = arr[i];
}
}
}
}
bool needUpdate(DataRow row, string[] cols)
{
if (row == null)
{
return(false);
}
bool flagResetOnAllNullOrDef = flags.isFlagEnabled(UpdateTypeFlags.resetIfAllCurrentRelColsAreDefaultOrNull);
bool flagStopIfOneNullOrDef = !flags.isFlagEnabled(UpdateTypeFlags.continueIfOneOfCurrentRelColsDefaultOrNull);
if (ToolCell.isDefaultOrNullAll(row, cols))
{
if (flagResetOnAllNullOrDef)
{
emptyDest();
return(false);
}
if (flagStopIfOneNullOrDef)
{
return(false);
}
}
if (ToolCell.hasDefaultOrNull(row, cols))
{
if (flagStopIfOneNullOrDef)
{
return(false);
}
}
return(true);
}
public override DataTable get()
{
string stock = (string)ToolCell.isNull(getBuilder().getParameterValue(TableITEMS.LOGICALREF), string.Empty);
short priceid = (short)ToolCell.isNull(getBuilder().getParameterValue(EXTPRICEID), (short)0);
getBuilder().deleteParameter(EXTPRICEID);
DataTable prices = base.get();
string priceCol = getPriceCol(priceid);
prices.Columns.Add(EXTPRICECOL, typeof(double));
if (priceid > 0 && prices.Columns.Contains(priceCol))
{
ToolColumn.copyColumn(prices, priceCol, EXTPRICECOL);
}
else
{
ToolColumn.setColumnValue(prices, EXTPRICECOL, 0.0);
}
//
//
return(prices);
}
void calcColumn(DataRow pRow, string pCol)
{
IEvaluator eval = evals[Array.IndexOf <string>(columnsCalc, pCol)];
object[] vals = ToolRow.copyRowToArr(columnsVars, pRow);
eval.setVarAll(vals);
ToolCell.set(pRow, pCol, eval.getResult());
}
object convertToType(object pVal, Type pType)
{
if (ToolCell.isNull(pVal))
{
pVal = ToolType.getTypeDefaulValue(pType);
}
return(Convert.ChangeType(pVal, pType));
}
//user need save
public object save(Form pForm)
{
object res = null;
bool ok = false;
try
{
environment.beginBatch();
res = adapter.update();
environment.commitBatch();
ok = true;
}
catch (Exception exc)
{
environment.rollbackBatch();
environment.getExceptionHandler().setException(exc);
}
if (ok)
{
environment.docEnd();
if (pForm != null)
{
pForm.Close();
}
if (handlerReferenceInformer != null)
{
handlerReferenceInformer.Invoke(this, res);
}
// onSaved();
}
if (ok)
{
var ds = adapter.getDataSet();
var code = (ds != null && ds.Tables.Count > 0 ? ds.Tables[0].TableName : "DUMMY");
if (ds != null)
{
ToolMobile.logRuntime(string.Format(
"Doc commited by [{0}] with id [{1}] and worked as [{2}]",
code,
ToolCell.isNull(res, "null").ToString(),
adapter.getAdapterWorkState().ToString()
));
}
}
return(res);
}
public static DataTable getMaterialUnitsBase(int stock, IEnvironment env, DataTable matUnits)
{
IPagedSource s = new PagedSourceUnits(env);
for (int i = 0; i < matUnits.Rows.Count; ++i)
{
s.getBuilder().addParameterValue(TableUNITSETL.LOGICALREF, ToolCell.isNull(matUnits.Rows[i][TableITMUNITA.UNITLINEREF], LRef.undef), SqlTypeRelations.equal, SqlTypeRelations.boolOr);
}
return(s.getAll());
}
String getBoolRelToStr(DataRow row)
{
string res = SqlTypeRelationsString.convert((SqlTypeRelations)ToolCell.isNull((SqlTypeRelations)row[TableDUMMY.RELATIONBOOL], SqlTypeRelations.undef));
if (res != string.Empty)
{
res = _space + res + _newLine;
}
return(res);
}
public static void setRecordEditor(DataRow row, IEnvironment env)
{
DateTime date = DateTime.Now;
ToolCell.set(row, TableDUMMY.CAPIBLOCK_MODIFIEDBY, env.getInfoApplication().userId);
ToolCell.set(row, TableDUMMY.CAPIBLOCK_MODIFIEDDATE, date.Date);
ToolCell.set(row, TableDUMMY.CAPIBLOCK_MODIFIEDHOUR, date.Hour);
ToolCell.set(row, TableDUMMY.CAPIBLOCK_MODIFIEDMIN, date.Minute);
ToolCell.set(row, TableDUMMY.CAPIBLOCK_MODIFIEDSEC, date.Second);
}
public bool check(DataRow row)
{
if (eval == null)
{
eval = new ImplRowEvaluator(row.Table);
eval.addExpression(exp, typeof(bool));
}
eval.setVar(row);
return((bool)ToolCell.isNull(eval.getResult(), false));
}
public virtual void resetRefs()
{
foreach (DataTable tab in getDataSet().Tables)
{
foreach (DataRow row in tab.Rows)
{
ToolCell.set(row, TableDUMMY.ID, ToolCell.getCellTypeDefaulValue(tab.Columns[TableDUMMY.ID].DataType));
}
}
}
protected virtual bool needUpdate()
{
Object res = SqlExecute.executeScalar(environment, SqlExecute.translate(getReplaceList(), environment.prepareSqlText(SQLTextCollection.NeedUpdate)));
if (ToolCell.isNull(res, string.Empty).ToString() == "1")
{
return(true);
}
return(false);
}
public void set(DataRow pRow)
{
if (pRow != null && validator.check(pRow))
{
for (int i = 0; i < cols.Length; ++i)
{
ToolCell.set(pRow, cols[i], vals[i]);
}
}
}
public virtual void initForColumnChanged(DataRow pRow)
{
for (int i = 0; i < columnsCalc.Length; ++i)
{
if (ToolCell.isNull(pRow[columnsCalc[i]]))
{
calcColumn(pRow, columnsCalc[i]);
}
}
}
protected virtual bool hasValidId(DataRow row, string col)
{
object defVal = ToolCell.getCellTypeDefaulValue(row.Table.Columns[col].DataType);
object curId = row[col];
if (ToolCell.isNull(curId) || ToolType.isEqual(defVal, curId))
{
return(false);
}
return(true);
}
public static void setReportingCurrInfo(DataRow row, double rate, String colRate, String colTotal, String colCurTotal)
{
if (colRate != null)
{
ToolCell.set(row, colRate, rate);
}
if ((colTotal != null) && (colCurTotal != null) && (rate > ConstValues.minPositive) && (ToolCell.isNull(row[colTotal], null) != null))
{
ToolCell.set(row, colCurTotal, (double)row[colTotal] / rate);
}
}
public void setVar(string name, object val)
{
try
{
ToolCell.set(evalData, name, ToolCell.isNull(val, DBNull.Value));
}
catch (Exception exc)
{
throw new MyException.MyExceptionError(MessageCollection.T_MSG_ERROR_DYNAMIC_EXPRESSION, exc);
}
}
public override DataTable get()
{
short curr = (short)ToolCell.isNull(getBuilder().getParameterValue(TableCURRENCYLIST.CURTYPE), (short)-100);
if (curr == 0)
{
getBuilder().deleteParameter(TableCURRENCYLIST.CURTYPE);
getBuilder().addParameterValue(TableCURRENCYLIST.CURTYPE, environment.getInfoApplication().periodCurrencyNativeId);
}
return(base.get());
}
public virtual void setAdded()
{
getDataSet().AcceptChanges();
foreach (DataTable tab in getDataSet().Tables)
{
foreach (DataRow row in tab.Rows)
{
row.SetAdded();
ToolCell.set(row, TableDUMMY.ID, ToolCell.getCellTypeDefaulValue(tab.Columns[TableDUMMY.ID].DataType));
}
}
}
public void set(DataRow pRow)
{
if (pRow != null)
{
foreach (DataColumn col in pRow.Table.Columns)
{
if (Array.IndexOf <string>(cols, col.ColumnName) < 0)
{
ToolCell.set(pRow, col.ColumnName, ToolCell.getCellTypeDefaulValue(col.DataType));
}
}
}
}
private void saveSpeCols(DataRow dataRow, DataRow rowInDb)
{
if (rowInDb != null && dataRow != null)
{
foreach (DataColumn col in dataRow.Table.Columns)
{
if (col.ColumnName.StartsWith("SPE_"))
{
ToolCell.set(rowInDb, col.ColumnName, dataRow[col]);
}
}
}
}
void fillRemain(DataRow pRow)
{
string SPE_REMAIN = "SPE_REMAIN";
DataTable tabList = getTable();
if (tabList != null && tabList.DefaultView.Count > 0 && tabList.Columns.Contains(SPE_REMAIN))
{
bool isOrder = ToolSlip.isDsOrder(environment.getCurDoc());
bool isSlip = ToolSlip.isDsSlip(environment.getCurDoc());
int indxMatLOGICALREF = tabList.Columns.IndexOf(TableITEMS.LOGICALREF);
int indxMatONHAND = tabList.Columns.IndexOf(TableITEMS.ONHAND);
int indxMatONHANDIO = tabList.Columns.IndexOf(TableITEMS.ONHANDIO);
int indxMatONMAIN = tabList.Columns.IndexOf(TableITEMS.ONMAIN);
int indxMatSPE_REMAIN = tabList.Columns.IndexOf(SPE_REMAIN);
foreach (DataRowView v in tabList.DefaultView)
{
if (pRow == null || object.ReferenceEquals(v.Row, pRow))
{
double remain = 0;
if (isOrder)
{
remain = (double)v[indxMatONMAIN];
}
else
// if ( isSlip)
{
object lref_ = v[indxMatLOGICALREF];
remain = (double)v[indxMatONHAND];
if (indxMatONHANDIO < 0)
{
remain += environment.getMatIOAmount(lref_);
}
else
{
remain += Convert.ToDouble(ToolCell.isNull(v[indxMatONHANDIO], 0));
remain += environment.getMatIOAmountDoc(lref_);
}
}
v.Row[indxMatSPE_REMAIN] = remain;
}
}
}
}
public double getMatDBIO(object id)
{
//if (_tableIO == null)
// refreshIOTable();
//DataRow rowIO = _tableIO.Rows.Find(id);
//if (rowIO != null && !rowIO.IsNull(indxIOAmount))
// return (double)rowIO[indxIOAmount];
//return 0;
if (!ToolCell.isNull(id))
{
return(Convert.ToDouble(ToolCell.isNull(SqlExecute.executeScalar(environment, "SELECT ONHANDIO FROM LG_$FIRM$_ITEMS WHERE LOGICALREF = @P1", new object[] { id }), 0)));
}
return(0);
}
