private void TaskResultGetAsyncCallback(IAsyncResult ar)
{
TransportClassTaskResult oTransportClassTaskResult = ar.AsyncState as TransportClassTaskResult;
try
{
TaskResultData oTask;
ErrorTypes eError = oTransportClassTaskResult.m_oTaskResult.GetEnd(ar, out oTask);
if (ErrorTypes.NoError == eError)
{
InputCommand cmd = oTransportClassTaskResult.m_oInputCommand;
switch (oTask.eStatus)
{
case FileStatus.Ok:
TaskResultGetAsyncCallbackOk(oTransportClassTaskResult);
break;
case FileStatus.Convert:
case FileStatus.WaitQueue:
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand("waitsave", cmd.data));
break;
case FileStatus.Err:
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand((ErrorTypes)oTask.nStatusInfo));
break;
case FileStatus.ErrToReload:
AsyncClearCacheOperation oAsyncClearCacheOperation = new AsyncClearCacheOperation();
TransportClassClearCache oTransportClassClearCache = new TransportClassClearCache(oTransportClassTaskResult, cmd, oAsyncClearCacheOperation, (ErrorTypes)oTask.nStatusInfo);
oAsyncClearCacheOperation.ClearCacheBegin(oTask.sKey, ClearCacheCallback, oTransportClassClearCache);
break;
default:
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
break;
}
}
else
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(eError));
}
catch
{
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
}
}
public TransportClassClearCache(TransportClassMainAshx m_oTransportClassMainAshx, InputCommand oInputCommand, AsyncClearCacheOperation oAsyncClearCacheOperation, object oParam)
: base(m_oTransportClassMainAshx.m_oHttpContext, m_oTransportClassMainAshx.m_oAsyncCallback)
{
m_oAsyncClearCacheOperation = oAsyncClearCacheOperation;
m_oInputCommand = oInputCommand;
m_oParam = oParam;
}
private void ClearCacheCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
AsyncClearCacheOperation oAsyncClearCacheOperation = new AsyncClearCacheOperation();
TransportClassClearCache oTransportClassClearCache = new TransportClassClearCache(oTransportClassContextRead, cmd, oAsyncClearCacheOperation, null);
oAsyncClearCacheOperation.ClearCacheBegin(cmd.id, TaskResultRemoveCallback, oTransportClassClearCache);
}
private void RemoveFromCoAuthoringHandler(TransportClassSaveChanges2 oTransportClassSaveChanges2)
{
try
{
AsyncClearCacheOperation oAsyncClearCacheOperation = new AsyncClearCacheOperation();
oTransportClassSaveChanges2.m_oAsyncClearCacheOperation = oAsyncClearCacheOperation;
oAsyncClearCacheOperation.ClearCacheBegin(oTransportClassSaveChanges2.m_oTaskQueueData.m_sKey, TaskResultRemoveCallback4, oTransportClassSaveChanges2);
}
catch (Exception e)
{
_log.Error("Exception catched in RemoveFromCoAuthoringHandler:", e);
WriteOutputCommand(oTransportClassSaveChanges2, new OutputCommand(ErrorTypes.Unknown));
}
}
private void TaskResultUpdateIfCallback(IAsyncResult ar)
{
TransportClassSaveChanges2 oTransportClassSaveChanges = ar.AsyncState as TransportClassSaveChanges2;
try
{
InputCommand cmd = oTransportClassSaveChanges.m_oInputCommand;
_log.DebugFormat("Enter TaskResultUpdateIfCallback(id={0})", cmd.id);
bool bUpdate;
ErrorTypes eError = oTransportClassSaveChanges.m_oTaskResult.UpdateIfEnd(ar, out bUpdate);
if (ErrorTypes.NoError == eError)
{
if (bUpdate)
{
oTransportClassSaveChanges.m_oDocsCallbacks = new DocsCallbacks();
oTransportClassSaveChanges.m_oDocsCallbacks.GetBegin(oTransportClassSaveChanges.m_oTaskQueueData.m_sFromKey, DocsCallbacksGetCallback, oTransportClassSaveChanges);
}
else
{
AsyncClearCacheOperation oAsyncClearCacheOperation = new AsyncClearCacheOperation();
oTransportClassSaveChanges.m_oAsyncClearCacheOperation = oAsyncClearCacheOperation;
oAsyncClearCacheOperation.ClearCacheBegin(oTransportClassSaveChanges.m_oTaskQueueData.m_sKey, TaskResultRemoveCallback3, oTransportClassSaveChanges);
}
}
else
{
_log.ErrorFormat("Error in TaskResultUpdateIfCallback(code={0})", (int)eError);
WriteOutputCommand(oTransportClassSaveChanges, new OutputCommand(eError));
}
}
catch (Exception e)
{
_log.Error("Exception catched in TaskResultUpdateIfCallback:", e);
WriteOutputCommand(oTransportClassSaveChanges, new OutputCommand(ErrorTypes.Unknown));
}
}
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 TransportClass2(TransportClassMainAshx oTransportClassMainAshx, AsyncClearCacheOperation oAsyncClearCacheOperation, ErrorTypes eError)
: base(oTransportClassMainAshx.m_oHttpContext, oTransportClassMainAshx.m_oAsyncCallback)
{
m_oAsyncClearCacheOperation = oAsyncClearCacheOperation;
m_eError = eError;
}
private void CheckStatus(TransportClass1 oTransportClass1, TaskResultData oTaskResultData)
{
switch (oTaskResultData.eStatus)
{
case FileStatus.Ok:
string sFilename = HttpUtility.UrlEncode("output." + FileFormats.ToString(oTransportClass1.m_oInputParams.m_nOutputtype));
string sPath = HttpUtility.UrlEncode(Path.GetFileNameWithoutExtension(oTransportClass1.m_oInputParams.m_sKey) + "/output." + FileFormats.ToString(oTransportClass1.m_oInputParams.m_nOutputtype));
string sDeletePath = HttpUtility.UrlEncode(Path.GetFileNameWithoutExtension(oTransportClass1.m_oInputParams.m_sKey));
string sSiteUrl = UrlBuilder.UrlWithoutPath(oTransportClass1.m_oHttpContext.Request);
string strFileUrl = sSiteUrl + Constants.mc_sResourceServiceUrlRel + sPath + "&nocache=true" +"&deletepath=" + sDeletePath + "&filename=" + sFilename;
WriteOutputCommand(oTransportClass1, new OutputCommand(strFileUrl, "100", true, ErrorTypes.NoError));
break;
case FileStatus.WaitQueue:
if (oTransportClass1.m_oInputParams.m_bAsyncConvert)
WriteOutputCommand(oTransportClass1, new OutputCommand("", "0", false, ErrorTypes.NoError));
else
WaitEnd(oTransportClass1);
break;
case FileStatus.Convert:
if (oTransportClass1.m_oInputParams.m_bAsyncConvert)
WriteOutputCommand(oTransportClass1, new OutputCommand("", oTaskResultData.nStatusInfo.ToString(), false, ErrorTypes.NoError));
else
WaitEnd(oTransportClass1);
break;
case FileStatus.Err:
case FileStatus.ErrToReload:
AsyncClearCacheOperation oAsyncClearCacheOperation = new AsyncClearCacheOperation();
TransportClass2 oTransportClass2 = new TransportClass2(oTransportClass1, oAsyncClearCacheOperation, (ErrorTypes)oTaskResultData.nStatusInfo);
oAsyncClearCacheOperation.ClearCacheBegin(oTransportClass1.m_oInputParams.m_sKey, ClearCacheCallback, oTransportClass2);
break;
default:
WriteOutputCommand(oTransportClass1, new OutputCommand(null, null, null, ErrorTypes.Unknown));
break;
}
}
