mirror of
https://github.com/ONLYOFFICE/document-server-integration.git
synced 2026-04-07 14:06:11 +08:00
375 lines
14 KiB
C#
375 lines
14 KiB
C#
/**
|
|
*
|
|
* (c) Copyright Ascensio System SIA 2021
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Web;
|
|
using System.Web.Script.Serialization;
|
|
using System.Web.Services;
|
|
using System.Web.Configuration;
|
|
using OnlineEditorsExampleMVC.Helpers;
|
|
using OnlineEditorsExampleMVC.Models;
|
|
using System.Diagnostics;
|
|
|
|
namespace OnlineEditorsExampleMVC
|
|
{
|
|
[WebService(Namespace = "http://tempuri.org/")]
|
|
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
|
|
public class WebEditor : IHttpHandler
|
|
{
|
|
public void ProcessRequest(HttpContext context)
|
|
{
|
|
switch (context.Request["type"])
|
|
{
|
|
case "upload":
|
|
Upload(context);
|
|
break;
|
|
case "download":
|
|
Download(context);
|
|
break;
|
|
case "convert":
|
|
Convert(context);
|
|
break;
|
|
case "track":
|
|
Track(context);
|
|
break;
|
|
case "remove":
|
|
Remove(context);
|
|
break;
|
|
case "assets":
|
|
Assets(context);
|
|
break;
|
|
case "csv":
|
|
GetCsv(context);
|
|
break;
|
|
case "files":
|
|
Files(context);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static void Upload(HttpContext context)
|
|
{
|
|
context.Response.ContentType = "text/plain";
|
|
try
|
|
{
|
|
var httpPostedFile = context.Request.Files[0];
|
|
string fileName;
|
|
|
|
if (HttpContext.Current.Request.Browser.Browser.ToUpper() == "IE")
|
|
{
|
|
var files = httpPostedFile.FileName.Split(new char[] { '\\' });
|
|
fileName = files[files.Length - 1];
|
|
}
|
|
else
|
|
{
|
|
fileName = httpPostedFile.FileName;
|
|
}
|
|
|
|
var curSize = httpPostedFile.ContentLength;
|
|
if (DocManagerHelper.MaxFileSize < curSize || curSize <= 0)
|
|
{
|
|
throw new Exception("File size is incorrect");
|
|
}
|
|
|
|
var curExt = (Path.GetExtension(fileName) ?? "").ToLower();
|
|
if (!DocManagerHelper.FileExts.Contains(curExt))
|
|
{
|
|
throw new Exception("File type is not supported");
|
|
}
|
|
|
|
fileName = DocManagerHelper.GetCorrectName(fileName);
|
|
var documentType = FileUtility.GetFileType(fileName).ToString().ToLower();
|
|
|
|
var savedFileName = DocManagerHelper.StoragePath(fileName);
|
|
httpPostedFile.SaveAs(savedFileName);
|
|
DocManagerHelper.CreateMeta(fileName, context.Request.Cookies.GetOrDefault("uid", ""), context.Request.Cookies.GetOrDefault("uname", ""));
|
|
|
|
context.Response.Write("{ \"filename\": \"" + fileName + "\", \"documentType\": \"" + documentType + "\"}");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
context.Response.Write("{ \"error\": \"" + e.Message + "\"}");
|
|
}
|
|
}
|
|
|
|
private static void Convert(HttpContext context)
|
|
{
|
|
context.Response.ContentType = "text/plain";
|
|
try
|
|
{
|
|
string fileData;
|
|
|
|
using (var receiveStream = context.Request.InputStream)
|
|
using (var readStream = new StreamReader(receiveStream))
|
|
{
|
|
fileData = readStream.ReadToEnd();
|
|
if (string.IsNullOrEmpty(fileData)) context.Response.Write("{\"error\":1,\"message\":\"Request stream is empty\"}");
|
|
}
|
|
|
|
var jss = new JavaScriptSerializer();
|
|
var body = jss.Deserialize<Dictionary<string, object>>(fileData);
|
|
|
|
var fileName = Path.GetFileName(body["filename"].ToString());
|
|
var filePass = body["filePass"] != null ? body["filePass"].ToString() : null;
|
|
var fileUri = DocManagerHelper.GetFileUri(fileName, true);
|
|
|
|
var extension = (Path.GetExtension(fileUri).ToLower() ?? "").Trim('.');
|
|
var internalExtension = DocManagerHelper.GetInternalExtension(FileUtility.GetFileType(fileName)).Trim('.');
|
|
|
|
if (DocManagerHelper.ConvertExts.Contains("." + extension)
|
|
&& !string.IsNullOrEmpty(internalExtension))
|
|
{
|
|
var key = ServiceConverter.GenerateRevisionId(fileUri);
|
|
|
|
var downloadUri = new UriBuilder(DocManagerHelper.GetServerUrl(true))
|
|
{
|
|
Path = HttpRuntime.AppDomainAppVirtualPath
|
|
+ (HttpRuntime.AppDomainAppVirtualPath.EndsWith("/") ? "" : "/")
|
|
+ "webeditor.ashx",
|
|
Query = "type=download&fileName=" + HttpUtility.UrlEncode(fileName)
|
|
};
|
|
|
|
string newFileUri;
|
|
var result = ServiceConverter.GetConvertedUri(downloadUri.ToString(), extension, internalExtension, key, true, out newFileUri, filePass);
|
|
if (result != 100)
|
|
{
|
|
context.Response.Write("{ \"step\" : \"" + result + "\", \"filename\" : \"" + fileName + "\"}");
|
|
return;
|
|
}
|
|
|
|
var correctName = DocManagerHelper.GetCorrectName(Path.GetFileNameWithoutExtension(fileName) + "." + internalExtension);
|
|
|
|
var req = (HttpWebRequest)WebRequest.Create(newFileUri);
|
|
|
|
using (var stream = req.GetResponse().GetResponseStream())
|
|
{
|
|
if (stream == null) throw new Exception("Stream is null");
|
|
const int bufferSize = 4096;
|
|
|
|
using (var fs = File.Open(DocManagerHelper.StoragePath(correctName), FileMode.Create))
|
|
{
|
|
var buffer = new byte[bufferSize];
|
|
int readed;
|
|
while ((readed = stream.Read(buffer, 0, bufferSize)) != 0)
|
|
{
|
|
fs.Write(buffer, 0, readed);
|
|
}
|
|
}
|
|
}
|
|
|
|
Remove(fileName);
|
|
fileName = correctName;
|
|
DocManagerHelper.CreateMeta(fileName, context.Request.Cookies.GetOrDefault("uid", ""), context.Request.Cookies.GetOrDefault("uname", ""));
|
|
}
|
|
|
|
var documentType = FileUtility.GetFileType(fileName).ToString().ToLower();
|
|
context.Response.Write("{ \"filename\" : \"" + fileName + "\", \"documentType\": \"" + documentType + "\" }");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
context.Response.Write("{ \"error\": \"" + e.Message + "\"}");
|
|
}
|
|
}
|
|
|
|
private enum TrackerStatus
|
|
{
|
|
NotFound = 0,
|
|
Editing = 1,
|
|
MustSave = 2,
|
|
Corrupted = 3,
|
|
Closed = 4,
|
|
MustForceSave = 6,
|
|
CorruptedForceSave = 7
|
|
}
|
|
|
|
private static void Track(HttpContext context)
|
|
{
|
|
var fileData = TrackManager.readBody(context);
|
|
|
|
var userAddress = context.Request["userAddress"];
|
|
var fileName = Path.GetFileName(context.Request["fileName"]);
|
|
var status = (TrackerStatus) (int) fileData["status"];
|
|
var saved = 1;
|
|
switch (status)
|
|
{
|
|
case TrackerStatus.Editing:
|
|
try
|
|
{
|
|
var jss = new JavaScriptSerializer();
|
|
var actions = jss.Deserialize <List<object>> (jss.Serialize(fileData["actions"]));
|
|
var action = jss.Deserialize <Dictionary<string, object>> (jss.Serialize(actions[0]));
|
|
if (action != null && action["type"].ToString().Equals("0"))
|
|
{
|
|
var user = action["userid"].ToString();
|
|
var users = jss.Deserialize<List<object>>(jss.Serialize(fileData["users"]));
|
|
if (!users.Contains(user))
|
|
{
|
|
TrackManager.commandRequest("forcesave", fileData["key"].ToString());
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.Print(e.StackTrace);
|
|
}
|
|
break;
|
|
|
|
case TrackerStatus.MustSave:
|
|
case TrackerStatus.Corrupted:
|
|
try
|
|
{
|
|
saved = TrackManager.processSave(fileData, fileName, userAddress);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
saved = 1;
|
|
}
|
|
context.Response.Write("{\"error\":" + saved + "}");
|
|
return;
|
|
|
|
case TrackerStatus.MustForceSave:
|
|
case TrackerStatus.CorruptedForceSave:
|
|
try
|
|
{
|
|
saved = TrackManager.processForceSave(fileData, fileName, userAddress);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
saved = 1;
|
|
}
|
|
context.Response.Write("{\"error\":" + saved + "}");
|
|
return;
|
|
}
|
|
|
|
context.Response.Write("{\"error\":0}");
|
|
}
|
|
|
|
private static void Remove(HttpContext context)
|
|
{
|
|
context.Response.ContentType = "text/plain";
|
|
try
|
|
{
|
|
var fileName = Path.GetFileName(context.Request["fileName"]);
|
|
Remove(fileName);
|
|
|
|
context.Response.Write("{ \"success\": true }");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
context.Response.Write("{ \"error\": \"" + e.Message + "\"}");
|
|
}
|
|
}
|
|
|
|
private static void Remove(string fileName)
|
|
{
|
|
var path = DocManagerHelper.StoragePath(fileName, null);
|
|
var histDir = DocManagerHelper.HistoryDir(path);
|
|
|
|
if (File.Exists(path)) File.Delete(path);
|
|
if (Directory.Exists(histDir)) Directory.Delete(histDir, true);
|
|
}
|
|
|
|
private static void Files(HttpContext context)
|
|
{
|
|
List<Dictionary<string, object>> files = null;
|
|
|
|
try
|
|
{
|
|
var jss = new JavaScriptSerializer();
|
|
context.Response.ContentType = "application/json";
|
|
|
|
if (context.Request["fileId"] == null)
|
|
{
|
|
files = DocManagerHelper.GetFilesInfo();
|
|
context.Response.Write(jss.Serialize(files));
|
|
}
|
|
else
|
|
{
|
|
var fileId = context.Request["fileId"];
|
|
files = DocManagerHelper.GetFilesInfo(fileId);
|
|
if (files.Count == 0)
|
|
{
|
|
context.Response.Write("\"File not found\"");
|
|
}
|
|
else
|
|
{
|
|
context.Response.Write(jss.Serialize(files));
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
context.Response.Write("{ \"error\": \"" + e.Message + "\"}");
|
|
}
|
|
}
|
|
|
|
private static void Assets(HttpContext context)
|
|
{
|
|
var fileName = Path.GetFileName(context.Request["filename"]);
|
|
var filePath = HttpRuntime.AppDomainAppPath + "assets/sample/" + fileName;
|
|
download(filePath, context);
|
|
}
|
|
|
|
private static void GetCsv(HttpContext context)
|
|
{
|
|
var fileName = "csv.csv";
|
|
var filePath = HttpRuntime.AppDomainAppPath + "assets/sample/" + fileName;
|
|
download(filePath, context);
|
|
}
|
|
|
|
private static void Download(HttpContext context)
|
|
{
|
|
try
|
|
{
|
|
var fileName = Path.GetFileName(context.Request["filename"]);
|
|
|
|
var filePath = DocManagerHelper.ForcesavePath(fileName, null, false);
|
|
if (filePath.Equals(""))
|
|
{
|
|
filePath = DocManagerHelper.StoragePath(fileName, null);
|
|
}
|
|
download(filePath, context);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
context.Response.Write("{ \"error\": \"File not found!\"}");
|
|
}
|
|
}
|
|
|
|
private static void download(string filePath, HttpContext context)
|
|
{
|
|
var fileinf = new FileInfo(filePath);
|
|
context.Response.AddHeader("Content-Length", fileinf.Length.ToString());
|
|
context.Response.AddHeader("Content-Type", MimeMapping.GetMimeMapping(filePath));
|
|
var tmp = HttpUtility.UrlEncode(Path.GetFileName(filePath));
|
|
tmp = tmp.Replace("+", "%20");
|
|
context.Response.AddHeader("Content-Disposition", "attachment; filename*=UTF-8\'\'" + tmp);
|
|
context.Response.TransmitFile(filePath);
|
|
}
|
|
|
|
public bool IsReusable
|
|
{
|
|
get { return false; }
|
|
}
|
|
}
|
|
} |