private string GetUPDATEString(string sKey, TaskResultDataToUpdate oTast)
{
List <string> aValues = new List <string>();
TaskResultDataToUpdateToArray(aValues, oTast, true);
return(string.Format("UPDATE tast_result SET {0} WHERE tr_key='{1}';", string.Join(",", aValues.ToArray()), Utils.MySqlEscape(sKey, m_sConnectionString)));
}
public void Update(TaskResultDataToUpdate oUpdate)
{
if (oUpdate != null)
{
if (oUpdate.eStatus != null)
{
this.eStatus = (FileStatus)oUpdate.eStatus;
}
if (oUpdate.oLastOpenDate.HasValue)
{
this.oLastOpenDate = oUpdate.oLastOpenDate.Value;
}
if (oUpdate.nStatusInfo != null)
{
this.nStatusInfo = (int)oUpdate.nStatusInfo;
}
if (oUpdate.sFormat != null)
{
this.sFormat = oUpdate.sFormat;
}
if (oUpdate.sTitle != null)
{
this.sTitle = oUpdate.sTitle;
}
}
}
public void UpdateIfBegin(string sKey, TaskResultDataToUpdate oMask, TaskResultDataToUpdate oTast, AsyncCallback fCallback, object oParam)
{
m_oUpdateIf = UpdateIf;
bool bUpdate;
m_oUpdateIf.BeginInvoke(sKey, oMask, oTast, out bUpdate, fCallback, oParam);
}
public ErrorTypes UpdateIf(string sKey, TaskResultDataToUpdate oMask, TaskResultDataToUpdate oTast, out bool bUpdate)
{
ErrorTypes eErrorTypes = ErrorTypes.NoError;
bUpdate = false;
try
{
using (IDbConnection sqlCon = GetDbConnection())
{
sqlCon.Open();
using (IDbCommand oSelCommand = sqlCon.CreateCommand())
{
oSelCommand.CommandText = GetUPDATEIFString(sKey, oMask, oTast);
if (oSelCommand.ExecuteNonQuery() > 0)
{
bUpdate = true;
}
}
}
}
catch
{
eErrorTypes = ErrorTypes.TaskResult;
}
return(eErrorTypes);
}
private ErrorTypes UpdateInMC(string sKey, TaskResultDataToUpdate oTast)
{
ErrorTypes oError = ErrorTypes.NoError;
try
{
TaskResultData oTask = null;
ulong cas = 0;
GetFromMCWithCas(sKey, out oTask, out cas);
if (oTask == null)
{
m_oTaskResultDB.Get(sKey, out oTask);
}
if (oTask != null && oTask.eStatus != FileStatus.Ok)
{
oTask.Update(oTast);
AddToMCWithCas(sKey, oTask, cas);
if (oTask.eStatus != FileStatus.Convert)
{
oError = m_oTaskResultDB.Update(sKey, oTast);
}
}
}
catch
{
oError = ErrorTypes.TaskResult;
}
return(oError);
}
public bool IsValidMask(TaskResultDataToUpdate oMask)
{
bool bRes = true;
if (oMask != null)
{
if (oMask.eStatus != null)
{
bRes = bRes && (this.eStatus == oMask.eStatus.Value);
}
if (oMask.oLastOpenDate != null)
{
bRes = bRes && (this.oLastOpenDate == oMask.oLastOpenDate.Value);
}
if (oMask.nStatusInfo != null)
{
bRes = bRes && (this.nStatusInfo == oMask.nStatusInfo.Value);
}
if (oMask.sFormat != null)
{
bRes = bRes && (this.sFormat == oMask.sFormat);
}
if (oMask.sTitle != null)
{
bRes = bRes && (this.sTitle == oMask.sTitle);
}
}
return(bRes);
}
public ErrorTypes UpdateIf(string sKey, TaskResultDataToUpdate oMask, TaskResultDataToUpdate oTast, out bool bUpdate)
{
ErrorTypes oError = ErrorTypes.NoError;
UpdateIfInMC(sKey, oTast, oMask, out bUpdate);
return(oError);
}
public ErrorTypes Update(string sKey, TaskResultDataToUpdate oTast)
{
ErrorTypes oError = ErrorTypes.NoError;
UpdateInMC(sKey, oTast);
return(oError);
}
public ErrorTypes Update(string sKey, TaskResultDataToUpdate oTast)
{
ErrorTypes oError = ErrorTypes.NoError;
bool bUpdate;
UpdateIfInMC(sKey, oTast, null, out bUpdate);
return(oError);
}
private string GetUPDATEIFString(string sKey, TaskResultDataToUpdate oMask, TaskResultDataToUpdate oTast)
{
List <string> aValues = new List <string>();
TaskResultDataToUpdateToArray(aValues, oTast, true);
List <string> aWheres = new List <string>();
aWheres.Add("tr_key='" + Utils.MySqlEscape(sKey, m_sConnectionString) + "'");
TaskResultDataToUpdateToArray(aWheres, oMask, false);
return(string.Format("UPDATE tast_result SET {0} WHERE {1};", string.Join(",", aValues.ToArray()), string.Join(" AND ", aWheres.ToArray())));
}
public void Update(TaskResultDataToUpdate oUpdate)
{
if (oUpdate != null)
{
if (oUpdate.eStatus != null)
this.eStatus = (FileStatus)oUpdate.eStatus;
if (oUpdate.oLastOpenDate.HasValue)
this.oLastOpenDate = oUpdate.oLastOpenDate.Value;
if (oUpdate.nStatusInfo != null)
this.nStatusInfo = (int)oUpdate.nStatusInfo;
if (oUpdate.sFormat != null)
this.sFormat = oUpdate.sFormat;
if (oUpdate.sTitle != null)
this.sTitle = oUpdate.sTitle;
}
}
private void GetOrCreateCallback(IAsyncResult ar)
{
try
{
bool bExist = false;
try
{
m_oGetOrCreate.m_delegateNonQuery.EndInvoke(ar);
}
catch
{
bExist = true;
}
if (bExist)
{
m_oGetOrCreate.m_bCreate = false;
if (null != m_oGetOrCreate.m_oCommand)
{
m_oGetOrCreate.m_oCommand.Dispose();
m_oGetOrCreate.m_oCommand = null;
}
IDbCommand oSelCommand = m_oGetOrCreate.m_oSqlCon.CreateCommand();
TaskResultDataToUpdate oToUpdate = new TaskResultDataToUpdate();
oToUpdate.oLastOpenDate = DateTime.UtcNow;
oSelCommand.CommandText = GetUPDATEString(m_oGetOrCreate.m_oTast.sKey, oToUpdate) + GetSELECTString(m_oGetOrCreate.m_oTast.sKey);
m_oGetOrCreate.m_oCommand = oSelCommand;
m_oGetOrCreate.m_delegateReader = new ExecuteReader(oSelCommand.ExecuteReader);
m_oGetOrCreate.m_delegateReader.BeginInvoke(m_oGetOrCreate.m_fCallback, m_oGetOrCreate.m_oParam);
}
else
{
m_oGetOrCreate.m_bCreate = true;
m_oGetOrCreate.m_delegateReader = null;
m_oGetOrCreate.FireCallback();
}
}
catch
{
m_oGetOrCreate.DisposeAndCallback();
}
}
public ErrorTypes Update(string sKey, TaskResultDataToUpdate oTast)
{
ErrorTypes eErrorTypes = ErrorTypes.NoError;
try
{
using (IDbConnection sqlCon = GetDbConnection())
{
sqlCon.Open();
using (IDbCommand oSelCommand = sqlCon.CreateCommand())
{
oSelCommand.CommandText = GetUPDATEString(sKey, oTast);
oSelCommand.ExecuteNonQuery();
}
}
}
catch
{
eErrorTypes = ErrorTypes.TaskResult;
}
return(eErrorTypes);
}
private void TaskResultDataToUpdateToArray(List <string> aValues, TaskResultDataToUpdate oTask, bool bUpdateTime)
{
if (false == string.IsNullOrEmpty(oTask.sFormat))
{
aValues.Add("tr_format='" + Utils.MySqlEscape(oTask.sFormat, m_sConnectionString) + "'");
}
if (oTask.eStatus.HasValue)
{
aValues.Add("tr_status='" + oTask.eStatus.Value.ToString("d") + "'");
}
if (oTask.nStatusInfo.HasValue)
{
aValues.Add("tr_status_info='" + oTask.nStatusInfo.Value.ToString() + "'");
}
if (bUpdateTime)
{
aValues.Add("tr_last_open_date='" + DateTime.UtcNow.ToString(Constants.mc_sDateTimeFormat) + "'");
}
if (false == string.IsNullOrEmpty(oTask.sTitle))
{
aValues.Add("tr_title='" + Utils.MySqlEscape(oTask.sTitle, m_sConnectionString) + "'");
}
}
private string GetUPDATEString(string sKey, TaskResultDataToUpdate oTast)
{
List <string> aValues = new List <string>();
if (false == string.IsNullOrEmpty(oTast.sFormat))
{
aValues.Add("tr_format='" + oTast.sFormat + "'");
}
if (oTast.eStatus.HasValue)
{
aValues.Add("tr_status='" + oTast.eStatus.Value.ToString("d") + "'");
}
if (oTast.nStatusInfo.HasValue)
{
aValues.Add("tr_status_info='" + oTast.nStatusInfo.Value.ToString() + "'");
}
aValues.Add("tr_last_open_date='" + DateTime.UtcNow.ToString(Constants.mc_sDateTimeFormat) + "'");
if (false == string.IsNullOrEmpty(oTast.sTitle))
{
aValues.Add("tr_title='" + Utils.MySqlEscape(oTast.sTitle, m_sConnectionString) + "'");
}
return(string.Format("UPDATE tast_result SET {0} WHERE tr_key='{1}';", string.Join(",", aValues.ToArray()), sKey));
}
private void TaskResultGetCallback2(IAsyncResult ar)
{
TransportClassSaveChanges1 oTransportClassSaveChanges = ar.AsyncState as TransportClassSaveChanges1;
try
{
InputCommand cmd = oTransportClassSaveChanges.m_oInputCommand;
_log.DebugFormat("Enter TaskResultGetCallback2(id={0})", cmd.id);
TaskResultData oTaskResultData;
ErrorTypes eError = oTransportClassSaveChanges.m_oTaskResult.GetEnd(ar, out oTaskResultData);
if (ErrorTypes.NoError == eError)
{
if (oTaskResultData.oLastOpenDate < DateTime.UtcNow.AddMilliseconds( - Convert.ToInt32(cmd.data)))
{
TaskResultDataToUpdate oTaskResultDataToUpdate = new TaskResultDataToUpdate();
oTaskResultDataToUpdate.eStatus = FileStatus.SaveVersion;
oTaskResultDataToUpdate.nStatusInfo = Convert.ToInt32(DateTime.UtcNow.TimeOfDay.TotalMilliseconds);
oTransportClassSaveChanges.m_oTaskResultDataToUpdate = oTaskResultDataToUpdate;
oTransportClassSaveChanges.m_oTaskResult.UpdateBegin(cmd.id, oTaskResultDataToUpdate, TaskResultUpdateCallback2, oTransportClassSaveChanges);
}
else
{
_log.DebugFormat("oTaskResultData.oLastOpenDate < DateTime.UtcNow.AddMilliseconds(id={0})", cmd.id);
WriteOutputCommand(oTransportClassSaveChanges, m_oSfcOk);
}
}
else
{
_log.ErrorFormat("Error in TaskResultGetCallback2(code={0})", (int)eError);
WriteOutputCommand(oTransportClassSaveChanges, new OutputCommand(eError));
}
}
catch (Exception e)
{
_log.Error("Exception catched in TaskResultGetCallback2:", e);
WriteOutputCommand(oTransportClassSaveChanges, new OutputCommand(ErrorTypes.Unknown));
}
}
public ErrorTypes Update(string sKey, TaskResultDataToUpdate oTast)
{
ErrorTypes oError = ErrorTypes.NoError;
UpdateInMC(sKey, oTast);
return oError;
}
private void TaskResultGetProcess(TaskResultData oTaskInfo, bool bDataCreate, InputCommand cmd, TransportClassMainAshx oTransportClassMainAshx)
{
switch (oTaskInfo.eStatus)
{
case FileStatus.Ok:
{
string sAffiliateId = null;
Signature.getVKeyStringParam(cmd.vkey, ConfigurationSettings.AppSettings["keyKeyID"], out sAffiliateId);
if (null != sAffiliateId)
{
string sTag = null;
switch (cmd.editorid)
{
case (int)LicenseInfo.EditorType.Spreadsheet: sTag = "open_sheet"; break;
case (int)LicenseInfo.EditorType.Presentation: sTag = "open_presentation"; break;
default: sTag = "open_word"; break;
}
FileConverterUtils2.FileStatistic oFileStat = new FileStatistic();
oFileStat.insert(sAffiliateId, cmd.id, DateTime.UtcNow, sTag);
}
ITaskResultInterface oTaskResult = TaskResult.NewTaskResult();
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(
oTransportClassMainAshx, cmd, oTaskResult);
string sOutputCommand = ("create" == cmd.c)? "create": "open";
WriteOutputCommand(oTransportClassTaskResult,
new OutputCommand(sOutputCommand, cmd.id + "/Editor.bin"));
}
break;
case FileStatus.Convert:
case FileStatus.WaitQueue:
{
if (bDataCreate)
{
AddTask(cmd, oTransportClassMainAshx);
}
else
{
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand("waitopen", oTaskInfo.nStatusInfo.ToString()));
}
}
break;
case FileStatus.None:
{
if (bDataCreate)
{
TaskResultDataToUpdate oToUpdate = new TaskResultDataToUpdate();
oToUpdate.eStatus = FileStatus.WaitQueue;
ITaskResultInterface oTaskResult = TaskResult.NewTaskResult();
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassMainAshx, cmd, oTaskResult);
oTaskResult.UpdateBegin(cmd.id, oToUpdate, TaskResultUpdateCallback, oTransportClassTaskResult);
}
else
{
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand("waitopen", oTaskInfo.nStatusInfo.ToString()));
}
}
break;
case FileStatus.NeedParams:
string sUrl = Constants.mc_sResourceServiceUrlRel + HttpUtility.UrlEncode(cmd.id + "/settings.json");
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand("needparams", sUrl));
break;
case FileStatus.ErrToReload:
{
AsyncClearCacheOperation oAsyncClearCacheOperation = new AsyncClearCacheOperation();
TransportClassClearCache oTempTransportClassClearCache = new TransportClassClearCache(oTransportClassMainAshx, cmd, oAsyncClearCacheOperation, oTaskInfo.nStatusInfo);
oAsyncClearCacheOperation.ClearCacheBegin(cmd.id, TaskResultRemoveCallback2, oTempTransportClassClearCache);
}
break;
case FileStatus.Err:
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand((ErrorTypes)oTaskInfo.nStatusInfo));
break;
case FileStatus.SaveVersion:
{
if (cmd.viewmode)
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand("updateversion", cmd.id + "/Editor.bin"));
else
{
ITaskResultInterface oTaskResult = TaskResult.NewTaskResult();
TaskResultDataToUpdate oTask = new TaskResultDataToUpdate();
oTask.eStatus = FileStatus.Ok;
TaskResultDataToUpdate oMask = new TaskResultDataToUpdate();
oMask.eStatus = FileStatus.SaveVersion;
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassMainAshx, cmd, oTaskResult);
oTaskResult.UpdateIfBegin(cmd.id, oMask, oTask, TaskResultUpdateIfCallback2, oTransportClassTaskResult);
}
}
break;
case FileStatus.UpdateVersion:
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand("updateversion", cmd.id + "/Editor.bin"));
break;
default:
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand(ErrorTypes.Unknown));
break;
}
}
public ErrorTypes GetOrCreate(string sKey, TaskResultData oDefaultTast, out TaskResultData oTaskResultData, out bool bCreate)
{
ErrorTypes eErrorTypes = ErrorTypes.TaskResult;
oTaskResultData = null;
bCreate = false;
try
{
using (IDbConnection sqlCon = GetDbConnection())
{
sqlCon.Open();
if (Constants.mc_sPostgreProvider == Utils.GetDbConnectionProviderName(m_sConnectionString))
{
using (IDbCommand oAddCommand = sqlCon.CreateCommand())
{
oAddCommand.CommandText = GetINSERTString(oDefaultTast);
bool bExist = false;
try
{
oAddCommand.ExecuteNonQuery();
}
catch
{
bExist = true;
}
if (bExist)
{
using (IDbCommand oSelCommand = sqlCon.CreateCommand())
{
TaskResultDataToUpdate oToUpdate = new TaskResultDataToUpdate();
oToUpdate.oLastOpenDate = DateTime.UtcNow;
oSelCommand.CommandText = GetUPDATEString(sKey, oToUpdate) + GetSELECTString(sKey);
using (IDataReader oReader = oSelCommand.ExecuteReader())
{
if (true == oReader.Read())
{
oTaskResultData = new TaskResultData();
TaskResultFromReader(oTaskResultData, oReader);
bCreate = false;
eErrorTypes = ErrorTypes.NoError;
}
}
}
}
else
{
oTaskResultData = oDefaultTast.Clone();
bCreate = true;
eErrorTypes = ErrorTypes.NoError;
}
}
}
else
{
using (IDbCommand oAddCommand = sqlCon.CreateCommand())
{
oAddCommand.CommandText = GetUPSERTString(oDefaultTast);
bool bExist = false;
try
{
int nNumRowsAffected = oAddCommand.ExecuteNonQuery();
oTaskResultData = oDefaultTast.Clone();
eErrorTypes = ErrorTypes.NoError;
bCreate = (nNumRowsAffected == 1);
bExist = (nNumRowsAffected > 1);
}
catch
{
bExist = true;
}
if (bExist)
{
using (IDbCommand oSelCommand = sqlCon.CreateCommand())
{
oSelCommand.CommandText = GetSELECTString(sKey);
using (IDataReader oReader = oSelCommand.ExecuteReader())
{
if (true == oReader.Read())
{
oTaskResultData = new TaskResultData();
TaskResultFromReader(oTaskResultData, oReader);
bCreate = false;
eErrorTypes = ErrorTypes.NoError;
}
}
}
}
}
}
}
}
catch
{
}
return eErrorTypes;
}
public void UpdateIfBegin(string sKey, TaskResultDataToUpdate oMask, TaskResultDataToUpdate oTast, AsyncCallback fCallback, object oParam)
{
m_oUpdateIf = UpdateIf;
bool bUpdate;
m_oUpdateIf.BeginInvoke(sKey, oMask, oTast, out bUpdate, fCallback, oParam);
}
public ErrorTypes Update(string sKey, TaskResultDataToUpdate oTast)
{
ErrorTypes oError = ErrorTypes.NoError;
bool bUpdate;
UpdateIfInMC(sKey, oTast, null, out bUpdate);
return oError;
}
public void UpdateIfBegin(string sKey, TaskResultDataToUpdate oMask, TaskResultDataToUpdate oTast, AsyncCallback fCallback, object oParam)
{
m_oTaskResultDB.UpdateIfBegin(sKey, oMask, oTast, fCallback, oParam);
}
public ErrorTypes Update(string sKey, TaskResultDataToUpdate oTast)
{
return(piTaskResult.Update(sKey, oTast));
}
public ErrorTypes Update(string sKey, TaskResultDataToUpdate oTast)
{
ErrorTypes eErrorTypes = ErrorTypes.NoError;
try
{
using (IDbConnection sqlCon = GetDbConnection())
{
sqlCon.Open();
using (IDbCommand oSelCommand = sqlCon.CreateCommand())
{
oSelCommand.CommandText = GetUPDATEString(sKey, oTast);
oSelCommand.ExecuteNonQuery();
}
}
}
catch
{
eErrorTypes = ErrorTypes.TaskResult;
}
return eErrorTypes;
}
public void UpdateBegin(string sKey, TaskResultDataToUpdate oTast, AsyncCallback fCallback, object oParam)
{
piTaskResult.UpdateBegin(sKey, oTast, fCallback, oParam);
}
public ErrorTypes UpdateIf(string sKey, TaskResultDataToUpdate oMask, TaskResultDataToUpdate oTast, out bool bUpdate)
{
ErrorTypes eErrorTypes = ErrorTypes.NoError;
bUpdate = false;
try
{
using (IDbConnection sqlCon = GetDbConnection())
{
sqlCon.Open();
using (IDbCommand oSelCommand = sqlCon.CreateCommand())
{
oSelCommand.CommandText = GetUPDATEIFString(sKey, oMask, oTast);
if (oSelCommand.ExecuteNonQuery() > 0)
bUpdate = true;
}
}
}
catch
{
eErrorTypes = ErrorTypes.TaskResult;
}
return eErrorTypes;
}
private string GetUPDATEIFString(string sKey, TaskResultDataToUpdate oMask, TaskResultDataToUpdate oTast)
{
List<string> aValues = new List<string>();
TaskResultDataToUpdateToArray(aValues, oTast, true);
List<string> aWheres = new List<string>();
aWheres.Add("tr_key='" + Utils.MySqlEscape(sKey, m_sConnectionString) + "'");
TaskResultDataToUpdateToArray(aWheres, oMask, false);
return string.Format("UPDATE tast_result SET {0} WHERE {1};", string.Join(",", aValues.ToArray()), string.Join(" AND ", aWheres.ToArray()));
}
public ErrorTypes GetOrCreate(string sKey, TaskResultData oDefaultTast, out TaskResultData oTaskResultData, out bool bCreate)
{
ErrorTypes eErrorTypes = ErrorTypes.TaskResult;
oTaskResultData = null;
bCreate = false;
try
{
using (IDbConnection sqlCon = GetDbConnection())
{
sqlCon.Open();
if (Constants.mc_sPostgreProvider == Utils.GetDbConnectionProviderName(m_sConnectionString))
{
using (IDbCommand oAddCommand = sqlCon.CreateCommand())
{
oAddCommand.CommandText = GetINSERTString(oDefaultTast);
bool bExist = false;
try
{
oAddCommand.ExecuteNonQuery();
}
catch
{
bExist = true;
}
if (bExist)
{
using (IDbCommand oSelCommand = sqlCon.CreateCommand())
{
TaskResultDataToUpdate oToUpdate = new TaskResultDataToUpdate();
oToUpdate.oLastOpenDate = DateTime.UtcNow;
oSelCommand.CommandText = GetUPDATEString(sKey, oToUpdate) + GetSELECTString(sKey);
using (IDataReader oReader = oSelCommand.ExecuteReader())
{
if (true == oReader.Read())
{
oTaskResultData = new TaskResultData();
TaskResultFromReader(oTaskResultData, oReader);
bCreate = false;
eErrorTypes = ErrorTypes.NoError;
}
}
}
}
else
{
oTaskResultData = oDefaultTast.Clone();
bCreate = true;
eErrorTypes = ErrorTypes.NoError;
}
}
}
else
{
using (IDbCommand oAddCommand = sqlCon.CreateCommand())
{
oAddCommand.CommandText = GetUPSERTString(oDefaultTast);
bool bExist = false;
try
{
int nNumRowsAffected = oAddCommand.ExecuteNonQuery();
oTaskResultData = oDefaultTast.Clone();
eErrorTypes = ErrorTypes.NoError;
bCreate = (nNumRowsAffected == 1);
bExist = (nNumRowsAffected > 1);
}
catch
{
bExist = true;
}
if (bExist)
{
using (IDbCommand oSelCommand = sqlCon.CreateCommand())
{
oSelCommand.CommandText = GetSELECTString(sKey);
using (IDataReader oReader = oSelCommand.ExecuteReader())
{
if (true == oReader.Read())
{
oTaskResultData = new TaskResultData();
TaskResultFromReader(oTaskResultData, oReader);
bCreate = false;
eErrorTypes = ErrorTypes.NoError;
}
}
}
}
}
}
}
}
catch
{
}
return(eErrorTypes);
}
private void TaskResultDataToUpdateToArray(List<string> aValues, TaskResultDataToUpdate oTask, bool bUpdateTime)
{
if (false == string.IsNullOrEmpty(oTask.sFormat))
aValues.Add("tr_format='" + Utils.MySqlEscape(oTask.sFormat, m_sConnectionString) + "'");
if (oTask.eStatus.HasValue)
aValues.Add("tr_status='" + oTask.eStatus.Value.ToString("d") + "'");
if (oTask.nStatusInfo.HasValue)
aValues.Add("tr_status_info='" + oTask.nStatusInfo.Value.ToString() + "'");
if(bUpdateTime)
aValues.Add("tr_last_open_date='" + DateTime.UtcNow.ToString(Constants.mc_sDateTimeFormat) + "'");
if (false == string.IsNullOrEmpty(oTask.sTitle))
aValues.Add("tr_title='" + Utils.MySqlEscape(oTask.sTitle, m_sConnectionString) + "'");
}
private void TaskResultGetSfcCallback(IAsyncResult ar)
{
TransportClassSaveChanges2 oTransportClassSaveChanges = ar.AsyncState as TransportClassSaveChanges2;
try
{
InputCommand cmd = oTransportClassSaveChanges.m_oInputCommand;
_log.DebugFormat("Enter TaskResultGetSfcCallback(id={0})", cmd.id);
TaskResultData oTaskResultData;
ErrorTypes eError = oTransportClassSaveChanges.m_oTaskResult.GetEnd(ar, out oTaskResultData);
if (ErrorTypes.NoError == eError)
{
oTransportClassSaveChanges.m_oTaskResultData = oTaskResultData;
TaskResultDataToUpdate oTask = new TaskResultDataToUpdate();
oTask.eStatus = FileStatus.UpdateVersion;
oTask.nStatusInfo = (int)ErrorTypes.NoError;
TaskResultDataToUpdate oMask = new TaskResultDataToUpdate();
oMask.eStatus = oTransportClassSaveChanges.m_oTaskResultDataToUpdate.eStatus;
oMask.nStatusInfo = oTransportClassSaveChanges.m_oTaskResultDataToUpdate.nStatusInfo;
oTransportClassSaveChanges.m_oTaskResult.UpdateIfBegin(oTransportClassSaveChanges.m_oTaskQueueData.m_sFromKey, oMask, oTask, TaskResultUpdateIfCallback, oTransportClassSaveChanges);
}
else
{
_log.ErrorFormat("Error in TaskResultGetSfcCallback(code={0})", (int)eError);
WriteOutputCommand(oTransportClassSaveChanges, new OutputCommand(eError));
}
}
catch (Exception e)
{
_log.Error("Exception catched in TaskResultGetSfcCallback:", e);
WriteOutputCommand(oTransportClassSaveChanges, new OutputCommand(ErrorTypes.Unknown));
}
}
public void UpdateBegin(string sKey, TaskResultDataToUpdate oTast, AsyncCallback fCallback, object oParam)
{
m_oUpdate = Update;
m_oUpdate.BeginInvoke(sKey, oTast, fCallback, oParam);
}
private void ReopenCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
try
{
TaskResultDataToUpdate oTaskResultData = new TaskResultDataToUpdate();
oTaskResultData.eStatus = FileStatus.WaitQueue;
oTaskResultData.nStatusInfo = (int)ErrorTypes.NoError;
ITaskResultInterface oTaskResult = TaskResult.NewTaskResult();
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
oTaskResult.UpdateBegin(cmd.id, oTaskResultData, TaskResultUpdateCallback, oTransportClassTaskResult);
}
catch
{
WriteOutputCommand(oTransportClassContextRead, new OutputCommand(ErrorTypes.Unknown));
}
}
private string GetUPDATEString(string sKey, TaskResultDataToUpdate oTast)
{
List<string> aValues = new List<string>();
if (false == string.IsNullOrEmpty(oTast.sFormat))
aValues.Add("tr_format='" + oTast.sFormat + "'");
if (oTast.eStatus.HasValue)
aValues.Add("tr_status='" + oTast.eStatus.Value.ToString("d") + "'");
if (oTast.nStatusInfo.HasValue)
aValues.Add("tr_status_info='" + oTast.nStatusInfo.Value.ToString() + "'");
aValues.Add("tr_last_open_date='" + DateTime.UtcNow.ToString(Constants.mc_sDateTimeFormat) + "'");
if (false == string.IsNullOrEmpty(oTast.sTitle))
aValues.Add("tr_title='" + Utils.MySqlEscape(oTast.sTitle, m_sConnectionString) + "'");
return string.Format("UPDATE tast_result SET {0} WHERE tr_key='{1}';", string.Join(",", aValues.ToArray()), sKey);
}
public ErrorTypes UpdateIf(string sKey, TaskResultDataToUpdate oMask, TaskResultDataToUpdate oTast, out bool bUpdate)
{
ErrorTypes oError = ErrorTypes.NoError;
UpdateIfInMC(sKey, oTast, oMask, out bUpdate);
return oError;
}
private string GetUPDATEString(string sKey, TaskResultDataToUpdate oTast)
{
List<string> aValues = new List<string>();
TaskResultDataToUpdateToArray(aValues, oTast, true);
return string.Format("UPDATE tast_result SET {0} WHERE tr_key='{1}';", string.Join(",", aValues.ToArray()), Utils.MySqlEscape(sKey, m_sConnectionString));
}
private ErrorTypes UpdateIfInMC(string sKey, TaskResultDataToUpdate oTast, TaskResultDataToUpdate oMask, out bool bUpdate)
{
ErrorTypes oError = ErrorTypes.NoError;
bUpdate = false;
try
{
TaskResultData oTask = null;
ulong cas = 0;
GetFromMCWithCas(sKey, out oTask, out cas);
if (oTask == null)
m_oTaskResultDB.Get(sKey, out oTask);
if (oTask != null && oTask.eStatus != FileStatus.Ok && oTask.IsValidMask(oMask))
{
bUpdate = true;
oTask.Update(oTast);
AddToMCWithCas(sKey, oTask, cas);
if (oTask.eStatus != FileStatus.Convert)
oError = m_oTaskResultDB.Update(sKey, oTast);
}
}
catch
{
oError = ErrorTypes.TaskResult;
}
return oError;
}
public void UpdateBegin(string sKey, TaskResultDataToUpdate oTast, AsyncCallback fCallback, object oParam)
{
m_oTaskResultDB.UpdateBegin(sKey, oTast, fCallback, oParam);
}
public bool IsValidMask(TaskResultDataToUpdate oMask)
{
bool bRes = true;
if (oMask != null)
{
if (oMask.eStatus != null)
bRes = bRes && (this.eStatus == oMask.eStatus.Value);
if (oMask.oLastOpenDate != null)
bRes = bRes && (this.oLastOpenDate == oMask.oLastOpenDate.Value);
if (oMask.nStatusInfo != null)
bRes = bRes && (this.nStatusInfo == oMask.nStatusInfo.Value);
if (oMask.sFormat != null)
bRes = bRes && (this.sFormat == oMask.sFormat);
if (oMask.sTitle != null)
bRes = bRes && (this.sTitle == oMask.sTitle);
}
return bRes;
}
private void GetOrCreateCallback(IAsyncResult ar)
{
try
{
bool bExist = false;
try
{
m_oGetOrCreate.m_delegateNonQuery.EndInvoke(ar);
}
catch
{
bExist = true;
}
if(bExist)
{
m_oGetOrCreate.m_bCreate = false;
if (null != m_oGetOrCreate.m_oCommand)
{
m_oGetOrCreate.m_oCommand.Dispose();
m_oGetOrCreate.m_oCommand = null;
}
IDbCommand oSelCommand = m_oGetOrCreate.m_oSqlCon.CreateCommand();
TaskResultDataToUpdate oToUpdate = new TaskResultDataToUpdate();
oToUpdate.oLastOpenDate = DateTime.UtcNow;
oSelCommand.CommandText = GetUPDATEString(m_oGetOrCreate.m_oTast.sKey, oToUpdate) + GetSELECTString(m_oGetOrCreate.m_oTast.sKey);
m_oGetOrCreate.m_oCommand = oSelCommand;
m_oGetOrCreate.m_delegateReader = new ExecuteReader(oSelCommand.ExecuteReader);
m_oGetOrCreate.m_delegateReader.BeginInvoke(m_oGetOrCreate.m_fCallback, m_oGetOrCreate.m_oParam);
}
else
{
m_oGetOrCreate.m_bCreate = true;
m_oGetOrCreate.m_delegateReader = null;
m_oGetOrCreate.FireCallback();
}
}
catch
{
m_oGetOrCreate.DisposeAndCallback();
}
}
public ErrorTypes Update(string sKey, TaskResultDataToUpdate oTast)
{
return piTaskResult.Update(sKey, oTast);
}
private ErrorTypes UpdateInMC(string sKey, TaskResultDataToUpdate oTast)
{
ErrorTypes oError = ErrorTypes.NoError;
try
{
TaskResultData oTask = null;
ulong cas = 0;
GetFromMCWithCas(sKey, out oTask, out cas);
if (oTask == null)
m_oTaskResultDB.Get(sKey, out oTask);
if (oTask != null && oTask.eStatus != FileStatus.Ok)
{
oTask.Update(oTast);
AddToMCWithCas(sKey, oTask, cas);
if (oTask.eStatus != FileStatus.Convert)
oError = m_oTaskResultDB.Update(sKey, oTast);
}
}
catch
{
oError = ErrorTypes.TaskResult;
}
return oError;
}
