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 SaveFormOriginCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
TaskResultData oTaskResultData = new TaskResultData();
oTaskResultData.sKey = cmd.id;
oTaskResultData.sFormat = cmd.format;
oTaskResultData.eStatus = FileStatus.WaitQueue;
ITaskResultInterface oTaskResult = TaskResult.NewTaskResult();
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
oTaskResult.AddRandomKeyBegin(cmd.id, oTaskResultData, TaskResultAddRandomKeyAsyncCallback2, oTransportClassTaskResult);
}
private void ImageUrlCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
AsyncMediaXmlOperation oAsyncMediaXmlOperation = new AsyncMediaXmlOperation();
TransportClassMediaXml oTransportClassMediaXml = new TransportClassMediaXml(oTransportClassContextRead, cmd, oAsyncMediaXmlOperation, null);
oAsyncMediaXmlOperation.GetMediaXmlBegin(Path.Combine(cmd.id, "media/media.xml"), GetMediaXmlCallback, oTransportClassMediaXml);
}
private void OpenCommand(TransportClassMainAshx oTransportClassMainAshx, InputCommand cmd)
{
try
{
TaskResultData oTaskResultData = new TaskResultData();
oTaskResultData.sKey = cmd.id;
if (false == string.IsNullOrEmpty(cmd.format))
oTaskResultData.sFormat = cmd.format;
oTaskResultData.eStatus = FileStatus.WaitQueue;
if (false == string.IsNullOrEmpty(cmd.title))
oTaskResultData.sTitle = cmd.title;
ITaskResultInterface oTaskResult = TaskResult.NewTaskResult();
TransportClassTaskResult oTransportClassClearCache = new TransportClassTaskResult(oTransportClassMainAshx, cmd, oTaskResult);
oTaskResult.GetOrCreateBegin(cmd.id, oTaskResultData, TaskResultGetOrCreateCallback, oTransportClassClearCache);
}
catch
{
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand(ErrorTypes.Unknown));
}
}
private void GetSettingsCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
OutputSettingsData oOutputSettingsData = new OutputSettingsData(cmd.format);
JavaScriptSerializer oJsSerializer = new JavaScriptSerializer();
OutputCommand oOutputCommand = new OutputCommand("getsettings", oJsSerializer.Serialize(oOutputSettingsData));
WriteOutputCommand(oTransportClassContextRead, oOutputCommand);
}
private void CheckOpenCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
ITaskResultInterface oTaskResult = TaskResult.NewTaskResult();
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
oTaskResult.GetBegin(cmd.id, TaskResultGetCallback, oTransportClassTaskResult);
}
private void AddTask(InputCommand cmd, TransportClassMainAshx oTransportClassMainAshx)
{
try
{
int nToFormat = FileFormats.AVS_OFFICESTUDIO_FILE_CANVAS;
TaskQueueData oTaskQueueData = new TaskQueueData(cmd.id, nToFormat, "Editor.bin");
oTaskQueueData.m_sFromUrl = cmd.url;
oTaskQueueData.m_sFromFormat = cmd.format;
if (cmd.codepage.HasValue)
oTaskQueueData.m_nCsvTxtEncoding = cmd.codepage.Value;
if (cmd.delimiter.HasValue)
oTaskQueueData.m_nCsvDelimiter = cmd.delimiter.Value;
oTaskQueueData.m_bEmbeddedFonts = false;
CTaskQueue oTaskQueue = new CTaskQueue();
TransportClassTaskQueue oTransportClassTaskQueue = new TransportClassTaskQueue(oTransportClassMainAshx, oTaskQueue, null);
oTaskQueue.AddTaskBegin(oTaskQueueData, Priority.High, TaskQueueAddCallback, oTransportClassTaskQueue);
WriteOutputCommand(oTransportClassTaskQueue, new OutputCommand("waitopen", "0"));
}
catch
{
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand(ErrorTypes.Unknown));
}
}
public TransportClassTaskResult(TransportClassMainAshx oTransportClassMainAshx, InputCommand oInputCommand, ITaskResultInterface oTaskResult)
: base(oTransportClassMainAshx.m_oHttpContext, oTransportClassMainAshx.m_oAsyncCallback)
{
m_oInputCommand = oInputCommand;
m_oTaskResult = oTaskResult;
}
public TransportClassStorage(TransportClassMainAshx oTransportClassMainAshx, InputCommand oInputCommand, Storage oStorage, Stream stream, string sKey)
: base(oTransportClassMainAshx.m_oHttpContext, oTransportClassMainAshx.m_oAsyncCallback)
{
m_oInputCommand = oInputCommand;
m_oStorage = oStorage;
m_oStream = stream;
m_sKey = sKey;
}
private void SaveFileChangesCallbackCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
try
{
_log.DebugFormat("Enter SaveFileChangesCallbackCommand(id={0})", cmd.id);
TransportClassSaveChanges2 oTransportClassSaveChanges = new TransportClassSaveChanges2(oTransportClassContextRead);
oTransportClassSaveChanges.m_oInputCommand = cmd;
oTransportClassSaveChanges.m_oTaskQueueData = cmd.task_queue_data;
oTransportClassSaveChanges.m_oTaskResultDataToUpdate = new TaskResultDataToUpdate();
oTransportClassSaveChanges.m_oTaskResultDataToUpdate.eStatus = (FileStatus)cmd.status;
oTransportClassSaveChanges.m_oTaskResultDataToUpdate.nStatusInfo = cmd.status_info;
oTransportClassSaveChanges.m_oTaskResult = TaskResult.NewTaskResult();
oTransportClassSaveChanges.m_oTaskResult.GetBegin(oTransportClassSaveChanges.m_oTaskQueueData.m_sKey, TaskResultGetSfcCallback, oTransportClassSaveChanges);
}
catch (Exception e)
{
_log.Error("Exception catched in SaveFileChangesCallbackCommand:", e);
WriteOutputCommand(oTransportClassContextRead, new OutputCommand(ErrorTypes.Unknown));
}
}
private ErrorTypes ProcessCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
ErrorTypes eError = ErrorTypes.NoError;
_log.DebugFormat("ProcessCommand {0}:", cmd.c);
switch (cmd.c)
{
case "create":
CreateCommand(oTransportClassContextRead, cmd);
break;
case "reopen":
ReopenCommand(oTransportClassContextRead, cmd);
break;
case "open":
OpenCommand(oTransportClassContextRead, cmd);
break;
case "chopen":
CheckOpenCommand(oTransportClassContextRead, cmd);
break;
case "save":
SaveCommand(oTransportClassContextRead, cmd);
break;
case "sfct":
SfctCommand(oTransportClassContextRead, cmd);
break;
case "chsave":
CheckSaveCommand(oTransportClassContextRead, cmd);
break;
case "cc":
ClearCacheCommand(oTransportClassContextRead, cmd);
break;
case "getcodepage":
GetCodepageCommand(oTransportClassContextRead);
break;
case "imgurl":
case "imgurls":
ImageUrlCommand(oTransportClassContextRead, cmd);
break;
case "sfc":
SaveFileChangesCommand(oTransportClassContextRead, cmd);
break;
case "sfcc":
SaveFileChangesCallbackCommand(oTransportClassContextRead, cmd);
break;
case "savefromorigin":
SaveFormOriginCommand(oTransportClassContextRead, cmd);
break;
case "getsettings":
GetSettingsCommand(oTransportClassContextRead, cmd);
break;
default:
_log.InfoFormat("Unknown command: {0}", cmd.c);
eError = ErrorTypes.Unknown;
break;
}
return eError;
}
private void TaskResultAddRandomKeyAsyncCallback3(IAsyncResult ar)
{
TransportClassSaveChanges1 oTransportClassSaveChanges = ar.AsyncState as TransportClassSaveChanges1;
try
{
InputCommand cmd = oTransportClassSaveChanges.m_oInputCommand;
_log.DebugFormat("Enter TaskResultAddRandomKeyAsyncCallback3(id={0})", cmd.id);
TaskResultData oTaskResultData;
ErrorTypes eError = oTransportClassSaveChanges.m_oTaskResult.AddRandomKeyEnd(ar, out oTaskResultData);
if (ErrorTypes.NoError == eError)
{
string sFilename = "output.zip";
int nOutputFormat = FileFormats.AVS_OFFICESTUDIO_FILE_OTHER_TEAMLAB_INNER;
if(cmd.outputformat.HasValue)
{
nOutputFormat = cmd.outputformat.Value;
sFilename = "output." + FileFormats.ToString(nOutputFormat);
}
TaskQueueData oTaskQueueData = new TaskQueueData(oTaskResultData.sKey, nOutputFormat, sFilename);
oTaskQueueData.m_sFromKey = cmd.id;
oTaskQueueData.m_sFromFormat = "bin";
oTaskQueueData.m_bFromChanges = true;
if (cmd.codepage.HasValue)
oTaskQueueData.m_nCsvTxtEncoding = cmd.codepage.Value;
if (cmd.delimiter.HasValue)
oTaskQueueData.m_nCsvDelimiter = cmd.delimiter.Value;
if (null != cmd.vkey)
{
bool bPaid;
Signature.getVKeyParams(cmd.vkey, out bPaid);
oTaskQueueData.m_bPaid = bPaid;
}
Priority oPriority = Priority.Low;
if (cmd.innersave)
oPriority = Priority.Normal;
oTaskQueueData.m_sResultCallbackUrl = UrlBuilder.FullUrl(oTransportClassSaveChanges.m_oHttpContext.Request);
InputCommand oSaveCommand = new InputCommand();
oSaveCommand.c = "sfcc";
oSaveCommand.id = cmd.id;
oSaveCommand.task_queue_data = oTaskQueueData;
oSaveCommand.url = cmd.url;
oSaveCommand.status = (int)oTransportClassSaveChanges.m_oTaskResultDataToUpdate.eStatus.Value;
oSaveCommand.status_info = oTransportClassSaveChanges.m_oTaskResultDataToUpdate.nStatusInfo.Value;
oTaskQueueData.m_sResultCallbackData = InputCommand.SerializeToJson(oSaveCommand);
_log.DebugFormat("oTaskQueueData.m_sResultCallbackData = {0}(id={1})", oTaskQueueData.m_sResultCallbackData, cmd.id);
CTaskQueue oTaskQueue = new CTaskQueue();
oTransportClassSaveChanges.m_oTaskQueue = oTaskQueue;
oTransportClassSaveChanges.m_oTaskQueueData = oTaskQueueData;
oTaskQueue.AddTaskBegin(oTaskQueueData, oPriority, TaskQueueAddCallbackSave2, oTransportClassSaveChanges);
}
else
{
_log.ErrorFormat("Error in TaskResultAddRandomKeyAsyncCallback3(code={0})", (int)eError);
WriteOutputCommand(oTransportClassSaveChanges, new OutputCommand(eError));
}
}
catch(Exception e)
{
_log.Error("Exception catched in TaskResultAddRandomKeyAsyncCallback3:", e);
WriteOutputCommand(oTransportClassSaveChanges, new OutputCommand(ErrorTypes.Unknown));
}
}
private void SaveFileChangesCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
try
{
_log.DebugFormat("Enter SaveFileChangesCommand(id={0})", cmd.id);
TransportClassSaveChanges1 oTransportClassSaveChanges = new TransportClassSaveChanges1(oTransportClassContextRead);
oTransportClassSaveChanges.m_oInputCommand = cmd;
oTransportClassSaveChanges.m_oTaskResult = TaskResult.NewTaskResult();
oTransportClassSaveChanges.m_oTaskResult.GetBegin(cmd.id, TaskResultGetCallback2, oTransportClassSaveChanges);
}
catch(Exception e)
{
_log.Error("Exception catched in SaveFileChangesCommand:", e);
WriteOutputCommand(oTransportClassContextRead, 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;
}
}
private void CheckSaveCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
JavaScriptSerializer oJavaScriptSerializer = new JavaScriptSerializer();
OutputWaitSaveData oOutputWaitSaveData = oJavaScriptSerializer.Deserialize<OutputWaitSaveData>(cmd.data);
ITaskResultInterface oTaskResult = TaskResult.NewTaskResult();
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
oTaskResult.GetBegin(oOutputWaitSaveData.key, TaskResultGetAsyncCallback, oTransportClassTaskResult);
}
public TransportClassStorage2(TransportClassMainAshx oTransportClassMainAshx, InputCommand oInputCommand, Storage oStorage, Stream stream, string sKey, string sFilename, string sExt, OutputCommand oOutputCommand)
: base(oTransportClassMainAshx, oInputCommand, oStorage, stream, sKey)
{
m_sFilename = sFilename;
m_sExt = sExt;
m_oOutputCommand = oOutputCommand;
}
private void SaveCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
_log.DebugFormat("SaveCommand, savetype={0}.", cmd.savetype);
switch (cmd.savetype)
{
case c_sSaveTypePartStart:
case c_sSaveTypeCompleteAll:
{
_log.Debug("cmd.savetype = SaveTypes.PartStart or SaveTypes.CompleteAll.");
TaskResultData oTaskResultData = new TaskResultData();
oTaskResultData.sKey = cmd.id;
oTaskResultData.sFormat = cmd.format;
oTaskResultData.eStatus = FileStatus.WaitQueue;
ITaskResultInterface oTaskResult = TaskResult.NewTaskResult();
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
oTaskResult.AddRandomKeyBegin(cmd.id, oTaskResultData, TaskResultAddRandomKeyAsyncCallback, oTransportClassTaskResult);
break;
}
case c_sSaveTypePart:
case c_sSaveTypeComplete:
default:
{
_log.Debug("cmd.savetype = SaveTypes.Part or SaveTypes.Complete or default.");
JavaScriptSerializer serializer = new JavaScriptSerializer();
OutputSavePartData oOutputSavePartData = new OutputSavePartData(cmd.savekey, cmd.outputformat.Value);
OutputCommand oOutputCommand = new OutputCommand("savepart", serializer.Serialize(oOutputSavePartData));
string sFilename = "Editor";
string sExt = ".bin";
Storage oStorage = new Storage();
TransportClassStorage2 oTransportClassStorage2 = new TransportClassStorage2(oTransportClassContextRead, cmd, oStorage, null, cmd.savekey, sFilename, sExt, oOutputCommand);
oStorage.GetTreeNodeBegin(cmd.savekey, GetTreeNodeCallback, oTransportClassStorage2);
break;
}
}
}
public TransportClassStorage3(TransportClassMainAshx oTransportClassMainAshx, InputCommand oInputCommand, Storage oStorage, Stream stream, string sKey, TransportClassSaveChanges2 oSaveChanges2)
: base(oTransportClassMainAshx, oInputCommand, oStorage, stream, sKey)
{
m_oSaveChanges2 = oSaveChanges2;
}
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));
}
}
public TransportClassMediaXml(TransportClassMainAshx m_oTransportClassMainAshx, InputCommand oInputCommand, AsyncMediaXmlOperation oAsyncMediaXmlOperation, object oParam)
: base(m_oTransportClassMainAshx.m_oHttpContext, m_oTransportClassMainAshx.m_oAsyncCallback)
{
m_oAsyncMediaXmlOperation = oAsyncMediaXmlOperation;
m_oInputCommand = oInputCommand;
m_oParam = oParam;
}
public static string SerializeToJson(InputCommand oData)
{
return new JavaScriptSerializer().Serialize(oData);
}
private void CreateCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
{
try
{
TaskResultData oTaskResultData = new TaskResultData();
oTaskResultData.sKey = cmd.id;
if (false == string.IsNullOrEmpty(cmd.format))
oTaskResultData.sFormat = cmd.format;
oTaskResultData.eStatus = FileStatus.Ok;
if (false == string.IsNullOrEmpty(cmd.title))
oTaskResultData.sTitle = cmd.title;
ITaskResultInterface oTaskResult = TaskResult.NewTaskResult();
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
oTaskResult.GetOrCreateBegin(cmd.id, oTaskResultData, TaskResultGetOrCreateCallback2, oTransportClassTaskResult);
}
catch
{
WriteOutputCommand(oTransportClassContextRead, new OutputCommand(ErrorTypes.Unknown));
}
}