/// <summary>
/// 获取自动定向的地址,如果nginx设置了https跳转, 参考如下:
/// if ($server_port !~ 443){
/// rewrite ^(/.*)$ https://fze.net$1 permanent;
/// }
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static string GetRdUrl(ICompatibleRequest request)
{
var host = request.GetHost();
if (host == "localhost")
{
return(null);
}
var target = request.GetEncodedUrl();
//if (target == null) return null;
var forceHttps = false;
if (Settings.SYS_FORCE_HTTPS && request.GetProto() != "https")
{
target = target.Replace("http://", "https://");
forceHttps = true;
}
var hostParts = host.Split('.').Length;
// 跳转到带www的二级域名
if (Settings.SYS_WWW_RD == 1 && hostParts == 2)
{
return(target.Replace(host, "www." + host));
}
// 跳转到不带www的顶级域名
if (Settings.SYS_WWW_RD == 2 && host.StartsWith("www."))
{
return(target.Replace("www.", ""));
}
return(forceHttps ? target : null);
}
private static CategoryDto InitCategoryDtoFromHttpPost(ICompatibleRequest form, CategoryDto category)
{
//form.BindToEntity(category);
category.Keywords = form.Form("Keywords");
category.PageTitle = form.Form("PageTitle");
category.Tag = form.Form("Tag");
category.Name = form.Form("Name");
category.SortNumber = int.Parse(form.Form("SortNumber"));
category.Description = form.Form("Description");
category.Location = form.Form("Location");
category.Icon = form.Form("Icon");
if (!string.IsNullOrEmpty(category.Keywords))
{
category.Keywords = Regex.Replace(category.Keywords, "，|\\s|\\|", ",");
}
//设置模板
string categoryTplPath = form.Form("CategoryTemplate"),
archiveTplPath = form.Form("CategoryArchiveTemplate");
//如果设置了栏目视图路径，则保存
category.CategoryTemplate = categoryTplPath;
//如果设置了文档视图路径，则保存
category.CategoryArchiveTemplate = archiveTplPath;
return(category);
}
/// <summary>
/// 输出缓存内容
/// </summary>
/// <param name="response"></param>
/// <param name="maxage"></param>
/// <param name="handler"></param>
/// <returns>是否缓存在客户端</returns>
public static bool Output(ICompatibleResponse response, int maxage, StringCreatorHandler handler)
{
/*
* Public 指示响应可被任何缓存区缓存。
* Private 指示对于单个用户的整个或部分响应消息，不能被共享缓存处理。这允许服务器仅仅描述当用户的
* 部分响应消息，此响应消息对于其他用户的请求无效。
* no-cache 指示请求或响应消息不能缓存（HTTP/1.0用Pragma的no-cache替换）
* 根据什么能被缓存
* no-store 用于防止重要的信息被无意的发布。在请求消息中发送将使得请求和响应消息都不使用缓存。
* 根据缓存超时
* max-age 指示客户机可以接收生存期不大于指定时间（以秒为单位）的响应。
* min-fresh 指示客户机可以接收响应时间小于当前时间加上指定时间的响应。
* max-stale 指示客户机可以接收超出超时期间的响应消息。如果指定max-stale消息的值，那么客户机可以
* 接收超出超时期指定值之内的响应消息。
* Expires 表示存在时间，允许客户端在这个时间之前不去检查（发请求），等同max-age的
* 效果。但是如果同时存在，则被Cache-Control的max-age覆盖。
* 格式：
*/
#region 获取缓存状态
ICompatibleRequest request = HttpHosting.Context.Request;
//现在时间
DateTime nowTime = DateTime.Now.ToUniversalTime();
bool b = request.TryGetHeader("If-Modified-Since", out var sinceModified);
if (b)
{
//最后修改时间
DateTime sinceTime;
DateTime.TryParse(sinceModified, out sinceTime);
sinceTime = sinceTime.ToUniversalTime();
if ((nowTime - sinceTime).TotalSeconds < maxage)
{
response.StatusCode(304);
// response.Status = "304 Not Modified";
return(true);
}
}
#endregion
#region 输出内容并缓存
response.WriteAsync(handler());
response.AddHeader("Cache-Control", "max-age=" + maxage.ToString());
response.AddHeader("Last-Modified", nowTime.ToString("r"));
#endregion
return(false);
}
public static string SaveByPostForm(ICompatibleRequest form)
{
var file = Cms.PhysicPath + CmsVariables.SITE_LOCALE_PATH;
IList <LangKvPair> list = new List <LangKvPair>();
var row = 0;
var lang = 0;
LangKvPair p;
IList <string> k1 = new List <string>();
IList <string> v1 = new List <string>();
foreach (var pk in form.FormKeys())
{
if (pk.StartsWith("k_"))
{
k1.Add(pk);
}
else if (pk.StartsWith("f_"))
{
v1.Add(pk);
}
}
foreach (var k in k1)
{
if (int.TryParse(k.Substring(2), out row)) //获取行号
{
p = new LangKvPair();
p.key = form.Form(k);
p.value = new Dictionary <int, string>();
var fPre = "f_" + row.ToString() + "_";
for (var j = 0; j < v1.Count; j++)
{
if (v1[j].StartsWith(fPre)) //获取对英语言的值，并移除
{
if (int.TryParse(v1[j].Substring(fPre.Length), out lang))
{
p.value[lang] = form.Form(v1[j]);
}
}
}
//v1.Remove(v1[j]);
list.Add(p);
}
}
if (list.Count > 0)
{
var arr = SortLocaleList(list);
return(FlushToFile(file, arr));
}
return(null);
}
/// <summary>
/// 是否通过代理https请求
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static bool IsProxyHttpsRequest(ICompatibleRequest request)
{
// nginx反向代理
if (request.GetHeader("X-Forwarded-Proto") == "https")
{
return(true);
}
// 兼容西部数码虚拟主机
if (request.GetHeader("SSL-FLAG") == "SSL" || request.GetHeader("From-Https") == "on")
{
return(true);
}
return(false);
}
/// <summary>
/// 检查客户端缓存是否过期,如果未过期，则直接输出http 304
/// </summary>
/// <param name="maxAge"></param>
/// <returns></returns>
public static bool CheckClientCacheExpires(int maxAge)
{
/*
* Public 指示响应可被任何缓存区缓存。
* Private 指示对于单个用户的整个或部分响应消息，不能被共享缓存处理。这允许服务器仅仅描述当用户的
* 部分响应消息，此响应消息对于其他用户的请求无效。
* no-cache 指示请求或响应消息不能缓存（HTTP/1.0用Pragma的no-cache替换）
* 根据什么能被缓存
* no-store 用于防止重要的信息被无意的发布。在请求消息中发送将使得请求和响应消息都不使用缓存。
* 根据缓存超时
* max-age 指示客户机可以接收生存期不大于指定时间（以秒为单位）的响应。
* min-fresh 指示客户机可以接收响应时间小于当前时间加上指定时间的响应。
* max-stale 指示客户机可以接收超出超时期间的响应消息。如果指定max-stale消息的值，那么客户机可以
* 接收超出超时期指定值之内的响应消息。
* Expires 表示存在时间，允许客户端在这个时间之前不去检查（发请求），等同max-age的
* 效果。但是如果同时存在，则被Cache-Control的max-age覆盖。
* 格式：
*/
if (maxAge > 0)
{
ICompatibleResponse response = HttpHosting.Context.Response;
ICompatibleRequest request = HttpHosting.Context.Request;
var v = request.TryGetHeader("If-Modified-Since", out var e);
if (v)
{
string sinceModified = e;
//现在时间
DateTime nowTime = DateTime.Now.ToUniversalTime();
//最后修改时间
DateTime sinceTime;
DateTime.TryParse(sinceModified, out sinceTime);
sinceTime = sinceTime.ToUniversalTime();
if ((nowTime - sinceTime).TotalSeconds < maxAge)
{
response.StatusCode(304);
//response.Status = "304 Not Modified";
return(false);
}
}
}
return(true);
}
/// <summary>
/// 检查客户端缓存是否过期,如果未过期，则直接输出http 304
/// </summary>
/// <param name="etag"></param>
/// <returns></returns>
public static bool CheckClientCacheExpires(string etag)
{
ICompatibleRequest request = HttpHosting.Context.Request;
var v = request.TryGetHeader("If-None-Match", out var e);
if (v)
{
string clientEtag = e;
if (String.CompareOrdinal(clientEtag, String.Concat("\"", etag, "\"")) == 0)
{
ICompatibleResponse response = HttpHosting.Context.Response;
response.StatusCode(304);
//response.Status = "304 Not Modified";
return(false);
}
}
return(true);
}
public static void SaveErrorLog(Exception exception)
{
lock (ErrorFilePath)
{
ICompatibleRequest req = HttpCtx.Request;
var path = req.GetPath();
var query = req.GetQueryString();
var PathAndQuery = path + query;
var referer = req.GetHeader("Referer");;
if (!File.Exists(ErrorFilePath))
{
string dir = EnvUtil.GetBaseDirectory() + "tmp/logs";
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
File.Create(ErrorFilePath).Close();
}
HttpCtx.Response.WriteAsync((File.Exists(ErrorFilePath).ToString()));
using (FileStream fs = new FileStream(ErrorFilePath, FileMode.Append, FileAccess.Write))
{
StreamWriter sw = new StreamWriter(fs);
StringBuilder sb = new StringBuilder();
sb.Append("---------------------------------------------------------------------\r\n")
.Append("[错误]：IP:").Append(HttpCtx.RemoteAddress())
.Append("\t时间：").Append(DateTime.Now.ToString())
.Append("\r\n[信息]：").Append(exception.Message)
.Append("\r\n[路径]：").Append(PathAndQuery)
.Append(" -> 来源：").Append(referer)
.Append("\r\n[堆栈]：").Append(exception.StackTrace)
.Append("\r\n\r\n");
sw.Write(sb.ToString());
sw.Flush();
sw.Dispose();
fs.Dispose();
}
}
}
/// <summary>
/// 上传
/// </summary>
/// <returns>异步则返回进程ID，同步返回上传文件的路径</returns>
public string Upload(ICompatiblePostedFile postedFile)
{
ICompatibleRequest request = HttpHosting.Context.Request;
String baseDir = EnvUtil.GetBaseDirectory();
string[] process = request.Form("upload_process")[0].Split('|');
string processId = process[1];
if (postedFile == null)
{
return(null);
}
string fileName = postedFile.GetFileName();
string fileExt = fileName.Substring(fileName.LastIndexOf('.') + 1); //扩展名
InitUplDirectory(baseDir, this._saveAbsoluteDir);
this._fileInfo = new UploadFileInfo
{
Id = processId,
ContentLength = postedFile.GetLength(),
FilePath = $"{this._saveAbsoluteDir}{this._fileName}.{fileExt}"
};
String targetPath = baseDir + this._fileInfo.FilePath;
if (!this._autoRename && File.Exists(targetPath))
{
throw new IOException("文件已存在");
}
// 自动将重复的名称命名
int i = 0;
while (File.Exists(targetPath))
{
i++;
this._fileInfo.FilePath = $"{this._saveAbsoluteDir}{this._fileName}_{i.ToString()}.{fileExt}";
targetPath = baseDir + this._fileInfo.FilePath;
}
this.SaveStream(postedFile.OpenReadStream(), targetPath);
return(_fileInfo.FilePath);
}
private ArchiveDto GetFormCopyedArchive(int siteId, ICompatibleRequest form, ArchiveDto archive, string alias)
{
string content = form.Form("Content");
//自动替换Tags
if (form.Form("auto_tag") == "on")
{
//todo: tags 顺序调换了下
/*
* HttpTags _tags = this.GetTags(siteId);
* content = _tags.Tags.RemoveAutoTags(content);
* content = _tags.Tags.ReplaceSingleTag(content);
*/
}
archive.Flag = 0;
if (form.Form("IsVisible") == "on")
{
archive.Flag |= (int)BuiltInArchiveFlags.Visible;
}
if (form.Form("AsPage") == "on")
{
archive.Flag |= (int)BuiltInArchiveFlags.AsPage;
}
if (form.Form("IsSpecial") == "on")
{
archive.Flag |= (int)BuiltInArchiveFlags.IsSpecial;
}
if (form.Form("IsSystem") == "on")
{
archive.Flag |= (int)BuiltInArchiveFlags.IsSystem;
}
archive.UpdateTime = DateTime.Now;
archive.Title = form.Form("Title").ToString().Trim();
archive.SmallTitle = form.Form("SmallTitle").ToString().Trim();
archive.Location = form.Form("location").ToString().Trim();
archive.Source = form.Form("Source");
archive.Outline = form.Form("Outline");
archive.Alias = alias;
archive.Tags = form.Form("Tags").ToString().Replace("，", ",");
archive.Content = content;
archive.Thumbnail = form.Form("Thumbnail");
//分类
var categoryId = int.Parse(form.Form("categoryid"));
archive.Category = new CategoryDto {
ID = categoryId
};
//检测图片是否为默认图片
if (archive.Thumbnail == CmsVariables.FRAMEWORK_ARCHIVE_NoPhoto)
{
archive.Thumbnail = string.Empty;
}
archive.ExtendValues = new List <IExtendValue>();
//=============== 更新扩展字段 ===================
IExtendField field;
string extendValue;
foreach (var key in form.FormKeys())
{
if (key.StartsWith("extend_"))
{
extendValue = form.Form(key);
field = new ExtendField(int.Parse(key.Substring(7)), null);
archive.ExtendValues.Add(new ExtendValue(-1, field, extendValue));
}
}
//更新模板设置
archive.TemplatePath = form.Form("TemplatePath");
if (archive.TemplatePath != string.Empty)
{
archive.IsSelfTemplate = true;
}
return(archive);
}
