/// <summary>
/// Prepare and Open runtime cursor
/// </summary>
/// <param name="runtimeCursor"></param>
private void PrepareAndOpenCursor(RuntimeCursor runtimeCursor, bool openTransaction)
{
GatewayResult result = null;
runtimeCursor.CursorDefinition.StartPosition = new DbPos(true);
runtimeCursor.CursorDefinition.CurrentPosition = new DbPos(true);
result = GatewayCommandsFactory.CreateCursorPrepareCommand(runtimeCursor, ClientManager.Instance.LocalManager).Execute();
if (result.Success)
{
if (openTransaction)
{
result = GatewayCommandsFactory.CreateGatewayCommandOpenTransaction(ClientManager.Instance.LocalManager).Execute();
}
if (result.Success)
{
result = GatewayCommandsFactory.CreateCursorOpenCommand(runtimeCursor, ClientManager.Instance.LocalManager).Execute();
}
}
if (!result.Success)
{
throw new DataSourceConversionFailedException(runtimeCursor.CursorDefinition.DataSourceDefinition.Name, result.ErrorDescription);
}
}
/// <summary>
/// Execute DbDisconnect command.
/// </summary>
/// <returns></returns>
internal override GatewayResult Execute()
{
GatewayResult result = new GatewayResult();
try
{
if (DbDefinition != null)
{
DatabaseDefinition dbDefinition = (DatabaseDefinition)DbDefinition.Clone();
UpdateDataBaseLocation(dbDefinition);
result.ErrorCode = GatewayAdapter.Gateway.DbDisconnect(dbDefinition.Location, out tableName);
}
else
{
result.ErrorCode = GatewayErrorCode.DatasourceNotExist;
}
}
catch
{
throw new NotImplementedException();
}
SetErrorDetails(result);
return(result);
}
/// <summary>
/// NOT IMLEMENTED !!!
/// </summary>
/// <returns></returns>
internal override ReturnResultBase Execute()
{
GatewayResult result = new GatewayResult();
//TODO: Implement
return(result);
}
internal override ReturnResultBase Execute()
{
List <IDataSourceViewDefinition> dataControlsSourceDefs = DataSourceDefinitionsBuilder.BuildDataControlSourceDefinitions(Task);
GatewayResult result = LocalDataviewManager.CreateDataControlViews(dataControlsSourceDefs);
return(result);
}
/// <summary>
/// fetch-and-compute loop
/// </summary>
/// <returns></returns>
private bool FindMatchingRecord()
{
bool recordFound = false;
if (!StartPosition.IsZero)
{
GatewayResult result = TaskViews.OpenCursors(Reverse, StartPosition);
if (result.Success)
{
IRecord record;
// Looking for one record only
do
{
record = GetBasicRecord();
if (record != null && RecordComputer.Compute(record, true, false, false).Success)
{
recordFound = true;
break;
}
} while (record != null);
}
TaskViews.CloseMainCursor();
}
return(recordFound);
}
internal override GatewayResult Execute()
{
Record();
GatewayResult result = new GatewayResult();
GatewayAdapterCursor gatewayAdapterCursor = GatewayAdapter.GetCursor(RuntimeCursor);
Debug.Assert(gatewayAdapterCursor != null);
// clear old ranges - might contain old locates.
gatewayAdapterCursor.Ranges.Clear();
// TODO 1:
// fm_crsr_cache_open ???
// Copy ranges from runtime to gateway
if (RuntimeCursor.RuntimeCursorData.Ranges != null)
{
foreach (RangeData runtimeRange in RuntimeCursor.RuntimeCursorData.Ranges)
{
RangeData gatewayRange = new RangeData(runtimeRange);
RangeConvert(gatewayRange, runtimeRange, gatewayAdapterCursor);
gatewayAdapterCursor.Ranges.Add(gatewayRange);
}
}
// TODO 2:
// fm_copy_sql_ranges
result.ErrorCode = GatewayAdapter.Gateway.CrsrOpen(gatewayAdapterCursor);
SetErrorDetails(result);
return(result);
}
/// <summary>
/// Execute SQL command.
/// </summary>
/// <returns></returns>
internal override GatewayResult Execute()
{
GatewayResult result = new GatewayResult();
try
{
if (DbDefinition != null)
{
DatabaseDefinition dbDefinition = (DatabaseDefinition)DbDefinition.Clone();
UpdateDataBaseLocation(dbDefinition);
result.ErrorCode = GatewayAdapter.Gateway.SQLExecute(dbDefinition, sqlStatement, storageAttributes, out statementReturnedValues, ref dbFields);
for (int i = 0; i < statementReturnedValues.Length; i++)
{
if (statementReturnedValues[i] != null)
{
statementReturnedValues[i] = GatewayAdapter.StorageConvertor.ConvertGatewayToRuntimeField(dbFields[i], statementReturnedValues[i]);
}
}
}
else
{
result.ErrorCode = GatewayErrorCode.DatasourceNotExist;
}
}
catch
{
throw new NotImplementedException();
}
SetErrorDetails(result);
return(result);
}
/// <summary>
/// update end of view
/// </summary>
/// <param name="result"></param>
void UpdateViewEnd(GatewayResult result)
{
if (result.ErrorCode == GatewayErrorCode.NoRecord && !TaskViews.ViewMain.IgnorePositionCache)
{
PositionCache.UpdateEnd(Reverse);
}
}
/// <summary>
/// activate on record's delete
/// </summary>
/// <param name="record"></param>
/// <returns></returns>
protected override GatewayResult OnDelete(IRecord record)
{
GatewayResult result = new GatewayResult();
ClearRecord(record);
return(result);
}
/// <summary>
/// open transaction
/// if there is no transaction opened already then
/// open and save it info on ClientManager.Instance.CurrentLocalTransactionOpened
/// else
/// if (transaction that was opend is in my parent task)
/// OK
/// else
/// failed !!!
///
/// </summary>
internal override ReturnResultBase Execute()
{
ReturnResultBase returnResultBase = new GatewayResult();
Transaction transaction = DataviewManager.Transaction.OwnerTask.DataviewManager.LocalDataviewManager.Transaction;
if (!transaction.isOpened())
{
// need to open in the gateway only if no opend before
if (TaskTransactionManager.LocalOpenedTransactionsCount == 0)
{
returnResultBase = GatewayCommandsFactory.CreateGatewayCommandOpenTransaction(LocalManager).Execute();
}
if (returnResultBase.Success)
{
transaction.Opened = true;
TaskTransactionManager.LocalOpenedTransactionsCount++;
//transaction.OwnerTask.TaskTransactionManager.SetCurrentOpenTransactionAsLocalTransaction();
//Debug.WriteLine("Open Transaction on task--> " + LocalDataviewManager.CurrentOpenTransaction.OwnerTask);
}
//else
//{
// // check if the open transaction is in the parent task
// if (!transaction.OwnerTask.isDescendentOf(LocalDataviewManager.CurrentOpenTransaction.OwnerTask))
// returnResultBase = new ReturnResult(MsgInterface.FMERROR_STR_TRANS_OPEN_FAILED);
//}
}
return(returnResultBase);
}
/// <summary>
/// open local tables
/// </summary>
/// <returns></returns>
private GatewayResult OpenTables()
{
GatewayResult retVal = new GatewayResult();
foreach (DataSourceReference dataSourceRef in Task.DataSourceReferences)
{
if (dataSourceRef.IsLocal)
{
String fileName;
if (dataSourceRef.NameExpression > 0)
{
Task.EvaluateExpressionAsUnicode(dataSourceRef.NameExpression, out fileName);
}
else
{
fileName = dataSourceRef.DataSourceDefinition.Name;
}
//create gw open command
GatewayCommandFileOpen fileOpenCommand = GatewayCommandsFactory.CreateFileOpenCommand(fileName, dataSourceRef.DataSourceDefinition,
dataSourceRef.Access, ClientManager.Instance.LocalManager);
retVal = fileOpenCommand.Execute();
if (!retVal.Success)
{
break;
}
}
}
return(retVal);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
internal override GatewayResult Execute()
{
GatewayResult gatewayResult = new GatewayResult();
// must set the DatabaseType, the getter of property GatewayAdapter is used it.
this.DatabaseType = GatewaysManager.DATA_SOURCE_DATATYPE_LOCAL;
//check if TransactionWasOpned
if (GatewayAdapter.TransactionWasOpned)
{
Record();
// call the gateway command
gatewayResult.ErrorCode = GatewayAdapter.Gateway.Trans((int)TransactionModes);
SetErrorDetails(gatewayResult);
// reset the static member
if (gatewayResult.Success)
{
GatewayAdapter.TransactionWasOpned = false;
}
}
return(gatewayResult);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
internal override ReturnResultBase Execute()
{
GatewayResult gatewayResult = new GatewayResult();
Transaction transaction = DataviewManager.Transaction.OwnerTask.DataviewManager.LocalDataviewManager.Transaction;
// closeclose the transaction only if there is transaction that open
if (TaskTransactionManager.LocalOpenedTransactionsCount > 0)
{
gatewayResult = CloseTransactionInGateway();
if (gatewayResult.Success)
{
//Debug.WriteLine("Commit Transaction on task--> " + LocalDataviewManager.CurrentOpenTransaction.OwnerTask);
transaction.Opened = false;
TaskTransactionManager.LocalOpenedTransactionsCount--;
// there is tasks that in local transaction, we must open the transaction again
if (TaskTransactionManager.LocalOpenedTransactionsCount > 0)
{
gatewayResult = GatewayCommandsFactory.CreateGatewayCommandOpenTransaction(LocalManager).Execute();
}
}
else
{
gatewayResult.ErrorCode = GatewayErrorCode.TransactionCommit;
}
}
return(gatewayResult);
}
/// <summary>
/// Convert DataSource from old DataSourceDefinition to new DataSourceDefinition. It create temporaryDataSource definition and perform all operations
/// on temporary DataSourcedefinition and return it.
/// </summary>
/// <param name="fromDataSourceDefinition"></param>
/// <param name="toDataSourceDefinition"></param>
/// <returns>Temporary DataSourceDefinition</returns>
private DataSourceDefinition ConvertDataSource(DataSourceDefinition fromDataSourceDefinition, DataSourceDefinition toDataSourceDefinition)
{
Logger.Instance.WriteSupportToLog("convertDataSource():>>>> ", true);
Logger.Instance.WriteSupportToLog(String.Format("convertDataSource(): converting table {0}", fromDataSourceDefinition.Name), true);
GatewayResult result = null;
string temporaryTableName = GetTemporaryTableName(fromDataSourceDefinition.Id);
DataSourceDefinition temporaryDataSourceDefinition = (DataSourceDefinition)toDataSourceDefinition.Clone();
temporaryDataSourceDefinition.Name = temporaryTableName;
// In order to genearte temporary key name for the temporary dbh set magic key mask on the keys.
for (int keyIndex = 0; keyIndex < temporaryDataSourceDefinition.Keys.Count; keyIndex++)
{
DBKey key = temporaryDataSourceDefinition.Keys[keyIndex];
key.SetMask(KeyMasks.MagicKeyMask);
}
// Delete temporary table, if exists
result = GatewayCommandsFactory.CreateFileDeleteCommand(temporaryTableName, temporaryDataSourceDefinition, ClientManager.Instance.LocalManager).Execute();
if (!result.Success && result.ErrorCode != GatewayErrorCode.FileNotExist)
{
throw new DataSourceConversionFailedException(fromDataSourceDefinition.Name, result.ErrorDescription);
}
// Open source and temporary table
temporaryDataSourceDefinition.SetMask(DbhMask.CheckExistMask);
result = GatewayCommandsFactory.CreateFileOpenCommand(temporaryTableName, temporaryDataSourceDefinition, Access.Write, ClientManager.Instance.LocalManager).Execute();
if (result.Success)
{
result = GatewayCommandsFactory.CreateFileOpenCommand(fromDataSourceDefinition.Name, fromDataSourceDefinition, Access.Read, ClientManager.Instance.LocalManager).Execute();
}
if (!result.Success)
{
throw new DataSourceConversionFailedException(fromDataSourceDefinition.Name, result.ErrorDescription);
}
//Convert values of source table and insert it into temporary table
ConvertAndInsertValues(fromDataSourceDefinition, temporaryDataSourceDefinition);
//Close source and temporary table
result = GatewayCommandsFactory.CreateFileCloseCommand(temporaryDataSourceDefinition, ClientManager.Instance.LocalManager).Execute();
if (result.Success)
{
GatewayCommandsFactory.CreateFileCloseCommand(fromDataSourceDefinition, ClientManager.Instance.LocalManager).Execute();
}
if (!result.Success)
{
throw new DataSourceConversionFailedException(fromDataSourceDefinition.Name, result.ErrorDescription);
}
Logger.Instance.WriteSupportToLog("convertDataSource():<<<< ", true);
return(temporaryDataSourceDefinition);
}
/// <summary>
/// Checks if correspondng table of data source is exist at backend
/// </summary>
/// <param name="dataSourceDefinition"></param>
/// <returns>returns true if table exists</returns>
private bool IsTableExist(DataSourceDefinition dataSourceDefinition)
{
GatewayCommandFileExist fileExistCommand = GatewayCommandsFactory.CreateFileExistCommand(dataSourceDefinition.Name, dataSourceDefinition,
ClientManager.Instance.LocalManager);
GatewayResult result = fileExistCommand.Execute();
return(result.Success);
}
internal override ReturnResultBase Execute()
{
GatewayResult result = new GatewayResult();
RecordComputer recordComputer = TaskViews.RecordComputer;
recordComputer.RecomputeUnit(UnitId, Record);
return(result);
}
/// <summary>
/// Execute DbDisConnect gateway command.
/// </summary>
/// <returns></returns>
internal override ReturnResultBase Execute()
{
GatewayResult result = new GatewayResult();
GatewayCommandDbDisconnect dbDisconnectCommand = GatewayCommandsFactory.CreateGatewayCommandDbDisconnect(LocalDataviewManager.LocalManager, dataBaseName);
result = dbDisconnectCommand.Execute();
return(result);
}
protected override void SetErrorDetails(GatewayResult result)
{
base.SetErrorDetails(result);
if (result.ErrorCode == GatewayErrorCode.DatasourceOpen)
{
result.ErrorParams[0] = ", data source: " + tableName;
}
}
protected override void SetErrorDetails(GatewayResult result)
{
base.SetErrorDetails(result);
if (!result.Success)
{
result.ErrorParams[0] = FileName;
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private GatewayResult RollbaclTransactionInGateway()
{
GatewayCommandBase TransactionCommand = new GatewayCommandCloseTransaction(TransactionModes.Abort);
TransactionCommand.LocalManager = LocalManager;
GatewayResult gatewayResult = TransactionCommand.Execute();
return(gatewayResult);
}
/// <summary>
/// update all links
/// </summary>
/// <param name="record"></param>
/// <returns></returns>
private GatewayResult UpdateLinks(IRecord record)
{
GatewayResult result = new GatewayResult();
for (int i = 0; i < LinkViews.Count && result.Success; i++)
{
result = LinkViews[i].ModifyRecord(record);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private GatewayResult CloseTransactionInGateway()
{
GatewayCommandBase transactionCommand = new GatewayCommandCloseTransaction(TransactionModes);
transactionCommand.LocalManager = LocalManager;
GatewayResult gatewayResult = transactionCommand.Execute();
return(gatewayResult);
}
/// <summary>
/// Execute SQL command
/// </summary>
/// <returns></returns>
internal override ReturnResultBase Execute()
{
GatewayResult result = new GatewayResult();
GatewayCommandSQLExecute gatewaySqlExecuteCommand = GatewayCommandsFactory.CreateGatewayCommandSQLExecute(LocalDataviewManager.LocalManager,
dataBaseName, sqlStatement, storageAttributes, sqlExecuteCommand.DbFields);
result = gatewaySqlExecuteCommand.Execute();
sqlExecuteCommand.statementReturnedValues = gatewaySqlExecuteCommand.statementReturnedValues;
return(result);
}
internal override GatewayResult Fetch(IRecord record)
{
GatewayResult result = base.Fetch(record);
if (result.Success && !IgnorePositionCache)
{
PositionCache.Set(GetPositionId(record), CurrentPosition);
}
return(result);
}
/// <summary>
/// check the transaction validation, if there is no transaction opend and use updated
/// filed from the data source ,a GatewayResult error will be return
/// </summary>
/// <returns></returns>
private GatewayResult CheckTransactionValidation()
{
GatewayResult gatewayResult = new GatewayResult();
if (!TaskTransactionManager.IsLocalTransactionOpned)
{
gatewayResult.ErrorCode = GatewayErrorCode.ModifyWithinTransaction;
gatewayResult.ErrorParams = new string[] { DataSourceViewDefinition.TaskDataSource.DataSourceDefinition.Name, "" };
}
return(gatewayResult);
}
/// <summary>
/// check if the flag set
/// </summary>
/// <param name="cursorProperties"></param>
/// <returns></returns>
protected GatewayResult CheckIsFlagSet(CursorProperties cursorProperties)
{
GatewayResult gatewayResult = new GatewayResult();
if (!RuntimeCursor.CursorDefinition.IsFlagSet(cursorProperties))
{
gatewayResult.ErrorCode = GatewayErrorCode.ReadOnly;
gatewayResult.ErrorParams = new string[] { RuntimeCursor.CursorDefinition.DataSourceDefinition.Name, "" };
}
return(gatewayResult);
}
/// <summary>
/// override - always get a new record, and no need to refresh the position cache
/// </summary>
/// <returns></returns>
protected override IRecord GetBasicRecord()
{
IRecord record = DataviewSynchronizer.GetRecord(false);
GatewayResult result = TaskViews.GetPrimaryView().Fetch(record);
if (!result.Success)
{
DataviewSynchronizer.RemoveRecord(record);
record = null;
}
return(record);
}
internal override ReturnResultBase Execute()
{
GatewayResult result = new GatewayResult();
TaskViews.RecordComputer.Compute(Record, false, false, true);
if (refreshSubforms)
{
Task.RefreshSubforms();
}
return(result);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
internal override ReturnResultBase Execute()
{
GatewayResult result = new GatewayResult();
if (!TaskViews.Task.isAborting() && TaskViews.ApplySort(Sorts))
{
localDataViewCommandViewRefresh.DataviewManager = DataviewManager;
localDataViewCommandViewRefresh.LocalManager = LocalManager;
localDataViewCommandViewRefresh.Execute();
}
return(result);
}
internal override GatewayResult Execute()
{
GatewayResult result = new GatewayResult();
DatabaseDefinition dbDefinition = (DatabaseDefinition)DbDefinition.Clone();
UpdateDataBaseLocation(dbDefinition);
result.ErrorCode = GatewayAdapter.Gateway.FileRename(DataSourceDefinition, DestinationDataSourceDefinition, dbDefinition);
SetErrorDetails(result);
return(result);
}
