vStationURM/Tools/UpgradePackageUploadTool/Services/WingServerService.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Principal;
using System.Text;
using System.Threading.Tasks;
using UpgradePackageUploadTool.Models;
using UpgradePackageUploadTool.Utilties;
using Vinno.IUS.Common.Network;
using Vinno.IUS.Common.Network.Leaf;
using Vinno.IUS.Common.Network.Tcp;
using Vinno.IUS.Common.Network.Transfer;
using Vinno.vCloud.Common.Storage;
using Vinno.vCloud.Common.Storage.ObjectStorageInfo;
using Vinno.vCloud.Common.Storage.Upload;
using Vinno.vCloud.Protocol.Infrastructures;
using Vinno.vCloud.Protocol.Initializers;
using Vinno.vCloud.Protocol.Messages.Client.Login;
using Vinno.vCloud.Protocol.Messages.Client.Storage;
using Vinno.vCloud.Protocol.Messages.Common;
using Vinno.vCloud.Protocol.Messages.Login;
using Vinno.vCloud.Protocol.Messages.Upgrade;
using static System.Net.Mime.MediaTypeNames;

namespace UpgradePackageUploadTool.Services
{
    public class WingServerService
    {
        private string _userToken = string.Empty;
        private ProxyManager _proxyManager;
        static HttpClient _httpClient = new HttpClient
        {
            Timeout = TimeSpan.FromMinutes(15)
        };

        /// <summary>
        /// 构造函数，初始化
        /// </summary>
        public WingServerService(string serverUrl)
        {
            _proxyManager = new ProxyManager(serverUrl);
        }

        public async Task<ResultModel> LoginAsync(string account, string password)
        {
            var encryptPassword = Encrypt(password);
            var response = await _proxyManager.PostAsync<dynamic, JsonRpcResult<Models.LoginResult>>(
                "/ILoginService/CommonLoginAsync",
                new
                {
                    AnyAccount = account,
                    Password = encryptPassword,
                    Platform = 0,
                    LoginSource = 3,
                });
            if (response.error != null)
            {
                var error = response.error;
                return ResultModel.FailedResult(error.message, error.code);
            }
            if (response.result.LoginState == 1)
            {
                return ResultModel.FailedResult($"Password incorrect, remaining retry attempts:{response.result.LockRemainingTimes ?? 0}");
            }
            _userToken = response.result.Token;
            return ResultModel.SuccessResult();
        }

        public async Task<ResultModel> LoginOutAsync()
        {
            if (!string.IsNullOrWhiteSpace(_userToken))
            {
                var response = await _proxyManager.PostAsync<dynamic, JsonRpcResult<bool>>(
                "/ILoginService/LoginOutAsync",
                new
                {
                    Token = _userToken,
                });
                if (response.error != null)
                {
                    var error = response.error;
                    return ResultModel.FailedResult(error.message, error.code);
                }
                if (!response.result)
                {
                    return ResultModel.FailedResult();
                }
                _userToken = string.Empty;
            }
            return ResultModel.SuccessResult();
        }

        public async Task<GeneralPackInfo> GetPackageInfoAsync(string uniquedCode)
        {
            var response = await _proxyManager.PostAsync<dynamic, JsonRpcResult<PackagesDTO>>(
                "/IUserService/GetPackageByUniquedCodeAsync",
                new
                {
                    UniquedCode = uniquedCode,
                });
            if (response.result != null && !string.IsNullOrWhiteSpace(response.result.FileUrl))
            {
                var package = response.result;
                return new GeneralPackInfo(package.UploadUserName, package.Description, package.Name, package.FileUrl, (int)package.FileSize, PackageType.Other, package.UpdateTime, package.Version, package.UniquedCode);
            }
            return null;
        }

        public async Task<GeneralPackInfo> UploadPackageAsync(string filePath, string version, string fileName, string description, string uniquedCode)
        {
            var uploadResult = await UploadAsync(filePath, fileName);
            if (!uploadResult.Success || string.IsNullOrWhiteSpace(uploadResult.Data))
            {
                throw new Exception($"Upload Fail, {uploadResult.ErrMessage}");
            }
            var fileUrl = uploadResult.Data;
            var response = await _proxyManager.PostAsync<dynamic, JsonRpcResult<string>>(
                "/IUserService/AddOrUpdatePackageAsync",
                new
                {
                    Token = _userToken,
                    PackageInfo = new
                    {
                        UniquedCode = uniquedCode,
                        Name = fileName,
                        Version = version,
                        Description = description,
                        FileUrl = fileUrl,
                        FileSize = (int)new FileInfo(filePath).Length,
                        UpdateTime = DateTime.UtcNow,
                    }
                });
            if (response.error != null)
            {
                var error = response.error;
                throw new Exception($"Upload Fail, {error.message}");
            }
            if (string.IsNullOrWhiteSpace(response.result))
            {
                throw new Exception($"Upload Fail");
            }
            return await GetPackageInfoAsync(uniquedCode);
        }

        private async Task<ResultModel<string>> UploadAsync(string filePath, string fileName)
        {
            var getAuthorizationResult = await _proxyManager.PostAsync<dynamic, JsonRpcResult<StorageServiceSettingDTO>>(
               "/IStorageService/GetAuthorizationAsync",
               new
               {
                   Token = _userToken,
                   FileName = fileName,
                   IsRechristen = false,
               });
            if (getAuthorizationResult.error != null)
            {
                var error = getAuthorizationResult.error;
                return ResultModel<string>.FailedResult(error.message, error.code);
            }
            var authorization = getAuthorizationResult.result?.Authorization;
            var storageUrl = getAuthorizationResult.result?.StorageUrl;
            if (string.IsNullOrWhiteSpace(authorization))
            {
                return ResultModel<string>.FailedResult("authorization error");
            }

            using (var fileStream = new FileStream(filePath, FileMode.Open))
            {
                var size = fileStream.Length;

                byte[] fileData = new byte[fileStream.Length];
                fileStream.Read(fileData, 0, fileData.Length);

                var requestHeads = new Dictionary<string, string>
                {
                    { "Authorization", authorization }
                };
                using (var request = new HttpRequestMessage())
                {
                    var fileExtension = Path.GetExtension(fileName);
                    var mimeType = FileHelper.GetMimeType(fileExtension);
                    var contentType = MediaTypeHeaderValue.Parse(mimeType);
                    using (UploadContent content = new UploadContent(fileData, contentType))
                    {
                        request.RequestUri = new Uri(storageUrl);
                        request.Method = HttpMethod.Put;
                        request.Content = content;
                        foreach (var head in requestHeads)
                        {
                            request.Headers.TryAddWithoutValidation(head.Key, head.Value);
                        }
                        var result = await ExecuteRequest(request);
                        if (!result)
                        {
                            throw new Exception("Upload file failed!");
                        }
                    }
                }
            }
            await _proxyManager.PostAsync<dynamic, JsonRpcResult<List<string>>>(
               "/IStorageService/CopyToOtherNodeAysnc",
               new
               {
                   Token = _userToken,
                   FileName = fileName,
                   FileUrl = storageUrl,
               });
            return ResultModel<string>.SuccessResult(storageUrl);
        }

        /// <summary>
        /// 执行请求
        /// </summary>
        /// <param name="httpRequestMessage"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public async Task<bool> ExecuteRequest(HttpRequestMessage httpRequestMessage)
        {
            try
            {
                var response = await _httpClient.SendAsync(httpRequestMessage);
                if (response != null && response.StatusCode == HttpStatusCode.OK)
                {
                    return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        private string Encrypt(string text)
        {
            if (string.IsNullOrEmpty(text))
            {
                return "";
            }

            char[] Base64Code = new char[]{'0','1','2','3','4','5','6','7',
                                            '8','9','+','/','a','b','c','d','e','f','g','h','i','j','k','l','m','n',
                                            'o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T',
                                            'U','V','W','X','Y','Z','='};
            byte empty = (byte)0;
            ArrayList byteMessage = new ArrayList(Encoding.UTF8.GetBytes(text));
            StringBuilder outmessage;
            int messageLen = byteMessage.Count;
            int page = messageLen / 3;
            int use = 0;
            if ((use = messageLen % 3) > 0)
            {
                for (int i = 0; i < 3 - use; i++)
                    byteMessage.Add(empty);
                page++;
            }
            outmessage = new System.Text.StringBuilder(page * 4);
            for (int i = 0; i < page; i++)
            {
                byte[] instr = new byte[3];
                instr[0] = (byte)byteMessage[i * 3];
                instr[1] = (byte)byteMessage[i * 3 + 1];
                instr[2] = (byte)byteMessage[i * 3 + 2];
                int[] outstr = new int[4];
                outstr[0] = instr[0] >> 2;
                outstr[1] = ((instr[0] & 0x03) << 4) ^ (instr[1] >> 4);
                if (!instr[1].Equals(empty))
                    outstr[2] = ((instr[1] & 0x0f) << 2) ^ (instr[2] >> 6);
                else
                    outstr[2] = 64;
                if (!instr[2].Equals(empty))
                    outstr[3] = (instr[2] & 0x3f);
                else
                    outstr[3] = 64;
                outmessage.Append(Base64Code[outstr[0]]);
                outmessage.Append(Base64Code[outstr[1]]);
                outmessage.Append(Base64Code[outstr[2]]);
                outmessage.Append(Base64Code[outstr[3]]);
            }
            var result = outmessage.ToString();

            return "Symmetry_" + result;
        }
    }
}