public static class HttpContext
    {
        private static IHttpContextAccessor _accessor;

        public static Microsoft.AspNetCore.Http.HttpContext Current => _accessor.HttpContext;

        public static void Configure(IHttpContextAccessor accessor)
        {
            _accessor = accessor;
        }
    }

    /// <summary>
    /// 兼容原来的HttpContext引用的静态类；注意在Service中使用，若有其他地方使用，后续可将HttpContext移至其他公共库中。
    /// </summary>
    public static class StaticHttpContextExtensions
    {
        public static void AddHttpContextAccessor(this IServiceCollection services)
        {
            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
        }

        public static IApplicationBuilder UseStaticHttpContext(this IApplicationBuilder app)
        {
            var httpContextAccessor = app.ApplicationServices.GetRequiredService<IHttpContextAccessor>();
            MessageServiceCenter.Service.HttpContext.Configure(httpContextAccessor);
            return app;
        }
    }

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseStaticHttpContext();
}
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
}

        /// <summary>
        /// MD5加密
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        public static string Md5(string s)
        {

            using (var md5 = MD5.Create())
            {
                var result = md5.ComputeHash(Encoding.UTF8.GetBytes(s));
                var strResult = BitConverter.ToString(result);
                return strResult.Replace("-", "").ToUpper();
            }

        }

        /// <summary>
        /// SHA
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        public static string SHA(string s)
        {
            using (var sha = SHA1.Create())
            {
                var result = sha.ComputeHash(Encoding.UTF8.GetBytes(s));
                var strResult = BitConverter.ToString(result);
                return strResult.Replace("-", "").ToUpper();
            }
        }

services.AddControllers(op =>
{
    //过滤器
    op.Filters.Add<Attribute>();
    op.Filters.Add<Attribute>();
}).AddNewtonsoftJson(options =>
{
    options.SerializerSettings.ContractResolver = new DefaultContractResolver();//移除默认驼峰格式
    options.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
    options.SerializerSettings.Converters.Add(new DatetimeJsonConverter());
});

    /// <summary>
    /// Newtonsoft.Json自定义时间格式转换
    /// </summary>
    public class DatetimeJsonConverter : DateTimeConverterBase
    {
        //读取对象，DateTimeFormat为空时就不按DateTimeFormat的格式强制序列化，"2021-08-29"这种只有日期的字符串也能序列化成功
        private static IsoDateTimeConverter isoDateTimeConverterRaad = new IsoDateTimeConverter() { };
        //写对象，输出时间格式为"yyyy-MM-dd HH:mm:ss"
        private static IsoDateTimeConverter isoDateTimeConverterWrite = new IsoDateTimeConverter() { DateTimeFormat = "yyyy-MM-dd HH:mm:ss" };

        /// <summary>
        /// 重写输入时的时间序列化格式
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="objectType"></param>
        /// <param name="existingValue"></param>
        /// <param name="serializer"></param>
        /// <returns></returns>
        public override object ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
        {
            object result = null;
            try
            {
                result = isoDateTimeConverterRaad.ReadJson(reader, objectType, existingValue, serializer);
            }
            catch (Exception)
            {
            }
            return result;
        }
        /// <summary>
        /// 重写输出时的时间格式
        /// </summary>
        /// <param name="writer"></param>
        /// <param name="value"></param>
        /// <param name="serializer"></param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            isoDateTimeConverterWrite.WriteJson(writer, value, serializer);
        }

    }

CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("zh-CN", true)
{
    DateTimeFormat = {
        ShortTimePattern = "H:mm:ss",
        ShortDatePattern = "yyyy/M/d",
        FullDateTimePattern = "yyyy/M/d HH:mm:ss",
        LongDatePattern = "yyyy/M/d",
        LongTimePattern = "HH:mm:ss"
    }
};

/// <summary>
/// 重写url规则
/// </summary>
public class RewriteRouteRule
{
    /// <summary>
    /// 处理url中的多斜杠("//")问题
    /// </summary>
    /// <param name="context"></param>
    public static void ReWriteRequests(RewriteContext context)
    {
        var request = context.HttpContext.Request;
        if (request.Path.Value.Contains("//"))
        {
            string[] splitlist = request.Path.Value.Split("/", StringSplitOptions.RemoveEmptyEntries);
            var newpath = "/" + string.Join("/", splitlist);
            request.Path = newpath;
        }
    }
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseRewriter(new RewriteOptions().Add(RewriteRouteRule.ReWriteRequests));
}

def remoteConfig = [:]
remoteConfig.name = "my-remote-server"
remoteConfig.host = "${REMOTE_HOST}"
remoteConfig.port = "${REMOTE_SSH_PORT}".toInteger()
remoteConfig.allowAnyHosts = true

withCredentials([
  sshUserPrivateKey(
    credentialsId: "${REMOTE_CRED}",
    keyFileVariable: "privateKeyFilePath"
  ),
  usernamePassword(
    credentialsId: "${CODING_ARTIFACTS_CREDENTIALS_ID}",
    usernameVariable: 'CODING_DOCKER_REG_USERNAME',
    passwordVariable: 'CODING_DOCKER_REG_PASSWORD'
  )
]) {
  // SSH 登陆用户名
  remoteConfig.user = "${REMOTE_USER_NAME}"
  // SSH 私钥文件地址
  remoteConfig.identityFile = privateKeyFilePath

  echo "docker login -u ${CODING_DOCKER_REG_USERNAME} -p ${CODING_DOCKER_REG_PASSWORD} ${CODING_DOCKER_REG_HOST}"


  // 请确保远端环境中有 Docker 环境
  sshCommand(
    remote: remoteConfig,
    command: "docker login -u ${CODING_DOCKER_REG_USERNAME} -p ${CODING_DOCKER_REG_PASSWORD} ${CODING_DOCKER_REG_HOST}",
    sudo: false,
  )

  sshCommand(
    remote: remoteConfig,
    command: "docker rm -f ${DOCKER_IMAGE_NAME} | true",
    sudo: false,
  )

  // DOCKER_IMAGE_VERSION 中涉及到 GIT_LOCAL_BRANCH / GIT_TAG / GIT_COMMIT 的环境变量的使用
  // 需要在本地完成拼接后，再传入到远端服务器中使用
  DOCKER_IMAGE_URL = sh(
    script: "echo ***.net/middleground/docker/${DOCKER_IMAGE_NAME}:latest",
    returnStdout: true
  )

  remoteConfig.runCom="docker run -d -v /etc/localtime:/etc/localtime:ro  -p ${host_port}:${internal_port} --name ${DOCKER_IMAGE_NAME} ${DOCKER_IMAGE_URL}"
  echo "${remoteConfig.runCom}"

  sshCommand(
    remote: remoteConfig,
    command: "${remoteConfig.runCom}",
    sudo: false,
  )

  echo "部署成功，请到 http://${REMOTE_HOST}:80 预览效果"
}