/// <summary>
/// 多条件搜索数据字典信息
/// </summary>
/// <param name="fieldParam">数据字典查询参数实体</param>
/// <returns></returns>
public IQueryable <SMFIELD> LoadSearchEntities(FieldParam fieldParam)
{
Expression <Func <SMFIELD, bool> > whereLambda = PredicateBuilder.True <SMFIELD>();
if (!string.IsNullOrEmpty(fieldParam.MYTEXTS))
{
whereLambda = whereLambda.And(u => u.MYTEXTS == fieldParam.MYTEXTS);
}
int count = 0;
IQueryable <SMFIELD> queryData = null;
if (!string.IsNullOrEmpty(fieldParam.order) && !string.IsNullOrEmpty(fieldParam.sort))
{
bool isAsc = fieldParam.order == "asc" ? true : false;
queryData = LoadPageEntities <SMFIELD>(fieldParam.page, fieldParam.rows, out count, whereLambda, fieldParam.sort, isAsc);
}
else
{
queryData = LoadPageEntities <SMFIELD>(fieldParam.page, fieldParam.rows, out count, whereLambda, fieldParam.sort, null);
}
fieldParam.TotalCount = count;
foreach (var item in queryData)
{
if (item.PARENTID != null && item.SMFIELD2 != null)
{
item.ParentIdOld = item.SMFIELD2.MYTEXTS.GetString();//
}
}
return(queryData);
}
public void SetFieldState(FieldParam param, bool state)
{
if (_state.ContainsKey(param))
{
_state[param] = state;
}
}
protected override void AfterSaveDelete()
{
Jurnal Jr = GetOriginal <Jurnal>();
if (Jr == null || IsErrorExist())
{
return;
}
if (Jr._BuatJurnalPembalik &&
Jr._NoJurnalPembalik.Length > 0)
{
FieldParam Param1 = new FieldParam("0",
Jr._NoJurnalPembalik);
ExecuteNonQuery(
"DELETE FROM Jurnal WHERE NoJurnal=@0",
Param1);
ExecuteNonQuery(
"DELETE FROM JurnalDetil WHERE NoJurnal=@0",
Param1);
}
if (Jr._TglDibalik < Jr._TglJurnal)
{
BaseGL.RingkasanAkun.Hapus(Jr._TglDibalik);
}
else
{
BaseGL.RingkasanAkun.Hapus(Jr._TglJurnal);
}
}
private string SqlFindFirst()
{
string strTemp = WhereExist ? " AND " : " WHERE ";
ParamFind = new FieldParam(_OrderFld, FindValue);
string strOrderFld = GetOderFieldName();
//SELECT TOP 1 KeyField FROM View WHERE
// OrdField LIKE @FindData
// ORDER BY OrdField, KeyField
switch (_OrderFld.DataType)
{
case DataType.Boolean:
return(Dp.GetSqlSelectTopN(
string.Concat(strQuery, strTemp,
strOrderFld, "=@", strOrderFld), 1,
strOrderFld + _strOrderAsc));
case DataType.Char:
case DataType.VarChar:
return(Dp.GetSqlSelectTopN(
string.Concat(strQuery, strTemp,
strOrderFld, " LIKE @",
strOrderFld), 1,
strOrderFld + _strOrderAsc));
default:
return(Dp.GetSqlSelectTopN(
string.Concat(strQuery, strTemp,
strOrderFld, ">=@",
strOrderFld), 1,
strOrderFld + _strOrderAsc));
}
}
/// <summary>
/// Digunakan untuk MovePrev dan MoveNext
/// </summary>
/// <param name="Op"></param>
/// <returns></returns>
private string GenKeyCondition(string Op)
{
string strKey;
FieldDef PrevField;
if (_CurrentKeyField.Length == 0)
{
PrevField = _OrderFld;
}
else
{
PrevField = _CurrentKeyField[0];
}
strKey = string.Concat(PrevField._FieldName,
Op, "@XCurrKeyX");
ParamMovePrevNext = (FieldParam[])_ParamCurrentKeyField.Clone();
int NumKeyField = ParamMovePrevNext.Length;
Array.Resize <FieldParam>(ref ParamMovePrevNext,
NumKeyField + 2);
ParamMovePrevNext[NumKeyField] =
new FieldParam("XCurrKeyX", PrevField,
PrevField.GetValue(_Entity._Original));
string strTemp = string.Empty;
if (_CurrentKeyField.Length > 0)
{
ParamMovePrevNext[0].Value = _CurrentKeyField[0]
.GetValue(_Entity._Original);
for (int i = 1; i < _CurrentKeyField.Length; i++)
{
strTemp = string.Concat(strTemp,
PrevField._FieldName, "=@",
PrevField._FieldName, " AND ");
FieldDef TmpFld = _CurrentKeyField[i];
ParamMovePrevNext[i].Value = TmpFld
.GetValue(_Entity._Original);
strKey = string.Concat(strKey, " OR ", strTemp,
TmpFld._FieldName,
Op, "@", TmpFld._FieldName);
PrevField = TmpFld;
}
}
strKey = string.Concat("(", strKey, ")");
return(strKey);
}
public bool GetFieldState(FieldParam param)
{
if (_state.ContainsKey(param))
{
return(_state[param]);
}
else
{
return(false);
}
}
/// <summary>
/// Find Key, Format: Key1,Key2,...
/// </summary>
/// <param name="NewKey"></param>
/// <returns></returns>
public bool FindKey(string NewKey)
{
string[] Keys = NewKey.Split(',');
Criteria = string.Empty;
CriteriaParams = new FieldParam[td.KeyFields.Count];
int i = 0;
foreach (FieldDef fld in td.KeyFields.Values)
{
Criteria = string.Concat(Criteria, " AND ",
fld._FieldName, "=@", fld._FieldName);
CriteriaParams[i] = new FieldParam(fld, Keys[i]);
i++;
}
Criteria = Criteria.Substring(5);
return(MoveData(MoveType.FindCriteria));
}
private void TransferTable(TableDef td, string Condition)
{
string strWhere = Condition.Length > 0 ?
" WHERE " + Condition : string.Empty;
DpDestination.ValidateTableDef(td);
FieldParam[] ListParam = new FieldParam[
td.KeyFields.Count + td.NonKeyFields.Count];
int paramCtr = 0;
StringBuilder strFieldsDest = new StringBuilder();
StringBuilder strFieldsSource = new StringBuilder();
foreach (FieldDef fld in td.KeyFields.Values)
{
strFieldsDest.Append(",").Append(fld._FieldName);
strFieldsSource.Append(",").Append(fld._FieldName);
ListParam[paramCtr++] = new FieldParam(fld);
}
foreach(FieldDef fld in td.NonKeyFields.Values)
{
strFieldsDest.Append(",").Append(fld._FieldName);
strFieldsSource.Append(",").Append(fld._FieldName);
ListParam[paramCtr++] = new FieldParam(fld);
}
string strTemp = strFieldsDest.Remove(0, 1).ToString();
string strInsert = string.Concat("INSERT INTO ",
td._TableName, "(",
strTemp, ") VALUES (",
strTemp.Replace(",", ",@").Insert(0, "@"), ")");
strTemp = strFieldsSource.Remove(0, 1).ToString();
DataTable dt = DpSource.OpenDataTable(string.Concat(
"SELECT ", strTemp, " FROM ", td._TableName, strWhere));
int j = dt.Columns.Count;
IDbCommand Cmd = DpDestination.CreateCommand(strInsert,
CommandType.Text, ListParam);
foreach (DataRow dr in dt.Rows)
{
for (int i = 0; i < j; i++)
Cmd.Parameters[i] = dr[i];
Cmd.ExecuteNonQuery();
}
}
public static void Hapus(DataPersistance Dp, string JenisDokSumber,
string NoDokSumber)
{
Jurnal Jr = new Jurnal();
if (Jr.FastLoadEntity(
"NoJurnal,TglJurnal,BuatJurnalPembalik,NoJurnalPembalik,TglDibalik",
"JenisDokSumber=@jds AND NoDokSumber=@nds",
new FieldParam("jds", JenisDokSumber),
new FieldParam("nds", NoDokSumber)))
{
FieldParam ParamNoJurnal = new FieldParam("0", Jr._NoJurnal);
using (EntityTransaction tr = new EntityTransaction(Dp))
{
Dp.ExecuteNonQuery(
"DELETE FROM Jurnal WHERE NoJurnal=@0",
ParamNoJurnal);
Dp.ExecuteNonQuery(
"DELETE FROM JurnalDetil WHERE NoJurnal=@0",
ParamNoJurnal);
if (Jr.BuatJurnalPembalik &&
Jr._NoJurnalPembalik.Length > 0)
{
ParamNoJurnal.Value = Jr._NoJurnalPembalik;
Dp.ExecuteNonQuery(
"DELETE FROM Jurnal WHERE NoJurnal=@0",
ParamNoJurnal);
Dp.ExecuteNonQuery(
"DELETE FROM JurnalDetil WHERE NoJurnal=@0",
ParamNoJurnal);
if (Jr._TglDibalik < Jr._TglJurnal)
{
Jr._TglJurnal = Jr._TglDibalik;
}
}
BaseGL.RingkasanAkun.Hapus(Jr._TglJurnal);
tr.CommitTransaction();
}
}
}
/// <summary>
/// Reload dari Database Entity sesuai Key Asal yang dimasukkan
/// </summary>
public bool Reload()
{
if (_Entity.FormMode == FormMode.FormAddNew)
{
return(false);
}
int i = 0;
CriteriaParams = new FieldParam[td.KeyFields.Count];
Criteria = string.Empty;
foreach (FieldDef fld in td.KeyFields.Values)
{
Criteria = string.Concat(Criteria,
" AND ", fld._FieldName, "=@", fld._FieldName);
CriteriaParams[i++] = new FieldParam(fld,
_Entity._Original);
}
Criteria = Criteria.Substring(5);
return(MoveData(MoveType.FindCriteria));
}
public BCSV(byte[] data)
{
Data = data;
EntryCount = BitConverter.ToUInt32(data, 0x0);
EntryLength = BitConverter.ToUInt32(data, 0x4);
FieldCount = BitConverter.ToUInt16(data, 0x8);
HasBCSVHeader = data[0xA] == 1;
Flag2 = data[0xB] == 1;
if (HasBCSVHeader)
{
Magic = BitConverter.ToUInt32(data, 0xC);
if (Magic != MAGIC)
{
throw new ArgumentException(nameof(Magic));
}
Unknown = BitConverter.ToInt32(data, 0x10);
Unknown1 = BitConverter.ToInt32(data, 0x14);
Unknown2 = BitConverter.ToInt32(data, 0x18);
FieldTableStart = 0x1C;
}
else
{
FieldTableStart = 0x0C;
}
var fields = new FieldParam[FieldCount];
for (int i = 0; i < fields.Length; i++)
{
var ofs = FieldTableStart + (i * FieldParam.SIZE);
var ident = BitConverter.ToUInt32(data, ofs);
var fo = BitConverter.ToInt32(data, ofs + 4);
fields[i] = new FieldParam(ident, fo);
}
FieldOffsets = fields;
}
public void DoAfterSendToPrinter()
{
TableDef td = MetaData.GetTableDef(_DataSource.GetType());
if (td.fldPrintCounter != null)
{
DataPersistance Dp = _DataSource.Dp;
string strTemp = string.Empty;
FieldParam[] fps = new FieldParam[td.KeyFields.Count];
int Ctr = 0;
foreach (FieldDef fld in td.KeyFields.Values)
{
strTemp = string.Concat(strTemp, " AND ", fld.FieldName, "=@", Ctr);
fps[Ctr] = new FieldParam(Ctr.ToString(), fld, fld.GetValue(_DataSource));
}
strTemp = strTemp.Substring(5);
Dp.ExecuteNonQuery(string.Concat("UPDATE ",
td.TableName, " SET ", td.fldPrintCounter.FieldName,
"=", td.fldPrintCounter.FieldName, "+1 WHERE ", strTemp), fps);
}
((IBaseEntity)_DataSource).DoAfterSendToPrinter();
}
public static void Hapus(DataPersistance Dp, string NoPengeluaranKas)
{
FieldParam ParamNoPengeluaranKas = new FieldParam("0", NoPengeluaranKas);
string NoJurnal = Jurnal.CariNoJurnal(Dp, ModuleName, NoPengeluaranKas);
using (EntityTransaction tr = new EntityTransaction(Dp))
{
if (NoJurnal.Length > 0)
{
Jurnal.Hapus(Dp, NoJurnal);
}
Dp.ExecuteNonQuery(
"DELETE FROM PengeluaranKasUmum WHERE NoPengeluaranKas=@0",
ParamNoPengeluaranKas);
Dp.ExecuteNonQuery(
"DELETE FROM PengeluaranKasUmumDetil WHERE NoPengeluaranKas=@0",
ParamNoPengeluaranKas);
tr.CommitTransaction();
}
}
protected override string GetSqlType(FieldParam Param)
{
switch (Param.DataType)
{
case DataType.VarChar:
case DataType.Char:
if (Param.Length < 256)
{
return(string.Concat(" Text(", Param.Length, ")"));
}
else
{
return(" Memo");
}
case DataType.DateTime:
case DataType.Date:
case DataType.Time:
case DataType.TimeStamp:
return(" DateTime");
case DataType.Boolean:
return(" Bit");
case DataType.Binary:
case DataType.Image:
return(" OleObject");
case DataType.Integer:
return(" Int");
case DataType.Decimal:
return(" Currency");
default:
return(string.Empty);
}
}
public JsonResult GetData(FieldParam fieldParam)
{
var queryData = SMFIELDService.LoadSearchEntities(fieldParam);
return(Json(new datagrid
{
total = fieldParam.TotalCount,
rows = queryData.Select(s => new
{
ID = s.ID,
MYTEXTS = s.MYTEXTS,
PARENTID = s.PARENTID,
MYTABLES = s.MYTABLES,
MYCOLUMS = s.MYCOLUMS,
SORT = s.SORT,
REMARK = s.REMARK,
CREATETIME = s.CREATETIME,
CREATEPERSON = s.CREATEPERSON,
UPDATETIME = s.UPDATETIME,
UPDATEPERSON = s.UPDATEPERSON
}
)
}));
}
public static System.Data.IDbCommand SetupDbCommand(BuilkInsert insertCommand, IConnection connection)
{
if (insertCommand.InsertCommands.Count == 0)
{
return(null);
}
var CmdText = new System.Text.StringBuilder();
var DbCommand = connection.DbConnection.CreateCommand();
var FieldList = new System.Text.StringBuilder();
foreach (var Fld in insertCommand.ColumnValues)
{
if (FieldList.Length == 0)
{
FieldList.Append(@"""" + Fld.ColumnName + @"""");
}
else
{
FieldList.Append(@", """ + Fld.ColumnName + @"""");
}
}
CmdText.Append(@"INSERT INTO """ + string.Join <string>(",", insertCommand.Tables) + @""" (" + FieldList.ToString() + ") VALUES ");
var CmdNum = 1;
foreach (Insert Cmd in insertCommand.InsertCommands)
{
var ParamList = new System.Text.StringBuilder();
foreach (IColumnValue ThisField in Cmd.ColumnValues)
{
string FieldParam;
var ParamName = "@" + ThisField.ColumnName + "_" + CmdNum.ToString();
if (ThisField.Value is qGen.SqlFunctions)
{
switch (((qGen.SqlFunctions)(ThisField.Value)))
{
case SqlFunctions.Now:
FieldParam = "NOW()";
break;
default:
throw new NotImplementedException();
}
}
else if (ThisField.Value is qGen.SqlExpression)
{
FieldParam = ThisField.Value.ToString();
}
else
{
if (connection.DbConnection is System.Data.Odbc.OdbcConnection)
{
FieldParam = "?";
}
else
{
FieldParam = ParamName;
}
}
if (ParamList.Length == 0)
{
ParamList.Append(FieldParam);
}
else
{
ParamList.Append(", " + FieldParam);
}
if (FieldParam == "?" || FieldParam.Substring(0, 1) == "@")
{
var Param = connection.Factory.Driver.GetParameter();
Param.ParameterName = ParamName;
if (ThisField.Value is DbDateTime && ThisField.Value != null)
{
Param.Value = ((DbDateTime)(ThisField.Value)).Value;
}
else
{
Param.Value = ThisField.Value;
}
if (ThisField.DataType == Lazaro.Orm.ColumnTypes.Blob)
{
Param.DbType = System.Data.DbType.Binary;
}
// FIXME: No debería hacer una excepción para ODBC
if (connection.Factory.Driver is OdbcDriver && ThisField.DataType == Lazaro.Orm.ColumnTypes.Blob)
{
((System.Data.Odbc.OdbcParameter)Param).OdbcType = System.Data.Odbc.OdbcType.VarBinary;
}
DbCommand.Parameters.Add(Param);
}
}
if (CmdNum > 1)
{
CmdText.AppendLine(",");
}
CmdText.Append(@"(" + ParamList.ToString() + ")");
CmdNum++;
}
DbCommand.CommandText = CmdText.ToString();
return(DbCommand);
}
private void UpdateStrQuery()
{
if (_OrderFld == null)
{
return;
}
int i = 0;
string tmpFilter;
string TmpStr2;
_strOrderAsc = string.Empty;
_strOrderDesc = string.Empty;
OrderInKey = false;
foreach (FieldDef fld in td.KeyFields.Values)
{
if (object.ReferenceEquals(fld, _OrderFld))
{
OrderInKey = true;
break;
}
}
int numKey = OrderInKey ?
td.KeyFields.Count - 1 : td.KeyFields.Count;
_CurrentKeyField = new FieldDef[numKey];
_ParamCurrentKeyField = new FieldParam[numKey];
foreach (FieldDef fld in td.KeyFields.Values)
{
if (!object.ReferenceEquals(fld, _OrderFld))
{
_CurrentKeyField[i] = fld;
_ParamCurrentKeyField[i++] = new FieldParam(fld);
_strOrderAsc = string.Concat(_strOrderAsc, ",",
fld._FieldName);
_strOrderDesc = string.Concat(_strOrderDesc, ",",
fld._FieldName, " DESC");
}
}
if (_Filter.Length > 0)
{
tmpFilter = string.Concat(
" WHERE (", _Filter, ")");
WhereExist = true;
}
else
{
tmpFilter = string.Empty;
WhereExist = false;
}
TmpStr2 = ((IRuleInitUI)_Entity).GetBrowseFilter();
if (TmpStr2.Length > 0)
{
if (WhereExist)
{
tmpFilter = string.Concat(tmpFilter, " AND (", TmpStr2, ")");
}
else
{
WhereExist = true;
tmpFilter = string.Concat(" WHERE (", TmpStr2, ")");
}
}
else
{
string SqlSelect, SqlCondition, SqlOrderBy;
((IRuleInitUI)_Entity).GetBrowseSql(out SqlSelect,
out SqlCondition, out SqlOrderBy);
if (SqlSelect.Length > 0)
{
if (SqlCondition.Length == 0)
{
strQuery = string.Concat("SELECT ",
_OrderFld._FieldName,
_strOrderAsc, " FROM (",
SqlSelect, ") AS X", tmpFilter);
}
else
{
tmpFilter = string.Concat(" WHERE (", SqlCondition, ")");
WhereExist = true;
strQuery = string.Concat("SELECT ",
_OrderFld._FieldName,
_strOrderAsc, " FROM (",
SqlSelect, ") AS X", tmpFilter);
}
return;
}
}
if (_OrderFld._dtlsa == null)
{
strQuery = string.Concat("SELECT ",
_OrderFld._FieldName,
_strOrderAsc, " FROM ",
td._TableName, tmpFilter);
}
else
{
strQuery = string.Concat("SELECT ",
_OrderFld._FieldName, _strOrderAsc,
" FROM (SELECT (", _Entity.Dp
.GetSqlCoalesceNoFormat(
string.Concat("(", _OrderFld._dtlsa.GetSqlQuery(), ")"),
_Entity.Dp
.FormatSqlValue(_OrderFld.GetDataTypeDefault())),
") AS ", _OrderFld._FieldName,
_strOrderAsc, " FROM ",
td._TableName, tmpFilter, ") AS X");
}
}
public override void SetupDbCommand(ref System.Data.IDbCommand baseCommand)
{
baseCommand.Parameters.Clear();
System.Text.StringBuilder FieldList = new System.Text.StringBuilder();
foreach (Lfx.Data.Field ThisField in this.Fields)
{
string FieldParam;
if (ThisField.Value is qGen.SqlFunctions)
{
switch (((qGen.SqlFunctions)(ThisField.Value)))
{
case SqlFunctions.Now:
FieldParam = "NOW()";
break;
default:
throw new NotImplementedException();
}
}
else if (ThisField.Value is qGen.SqlExpression)
{
FieldParam = ThisField.Value.ToString();
}
else
{
if (baseCommand.Connection is System.Data.Odbc.OdbcConnection)
{
FieldParam = "?";
}
else
{
FieldParam = "@" + ThisField.ColumnName;
}
}
if (FieldList.Length == 0)
{
FieldList.Append(@"""" + ThisField.ColumnName + @"""=" + FieldParam);
}
else
{
FieldList.Append(@", """ + ThisField.ColumnName + @"""=" + FieldParam);
}
if (FieldParam == "?" || FieldParam.Substring(0, 1) == "@")
{
System.Data.IDbDataParameter Param = Lfx.Data.DataBaseCache.DefaultCache.Provider.GetParameter();
Param.ParameterName = "@" + ThisField.ColumnName;
if (ThisField.Value is NullableDateTime && ThisField.Value != null)
{
Param.Value = ((NullableDateTime)(ThisField.Value)).Value;
}
else if (ThisField.Value != null && ThisField.Value.GetType().IsEnum)
{
Param.Value = System.Convert.ToInt32(ThisField.Value);
}
else
{
Param.Value = ThisField.Value;
}
if (ThisField.DataType == Lfx.Data.DbTypes.Blob)
{
Param.DbType = System.Data.DbType.Binary;
}
if (Lfx.Data.DataBaseCache.DefaultCache.Provider is qGen.Providers.Odbc && ThisField.DataType == Lfx.Data.DbTypes.Blob)
{
((System.Data.Odbc.OdbcParameter)Param).OdbcType = System.Data.Odbc.OdbcType.VarBinary;
}
baseCommand.Parameters.Add(Param);
}
}
baseCommand.CommandText = @"UPDATE """ + this.Tables + @""" SET " + FieldList.ToString() + " WHERE " + WhereClause.ToString();
}
protected override IDataParameter CreateParameter(string ParamName, FieldParam Param)
{
NpgsqlParameter p = new NpgsqlParameter();
p.ParameterName = GetSqlParam() + ParamName;
switch (Param.DataType)
{
case DataType.VarChar:
p.NpgsqlDbType = NpgsqlDbType.Varchar;
p.Size = Param.Length;
break;
case DataType.Char:
p.NpgsqlDbType = NpgsqlDbType.Char;
p.Size = Param.Length;
break;
case DataType.Integer:
p.NpgsqlDbType = NpgsqlDbType.Integer;
break;
case DataType.Decimal:
p.NpgsqlDbType = NpgsqlDbType.Numeric;
p.Precision = (byte)Param.Length;
p.Scale = (byte)Param.Scale;
break;
case DataType.Boolean:
p.NpgsqlDbType = NpgsqlDbType.Boolean;
break;
case DataType.DateTime:
p.NpgsqlDbType = NpgsqlDbType.Date;
break;
case DataType.Date:
p.NpgsqlDbType = NpgsqlDbType.Date;
break;
case DataType.Time:
p.NpgsqlDbType = NpgsqlDbType.Time;
break;
case DataType.TimeStamp:
p.NpgsqlDbType = NpgsqlDbType.Date;
break;
case DataType.Binary:
p.NpgsqlDbType = NpgsqlDbType.Bytea;
break;
case DataType.Image:
p.NpgsqlDbType = NpgsqlDbType.Bytea;
if (Param.Value != null)
{
p.Value = Helper.ConvertImageToByteArray(
(Image)Param.Value);
}
return(p);
}
if (Param.Value != null)
{
p.Value = Param.Value;
}
return(p);
}
protected override void AfterSaveUpdate()
{
if (ListAkun == null || IsErrorExist())
{
return;
}
Jurnal OrigJurnal = GetOriginal <Jurnal>();
if (OrigJurnal == null)
{
return;
}
if (OrigJurnal._NoJurnalPembalik.Length > 0)
{
FieldParam Param1 = new FieldParam("0",
OrigJurnal._NoJurnalPembalik);
ExecuteNonQuery(
"DELETE FROM Jurnal WHERE NoJurnal=@0",
Param1);
ExecuteNonQuery(
"DELETE FROM JurnalDetil WHERE NoJurnal=@0",
Param1);
}
if (_BuatJurnalPembalik)
{
Jurnal JurnalBalik = (Jurnal)MetaData.Clone(
this);
if (OrigJurnal._NoJurnalPembalik.Length > 0)
{
JurnalBalik._NoJurnal =
OrigJurnal._NoJurnalPembalik;
}
JurnalBalik.BuatJurnalPembalik = false;
JurnalBalik._Internal = true;
JurnalBalik._NoJurnal = string.Empty;
JurnalBalik._NoJurnalPembalik = string.Empty;
JurnalBalik._NoDokSumber = _NoJurnal;
JurnalBalik.JenisDokSumber = "Jurnal Pembalik";
JurnalBalik._TglJurnal = _TglDibalik;
foreach (JurnalDetil Jd in JurnalBalik.JurnalDetil)
{
Jd.Debit = -Jd.Debit;
Jd.Kredit = -Jd.Kredit;
}
JurnalBalik.SaveNew(true, false);
_NoJurnalPembalik = JurnalBalik._NoJurnal;
ExecuteNonQuery(
"UPDATE Jurnal SET NoJurnalPembalik=@0 WHERE NoJurnal=@1",
new FieldParam("0", _NoJurnalPembalik),
new FieldParam("1", _NoJurnal));
}
DateTime Tmp = OrigJurnal._TglJurnal;
if (Tmp > _TglJurnal)
{
Tmp = _TglJurnal;
}
BaseGL.RingkasanAkun.Hapus(Tmp);
_AturanJurnal = string.Empty;
}
internal string GetSqlQueryValue(BaseEntity Entity,
out FieldParam[] Parameters)
{
if (_SqlQueryValue != null)
{
foreach (FieldParam fldp in QueryValueParams)
{
fldp.Value = Entity;
}
}
else
{
string retVal;
TableDef tdParent = MetaData.GetTableDef(_ParentType);
FieldDef fldParent = tdParent.GetFieldDef(ParentFieldName);
if (fldParent._dtlsa == null)
{
retVal = string.Concat("SELECT ", ParentFieldName,
" FROM ", tdParent._TableName, " AS x1 WHERE ");
}
else
{
retVal = string.Concat("SELECT (", fldParent._dtlsa
.GetSqlQueryNested(1), ") AS ", ParentFieldName,
" FROM ", tdParent._TableName, " AS x1 WHERE ");
}
string[] tmpStr = _RelationKeyField.Split(',');
int NumRel = tmpStr.Length;
TableDef td = MetaData.GetTableDef(Entity.GetType());
FieldDef fld;
QueryValueParams = new FieldParam[NumRel];
string tmpStr2 = tmpStr[0].Trim();
string[] tmpData = tmpStr2.Split('=');
if (tmpData.Length == 1)
{
retVal = string.Concat(retVal, "x1.",
tmpStr2, "=@0");
fld = td.GetFieldDef(tmpStr2);
}
else
{
retVal = string.Concat(retVal, "x1.",
tmpData[0], "=@0");
fld = td.GetFieldDef(tmpData[1]);
}
QueryValueParams[0] = new FieldParam("0", fld,
fld.GetValue(Entity));
for (int i = 1; i < NumRel; i++)
{
tmpStr2 = tmpStr[i];
tmpData = tmpStr2.Split('=');
if (tmpData.Length == 1)
{
retVal = string.Concat(retVal,
" AND x1.", tmpStr2, "=@", i.ToString());
fld = td.GetFieldDef(tmpStr2);
}
else
{
retVal = string.Concat(retVal,
" AND x1.", tmpData[0], "=@", i.ToString());
fld = td.GetFieldDef(tmpData[1]);
}
QueryValueParams[i] = new FieldParam(i.ToString(),
fld, fld.GetValue(Entity));
}
_SqlQueryValue = retVal;
}
Parameters = QueryValueParams;
return(_SqlQueryValue);
}
public bool MoveData(MoveType MovingType)
{
if (_OrderFld == null)
{
return(false);
}
IDataReader rdr;
#region Cek MovingType
switch (MovingType)
{
case MoveType.MoveFirst:
rdr = Dp.ExecuteReader(
SqlMoveFirst());
break;
case MoveType.MovePrevious:
if (!IsError)
{
rdr = Dp.ExecuteReader(
SqlMovePrevious(), ParamMovePrevNext);
}
else
{
rdr = Dp.ExecuteReader(
SqlMoveFirst());
}
break;
case MoveType.MoveNext:
if (!IsError)
{
rdr = Dp.ExecuteReader(
SqlMoveNext(), ParamMovePrevNext);
}
else
{
rdr = Dp.ExecuteReader(
SqlMoveLast());
}
break;
case MoveType.FindCriteria:
rdr = Dp.ExecuteReader(
SqlFindCriteria(), CriteriaParams);
break;
case MoveType.FindFirst:
rdr = Dp.ExecuteReader(
SqlFindFirst(), ParamFind);
break;
case MoveType.FindLast:
rdr = Dp.ExecuteReader(
SqlFindLast(), ParamFind);
break;
default: // MoveLast
rdr = Dp.ExecuteReader(
SqlMoveLast());
break;
}
#endregion
try
{
if (rdr.Read())
{
string strKeyWhere = string.Empty;
FieldParam[] LoadParam = (FieldParam[])
_ParamCurrentKeyField.Clone();
for (int i = 0; i < _CurrentKeyField.Length; i++)
{
strKeyWhere = string.Concat(strKeyWhere, " AND ",
_CurrentKeyField[i]._FieldName, "=@",
_CurrentKeyField[i]._FieldName);
LoadParam[i].Value = rdr.GetValue(i + 1);
}
if (OrderInKey)
{
int SizeLoadParam = LoadParam.Length;
Array.Resize <FieldParam>(ref LoadParam,
SizeLoadParam + 1);
LoadParam[SizeLoadParam] = new FieldParam(
_OrderFld, rdr.GetValue(0));
strKeyWhere = string.Concat(
_OrderFld._FieldName, "=@",
_OrderFld._FieldName, strKeyWhere);
}
else
{
strKeyWhere = strKeyWhere.Substring(5);
}
_Entity.LoadEntity(strKeyWhere, true, LoadParam);
IsError = false;
if (_Entity.FormMode != FormMode.FormEdit &&
_Entity.FormMode != FormMode.FormView)
{
_Entity.FormMode = FormMode.FormEdit;
}
}
else
{
switch (MovingType)
{
case MoveType.MovePrevious:
return(MoveFirst());
case MoveType.MoveNext:
return(MoveLast());
}
IsError = true;
_Entity.FormMode = FormMode.FormError;
}
//if (!IsError && onAfterLoad != null) onAfterLoad();
if (onDataMoving != null)
{
onDataMoving(MovingType, IsError);
}
return(!IsError);
}
finally
{
if (rdr != null)
{
rdr.Close();
}
}
}
protected override string GetSqlType(FieldParam Param)
{
return(SqlServerType(Param));
}
private string SqlServerType(FieldParam fldp)
{
return(SqlServerType(fldp.DataType, fldp.Length, fldp.Scale));
}
protected override IDataParameter CreateParameter(
string ParamName, FieldParam Param)
{
SqlParameter p = new SqlParameter();
p.ParameterName = GetSqlParam() + ParamName;
switch (Param.DataType)
{
case DataType.VarChar:
p.DbType = DbType.String;
p.Size = Param.Length;
break;
case DataType.Char:
p.DbType = DbType.StringFixedLength;
p.Size = Param.Length;
break;
case DataType.Integer:
p.DbType = DbType.Int32;
break;
case DataType.Decimal:
p.DbType = DbType.Decimal;
p.Precision = (byte)Param.Length;
p.Scale = (byte)Param.Scale;
break;
case DataType.Boolean:
p.DbType = DbType.Boolean;
break;
case DataType.DateTime:
p.DbType = DbType.DateTime;
break;
case DataType.Date:
case DataType.Time:
case DataType.TimeStamp:
p.DbType = DbType.Date;
break;
case DataType.Binary:
p.DbType = DbType.Binary;
if (Param.Value != null)
{
p.Value = Param.Value;
}
else
{
p.Value = DBNull.Value;
}
return(p);
case DataType.Image:
p.DbType = DbType.Binary;
if (Param.Value != null)
{
p.Value = Helper.ConvertImageToByteArray(
(Image)Param.Value);
}
else
{
p.Value = DBNull.Value;
}
return(p);
}
if (Param.Value != null)
{
p.Value = Param.Value;
}
return(p);
}
public override void SetupDbCommand(ref System.Data.IDbCommand baseCommand)
{
System.Text.StringBuilder FieldList = new System.Text.StringBuilder();
System.Text.StringBuilder ParamList = new System.Text.StringBuilder();
foreach (Lfx.Data.Field ThisField in this.Fields)
{
if (FieldList.Length == 0)
{
FieldList.Append(@"""" + ThisField.ColumnName + @"""");
}
else
{
FieldList.Append(@", """ + ThisField.ColumnName + @"""");
}
string FieldParam;
if (ThisField.Value is qGen.SqlFunctions)
{
switch (((qGen.SqlFunctions)(ThisField.Value)))
{
case SqlFunctions.Now:
FieldParam = "NOW()";
break;
default:
throw new NotImplementedException();
}
}
else if (ThisField.Value is qGen.SqlExpression)
{
FieldParam = ThisField.Value.ToString();
}
else
{
if (baseCommand.Connection is System.Data.Odbc.OdbcConnection)
{
FieldParam = "?";
}
else
{
FieldParam = "@" + ThisField.ColumnName;
}
}
if (ParamList.Length == 0)
{
ParamList.Append(FieldParam);
}
else
{
ParamList.Append(", " + FieldParam);
}
if (FieldParam == "?" || FieldParam.Substring(0, 1) == "@")
{
System.Data.IDbDataParameter Param = Lfx.Data.DataBaseCache.DefaultCache.Provider.GetParameter();
Param.ParameterName = "@" + ThisField.ColumnName;
if (ThisField.Value is NullableDateTime && ThisField.Value != null)
{
Param.Value = ((NullableDateTime)(ThisField.Value)).Value;
}
else
{
Param.Value = ThisField.Value;
}
if (ThisField.DataType == Lfx.Data.DbTypes.Blob)
{
Param.DbType = System.Data.DbType.Binary;
}
if (Lfx.Data.DataBaseCache.DefaultCache.Provider is qGen.Providers.Odbc && ThisField.DataType == Lfx.Data.DbTypes.Blob)
{
((System.Data.Odbc.OdbcParameter)Param).OdbcType = System.Data.Odbc.OdbcType.VarBinary;
}
baseCommand.Parameters.Add(Param);
}
}
baseCommand.CommandText += @"INSERT INTO """ + this.Tables + @""" (" + FieldList.ToString() + ") VALUES (" + ParamList.ToString() + ")";
if (this.OnDuplicateKeyUpdate)
{
string UpdateClause = null;
foreach (Lfx.Data.Field ThisField in this.Fields)
{
if (UpdateClause == null)
{
UpdateClause = @" ON DUPLICATE KEY UPDATE """ + ThisField.ColumnName + @"""=VALUES(""" + ThisField.ColumnName + @""")";
}
else
{
UpdateClause += @", """ + ThisField.ColumnName + @"""=VALUES(""" + ThisField.ColumnName + @""")";
}
}
baseCommand.CommandText += UpdateClause;
}
}
public System.Data.IDbCommand SetupDbCommand(Insert insertCommand, IConnection connection)
{
var FieldList = new System.Text.StringBuilder();
var ParamList = new System.Text.StringBuilder();
var DbCommand = connection.DbConnection.CreateCommand();
foreach (IColumnValue ThisField in insertCommand.ColumnValues)
{
if (FieldList.Length == 0)
{
FieldList.Append(@"""" + ThisField.ColumnName + @"""");
}
else
{
FieldList.Append(@", """ + ThisField.ColumnName + @"""");
}
string FieldParam;
if (ThisField.Value is qGen.SqlFunctions)
{
switch (((qGen.SqlFunctions)(ThisField.Value)))
{
case SqlFunctions.Now:
FieldParam = "NOW()";
break;
default:
throw new NotImplementedException();
}
}
else if (ThisField.Value is qGen.SqlExpression)
{
FieldParam = ThisField.Value.ToString();
}
else
{
if (connection.DbConnection is System.Data.Odbc.OdbcConnection)
{
FieldParam = "?";
}
else
{
FieldParam = "@" + ThisField.ColumnName;
}
}
if (ParamList.Length == 0)
{
ParamList.Append(FieldParam);
}
else
{
ParamList.Append(", " + FieldParam);
}
if (FieldParam == "?" || FieldParam.Substring(0, 1) == "@")
{
var Param = connection.Factory.Driver.GetParameter();
Param.ParameterName = "@" + ThisField.ColumnName;
if (ThisField.Value is DbDateTime && ThisField.Value != null)
{
Param.Value = ((DbDateTime)(ThisField.Value)).Value;
}
else
{
Param.Value = ThisField.Value;
}
if (ThisField.DataType == Lazaro.Orm.ColumnTypes.Blob)
{
Param.DbType = System.Data.DbType.Binary;
}
// FIXME: no debería hacer una excepción para OdbcDriver
if (connection.Factory.Driver is OdbcDriver && ThisField.DataType == Lazaro.Orm.ColumnTypes.Blob)
{
((System.Data.Odbc.OdbcParameter)Param).OdbcType = System.Data.Odbc.OdbcType.VarBinary;
}
DbCommand.Parameters.Add(Param);
}
}
DbCommand.CommandText += @"INSERT INTO """ + string.Join <string>(",", insertCommand.Tables) + @""" (" + FieldList.ToString() + ") VALUES (" + ParamList.ToString() + ")";
if (insertCommand.OnDuplicateKeyUpdate)
{
var UpdateClause = new StringBuilder();
foreach (IColumnValue ThisField in insertCommand.ColumnValues)
{
if (UpdateClause.Length == 0)
{
UpdateClause.Append(@" ON DUPLICATE KEY UPDATE """ + ThisField.ColumnName + @"""=VALUES(""" + ThisField.ColumnName + @""")");
}
else
{
UpdateClause.Append(@", """ + ThisField.ColumnName + @"""=VALUES(""" + ThisField.ColumnName + @""")");
}
}
DbCommand.CommandText += UpdateClause.ToString();
}
return(DbCommand);
}
public override void SetupDbCommand(ref System.Data.IDbCommand baseCommand)
{
if (this.InsertCommands.Count == 0)
{
return;
}
System.Text.StringBuilder CmdText = new System.Text.StringBuilder(baseCommand.CommandText);
System.Text.StringBuilder FieldList = new System.Text.StringBuilder();
foreach (Lfx.Data.Field ThisField in this.Fields)
{
if (FieldList.Length == 0)
{
FieldList.Append(@"""" + ThisField.ColumnName + @"""");
}
else
{
FieldList.Append(@", """ + ThisField.ColumnName + @"""");
}
}
CmdText.Append(@"INSERT INTO """ + this.Tables + @""" (" + FieldList.ToString() + ") VALUES ");
int CmdNum = 1;
foreach (Insert Cmd in this.InsertCommands)
{
System.Text.StringBuilder ParamList = new System.Text.StringBuilder();
foreach (Lfx.Data.Field ThisField in Cmd.Fields)
{
string FieldParam;
string ParamName = "@" + ThisField.ColumnName + "_" + CmdNum.ToString();
if (ThisField.Value is qGen.SqlFunctions)
{
switch (((qGen.SqlFunctions)(ThisField.Value)))
{
case SqlFunctions.Now:
FieldParam = "NOW()";
break;
default:
throw new NotImplementedException();
}
}
else if (ThisField.Value is qGen.SqlExpression)
{
FieldParam = ThisField.Value.ToString();
}
else
{
if (baseCommand.Connection is System.Data.Odbc.OdbcConnection)
{
FieldParam = "?";
}
else
{
FieldParam = ParamName;
}
}
if (ParamList.Length == 0)
{
ParamList.Append(FieldParam);
}
else
{
ParamList.Append(", " + FieldParam);
}
if (FieldParam == "?" || FieldParam.Substring(0, 1) == "@")
{
System.Data.IDbDataParameter Param = Lfx.Data.DataBaseCache.DefaultCache.Provider.GetParameter();
Param.ParameterName = ParamName;
if (ThisField.Value is NullableDateTime && ThisField.Value != null)
{
Param.Value = ((NullableDateTime)(ThisField.Value)).Value;
}
else
{
Param.Value = ThisField.Value;
}
if (ThisField.DataType == Lazaro.Orm.ColumnTypes.Blob)
{
Param.DbType = System.Data.DbType.Binary;
}
if (Lfx.Data.DataBaseCache.DefaultCache.Provider is OdbcDriver && ThisField.DataType == Lazaro.Orm.ColumnTypes.Blob)
{
((System.Data.Odbc.OdbcParameter)Param).OdbcType = System.Data.Odbc.OdbcType.VarBinary;
}
baseCommand.Parameters.Add(Param);
}
}
if (CmdNum > 1)
{
CmdText.AppendLine(",");
}
CmdText.Append(@"(" + ParamList.ToString() + ")");
CmdNum++;
}
baseCommand.CommandText = CmdText.ToString();
}
public System.Data.IDbCommand SetupDbCommand(Update updateCommand, IConnection connection)
{
var FieldList = new System.Text.StringBuilder();
var DbCommand = connection.DbConnection.CreateCommand();
foreach (IColumnValue Fld in updateCommand.ColumnValues)
{
string FieldParam;
if (Fld.Value is qGen.SqlFunctions)
{
switch (((qGen.SqlFunctions)(Fld.Value)))
{
case SqlFunctions.Now:
FieldParam = "NOW()";
break;
default:
throw new NotImplementedException();
}
}
else if (Fld.Value is qGen.SqlExpression)
{
FieldParam = Fld.Value.ToString();
}
else
{
if (connection.DbConnection is System.Data.Odbc.OdbcConnection)
{
FieldParam = "?";
}
else
{
FieldParam = "@" + Fld.ColumnName;
}
}
if (FieldList.Length == 0)
{
FieldList.Append(@"""" + Fld.ColumnName + @"""=" + FieldParam);
}
else
{
FieldList.Append(@", """ + Fld.ColumnName + @"""=" + FieldParam);
}
if (FieldParam == "?" || FieldParam.Substring(0, 1) == "@")
{
System.Data.IDbDataParameter Param = connection.Factory.Driver.GetParameter();
Param.ParameterName = "@" + Fld.ColumnName;
if (Fld.Value is DbDateTime && Fld.Value != null)
{
Param.Value = ((DbDateTime)(Fld.Value)).Value;
}
else if (Fld.Value != null && Fld.Value.GetType().IsEnum)
{
Param.Value = System.Convert.ToInt32(Fld.Value);
}
else
{
Param.Value = Fld.Value;
}
if (Fld.DataType == Lazaro.Orm.ColumnTypes.Blob)
{
Param.DbType = System.Data.DbType.Binary;
}
// FIXME: no debería hacer una excepción para OdbcDriver
if (connection.Factory.Driver is OdbcDriver && Fld.DataType == Lazaro.Orm.ColumnTypes.Blob)
{
((System.Data.Odbc.OdbcParameter)Param).OdbcType = System.Data.Odbc.OdbcType.VarBinary;
}
DbCommand.Parameters.Add(Param);
}
}
DbCommand.CommandText = @"UPDATE """ + string.Join <string>(",", updateCommand.Tables) + @""" SET " + FieldList.ToString() + " WHERE " + this.SqlText(updateCommand.WhereClause);
return(DbCommand);
}
public void SetFieldState(int x, int y, FieldParam param, bool state)
{
_field[x, y].SetFieldState(param, state);
OnChangeField.Invoke();
}