mirror of
https://github.com/ONLYOFFICE/document-server-integration.git
synced 2026-02-10 18:05:10 +08:00
641 lines
26 KiB
C#
641 lines
26 KiB
C#
/**
|
|
*
|
|
* (c) Copyright Ascensio System SIA 2025
|
|
*
|
|
* 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.Text.RegularExpressions;
|
|
using System.Web;
|
|
using System.Web.Configuration;
|
|
using System.Web.Script.Serialization;
|
|
using System.Web.UI;
|
|
using ASC.Api.DocumentConverter;
|
|
|
|
namespace OnlineEditorsExample
|
|
{
|
|
public partial class _Default : Page
|
|
{
|
|
|
|
//get server version
|
|
public static string GetVersion()
|
|
{
|
|
return WebConfigurationManager.AppSettings["version"];
|
|
}
|
|
|
|
// get the virtual path
|
|
public static string VirtualPath
|
|
{
|
|
get
|
|
{
|
|
return Path.IsPathRooted(WebConfigurationManager.AppSettings["storage-path"]) ?
|
|
WebConfigurationManager.AppSettings["storage-path"] + "/"
|
|
:
|
|
HttpRuntime.AppDomainAppVirtualPath
|
|
+ (HttpRuntime.AppDomainAppVirtualPath.EndsWith("/") ? "" : "/")
|
|
+ WebConfigurationManager.AppSettings["storage-path"]
|
|
+ CurUserHostAddress(null) + "/";
|
|
}
|
|
}
|
|
|
|
private static bool? _ismono;
|
|
|
|
public static bool IsMono
|
|
{
|
|
get { return _ismono.HasValue ? _ismono.Value : (_ismono = (bool?)(Type.GetType("Mono.Runtime") != null)).Value; }
|
|
}
|
|
|
|
// get maximum file size
|
|
private static long MaxFileSize
|
|
{
|
|
get
|
|
{
|
|
long size;
|
|
long.TryParse(WebConfigurationManager.AppSettings["filesize-max"], out size);
|
|
return size > 0 ? size : 5*1024*1024;
|
|
}
|
|
}
|
|
|
|
// get all the supported file extensions
|
|
private static List<string> FileExts
|
|
{
|
|
get { return ViewedExts.Concat(EditedExts).Concat(ConvertExts).Concat(FillFormsExts).ToList(); }
|
|
}
|
|
|
|
// file extensions that can be viewed
|
|
private static List<string> ViewedExts
|
|
{
|
|
get { return FormatManager.ViewableExtensions(); }
|
|
}
|
|
|
|
public static List<string> FillFormsExts
|
|
{
|
|
get { return FormatManager.FillableExtensions(); }
|
|
}
|
|
|
|
// file extensions that can be edited
|
|
public static List<string> EditedExts
|
|
{
|
|
get { return FormatManager.EditableExtensions(); }
|
|
}
|
|
|
|
// file extensions that can be converted
|
|
public static List<string> ConvertExts
|
|
{
|
|
get { return FormatManager.ConvertibleExtensions(); }
|
|
}
|
|
|
|
private static string _fileName;
|
|
|
|
// get current user host address
|
|
public static string CurUserHostAddress(string userAddress)
|
|
{
|
|
return Regex.Replace(userAddress ?? HttpContext.Current.Request.UserHostAddress, "[^0-9a-zA-Z.=]", "_");
|
|
}
|
|
|
|
// get the storage path of the given file
|
|
public static string StoragePath(string fileName, string userAddress)
|
|
{
|
|
var directory = "";
|
|
if (Path.IsPathRooted(WebConfigurationManager.AppSettings["storage-path"]))
|
|
{
|
|
directory = WebConfigurationManager.AppSettings["storage-path"] + "\\";
|
|
}
|
|
else
|
|
{
|
|
directory = HttpRuntime.AppDomainAppPath + WebConfigurationManager.AppSettings["storage-path"] + CurUserHostAddress(userAddress) + "\\";
|
|
}
|
|
|
|
if (!Directory.Exists(directory))
|
|
{
|
|
Directory.CreateDirectory(directory); // if the file directory doesn't exist, make it
|
|
}
|
|
return directory + (fileName.Contains("\\") ? fileName : Path.GetFileName(fileName));
|
|
}
|
|
|
|
// get the path to the history file version
|
|
public static string HistoryPath(string fileName, string userAddress, string version, string file)
|
|
{
|
|
var directory = "";
|
|
if (Path.IsPathRooted(WebConfigurationManager.AppSettings["storage-path"]))
|
|
{
|
|
directory = WebConfigurationManager.AppSettings["storage-path"] + "\\";
|
|
}
|
|
else
|
|
{
|
|
directory = HttpRuntime.AppDomainAppPath + WebConfigurationManager.AppSettings["storage-path"] + CurUserHostAddress(userAddress) + "\\";
|
|
}
|
|
var filepath = directory + Path.GetFileName(fileName) + "-hist" + "\\" + version + "\\" + file;
|
|
return filepath;
|
|
}
|
|
|
|
// get the path to the forcesaved file version
|
|
public static string ForcesavePath(string fileName, string userAddress, Boolean create)
|
|
{
|
|
var directory = "";
|
|
if (Path.IsPathRooted(WebConfigurationManager.AppSettings["storage-path"]))
|
|
{
|
|
directory = WebConfigurationManager.AppSettings["storage-path"] + "\\";
|
|
}
|
|
else
|
|
{
|
|
directory = HttpRuntime.AppDomainAppPath + WebConfigurationManager.AppSettings["storage-path"] + CurUserHostAddress(userAddress) + "\\";
|
|
}
|
|
|
|
if (!Directory.Exists(directory)) // the directory with host address doesn't exist
|
|
{
|
|
return "";
|
|
}
|
|
|
|
directory = directory + Path.GetFileName(fileName) + "-hist" + "\\"; // get the path to the history of the given file
|
|
if (!Directory.Exists(directory))
|
|
{
|
|
if (create) // create history directory if it doesn't exist
|
|
{
|
|
Directory.CreateDirectory(directory);
|
|
}
|
|
else // the history directory doesn't exist and we are not supposed to create it
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
directory = directory + Path.GetFileName(fileName); // get the path to the given file
|
|
if (!File.Exists(directory))
|
|
{
|
|
if (!create)
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
return directory;
|
|
}
|
|
|
|
// create the path to the file history
|
|
public static string HistoryDir(string storagePath)
|
|
{
|
|
return storagePath += "-hist";
|
|
}
|
|
|
|
// get the path to the specified file version by its history directory
|
|
public static string VersionDir(string histPath, int version)
|
|
{
|
|
return Path.Combine(histPath, version.ToString());
|
|
}
|
|
|
|
// get the path to the specified file version by the file name and the user address
|
|
public static string VersionDir(string fileName, string userAddress, int version)
|
|
{
|
|
return VersionDir(HistoryDir(StoragePath(fileName, userAddress)), version);
|
|
}
|
|
|
|
// get the last file version by its history directory
|
|
public static int GetFileVersion(string historyPath)
|
|
{
|
|
if (!Directory.Exists(historyPath)) return 1;
|
|
return Directory.EnumerateDirectories(historyPath).Count() + 1; // run through all the file versions and count them
|
|
}
|
|
|
|
// get the last file version by the file name and the user address
|
|
public static int GetFileVersion(string fileName, string userAddress)
|
|
{
|
|
return GetFileVersion(HistoryDir(StoragePath(fileName, userAddress)));
|
|
}
|
|
|
|
// get url to the original file
|
|
public static string FileUri(string fileName, Boolean forDocumentServer)
|
|
{
|
|
var uri = new UriBuilder(GetServerUrl(forDocumentServer));
|
|
uri.Path = VirtualPath + fileName; // get full url address to the file
|
|
return uri.ToString();
|
|
}
|
|
|
|
// get server url
|
|
public static string GetServerUrl(Boolean forDocumentServer)
|
|
{
|
|
if (forDocumentServer && !WebConfigurationManager.AppSettings["files.docservice.url.example"].Equals(""))
|
|
{
|
|
return WebConfigurationManager.AppSettings["files.docservice.url.example"];
|
|
}
|
|
else
|
|
{
|
|
var uri = new UriBuilder(HttpContext.Current.Request.Url) { Query = "" };
|
|
var requestHost = HttpContext.Current.Request.Headers["Host"];
|
|
if (!string.IsNullOrEmpty(requestHost))
|
|
uri = new UriBuilder(uri.Scheme + "://" + requestHost);
|
|
|
|
return uri.ToString();
|
|
}
|
|
}
|
|
|
|
// get the document type
|
|
public static string DocumentType(string fileName)
|
|
{
|
|
var ext = Path.GetExtension(fileName).ToLower();
|
|
|
|
if (FormatManager.PdfExtensions().Contains(ext)) return "pdf"; // pdf for pdf extensions
|
|
if (FormatManager.DocumentExtensions().Contains(ext)) return "word"; // word for text document extensions
|
|
if (FormatManager.SpreadsheetExtensions().Contains(ext)) return "cell"; // cell for spreadsheet extensions
|
|
if (FormatManager.PresentationExtensions().Contains(ext)) return "slide"; // slide for presentation extensions
|
|
|
|
return "word"; // the default document type is word
|
|
}
|
|
|
|
protected string UrlPreloadScripts = WebConfigurationManager.AppSettings["files.docservice.url.site"] + WebConfigurationManager.AppSettings["files.docservice.url.preloader"];
|
|
|
|
|
|
protected void Page_Load(object sender, EventArgs e)
|
|
{
|
|
}
|
|
|
|
// uploading a file by the HtthContext object
|
|
public static string DoUpload(HttpContext context)
|
|
{
|
|
var httpPostedFile = context.Request.Files[0];
|
|
|
|
if (HttpContext.Current.Request.Browser.Browser.ToUpper() == "IE") // check from which browser the request came for
|
|
{
|
|
var files = httpPostedFile.FileName.Split(new char[] { '\\' });
|
|
_fileName = files[files.Length - 1]; // get file name
|
|
}
|
|
else
|
|
{
|
|
_fileName = httpPostedFile.FileName;
|
|
}
|
|
|
|
var curSize = httpPostedFile.ContentLength;
|
|
if (MaxFileSize < curSize || curSize <= 0) // check if the file size exceeds the maximum file size
|
|
{
|
|
throw new Exception("File size is incorrect");
|
|
}
|
|
|
|
var curExt = (Path.GetExtension(_fileName) ?? "").ToLower();
|
|
if (!FileExts.Contains(curExt)) // check if the file extension is supported by the editor
|
|
{
|
|
throw new Exception("File type is not supported");
|
|
}
|
|
|
|
_fileName = GetCorrectName(_fileName); // get the correct file name if such a name already exists
|
|
|
|
var savedFileName = StoragePath(_fileName, null); // get the storage path to the uploading file
|
|
httpPostedFile.SaveAs(savedFileName); // and save it
|
|
|
|
// get file meta information or create the default one
|
|
var id = context.Request.Cookies.GetOrDefault("uid", null);
|
|
var user = Users.getUser(id); // get the user
|
|
DocEditor.CreateMeta(_fileName, user.id, user.name, null);
|
|
|
|
return _fileName;
|
|
}
|
|
|
|
// uploading a file by the file url and the request
|
|
public static string DoUpload(string fileUri, HttpRequest request)
|
|
{
|
|
_fileName = GetCorrectName(Path.GetFileName(fileUri)); // get the correct file name if such a name already exists
|
|
|
|
var curExt = (Path.GetExtension(_fileName) ?? "").ToLower();
|
|
if (!FileExts.Contains(curExt)) // check if the file extension is supported by the editor
|
|
{
|
|
throw new Exception("File type is not supported");
|
|
}
|
|
|
|
var req = (HttpWebRequest)WebRequest.Create(fileUri);
|
|
|
|
try
|
|
{
|
|
VerifySSL();
|
|
|
|
using (var stream = req.GetResponse().GetResponseStream()) // get response stream of the uploading file
|
|
{
|
|
if (stream == null) throw new Exception("stream is null");
|
|
const int bufferSize = 4096;
|
|
|
|
using (var fs = File.Open(StoragePath(_fileName, null), FileMode.Create))
|
|
{
|
|
var buffer = new byte[bufferSize];
|
|
int readed;
|
|
while ((readed = stream.Read(buffer, 0, bufferSize)) != 0)
|
|
{
|
|
fs.Write(buffer, 0, readed); // write bytes to the output stream
|
|
}
|
|
}
|
|
}
|
|
|
|
// get file meta information or create the default one
|
|
var id = request.Cookies.GetOrDefault("uid", null);
|
|
var user = Users.getUser(id); // get the user
|
|
DocEditor.CreateMeta(_fileName, user.id, user.name, null);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
|
|
}
|
|
return _fileName;
|
|
}
|
|
|
|
public static string DoSaveAs(HttpContext context)
|
|
{
|
|
string fileData;
|
|
try
|
|
{
|
|
using (var receiveStream = context.Request.InputStream)
|
|
using (var readStream = new StreamReader(receiveStream))
|
|
{
|
|
fileData = readStream.ReadToEnd();
|
|
if (string.IsNullOrEmpty(fileData)) return "{\"error\":\"Request stream is empty\"}";
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new HttpException((int)HttpStatusCode.BadRequest, e.Message);
|
|
}
|
|
|
|
var jss = new JavaScriptSerializer();
|
|
var body = jss.Deserialize<Dictionary<string, object>>(fileData);
|
|
var fileUrl = (string) body["url"];
|
|
var title = (string) body["title"];
|
|
var fileName = GetCorrectName(title);
|
|
var extension = "." + (Path.GetExtension(fileName).ToLower() ?? "").Trim('.');
|
|
|
|
var allExt = ConvertExts.Concat(EditedExts).Concat(ViewedExts).Concat(FillFormsExts).ToArray();
|
|
|
|
if (!allExt.Contains(extension))
|
|
{
|
|
return "{\"error\":\"File type is not supported\"}";
|
|
}
|
|
|
|
var req = (HttpWebRequest)WebRequest.Create(fileUrl);
|
|
|
|
VerifySSL();
|
|
|
|
using (var stream = req.GetResponse().GetResponseStream())
|
|
{
|
|
|
|
if (stream == null || req.GetResponse().ContentLength <= 0 || req.GetResponse().ContentLength > MaxFileSize)
|
|
{
|
|
return "{\"error\": \"File size is incorrect\"}";
|
|
}
|
|
const int bufferSize = 4096;
|
|
|
|
using (var fs = File.Open(StoragePath(fileName, null), FileMode.Create))
|
|
{
|
|
var buffer = new byte[bufferSize];
|
|
int readed;
|
|
while ((readed = stream.Read(buffer, 0, bufferSize)) != 0)
|
|
{
|
|
fs.Write(buffer, 0, readed); // write bytes to the output stream
|
|
}
|
|
}
|
|
}
|
|
|
|
var id = context.Request.Cookies.GetOrDefault("uid", null);
|
|
var user = Users.getUser(id); // get the user
|
|
DocEditor.CreateMeta(fileName, user.id, user.name, null);
|
|
|
|
return "{\"file\": \"" + fileName + "\"}";
|
|
}
|
|
|
|
// converting a file
|
|
public static string DoConvert(HttpContext context)
|
|
{
|
|
string fileData;
|
|
try
|
|
{
|
|
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\"}");
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new HttpException((int)HttpStatusCode.BadRequest, e.Message);
|
|
}
|
|
|
|
var jss = new JavaScriptSerializer();
|
|
var body = jss.Deserialize<Dictionary<string, object>>(fileData);
|
|
|
|
_fileName = Path.GetFileName(body["filename"].ToString());
|
|
var filePass = body["filePass"] != null ? body["filePass"].ToString() : null;
|
|
var lang = context.Request.Cookies.GetOrDefault("ulang", null);
|
|
|
|
var extension = (Path.GetExtension(_fileName).ToLower() ?? "").Trim('.');
|
|
string conversionExtension = "ooxml"; // set the default conversion extension as ooxml
|
|
object fileExt;
|
|
|
|
// change the conversion extension if it was provided in the request body
|
|
if (body.TryGetValue("fileExt", out fileExt) && !String.IsNullOrEmpty(fileExt.ToString()))
|
|
{
|
|
conversionExtension = fileExt.ToString();
|
|
}
|
|
|
|
object keepOriginal;
|
|
bool removeOriginal = true;
|
|
if (body.TryGetValue("keepOriginal", out keepOriginal) && !String.IsNullOrEmpty(keepOriginal.ToString()))
|
|
{
|
|
removeOriginal = keepOriginal.ToString().ToLower() != "true";
|
|
}
|
|
|
|
// check if the file with such an extension can be converted
|
|
if (ConvertExts.Contains("." + extension) || conversionExtension != "ooxml")
|
|
{
|
|
// generate document key
|
|
var key = ServiceConverter.GenerateRevisionId(FileUri(_fileName, true));
|
|
|
|
var fileUrl = new UriBuilder(_Default.GetServerUrl(true));
|
|
fileUrl.Path = HttpRuntime.AppDomainAppVirtualPath
|
|
+ (HttpRuntime.AppDomainAppVirtualPath.EndsWith("/") ? "" : "/")
|
|
+ "webeditor.ashx";
|
|
fileUrl.Query = "type=download&fileName=" + HttpUtility.UrlEncode(_fileName)
|
|
+ "&userAddress=" + HttpUtility.UrlEncode(CurUserHostAddress(HttpContext.Current.Request.UserHostAddress));
|
|
|
|
// get the url and file type of the converted file
|
|
Dictionary<string, string> newFileData;
|
|
var result = ServiceConverter.GetConvertedData(fileUrl.ToString() , extension, conversionExtension, key, true, out newFileData, filePass, lang, _fileName);
|
|
if (result != 100)
|
|
{
|
|
return "{ \"step\" : \"" + result + "\", \"filename\" : \"" + _fileName + "\"}";
|
|
}
|
|
|
|
var newFileUri = newFileData["fileUrl"];
|
|
var newFileType = newFileData["fileType"];
|
|
if (!FormatManager.All().Any(f => f.Name == newFileType && f.Type != ""))
|
|
{
|
|
return "{\"step\": \"" + result + "\", \"filename\": \"" + newFileUri + "\", \"error\": \"FileTypeIsNotSupported\"}";
|
|
}
|
|
// get a file name of an internal file extension with an index if the file with such a name already exists
|
|
var fileName = GetCorrectName(Path.GetFileNameWithoutExtension(_fileName) + "." + newFileType);
|
|
|
|
var req = (HttpWebRequest)WebRequest.Create(newFileUri);
|
|
|
|
VerifySSL();
|
|
|
|
using (var stream = req.GetResponse().GetResponseStream()) // get response stream of the converting file
|
|
{
|
|
if (stream == null) throw new Exception("Stream is null");
|
|
const int bufferSize = 4096;
|
|
|
|
using (var fs = File.Open(StoragePath(fileName, null), FileMode.Create))
|
|
{
|
|
var buffer = new byte[bufferSize];
|
|
int readed;
|
|
while ((readed = stream.Read(buffer, 0, bufferSize)) != 0)
|
|
{
|
|
fs.Write(buffer, 0, readed); // write bytes to the output stream
|
|
}
|
|
}
|
|
}
|
|
|
|
if (removeOriginal)
|
|
{
|
|
// remove the original file and its history if it exists
|
|
var storagePath = StoragePath(_fileName, null);
|
|
var histDir = HistoryDir(storagePath);
|
|
File.Delete(storagePath);
|
|
if (Directory.Exists(histDir)) Directory.Delete(histDir, true);
|
|
}
|
|
// create meta information about the converted file with user id and name specified
|
|
_fileName = fileName;
|
|
var id = context.Request.Cookies.GetOrDefault("uid", null);
|
|
var user = Users.getUser(id); // get the user
|
|
DocEditor.CreateMeta(_fileName, user.id, user.name, null);
|
|
|
|
return "{\"step\": \"" + result + "\", \"filename\": \"" + _fileName + "\"}";
|
|
}
|
|
|
|
return "{ \"filename\" : \"" + _fileName + "\"}";
|
|
}
|
|
|
|
// get the correct file name if such a name already exists
|
|
public static string GetCorrectName(string fileName, string userAddress = null)
|
|
{
|
|
int maxName;
|
|
int.TryParse(WebConfigurationManager.AppSettings["filename-max"], out maxName);
|
|
var baseName = Path.GetFileNameWithoutExtension(fileName); // get file name without extension
|
|
if (baseName.Length > maxName){
|
|
baseName = baseName.Substring(0, maxName) + "[...]";
|
|
}
|
|
var ext = Path.GetExtension(fileName).ToLower(); // get file extension
|
|
var name = baseName + ext; // get full file name
|
|
|
|
// if the file with such a name already exists in this directory
|
|
for (var i = 1; File.Exists(StoragePath(name, userAddress)); i++)
|
|
{
|
|
name = baseName + " (" + i + ")" + ext; // add an index after its base name
|
|
}
|
|
return name;
|
|
}
|
|
|
|
// get all the stored files from the folder
|
|
protected static List<FileInfo> GetStoredFiles()
|
|
{
|
|
var directory = "";
|
|
if (Path.IsPathRooted(WebConfigurationManager.AppSettings["storage-path"]))
|
|
{
|
|
directory = WebConfigurationManager.AppSettings["storage-path"] + "\\";
|
|
}
|
|
else
|
|
{
|
|
directory = HttpRuntime.AppDomainAppPath + WebConfigurationManager.AppSettings["storage-path"] + CurUserHostAddress(null) + "\\";
|
|
}
|
|
|
|
if (!Directory.Exists(directory)) return new List<FileInfo>();
|
|
|
|
var directoryInfo = new DirectoryInfo(directory); // read the user host directory contents
|
|
|
|
// get the list of stored files from the host directory
|
|
var storedFiles = directoryInfo.GetFiles("*.*", SearchOption.TopDirectoryOnly).ToList();
|
|
|
|
storedFiles.Sort((a, b) => b.LastWriteTimeUtc.CompareTo(a.LastWriteTimeUtc)); // sort files by the modification date
|
|
|
|
return storedFiles;
|
|
}
|
|
|
|
// get files information
|
|
public static List<Dictionary<string, object>> GetFilesInfo(string fileId = null)
|
|
{
|
|
var files = new List<Dictionary<string, object>>();
|
|
|
|
// run through all the files from the directory
|
|
foreach (var file in GetStoredFiles())
|
|
{
|
|
// write file parameters to the file object
|
|
var dictionary = new Dictionary<string, object>();
|
|
dictionary.Add("version", GetFileVersion(file.Name, null));
|
|
dictionary.Add("id", ServiceConverter.GenerateRevisionId(_Default.CurUserHostAddress(null) + "/" + file.Name + "/" + File.GetLastWriteTime(_Default.StoragePath(file.Name, null)).GetHashCode()));
|
|
dictionary.Add("contentLength", Math.Round(file.Length / 1024.0, 2) + " KB");
|
|
dictionary.Add("pureContentLength", file.Length);
|
|
dictionary.Add("title", file.Name);
|
|
dictionary.Add("updated", file.LastWriteTime.ToString());
|
|
if (fileId != null)
|
|
{
|
|
// if file id is defined and it is equal to the document key value
|
|
if (fileId.Equals(dictionary["id"]))
|
|
{
|
|
files.Add(dictionary); // add file object to the files
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
files.Add(dictionary);
|
|
}
|
|
}
|
|
|
|
return files;
|
|
}
|
|
|
|
// enable certificate ignore
|
|
public static void VerifySSL()
|
|
{
|
|
// hack. http://ubuntuforums.org/showthread.php?t=1841740
|
|
if(WebConfigurationManager.AppSettings["files.docservice.verify-peer-off"].Equals("true")) {
|
|
ServicePointManager.ServerCertificateValidationCallback += (s, ce, ca, p) => true;
|
|
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
|
|
}
|
|
}
|
|
|
|
public static Dictionary<string, string> GetLanguages()
|
|
{
|
|
var languages = new Dictionary<string, string>();
|
|
String[] couples = (WebConfigurationManager.AppSettings["files.docservice.languages"] ?? "").Split('|');
|
|
foreach (string couple in couples)
|
|
{
|
|
String[] tmp = couple.Split(':');
|
|
languages.Add(tmp[0],tmp[1]);
|
|
}
|
|
return languages;
|
|
}
|
|
|
|
public static string GetDirectUrlParam()
|
|
{
|
|
string isEnabledDirectUrl = HttpUtility.ParseQueryString(HttpContext.Current.Request.Url.Query).Get("directUrl");
|
|
return "&directUrl=" + (isEnabledDirectUrl != null ? isEnabledDirectUrl : "false");
|
|
}
|
|
|
|
// get direct url flag
|
|
public static bool IsEnabledDirectUrl()
|
|
{
|
|
string isEnabledDirectUrl = HttpUtility.ParseQueryString(HttpContext.Current.Request.Url.Query).Get("directUrl");
|
|
return isEnabledDirectUrl != null ? Convert.ToBoolean(isEnabledDirectUrl) : false;
|
|
}
|
|
}
|
|
} |