1722 lines
76 KiB
Plaintext
1722 lines
76 KiB
Plaintext
<%@ WebHandler Language="C#" Class="CanvasService" %>
|
|
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2014
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
|
|
* EU, LV-1021.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
using System;
|
|
using System.Net;
|
|
using System.Web;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Runtime.Serialization;
|
|
using System.Runtime.Serialization.Json;
|
|
using System.Configuration;
|
|
using System.Web.Script.Serialization;
|
|
using System.Security.Cryptography;
|
|
using System.Xml;
|
|
using System.Collections.Generic;
|
|
|
|
using FileConverterUtils2;
|
|
using ASC.Core.Billing;
|
|
using log4net;
|
|
|
|
public class CanvasService : IHttpAsyncHandler
|
|
{
|
|
private const char c_cCharDelimiter = (char)5;
|
|
private const string c_sSaveTypePartStart = "partstart";
|
|
private const string c_sSaveTypePart = "part";
|
|
private const string c_sSaveTypeComplete = "complete";
|
|
private const string c_sSaveTypeCompleteAll = "completeall";
|
|
private const string c_sSaveTypeChanges = "changes";
|
|
private readonly ILog _log = LogManager.GetLogger(typeof(CanvasService));
|
|
|
|
public CanvasService()
|
|
{
|
|
}
|
|
public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, Object extraData)
|
|
{
|
|
TransportClassMainAshx oTransportClassMainAshx = new TransportClassMainAshx(context, cb);
|
|
AsyncContextReadOperation asynch = new AsyncContextReadOperation();
|
|
TransportClassContextRead oTransportClassContextRead = new TransportClassContextRead(oTransportClassMainAshx, asynch);
|
|
try
|
|
{
|
|
asynch.ReadContextBegin(context.Request.InputStream, ReadContext, oTransportClassContextRead);
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
OutputCommand oOutputCommand = new OutputCommand(ErrorTypes.Unknown);
|
|
WriteOutputCommand(new TransportClassMainAshx(context, cb), oOutputCommand);
|
|
|
|
_log.Error("Exception catched in BeginProcessRequest:", e);
|
|
}
|
|
return new AsyncOperationData(extraData);
|
|
}
|
|
public void EndProcessRequest(IAsyncResult result)
|
|
{
|
|
}
|
|
public void ProcessRequest(HttpContext context)
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
public bool IsReusable
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#region Callbacks
|
|
private void ReadContext(IAsyncResult ar)
|
|
{
|
|
TransportClassContextRead oTransportClassContextRead = ar.AsyncState as TransportClassContextRead;
|
|
AsyncContextReadOperation asyncOp = oTransportClassContextRead.m_oAsyncContextReadOperation;
|
|
ErrorTypes eError = ErrorTypes.NoError;
|
|
string strStream = null;
|
|
try
|
|
{
|
|
eError = asyncOp.ReadContextEnd(ar);
|
|
strStream = System.Text.Encoding.UTF8.GetString(asyncOp.m_aBuffer);
|
|
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
InputCommand cmd = ReadCommand(strStream);
|
|
|
|
eError = ProcessCommand(oTransportClassContextRead, cmd);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
eError = ErrorTypes.Unknown;
|
|
|
|
_log.ErrorFormat("Input command: {0}", strStream);
|
|
_log.Error("Exception catched in ReadContext:", e);
|
|
}
|
|
finally
|
|
{
|
|
if (ErrorTypes.NoError != eError)
|
|
WriteOutputCommand(oTransportClassContextRead, new OutputCommand(eError));
|
|
}
|
|
}
|
|
|
|
private ErrorTypes ProcessCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
|
|
{
|
|
ErrorTypes eError = ErrorTypes.NoError;
|
|
|
|
LicenseInfo.LicenseRights oRights = null;
|
|
|
|
oRights = new LicenseInfo.LicenseRights(true);
|
|
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
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 "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 "savefromorigin":
|
|
SaveFormOriginCommand(oTransportClassContextRead, cmd);
|
|
break;
|
|
|
|
case "getsettings":
|
|
GetSettingsCommand(oTransportClassContextRead, cmd, oRights);
|
|
break;
|
|
|
|
case "getlicense":
|
|
GetLicenseCommand(oTransportClassContextRead, cmd);
|
|
break;
|
|
|
|
default:
|
|
eError = ErrorTypes.Unknown;
|
|
break;
|
|
}
|
|
}
|
|
return eError;
|
|
}
|
|
|
|
private ErrorTypes GetRights(InputCommand cmd, out LicenseInfo.LicenseRights oRights)
|
|
{
|
|
oRights = null;
|
|
ErrorTypes eError = ErrorTypes.NoError;
|
|
|
|
LicenseInfo.LicenseMetaData oLicenseMetaData = null;
|
|
|
|
oLicenseMetaData = new LicenseInfo.LicenseMetaData(
|
|
null == cmd.vkey ? "" : cmd.vkey,
|
|
cmd.id,
|
|
null == cmd.userid ? "" : cmd.userid,
|
|
cmd.editorid);
|
|
|
|
oRights = ASP.global_asax.LicenseInfo.getRights(oLicenseMetaData, out eError);
|
|
|
|
if (null == oRights && ErrorTypes.NoError == eError)
|
|
eError = ErrorTypes.LicenseError;
|
|
else
|
|
eError = CheckRights(cmd, oRights);
|
|
|
|
return eError;
|
|
}
|
|
|
|
private static InputCommand ReadCommand(string strStream)
|
|
{
|
|
JavaScriptSerializer oJavaScriptSerializer = new JavaScriptSerializer();
|
|
string sSearchString = "mnuSaveAs";
|
|
InputCommand cmd;
|
|
if (strStream.StartsWith(sSearchString))
|
|
{
|
|
|
|
int nSearchStringLength = sSearchString.Length;
|
|
int nIdStart = nSearchStringLength + 1;
|
|
int nIdEnd = strStream.IndexOf(c_cCharDelimiter, nIdStart);
|
|
|
|
string sJson = strStream.Substring(nIdStart, nIdEnd - nIdStart);
|
|
cmd = oJavaScriptSerializer.Deserialize<InputCommand>(sJson);
|
|
cmd.data = strStream.Substring(nIdEnd + 1);
|
|
}
|
|
else
|
|
cmd = oJavaScriptSerializer.Deserialize<InputCommand>(strStream);
|
|
return cmd;
|
|
}
|
|
|
|
private void GetSettingsCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd, LicenseInfo.LicenseRights oRights)
|
|
{
|
|
OutputSettingsTrackingData oTrackingData = null;
|
|
|
|
oTrackingData = new OutputSettingsTrackingData();
|
|
|
|
oTrackingData.licenseId = "";
|
|
oTrackingData.trackingUrl = null;
|
|
oTrackingData.trackingType = TrackingType.TT_NONE;
|
|
|
|
JavaScriptSerializer oJsSerializer = new JavaScriptSerializer();
|
|
|
|
OutputSettingsData oOutputSettingsData = new OutputSettingsData(oRights, cmd.format, oTrackingData);
|
|
|
|
OutputCommand oOutputCommand = new OutputCommand("getsettings", oJsSerializer.Serialize(oOutputSettingsData));
|
|
WriteOutputCommand(oTransportClassContextRead, oOutputCommand);
|
|
}
|
|
private void GetLicenseCommand (TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
|
|
{
|
|
LicenseInfo oLicenseInfo = ASP.global_asax.LicenseInfo;
|
|
|
|
LicenseInfo.LicenseCustomerInfo customer_info = (null == oLicenseInfo) ? null : oLicenseInfo.getCustomerInfo();
|
|
|
|
JavaScriptSerializer oJsSerializer = new JavaScriptSerializer();
|
|
|
|
OutputCommand oOutputCommand = new OutputCommand("getlicense", oJsSerializer.Serialize(customer_info));
|
|
WriteOutputCommand(oTransportClassContextRead, oOutputCommand);
|
|
}
|
|
|
|
private void SaveFormOriginCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
|
|
{
|
|
TaskResultData oTaskResultData = new TaskResultData();
|
|
oTaskResultData.sKey = cmd.id;
|
|
oTaskResultData.sFormat = cmd.format;
|
|
oTaskResultData.eStatus = FileStatus.WaitQueue;
|
|
oTaskResultData.oLastOpenDate = DateTime.UtcNow;
|
|
TaskResult oTaskResult = new TaskResult();
|
|
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
|
|
oTaskResult.AddRandomKeyBegin(cmd.id, oTaskResultData, TaskResultAddRandomKeyAsyncCallback2, oTransportClassTaskResult);
|
|
}
|
|
|
|
private void SaveFileChangesCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
|
|
{
|
|
TaskResultData oTaskResultData = new TaskResultData();
|
|
oTaskResultData.sKey = cmd.id;
|
|
oTaskResultData.sFormat = cmd.format;
|
|
oTaskResultData.eStatus = FileStatus.WaitQueue;
|
|
oTaskResultData.oLastOpenDate = DateTime.UtcNow;
|
|
TaskResult oTaskResult = new TaskResult();
|
|
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
|
|
oTaskResult.AddRandomKeyBegin(cmd.id, oTaskResultData, TaskResultAddRandomKeyAsyncCallback3, 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 GetCodepageCommand(TransportClassContextRead oTransportClassContextRead)
|
|
{
|
|
string sJson = Utils.GetSerializedEncodingProperty(null, null);
|
|
WriteOutputCommand(oTransportClassContextRead, new OutputCommand("getcodepage", sJson));
|
|
}
|
|
|
|
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 CheckSaveCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
|
|
{
|
|
JavaScriptSerializer oJavaScriptSerializer = new JavaScriptSerializer();
|
|
OutputWaitSaveData oOutputWaitSaveData = oJavaScriptSerializer.Deserialize<OutputWaitSaveData>(cmd.data);
|
|
TaskResult oTaskResult = new TaskResult();
|
|
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
|
|
oTaskResult.GetBegin(oOutputWaitSaveData.key, TaskResultGetAsyncCallback, oTransportClassTaskResult);
|
|
}
|
|
|
|
private void SaveCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
|
|
{
|
|
switch (cmd.savetype)
|
|
{
|
|
case c_sSaveTypeChanges:
|
|
{
|
|
OutputCommand oOutputCommand = new OutputCommand("changes", null);
|
|
string sFilename = "changes";
|
|
string sExt = ".json";
|
|
Storage oStorage = new Storage();
|
|
TransportClassStorage2 oTransportClassStorage2 = new TransportClassStorage2(oTransportClassContextRead, cmd, oStorage, null, cmd.id + "/changes", sFilename, sExt, oOutputCommand);
|
|
oStorage.GetTreeNodeBegin(cmd.id + "/changes", GetTreeNodeCallback, oTransportClassStorage2);
|
|
break;
|
|
}
|
|
case c_sSaveTypePartStart:
|
|
case c_sSaveTypeCompleteAll:
|
|
{
|
|
TaskResultData oTaskResultData = new TaskResultData();
|
|
oTaskResultData.sKey = cmd.id;
|
|
oTaskResultData.sFormat = cmd.format;
|
|
oTaskResultData.eStatus = FileStatus.WaitQueue;
|
|
oTaskResultData.oLastOpenDate = DateTime.UtcNow;
|
|
TaskResult oTaskResult = new TaskResult();
|
|
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
|
|
oTaskResult.AddRandomKeyBegin(cmd.id, oTaskResultData, TaskResultAddRandomKeyAsyncCallback, oTransportClassTaskResult);
|
|
break;
|
|
}
|
|
case c_sSaveTypePart:
|
|
case c_sSaveTypeComplete:
|
|
default:
|
|
{
|
|
|
|
JavaScriptSerializer serializer = new JavaScriptSerializer();
|
|
OutputSavePartData oOutputSavePartData = new OutputSavePartData(cmd.savekey, cmd.outputformat);
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CheckOpenCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
|
|
{
|
|
TaskResult oTaskResult = new TaskResult();
|
|
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
|
|
oTaskResult.GetBegin(cmd.id, TaskResultGetCallback, oTransportClassTaskResult);
|
|
}
|
|
|
|
private void ReopenCommand(TransportClassContextRead oTransportClassContextRead, InputCommand cmd)
|
|
{
|
|
|
|
AsyncClearCacheOperation oAsyncClearCacheOperation = new AsyncClearCacheOperation();
|
|
TransportClassClearCache oTransportClassClearCache = new TransportClassClearCache(oTransportClassContextRead, cmd, oAsyncClearCacheOperation, null);
|
|
oAsyncClearCacheOperation.ClearCacheBegin(cmd.id, TaskResultRemoveCallback3, oTransportClassClearCache);
|
|
}
|
|
|
|
private static ErrorTypes CheckRights(InputCommand cmd, LicenseInfo.LicenseRights oRights)
|
|
{
|
|
ErrorTypes eError = ErrorTypes.NoError;
|
|
switch (cmd.c)
|
|
{
|
|
case "create":
|
|
case "reopen":
|
|
case "open":
|
|
case "chopen":
|
|
{
|
|
if (true != oRights.CanOpen)
|
|
eError = ErrorTypes.LicenseErrorPermission;
|
|
}
|
|
break;
|
|
|
|
case "savefromorigin":
|
|
{
|
|
if (true != oRights.CanPrint)
|
|
eError = ErrorTypes.LicenseErrorPermission;
|
|
}
|
|
break;
|
|
|
|
case "save":
|
|
{
|
|
if (FileFormats.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF == cmd.outputformat)
|
|
{
|
|
if (true != oRights.CanPrint)
|
|
eError = ErrorTypes.LicenseErrorPermission;
|
|
}
|
|
else if (true == cmd.innersave)
|
|
{
|
|
if (true != oRights.CanSave)
|
|
eError = ErrorTypes.LicenseErrorPermission;
|
|
}
|
|
else if (true != oRights.CanExport)
|
|
eError = ErrorTypes.LicenseErrorPermission;
|
|
}
|
|
break;
|
|
|
|
case "imgurl":
|
|
case "imgurls":
|
|
case "sfc":
|
|
{
|
|
if (true != oRights.CanSave)
|
|
eError = ErrorTypes.LicenseErrorPermission;
|
|
}
|
|
break;
|
|
|
|
case "getsettings":
|
|
case "getlicense":
|
|
case "chsave":
|
|
default:
|
|
break;
|
|
}
|
|
return eError;
|
|
}
|
|
private void GetTreeNodeCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassStorage2 oTransportClassStorage = ar.AsyncState as TransportClassStorage2;
|
|
try
|
|
{
|
|
Storage oStorage = oTransportClassStorage.m_oStorage;
|
|
InputCommand cmd = oTransportClassStorage.m_oInputCommand;
|
|
StorageTreeNode oStorageTreeNode = oStorage.GetTreeNodeEnd(ar);
|
|
int nMaxIndex = 0;
|
|
string sSearchString = oTransportClassStorage.m_sFilename;
|
|
for (int i = 0, length = oStorageTreeNode.m_aSubNodes.Count; i < length; ++i)
|
|
{
|
|
StorageTreeNode oCurNode = oStorageTreeNode.m_aSubNodes[i];
|
|
if (false == oCurNode.m_bIsDirectory)
|
|
{
|
|
if (0 == oCurNode.m_sName.IndexOf(sSearchString))
|
|
{
|
|
int nDotIndex = oCurNode.m_sName.LastIndexOf('.');
|
|
|
|
int nCurIndex = 0;
|
|
try
|
|
{
|
|
if (-1 != nDotIndex)
|
|
nCurIndex = int.Parse(oCurNode.m_sName.Substring(sSearchString.Length, nDotIndex - sSearchString.Length));
|
|
else
|
|
nCurIndex = int.Parse(oCurNode.m_sName.Substring(sSearchString.Length));
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
if (nMaxIndex < nCurIndex)
|
|
nMaxIndex = nCurIndex;
|
|
}
|
|
}
|
|
}
|
|
nMaxIndex++;
|
|
MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(cmd.data));
|
|
oTransportClassStorage.m_oStream = ms;
|
|
oStorage.WriteFileBegin(Path.Combine(oTransportClassStorage.m_sKey, oTransportClassStorage.m_sFilename + nMaxIndex + oTransportClassStorage.m_sExt), ms, ChangesWriteCallback, oTransportClassStorage);
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassStorage, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void EditorBinWriteCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassStorage oTransportClassStorage = ar.AsyncState as TransportClassStorage;
|
|
try
|
|
{
|
|
int nReadWriteBytes;
|
|
ErrorTypes eErrorTypes = oTransportClassStorage.m_oStorage.WriteFileEnd(ar, out nReadWriteBytes);
|
|
if (null != oTransportClassStorage.m_oStream)
|
|
oTransportClassStorage.m_oStream.Dispose();
|
|
if (ErrorTypes.NoError == eErrorTypes)
|
|
{
|
|
TaskResultData oTaskResultData = new TaskResultData();
|
|
oTaskResultData.eStatus = FileStatus.Ok;
|
|
oTaskResultData.nStatusInfo = (int)ErrorTypes.NoError;
|
|
TaskResultGetProcess(oTaskResultData, false, oTransportClassStorage.m_oInputCommand, oTransportClassStorage);
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassStorage, new OutputCommand(eErrorTypes));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassStorage, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void ChangesWriteCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassStorage2 oTransportClassStorage = ar.AsyncState as TransportClassStorage2;
|
|
try
|
|
{
|
|
int nReadWriteBytes;
|
|
oTransportClassStorage.m_oStorage.WriteFileEnd(ar, out nReadWriteBytes);
|
|
if (null != oTransportClassStorage.m_oStream)
|
|
oTransportClassStorage.m_oStream.Dispose();
|
|
InputCommand cmd = oTransportClassStorage.m_oInputCommand;
|
|
if (c_sSaveTypeComplete == cmd.savetype || c_sSaveTypeCompleteAll == cmd.savetype)
|
|
{
|
|
|
|
int nOutputFormat = cmd.outputformat;
|
|
TaskQueueData oTaskQueueData = new TaskQueueData(oTransportClassStorage.m_sKey, nOutputFormat, "output." + FileFormats.ToString(nOutputFormat));
|
|
oTaskQueueData.m_sFromKey = cmd.id;
|
|
oTaskQueueData.m_sFromFormat = "bin";
|
|
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;
|
|
CTaskQueue oTaskQueue = new CTaskQueue();
|
|
TransportClassTaskQueue oTransportClassTaskQueue = new TransportClassTaskQueue(oTransportClassStorage, oTaskQueue, oTaskQueueData);
|
|
oTaskQueue.AddTaskBegin(oTaskQueueData, oPriority, TaskQueueAddCallbackSave, oTransportClassTaskQueue);
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassStorage, oTransportClassStorage.m_oOutputCommand);
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassStorage, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
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:
|
|
JavaScriptSerializer oJavaScriptSerializer = new JavaScriptSerializer();
|
|
OutputWaitSaveData oOutputWaitSaveData = oJavaScriptSerializer.Deserialize<OutputWaitSaveData>(cmd.data);
|
|
string sPath = HttpUtility.UrlEncode(oOutputWaitSaveData.key + "/" + oOutputWaitSaveData.filename);
|
|
string sDeletePath = HttpUtility.UrlEncode(oOutputWaitSaveData.key);
|
|
string sFilename = HttpUtility.UrlEncode(cmd.title + "." + FileFormats.ToString(oOutputWaitSaveData.format));
|
|
Uri oSiteUri = oTransportClassTaskResult.m_oHttpContext.Request.Url;
|
|
string sSiteUrl = oSiteUri.Scheme + "://" + oSiteUri.Host;
|
|
if (-1 != oSiteUri.Port)
|
|
sSiteUrl += ":" + oSiteUri.Port;
|
|
string sUrl = sSiteUrl + Constants.mc_sResourceServiceUrlRel + sPath + "&deletepath=" + sDeletePath + "&filename=" + sFilename;
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand("save", sUrl));
|
|
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));
|
|
}
|
|
}
|
|
private void TaskResultAddRandomKeyAsyncCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassTaskResult oTransportClassTaskResult = ar.AsyncState as TransportClassTaskResult;
|
|
try
|
|
{
|
|
TaskResultData oTaskResultData;
|
|
ErrorTypes eError = oTransportClassTaskResult.m_oTaskResult.AddRandomKeyEnd(ar, out oTaskResultData);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
InputCommand cmd = oTransportClassTaskResult.m_oInputCommand;
|
|
string sFilename;
|
|
if (c_sSaveTypeCompleteAll == cmd.savetype)
|
|
sFilename = "Editor.bin";
|
|
else
|
|
sFilename = "Editor1.bin";
|
|
|
|
byte[] aBuffer = Encoding.ASCII.GetBytes(cmd.data);
|
|
MemoryStream oMemoryStream = new MemoryStream(aBuffer);
|
|
Storage oStorage = new Storage();
|
|
TransportClassStorage oTransportClassStorage = new TransportClassStorage(oTransportClassTaskResult, cmd, oStorage, oMemoryStream, oTaskResultData.sKey);
|
|
oStorage.WriteFileBegin(Path.Combine(oTaskResultData.sKey, sFilename), oMemoryStream, StorageWriteFileAsyncCallback, oTransportClassStorage);
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void TaskResultAddRandomKeyAsyncCallback2(IAsyncResult ar)
|
|
{
|
|
TransportClassTaskResult oTransportClassTaskResult = ar.AsyncState as TransportClassTaskResult;
|
|
try
|
|
{
|
|
TaskResultData oTaskResultData;
|
|
ErrorTypes eError = oTransportClassTaskResult.m_oTaskResult.AddRandomKeyEnd(ar, out oTaskResultData);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
|
|
InputCommand cmd = oTransportClassTaskResult.m_oInputCommand;
|
|
TaskQueueData oTaskQueueData = new TaskQueueData(oTaskResultData.sKey, FileFormats.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF, "output.pdf");
|
|
oTaskQueueData.m_sFromKey = cmd.id;
|
|
oTaskQueueData.m_sFromFormat = "pdf";
|
|
oTaskQueueData.m_bFromOrigin = 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;
|
|
}
|
|
|
|
CTaskQueue oTaskQueue = new CTaskQueue();
|
|
TransportClassTaskQueue oTransportClassTaskQueue = new TransportClassTaskQueue(oTransportClassTaskResult, oTaskQueue, oTaskQueueData);
|
|
oTaskQueue.AddTaskBegin(oTaskQueueData, Priority.Low, TaskQueueAddCallbackSave, oTransportClassTaskQueue);
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void TaskResultAddRandomKeyAsyncCallback3(IAsyncResult ar)
|
|
{
|
|
TransportClassTaskResult oTransportClassTaskResult = ar.AsyncState as TransportClassTaskResult;
|
|
try
|
|
{
|
|
TaskResultData oTaskResultData;
|
|
ErrorTypes eError = oTransportClassTaskResult.m_oTaskResult.AddRandomKeyEnd(ar, out oTaskResultData);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
|
|
InputCommand cmd = oTransportClassTaskResult.m_oInputCommand;
|
|
int nOutputFormat = cmd.outputformat;
|
|
TaskQueueData oTaskQueueData = new TaskQueueData(oTaskResultData.sKey, nOutputFormat, "output." + FileFormats.ToString(nOutputFormat));
|
|
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;
|
|
CTaskQueue oTaskQueue = new CTaskQueue();
|
|
TransportClassTaskQueue oTransportClassTaskQueue = new TransportClassTaskQueue(oTransportClassTaskResult, oTaskQueue, oTaskQueueData);
|
|
oTaskQueue.AddTaskBegin(oTaskQueueData, oPriority, TaskQueueAddCallbackSave, oTransportClassTaskQueue);
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void StorageWriteFileAsyncCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassStorage oTransportClassStorage = ar.AsyncState as TransportClassStorage;
|
|
try
|
|
{
|
|
int nReadWriteBytes;
|
|
ErrorTypes eError = oTransportClassStorage.m_oStorage.WriteFileEnd(ar, out nReadWriteBytes);
|
|
if (null != oTransportClassStorage.m_oStream)
|
|
oTransportClassStorage.m_oStream.Dispose();
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
InputCommand cmd = oTransportClassStorage.m_oInputCommand;
|
|
if (c_sSaveTypeCompleteAll == cmd.savetype || c_sSaveTypeComplete == cmd.savetype)
|
|
{
|
|
|
|
int nOutputFormat = cmd.outputformat;
|
|
TaskQueueData oTaskQueueData = new TaskQueueData(oTransportClassStorage.m_sKey, nOutputFormat, "output." + FileFormats.ToString(nOutputFormat));
|
|
oTaskQueueData.m_sFromKey = cmd.id;
|
|
oTaskQueueData.m_sFromFormat = "bin";
|
|
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;
|
|
CTaskQueue oTaskQueue = new CTaskQueue();
|
|
TransportClassTaskQueue oTransportClassTaskQueue = new TransportClassTaskQueue(oTransportClassStorage, oTaskQueue, oTaskQueueData);
|
|
oTaskQueue.AddTaskBegin(oTaskQueueData, oPriority, TaskQueueAddCallbackSave, oTransportClassTaskQueue);
|
|
}
|
|
else
|
|
{
|
|
JavaScriptSerializer serializer = new JavaScriptSerializer();
|
|
OutputSavePartData oOutputSavePartData = new OutputSavePartData(oTransportClassStorage.m_sKey, cmd.outputformat);
|
|
WriteOutputCommand(oTransportClassStorage, new OutputCommand("savepart", serializer.Serialize(oOutputSavePartData)));
|
|
}
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassStorage, new OutputCommand(eError));
|
|
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassStorage, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void TaskQueueAddCallbackSave(IAsyncResult ar)
|
|
{
|
|
TransportClassTaskQueue oTransportClassTaskQueue = ar.AsyncState as TransportClassTaskQueue;
|
|
try
|
|
{
|
|
ErrorTypes eError = oTransportClassTaskQueue.m_oTaskQueue.AddTaskEnd(ar);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
TaskQueueData oTaskQueueData = oTransportClassTaskQueue.m_oParam as TaskQueueData;
|
|
OutputWaitSaveData oOutputWaitSaveData = new OutputWaitSaveData(oTaskQueueData.m_sKey, oTaskQueueData.m_sToFile, oTaskQueueData.m_nToFormat);
|
|
JavaScriptSerializer serializer = new JavaScriptSerializer();
|
|
WriteOutputCommand(oTransportClassTaskQueue, new OutputCommand("waitsave", serializer.Serialize(oOutputWaitSaveData)));
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassTaskQueue, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassTaskQueue, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void TaskResultGetOrCreateCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassTaskResult oTransportClassTaskResult = ar.AsyncState as TransportClassTaskResult;
|
|
try
|
|
{
|
|
TaskResultData oTaskResultData;
|
|
bool bCreate;
|
|
ErrorTypes eError = oTransportClassTaskResult.m_oTaskResult.GetOrCreateEnd(ar, out oTaskResultData, out bCreate);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
TaskResultGetProcess(oTaskResultData, bCreate, oTransportClassTaskResult.m_oInputCommand, oTransportClassTaskResult);
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void TaskResultGetOrCreateCallback2(IAsyncResult ar)
|
|
{
|
|
TransportClassTaskResult oTransportClassTaskResult = ar.AsyncState as TransportClassTaskResult;
|
|
try
|
|
{
|
|
TaskResultData oTaskResultData;
|
|
bool bCreate;
|
|
ErrorTypes eError = oTransportClassTaskResult.m_oTaskResult.GetOrCreateEnd(ar, out oTaskResultData, out bCreate);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
if (bCreate)
|
|
{
|
|
InputCommand cmd = oTransportClassTaskResult.m_oInputCommand;
|
|
MemoryStream oMemoryStream = new MemoryStream(Encoding.ASCII.GetBytes(cmd.data));
|
|
Storage oStorage = new Storage();
|
|
oStorage.CreateDirectory(cmd.id + "/media");
|
|
TransportClassStorage oTransportClassStorage = new TransportClassStorage(oTransportClassTaskResult, cmd, oStorage, oMemoryStream, cmd.id);
|
|
oStorage.WriteFileBegin(cmd.id + "/Editor.bin", oMemoryStream, EditorBinWriteCallback, oTransportClassStorage);
|
|
}
|
|
else
|
|
{
|
|
TaskResultData oTaskResultDataTemp = new TaskResultData();
|
|
oTaskResultDataTemp.eStatus = FileStatus.Ok;
|
|
oTaskResultDataTemp.nStatusInfo = (int)ErrorTypes.NoError;
|
|
TaskResultGetProcess(oTaskResultDataTemp, false, oTransportClassTaskResult.m_oInputCommand, oTransportClassTaskResult);
|
|
}
|
|
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void TaskResultGetCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassTaskResult oTransportClassTaskResult = ar.AsyncState as TransportClassTaskResult;
|
|
try
|
|
{
|
|
TaskResultData oTaskResultData;
|
|
ErrorTypes eError = oTransportClassTaskResult.m_oTaskResult.GetEnd(ar, out oTaskResultData);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
TaskResultGetProcess(oTaskResultData, false, oTransportClassTaskResult.m_oInputCommand, oTransportClassTaskResult);
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void TaskResultUpdateCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassTaskResult oTransportClassTaskResult = ar.AsyncState as TransportClassTaskResult;
|
|
try
|
|
{
|
|
ErrorTypes eError = oTransportClassTaskResult.m_oTaskResult.UpdateEnd(ar);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
|
|
InputCommand cmd = oTransportClassTaskResult.m_oInputCommand;
|
|
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(oTransportClassTaskResult, oTaskQueue, null);
|
|
oTaskQueue.AddTaskBegin(oTaskQueueData, Priority.High, TaskQueueAddCallback, oTransportClassTaskQueue);
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassTaskResult, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void TaskQueueAddCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassTaskQueue oTransportClassTaskQueue = ar.AsyncState as TransportClassTaskQueue;
|
|
try
|
|
{
|
|
ErrorTypes eError = oTransportClassTaskQueue.m_oTaskQueue.AddTaskEnd(ar);
|
|
if (ErrorTypes.NoError == eError)
|
|
WriteOutputCommand(oTransportClassTaskQueue, new OutputCommand("waitopen", "0"));
|
|
else
|
|
WriteOutputCommand(oTransportClassTaskQueue, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassTaskQueue, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void TaskResultRemoveCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassClearCache oTransportClassClearCache = ar.AsyncState as TransportClassClearCache;
|
|
try
|
|
{
|
|
ErrorTypes eError = oTransportClassClearCache.m_oAsyncClearCacheOperation.ClearCacheEnd(ar);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
WriteOutputCommand(oTransportClassClearCache, new OutputCommand("cc", "true"));
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassClearCache, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassClearCache, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void TaskResultRemoveCallback2(IAsyncResult ar)
|
|
{
|
|
TransportClassClearCache oTransportClassClearCache = ar.AsyncState as TransportClassClearCache;
|
|
try
|
|
{
|
|
ErrorTypes eError = (ErrorTypes)oTransportClassClearCache.m_oParam;
|
|
WriteOutputCommand(oTransportClassClearCache, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassClearCache, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void TaskResultRemoveCallback3(IAsyncResult ar)
|
|
{
|
|
TransportClassClearCache oTransportClassClearCache = ar.AsyncState as TransportClassClearCache;
|
|
try
|
|
{
|
|
ErrorTypes eError = oTransportClassClearCache.m_oAsyncClearCacheOperation.ClearCacheEnd(ar);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
OpenCommand(oTransportClassClearCache, oTransportClassClearCache.m_oInputCommand);
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassClearCache, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassClearCache, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void GetMediaXmlCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassMediaXml oTransportClassMediaXml = ar.AsyncState as TransportClassMediaXml;
|
|
try
|
|
{
|
|
Dictionary<string, string> aMediaXmlMapHash;
|
|
Dictionary<string, string> aMediaXmlMapFilename;
|
|
ErrorTypes eError = oTransportClassMediaXml.m_oAsyncMediaXmlOperation.GetMediaXmlEnd(ar, out aMediaXmlMapHash, out aMediaXmlMapFilename);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
oTransportClassMediaXml.m_aMediaXmlMapHash = aMediaXmlMapHash;
|
|
oTransportClassMediaXml.m_aMediaXmlMapFilename = aMediaXmlMapFilename;
|
|
|
|
string[] aUrls;
|
|
string sSupportedFormats = "";
|
|
if ("imgurl" == oTransportClassMediaXml.m_oInputCommand.c)
|
|
{
|
|
aUrls = new string[] { oTransportClassMediaXml.m_oInputCommand.data };
|
|
sSupportedFormats = ConfigurationSettings.AppSettings["limits.image.types.upload"] ?? "jpg";
|
|
}
|
|
else
|
|
{
|
|
JavaScriptSerializer oJavaScriptSerializer = new JavaScriptSerializer();
|
|
aUrls = oJavaScriptSerializer.Deserialize<string[]>(oTransportClassMediaXml.m_oInputCommand.data);
|
|
sSupportedFormats = ConfigurationSettings.AppSettings["limits.image.types.copy"] ?? "jpg";
|
|
}
|
|
TransportClassImgUrl oTransportClassImgUrl = new TransportClassImgUrl(oTransportClassMediaXml, aUrls, sSupportedFormats, DownloadImages);
|
|
DownloadImages(new AsyncOperationData(oTransportClassImgUrl));
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassMediaXml, new OutputCommand(ErrorTypes.Upload));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassMediaXml, new OutputCommand(ErrorTypes.Upload));
|
|
}
|
|
}
|
|
void DownloadImages(IAsyncResult ar)
|
|
{
|
|
TransportClassImgUrl oTransportClassImgUrl = ar.AsyncState as TransportClassImgUrl;
|
|
try
|
|
{
|
|
TransportClassMediaXml oTransportClassMediaXml = oTransportClassImgUrl.m_oTransportClassMediaXml;
|
|
string sUrl = oTransportClassImgUrl.GetNextUrl();
|
|
if (null == sUrl)
|
|
{
|
|
oTransportClassMediaXml.m_oAsyncMediaXmlOperation.WriteMediaXmlBegin(Path.Combine(oTransportClassMediaXml.m_oInputCommand.id, @"media\media.xml"), oTransportClassMediaXml.m_aMediaXmlMapHash, WriteMediaXmlCallback, oTransportClassImgUrl);
|
|
}
|
|
else
|
|
{
|
|
int nMaxBytes = Convert.ToInt32(ConfigurationSettings.AppSettings["limits.image.size"] ?? "25000000");
|
|
|
|
if ("data:" == sUrl.Substring(0, "data:".Length))
|
|
{
|
|
int nDelimiterIndex = sUrl.IndexOf(',');
|
|
if (-1 != nDelimiterIndex)
|
|
{
|
|
byte[] aBuffer = System.Convert.FromBase64String(sUrl.Substring(nDelimiterIndex + 1));
|
|
if (aBuffer.Length <= nMaxBytes)
|
|
ProcessImage(aBuffer, oTransportClassImgUrl);
|
|
else
|
|
oTransportClassImgUrl.SetErrorAndCallback(ErrorTypes.UploadContentLength);
|
|
}
|
|
else
|
|
oTransportClassImgUrl.SetErrorAndCallback(ErrorTypes.UploadExtension);
|
|
}
|
|
else
|
|
{
|
|
AsyncDownloadOperation oAsyncDownloadOperation = new AsyncDownloadOperation(nMaxBytes);
|
|
oTransportClassMediaXml.m_oDownloadOperation = oAsyncDownloadOperation;
|
|
oAsyncDownloadOperation.DownloadBegin(sUrl, DownloadDataCompleted, oTransportClassImgUrl);
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassImgUrl, new OutputCommand(ErrorTypes.Upload));
|
|
}
|
|
}
|
|
void DownloadDataCompleted(IAsyncResult ar)
|
|
{
|
|
TransportClassImgUrl oTransportClassImgUrl = ar.AsyncState as TransportClassImgUrl;
|
|
try
|
|
{
|
|
TransportClassMediaXml oTransportClassMediaXml = oTransportClassImgUrl.m_oTransportClassMediaXml;
|
|
ErrorTypes eError;
|
|
byte[] aBuffer;
|
|
oTransportClassMediaXml.m_oDownloadOperation.DownloadEnd(ar, out eError, out aBuffer);
|
|
if (ErrorTypes.NoError == eError)
|
|
ProcessImage(aBuffer, oTransportClassImgUrl);
|
|
else
|
|
oTransportClassImgUrl.SetErrorAndCallback(eError);
|
|
}
|
|
catch
|
|
{
|
|
oTransportClassImgUrl.SetErrorAndCallback(ErrorTypes.Upload);
|
|
}
|
|
}
|
|
private void ProcessImage(byte[] aBuffer, TransportClassImgUrl oTransportClassImgUrl)
|
|
{
|
|
TransportClassMediaXml oTransportClassMediaXml = oTransportClassImgUrl.m_oTransportClassMediaXml;
|
|
int nImageFormat = Utils.GetFileFormat(aBuffer);
|
|
if ((0 != (FileFormats.AVS_OFFICESTUDIO_FILE_IMAGE & nImageFormat) || FileFormats.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_SVG == nImageFormat) && -1 != oTransportClassImgUrl.m_sSupportedFormats.IndexOf(FileFormats.ToString(nImageFormat)))
|
|
{
|
|
MemoryStream ms = new MemoryStream(aBuffer);
|
|
string sHash = Utils.getMD5HexString(ms);
|
|
string sExistFilename;
|
|
if (oTransportClassMediaXml.m_aMediaXmlMapHash.TryGetValue(sHash, out sExistFilename))
|
|
{
|
|
|
|
oTransportClassImgUrl.SetUrl(Constants.mc_sResourceServiceUrlRel + oTransportClassMediaXml.m_oInputCommand.id + "/media/" + sExistFilename);
|
|
oTransportClassImgUrl.SetErrorAndCallback(ErrorTypes.NoError);
|
|
}
|
|
else
|
|
{
|
|
string ext = "." + FileFormats.ToString(nImageFormat);
|
|
string sNewName;
|
|
if(false == oTransportClassImgUrl.m_mapUrlToName.TryGetValue(oTransportClassImgUrl.m_sCurUrl, out sNewName))
|
|
{
|
|
|
|
string sSearchName = "image";
|
|
List<int> aIndexes = new List<int>();
|
|
foreach (KeyValuePair<string, string> kvp in oTransportClassMediaXml.m_aMediaXmlMapFilename)
|
|
{
|
|
string sFilename = Path.GetFileNameWithoutExtension(kvp.Key);
|
|
if (0 == sFilename.IndexOf(sSearchName))
|
|
{
|
|
int nCurIndex;
|
|
if (int.TryParse(sFilename.Substring(sSearchName.Length), out nCurIndex))
|
|
aIndexes.Add(nCurIndex);
|
|
}
|
|
}
|
|
int nMaxIndex = -1;
|
|
for (int i = 0, length = aIndexes.Count; i < length; ++i)
|
|
{
|
|
int nCurIndex = aIndexes[i];
|
|
if (nMaxIndex < nCurIndex)
|
|
nMaxIndex = nCurIndex;
|
|
}
|
|
int nNewIndex = 1;
|
|
if (nMaxIndex >= nNewIndex)
|
|
nNewIndex = nMaxIndex + 1;
|
|
sNewName = sSearchName + nNewIndex + ext;
|
|
}
|
|
if (FileFormats.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_SVG == nImageFormat)
|
|
{
|
|
|
|
string sCurUrl = oTransportClassImgUrl.m_sCurUrl;
|
|
int nExtIndex = sCurUrl.LastIndexOf(".svg");
|
|
if (-1 != nExtIndex)
|
|
{
|
|
string sStart = sCurUrl.Substring(0, nExtIndex);
|
|
string sEmfUrl = sStart + ".emf";
|
|
string sWmfUrl = sStart + ".wmf";
|
|
oTransportClassImgUrl.AddUrls(new string[] { sEmfUrl, sWmfUrl });
|
|
oTransportClassImgUrl.m_mapUrlToName[sEmfUrl] = Path.ChangeExtension(sNewName, ".emf");
|
|
oTransportClassImgUrl.m_mapUrlToName[sWmfUrl] = Path.ChangeExtension(sNewName, ".wmf");
|
|
}
|
|
}
|
|
oTransportClassMediaXml.m_aMediaXmlMapHash.Add(sHash, sNewName);
|
|
oTransportClassMediaXml.m_aMediaXmlMapFilename.Add(sNewName, sHash);
|
|
oTransportClassMediaXml.m_oStorage = new Storage();
|
|
oTransportClassMediaXml.m_oMemoryStream = ms;
|
|
oTransportClassMediaXml.m_oParam = sNewName;
|
|
ms.Position = 0;
|
|
InputCommand cmd = oTransportClassMediaXml.m_oInputCommand;
|
|
oTransportClassMediaXml.m_oStorage.WriteFileBegin(Path.Combine(cmd.id, @"media\" + sNewName), ms, WriteFileCallback, oTransportClassImgUrl);
|
|
}
|
|
}
|
|
else
|
|
oTransportClassImgUrl.SetErrorAndCallback(ErrorTypes.UploadExtension);
|
|
}
|
|
private void WriteFileCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassImgUrl oTransportClassImgUrl = ar.AsyncState as TransportClassImgUrl;
|
|
try
|
|
{
|
|
TransportClassMediaXml oTransportClassMediaXml = oTransportClassImgUrl.m_oTransportClassMediaXml;
|
|
int nReadWriteBytes;
|
|
ErrorTypes eError = oTransportClassMediaXml.m_oStorage.WriteFileEnd(ar, out nReadWriteBytes);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
|
|
oTransportClassImgUrl.SetUrl(Constants.mc_sResourceServiceUrlRel + oTransportClassMediaXml.m_oInputCommand.id + "/media/" + (string)oTransportClassMediaXml.m_oParam);
|
|
oTransportClassImgUrl.SetErrorAndCallback(ErrorTypes.NoError);
|
|
}
|
|
else
|
|
oTransportClassImgUrl.SetErrorAndCallback(ErrorTypes.Upload);
|
|
}
|
|
catch
|
|
{
|
|
oTransportClassImgUrl.SetErrorAndCallback(ErrorTypes.Upload);
|
|
}
|
|
}
|
|
private void WriteMediaXmlCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassImgUrl oTransportClassImgUrl = ar.AsyncState as TransportClassImgUrl;
|
|
try
|
|
{
|
|
TransportClassMediaXml oTransportClassMediaXml = oTransportClassImgUrl.m_oTransportClassMediaXml;
|
|
ErrorTypes eError = oTransportClassMediaXml.m_oAsyncMediaXmlOperation.WriteMediaXmlEnd(ar);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
if ("imgurl" == oTransportClassImgUrl.m_oTransportClassMediaXml.m_oInputCommand.c)
|
|
{
|
|
if (oTransportClassImgUrl.m_aErrors.Length > 0)
|
|
{
|
|
ErrorTypes eNewError = oTransportClassImgUrl.m_aErrors[0];
|
|
string sNewUrl = oTransportClassImgUrl.m_aNewUrls[0];
|
|
if (ErrorTypes.NoError == eNewError)
|
|
WriteOutputCommand(oTransportClassImgUrl, new OutputCommand("imgurl", sNewUrl));
|
|
else
|
|
WriteOutputCommand(oTransportClassImgUrl, new OutputCommand(eNewError));
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassImgUrl, new OutputCommand(ErrorTypes.Upload));
|
|
}
|
|
else
|
|
{
|
|
JavaScriptSerializer oJavaScriptSerializer = new JavaScriptSerializer();
|
|
WriteOutputCommand(oTransportClassImgUrl, new OutputCommand("imgurls", oJavaScriptSerializer.Serialize(oTransportClassImgUrl.GetFromToMap())));
|
|
}
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassImgUrl, new OutputCommand(ErrorTypes.Upload));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassImgUrl, new OutputCommand(ErrorTypes.Upload));
|
|
}
|
|
}
|
|
private void ClearCacheCallback(IAsyncResult ar)
|
|
{
|
|
TransportClassClearCache oTransportClassClearCache = ar.AsyncState as TransportClassClearCache;
|
|
try
|
|
{
|
|
ErrorTypes eError = oTransportClassClearCache.m_oAsyncClearCacheOperation.ClearCacheEnd(ar);
|
|
if (ErrorTypes.NoError == eError)
|
|
{
|
|
WriteOutputCommand(oTransportClassClearCache, new OutputCommand((ErrorTypes)oTransportClassClearCache.m_oParam));
|
|
}
|
|
else
|
|
WriteOutputCommand(oTransportClassClearCache, new OutputCommand(eError));
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassClearCache, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
private void WriteOutputCommand(TransportClassMainAshx oTransportClassMainAshx, OutputCommand oOutputCommand)
|
|
{
|
|
HttpContext oHttpContext = oTransportClassMainAshx.m_oHttpContext;
|
|
AsyncCallback fAsyncCallback = oTransportClassMainAshx.m_oAsyncCallback;
|
|
oHttpContext.Response.ContentType = "text/plain";
|
|
DataContractJsonSerializer serOut = new DataContractJsonSerializer(typeof(OutputCommand));
|
|
serOut.WriteObject(oHttpContext.Response.OutputStream, oOutputCommand);
|
|
|
|
fAsyncCallback.Invoke(new AsyncOperationData(null));
|
|
}
|
|
#endregion
|
|
#region HelpFunction
|
|
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;
|
|
oTaskResultData.oLastOpenDate = DateTime.UtcNow;
|
|
|
|
if (false == string.IsNullOrEmpty(cmd.title))
|
|
oTaskResultData.sTitle = cmd.title;
|
|
|
|
TaskResult oTaskResult = new TaskResult();
|
|
TransportClassTaskResult oTransportClassTaskResult = new TransportClassTaskResult(oTransportClassContextRead, cmd, oTaskResult);
|
|
|
|
oTaskResult.GetOrCreateBegin(cmd.id, oTaskResultData, TaskResultGetOrCreateCallback2, oTransportClassTaskResult);
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassContextRead, new OutputCommand(ErrorTypes.Unknown));
|
|
}
|
|
}
|
|
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;
|
|
oTaskResultData.oLastOpenDate = DateTime.UtcNow;
|
|
|
|
if (false == string.IsNullOrEmpty(cmd.title))
|
|
oTaskResultData.sTitle = cmd.title;
|
|
|
|
TaskResult oTaskResult = new TaskResult();
|
|
TransportClassTaskResult oTransportClassClearCache = new TransportClassTaskResult(oTransportClassMainAshx, cmd, oTaskResult);
|
|
|
|
oTaskResult.GetOrCreateBegin(cmd.id, oTaskResultData, TaskResultGetOrCreateCallback, oTransportClassClearCache);
|
|
}
|
|
catch
|
|
{
|
|
WriteOutputCommand(oTransportClassMainAshx, 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);
|
|
}
|
|
if ("create" == cmd.c)
|
|
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand("create", cmd.id + "/Editor.bin"));
|
|
else
|
|
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand("open", 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;
|
|
TaskResult oTaskResult = new TaskResult();
|
|
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;
|
|
default:
|
|
WriteOutputCommand(oTransportClassMainAshx, new OutputCommand(ErrorTypes.Unknown));
|
|
break;
|
|
}
|
|
}
|
|
#endregion
|
|
#region TransportClasses
|
|
private class TransportClassContextRead : TransportClassMainAshx
|
|
{
|
|
public AsyncContextReadOperation m_oAsyncContextReadOperation;
|
|
public TransportClassContextRead(TransportClassMainAshx m_oTransportClassMainAshx, AsyncContextReadOperation oAsyncContextReadOperation)
|
|
: base(m_oTransportClassMainAshx.m_oHttpContext, m_oTransportClassMainAshx.m_oAsyncCallback)
|
|
{
|
|
m_oAsyncContextReadOperation = oAsyncContextReadOperation;
|
|
}
|
|
}
|
|
private class TransportClassTaskResult : TransportClassMainAshx
|
|
{
|
|
public InputCommand m_oInputCommand;
|
|
public TaskResult m_oTaskResult;
|
|
public TransportClassTaskResult(TransportClassMainAshx oTransportClassMainAshx, InputCommand oInputCommand, TaskResult oTaskResult)
|
|
: base(oTransportClassMainAshx.m_oHttpContext, oTransportClassMainAshx.m_oAsyncCallback)
|
|
{
|
|
m_oInputCommand = oInputCommand;
|
|
m_oTaskResult = oTaskResult;
|
|
}
|
|
}
|
|
private class TransportClassStorage : TransportClassMainAshx
|
|
{
|
|
public InputCommand m_oInputCommand;
|
|
public Storage m_oStorage;
|
|
public Stream m_oStream;
|
|
public string m_sKey;
|
|
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 class TransportClassStorage2 : TransportClassStorage
|
|
{
|
|
public string m_sFilename;
|
|
public string m_sExt;
|
|
public OutputCommand m_oOutputCommand;
|
|
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 class TransportClassTaskQueue : TransportClassMainAshx
|
|
{
|
|
public CTaskQueue m_oTaskQueue;
|
|
public object m_oParam;
|
|
public TransportClassTaskQueue(TransportClassMainAshx oTransportClassMainAshx, CTaskQueue oTaskQueue, object oParam)
|
|
: base(oTransportClassMainAshx.m_oHttpContext, oTransportClassMainAshx.m_oAsyncCallback)
|
|
{
|
|
m_oTaskQueue = oTaskQueue;
|
|
m_oParam = oParam;
|
|
}
|
|
}
|
|
private class TransportClassClearCache : TransportClassMainAshx
|
|
{
|
|
public AsyncClearCacheOperation m_oAsyncClearCacheOperation;
|
|
public InputCommand m_oInputCommand;
|
|
public object m_oParam;
|
|
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 class TransportClassMediaXml : TransportClassMainAshx
|
|
{
|
|
public AsyncMediaXmlOperation m_oAsyncMediaXmlOperation;
|
|
public AsyncDownloadOperation m_oDownloadOperation;
|
|
public InputCommand m_oInputCommand;
|
|
public Dictionary<string, string> m_aMediaXmlMapHash;
|
|
public Dictionary<string, string> m_aMediaXmlMapFilename;
|
|
public Storage m_oStorage;
|
|
public MemoryStream m_oMemoryStream;
|
|
public object m_oParam;
|
|
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;
|
|
}
|
|
}
|
|
private class TransportClassImgUrl : TransportClassMainAshx
|
|
{
|
|
public delegate void TransportClassImgUrlErrorCallback(IAsyncResult ar);
|
|
public TransportClassMediaXml m_oTransportClassMediaXml;
|
|
public string[] m_aUrls;
|
|
private int m_nIndex;
|
|
public string[] m_aNewUrls;
|
|
public ErrorTypes[] m_aErrors;
|
|
public string m_sSupportedFormats;
|
|
public string m_sCurUrl;
|
|
public Dictionary<string, string> m_mapUrlToName = new Dictionary<string, string>();
|
|
private TransportClassImgUrlErrorCallback m_oTransportClassImgUrlErrorCallback;
|
|
public TransportClassImgUrl(TransportClassMediaXml oTransportClassMediaXml, string[] aUrls, string sSupportedFormats, TransportClassImgUrlErrorCallback oTransportClassImgUrlErrorCallback)
|
|
: base(oTransportClassMediaXml.m_oHttpContext, oTransportClassMediaXml.m_oAsyncCallback)
|
|
{
|
|
m_oTransportClassMediaXml = oTransportClassMediaXml;
|
|
m_oTransportClassImgUrlErrorCallback = oTransportClassImgUrlErrorCallback;
|
|
m_aUrls = aUrls;
|
|
m_nIndex = 0;
|
|
m_aNewUrls = new string[m_aUrls.Length];
|
|
m_aErrors = new ErrorTypes[m_aUrls.Length];
|
|
m_sSupportedFormats = sSupportedFormats;
|
|
for (int i = 0, length = m_aUrls.Length; i < length; ++i)
|
|
{
|
|
m_aErrors[i] = ErrorTypes.Unknown;
|
|
m_aNewUrls[i] = "error";
|
|
}
|
|
}
|
|
public void AddUrls(string[] aUrls)
|
|
{
|
|
if (aUrls.Length > 0)
|
|
{
|
|
int nCurLength = m_aUrls.Length;
|
|
int nAddLength = aUrls.Length;
|
|
string[] aTempUrls = new string[nCurLength + nAddLength];
|
|
m_aUrls.CopyTo(aTempUrls, 0);
|
|
aUrls.CopyTo(aTempUrls, nCurLength);
|
|
m_aUrls = aTempUrls;
|
|
string[] aTempNewUrls = new string[nCurLength + nAddLength];
|
|
m_aNewUrls.CopyTo(aTempNewUrls, 0);
|
|
m_aNewUrls = aTempNewUrls;
|
|
ErrorTypes[] aTempErrors = new ErrorTypes[nCurLength + nAddLength];
|
|
m_aErrors.CopyTo(aTempErrors, 0);
|
|
m_aErrors = aTempErrors;
|
|
for (int i = 0; i < nAddLength; i++)
|
|
{
|
|
m_aErrors[nCurLength + i] = ErrorTypes.Unknown;
|
|
m_aNewUrls[nCurLength + i] = "error";
|
|
}
|
|
|
|
}
|
|
}
|
|
public string GetNextUrl()
|
|
{
|
|
string sRes = null;
|
|
if (m_nIndex < m_aUrls.Length)
|
|
{
|
|
sRes = m_aUrls[m_nIndex];
|
|
m_nIndex++;
|
|
}
|
|
m_sCurUrl = sRes;
|
|
return sRes;
|
|
}
|
|
public void SetErrorAndCallback(ErrorTypes eError)
|
|
{
|
|
if (m_nIndex - 1 < m_aUrls.Length)
|
|
m_aErrors[m_nIndex - 1] = eError;
|
|
if (null != m_oTransportClassImgUrlErrorCallback)
|
|
m_oTransportClassImgUrlErrorCallback.Invoke(new AsyncOperationData(this));
|
|
}
|
|
public void SetUrl(string sUrl)
|
|
{
|
|
if (m_nIndex - 1 < m_aUrls.Length)
|
|
m_aNewUrls[m_nIndex - 1] = sUrl;
|
|
}
|
|
public Dictionary<string, string> GetFromToMap()
|
|
{
|
|
Dictionary<string, string> oFromTo = new Dictionary<string, string>();
|
|
for (int i = 0, length1 = m_aUrls.Length, length2 = m_aNewUrls.Length; i < length1 && i < length2; i++)
|
|
oFromTo[m_aUrls[i]] = m_aNewUrls[i];
|
|
return oFromTo;
|
|
}
|
|
}
|
|
public class InputCommand
|
|
{
|
|
public string id { get; set; }
|
|
public string format { get; set; }
|
|
public int editorid { get; set; }
|
|
public string c { get; set; }
|
|
public string url { get; set; }
|
|
public string vkey { get; set; }
|
|
public string title { get; set; }
|
|
public string data { get; set; }
|
|
public int outputformat { get; set; }
|
|
public string savetype { get; set; }
|
|
public string savekey { get; set; }
|
|
public int? codepage { get; set; }
|
|
public int? delimiter { get; set; }
|
|
public bool embeddedfonts { get; set; }
|
|
public bool innersave { get; set; }
|
|
public string userid { get; set; }
|
|
|
|
public string t { get; set; }
|
|
public string v { get; set; }
|
|
|
|
public InputCommand()
|
|
{
|
|
innersave = false;
|
|
}
|
|
}
|
|
[DataContract]
|
|
public class OutputCommand
|
|
{
|
|
[DataMember]
|
|
internal string type;
|
|
[DataMember]
|
|
internal string data;
|
|
public OutputCommand(string t, string d)
|
|
{
|
|
type = t;
|
|
data = d;
|
|
}
|
|
public OutputCommand(ErrorTypes eError)
|
|
{
|
|
type = "err";
|
|
data = eError.ToString("d");
|
|
}
|
|
}
|
|
public class OutputWaitSaveData
|
|
{
|
|
public string key;
|
|
public string filename;
|
|
public int format;
|
|
public OutputWaitSaveData()
|
|
{
|
|
}
|
|
public OutputWaitSaveData(string _key, string _filename, int _format)
|
|
{
|
|
key = _key;
|
|
filename = _filename;
|
|
format = _format;
|
|
}
|
|
}
|
|
public class OutputSavePartData
|
|
{
|
|
public string savekey;
|
|
public int format;
|
|
public OutputSavePartData()
|
|
{
|
|
}
|
|
public OutputSavePartData(string _savekey, int _format)
|
|
{
|
|
savekey = _savekey;
|
|
format = _format;
|
|
}
|
|
}
|
|
|
|
public enum TrackingType {
|
|
TT_USER_COUNT = 0,
|
|
TT_ACTIVE_CONNECTION = 1,
|
|
TT_TIME_USAGE = 2,
|
|
TT_DOCUMENT_SESSION = 3,
|
|
TT_NONE = 4,
|
|
TT_USER_COUNT2 = 5
|
|
};
|
|
public class OutputSettingsTrackingData
|
|
{
|
|
public TrackingType trackingType;
|
|
public string licenseId;
|
|
public string trackingUrl;
|
|
}
|
|
|
|
public class OutputSettingsData
|
|
{
|
|
public bool canEdit;
|
|
public bool canDownload;
|
|
public bool canCoAuthoring;
|
|
public bool canReaderMode;
|
|
public bool canAd;
|
|
public bool canBranding;
|
|
public bool isAutosaveEnable;
|
|
public int AutosaveMinInterval;
|
|
public string g_cAscCoAuthoringUrl;
|
|
public string g_cAscSpellCheckUrl;
|
|
|
|
public OutputSettingsTrackingData trackingInfo;
|
|
|
|
public int TrackingInterval;
|
|
|
|
public OutputSettingsData()
|
|
{
|
|
canEdit = true;
|
|
canDownload = true;
|
|
canCoAuthoring = true;
|
|
canReaderMode = true;
|
|
canAd = true;
|
|
canBranding = true;
|
|
|
|
isAutosaveEnable = bool.Parse(ConfigurationSettings.AppSettings["editor.settings.autosave.enable1"] ?? "true");
|
|
AutosaveMinInterval = int.Parse(ConfigurationSettings.AppSettings["editor.settings.autosave.mininterval1"] ?? "300");
|
|
|
|
g_cAscCoAuthoringUrl = ConfigurationSettings.AppSettings["editor.settings.coauthoring.url"] ?? "";
|
|
g_cAscSpellCheckUrl = ConfigurationSettings.AppSettings["editor.settings.spellchecker.url"] ?? "";
|
|
|
|
trackingInfo = null;
|
|
|
|
TrackingInterval = int.Parse(ConfigurationSettings.AppSettings["license.activeconnections.tracking.interval"] ?? "300");
|
|
}
|
|
public OutputSettingsData(LicenseInfo.LicenseRights oRights, string sFormat, OutputSettingsTrackingData oTrackingInfo)
|
|
: this()
|
|
{
|
|
if (null != sFormat)
|
|
{
|
|
sFormat = sFormat.ToLower();
|
|
|
|
char[] aDelemiters = { '|', ',', ';' };
|
|
string sReaderFormats = ConfigurationSettings.AppSettings["editor.settings.readerformats"] ?? "";
|
|
List<string> aReaderFormats = (sReaderFormats.Split(aDelemiters, StringSplitOptions.RemoveEmptyEntries)).ToList();
|
|
canReaderMode = aReaderFormats.Contains(sFormat);
|
|
|
|
string sEditorFormats = ConfigurationSettings.AppSettings["editor.settings.editorformats"] ?? "";
|
|
List<string> aEditorFormats = (sEditorFormats.Split(aDelemiters, StringSplitOptions.RemoveEmptyEntries)).ToList();
|
|
canEdit = aEditorFormats.Contains(sFormat);
|
|
|
|
string sViewerFormats = ConfigurationSettings.AppSettings["editor.settings.viewerformats"] ?? "";
|
|
List<string> aViewerFormats = (sViewerFormats.Split(aDelemiters, StringSplitOptions.RemoveEmptyEntries)).ToList();
|
|
canDownload = !aViewerFormats.Contains(sFormat);
|
|
}
|
|
|
|
if (null != oRights)
|
|
{
|
|
canEdit &= oRights.CanSave;
|
|
canCoAuthoring = oRights.CanCoAuthoring;
|
|
canBranding = oRights.CanBranding;
|
|
canDownload &= oRights.CanExport;
|
|
|
|
}
|
|
|
|
if (null != oTrackingInfo)
|
|
{
|
|
trackingInfo = oTrackingInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
} |