public static SMsgPvpInviteFriend_CSC ParsePackage(byte[] dataBuffer)
{
return(PackageHelper.BytesToStuct <SMsgPvpInviteFriend_CSC>(dataBuffer));
}
/// <summary>
/// Performs installation of the Zoombraco package.
/// Note: At this point in time it is not possible to register the package as installed to the CMS. This means that we are
/// unable to automatically uninstall the package.
/// </summary>
/// <param name="umbracoApplication">
/// The current <see cref="UmbracoApplicationBase"/>
/// </param>
/// <param name="applicationContext">
/// The Umbraco <see cref="ApplicationContext"/> for the current application.
/// </param>
/// <returns>The <see cref="bool"/></returns>
public static bool Install(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
{
if (!applicationContext.IsConfigured)
{
LogHelper.Info <ZoombracoBootstrapper>("Umbraco is not configured. Aborting Zoombraco setup.");
return(false);
}
// Check our versioning.
Assembly assembly = VersionParser.Assembly;
SemVersion currentVersion = VersionParser.ZoombracoProductVersion();
SemVersion installedVersion = ZoombracoConfiguration.Instance.ProductVersion;
if (installedVersion >= currentVersion)
{
LogHelper.Info <ZoombracoBootstrapper>($"Zoombraco {installedVersion} is installed and up-to-date. Aborting Zoombraco setup.");
return(true);
}
try
{
// Install our package.
string resourceName;
using (Stream package = EmbeddedResourceHelper.GetResource(assembly, "package.xml", out resourceName))
{
PackageHelper packageHelper = new PackageHelper(package, applicationContext);
packageHelper.Unpack();
using (Stream meta = EmbeddedResourceHelper.GetResource(assembly, "_Meta.cshtml", out resourceName))
using (Stream sitemap = EmbeddedResourceHelper.GetResource(assembly, "XmlSitemap.cshtml", out resourceName))
using (Stream error = EmbeddedResourceHelper.GetResource(assembly, "Error.cshtml", out resourceName))
{
packageHelper.UnpackFile(meta, "_Meta.cshtml");
packageHelper.UnpackFile(sitemap, "XmlSitemap.cshtml");
packageHelper.UnpackFile(error, "Error.cshtml");
}
}
// Edit the Examine config file.
string settings = Path.Combine(IOHelper.GetRootDirectorySafe(), "Config", "ExamineSettings.config");
if (!File.Exists(settings))
{
LogHelper.Error <ZoombracoBootstrapper>($"Unable to install the Zoombraco. No ExamineSetting.config exists at the path {settings}", new FileNotFoundException());
return(false);
}
using (FileStream stream = File.Open(settings, FileMode.Open, FileAccess.ReadWrite))
{
ExamineHelper examineHelper = new ExamineHelper(stream);
examineHelper.UpdateExamineAnalyzer();
}
// Set default values.
if (installedVersion == new SemVersion(0))
{
ZoombracoConfiguration.SaveSetting(ZoombracoConstants.Configuration.OutputCacheDuration, "0");
ZoombracoConfiguration.SaveSetting(ZoombracoConstants.Configuration.ImageCdnRequestTimeout, "2000");
ZoombracoConfiguration.SaveSetting(ZoombracoConstants.Configuration.ModelsBuilderEnabled, "false");
}
// Update our version number
ZoombracoConfiguration.SaveSetting(ZoombracoConstants.Configuration.Version, currentVersion.ToSemanticString());
return(true);
}
catch (Exception e)
{
LogHelper.Error <ZoombracoBootstrapper>("Unable to install the Zoombraco.", e);
return(false);
}
}
public static List <string> MultiRootAnalyze(IEnumerable <string> files, PackageFormat format)
{
var transformedDirectories = new List <string>();
if (format == PackageFormat.NoFormat)
{
throw new ArgumentException("Package format unknown!");
}
switch (format)
{
case PackageFormat.ResModRoot:
transformedDirectories = files.Select(f => PackageHelper.RemoveUntilFolderBackward(Path.GetDirectoryName(f), PackageHelper.GetWotVersionFolder(f))).ToList();
break;
case PackageFormat.VersionRoot:
break;
case PackageFormat.WotHomeRoot:
transformedDirectories = files.Select(f => PackageHelper.RemoveUntilFolderBackward(Path.GetDirectoryName(f), Constants.ResModsFolder)).ToList();
break;
case PackageFormat.WotMod:
break;
case PackageFormat.WotModHomeRoot:
transformedDirectories = files.Select(f => PackageHelper.RemoveUntilFolderBackward(Path.GetDirectoryName(f), Constants.ModsFolder)).ToList();
break;
case PackageFormat.WotModModsRoot:
transformedDirectories = files.Select(f => PackageHelper.RemoveUntilFolderBackward(Path.GetDirectoryName(f), PackageHelper.GetWotVersionFolder(f))).ToList();
break;
}
transformedDirectories = transformedDirectories.Where(f => !string.IsNullOrEmpty(f)).Distinct().ToList();
return(transformedDirectories);
}
public override void Execute(Pipeline pipeline)
{
var unityPackageData = pipeline.Manifest.Data.OfType <UnityPackages>().ToArray();
var unityObjects = unityPackageData
.SelectMany(upd => upd.unityPackages)
.SelectMany(up => up.AssetFiles)
.Select(AssetDatabase.GetAssetPath)
.SelectMany(path =>
{
if (AssetDatabase.IsValidFolder(path))
{
return(Directory.GetFiles(path, "*", SearchOption.AllDirectories));
}
else
{
return(Enumerable.Repeat(path, 1));
}
})
.Select(path => new AssetPath(path, AssetDatabase.LoadAssetAtPath <Object>(path)))
.ToArray();
var remappableAssets = unityObjects.SelectMany(map =>
{
var path = map.path;
var asset = map.asset;
if (asset is Preset preset)
{
var presetSo = new SerializedObject(preset);
SerializedProperty m_TargetType, m_ManagedTypePPtr;
m_TargetType = presetSo.FindProperty(nameof(m_TargetType));
m_ManagedTypePPtr = m_TargetType.FindPropertyRelative(nameof(m_ManagedTypePPtr));
var monoScript = m_ManagedTypePPtr.objectReferenceValue as MonoScript;
return(Enumerable.Repeat(new ScriptPath(path, monoScript), 1));
}
if (asset is GameObject goAsset)
{
return(goAsset.GetComponentsInChildren <MonoBehaviour>()
.Select(mb => new ScriptPath(path, MonoScript.FromMonoBehaviour(mb))));
}
if (asset is ScriptableObject soAsset)
{
return(Enumerable.Repeat(new ScriptPath(path, MonoScript.FromScriptableObject(soAsset)), 1));
}
return(Enumerable.Empty <ScriptPath>());
})
.Select(map =>
{
var type = map.monoScript.GetClass();
var fileId = FileIdUtil.Compute(type);
var assemblyPath = type.Assembly.Location;
var libraryGuid = PackageHelper.GetFileNameHash(assemblyPath);
AssetDatabase.TryGetGUIDAndLocalFileIdentifier(map.monoScript, out string scriptGuid, out long scriptId);
return(new RemapData(map.path,
new Regex($"(\\{{fileID:)\\s*?{scriptId},(\\s*?guid:)\\s*?{scriptGuid},(\\s*?type:\\s*?\\d+\\s*?\\}})", RegexOptions.Singleline),
new Regex($"(\\{{fileID:)\\s*?{fileId},(\\s*?guid:)\\s*?{libraryGuid},(\\s*?type:\\s*?\\d+\\s*?\\}})", RegexOptions.Singleline),
$"$1 {scriptId},$2 {scriptGuid},$3",
$"$1 {fileId},$2 {libraryGuid},$3"
));
})
.ToArray();
foreach (var map in remappableAssets)
{
var fileText = File.ReadAllText(map.Path);
fileText = map.ToAssemblyReference.Replace(fileText, map.AssemblyReference);
File.WriteAllText(map.Path, fileText);
}
foreach (var unityPackageDatum in unityPackageData)
{
foreach (var outputPath in unityPackageDatum.StagingPaths.Select(path => path.Resolve(pipeline, this)))
{
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
foreach (var unityPackage in unityPackageDatum.unityPackages)
{
unityPackage.Export(outputPath);
}
}
}
foreach (var map in remappableAssets)
{
var fileText = File.ReadAllText(map.Path);
fileText = map.ToScriptReference.Replace(fileText, map.ScriptReference);
File.WriteAllText(map.Path, fileText);
}
}
public void ResolveUnknownPackageThrows()
{
ExceptionAssert.Throws <InvalidOperationException>(
() => PackageHelper.ResolvePackage(new MockPackageRepository(), new MockPackageRepository(), "elmah", null, allowPrereleaseVersions: false),
"Unable to find package 'elmah'.");
}
private async void Download_Click(object sender, RoutedEventArgs e)
{
InstallButton.IsEnabled = false;
var gettingPackagesDialog = new ProgressDialog()
{
Title = ViewModel.Product.Title,
Body = "Fetching packages..."
};
await PackageHelper.DownloadPackage(ViewModel.Product,
gettingPackagesCallback : product =>
{
gettingPackagesDialog.ShowAsync();
},
noPackagesCallback : async product =>
{
var noPackagesDialog = new ContentDialog()
{
Title = product.Title,
Content = "No available packages for this product.",
PrimaryButtonText = "Ok"
};
await noPackagesDialog.ShowAsync();
},
packagesLoadedCallback : product =>
{
gettingPackagesDialog.Hide();
},
packageDownloadedCallback : async(product, details, file, toast) =>
{
var savePicker = new Windows.Storage.Pickers.FileSavePicker();
savePicker.SuggestedStartLocation =
Windows.Storage.Pickers.PickerLocationId.Downloads;
if (file.FileType.EndsWith("bundle"))
{
savePicker.FileTypeChoices.Add("Windows App Bundle", new string[] { file.FileType });
}
else
{
savePicker.FileTypeChoices.Add("Windows App Package", new string[] { file.FileType });
}
savePicker.SuggestedFileName = file.DisplayName;
savePicker.SuggestedSaveFile = file;
var userFile = await savePicker.PickSaveFileAsync();
if (userFile != null)
{
await file.MoveAndReplaceAsync(userFile);
}
});
InstallButton.IsEnabled = true;
return;
var culture = CultureInfo.CurrentUICulture;
string productId = ViewModel.Product.ProductId;
DisplayCatalogHandler dcathandler = new DisplayCatalogHandler(DCatEndpoint.Production, new Locale(culture, true));
await dcathandler.QueryDCATAsync(productId);
var packs = await dcathandler.GetMainPackagesForProductAsync();
string packageFamilyName = dcathandler.ProductListing.Product.Properties.PackageFamilyName;
gettingPackagesDialog.Hide();
if (packs != null)// && packs.Count > 0)
{
var package = PackageHelper.GetLatestDesktopPackage(packs.ToList(), packageFamilyName, ViewModel.Product);
if (package == null)
{
return;
}
else
{
var file = (await PackageHelper.DownloadPackage(package, ViewModel.Product)).Item1;
var toast = PackageHelper.GenerateDownloadSuccessToast(package, ViewModel.Product, file);
Windows.UI.Notifications.ToastNotificationManager.GetDefault().CreateToastNotifier().Show(toast);
}
}
InstallButton.IsEnabled = true;
}
private static async Task UploadPackage(PushOptions options, PackageHelper packageHelper, PackageInfo packageInfo)
{
try
{
// HttpClient will use this event handler to give us
// Reporting on how its progress the file upload
var processMsgHandler = new ProgressMessageHandler(new HttpClientHandler());
processMsgHandler.HttpSendProgress += (sender, e) =>
{
// Could try to reimplement progressbar - but that library did not work in GH Actions :(
var percent = e.ProgressPercentage;
};
var keyParts = packageHelper.SplitKey(options.ApiKey);
var packageFileName = Path.GetFileName(options.Package);
Console.WriteLine(Resources.Push_Uploading, packageFileName);
var url = "/Umbraco/Api/ProjectUpload/UpdatePackage";
using (var client = packageHelper.GetClientBase(url, keyParts.Token, keyParts.MemberId, keyParts.ProjectId))
{
MultipartFormDataContent form = new MultipartFormDataContent();
var fileInfo = new FileInfo(options.Package);
var content = new StreamContent(fileInfo.OpenRead());
content.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "file",
FileName = fileInfo.Name
};
form.Add(content);
form.Add(new StringContent(ParseCurrentFlag(options.Current)), "isCurrent");
form.Add(new StringContent(options.DotNetVersion), "dotNetVersion");
form.Add(new StringContent("package"), "fileType");
form.Add(GetVersionCompatibility(options.WorksWith), "umbracoVersions");
form.Add(new StringContent(packageInfo.VersionString), "packageVersion");
var httpResponse = await client.PostAsync(url, form);
if (httpResponse.StatusCode == HttpStatusCode.Unauthorized)
{
packageHelper.WriteError(Resources.Push_ApiKeyInvalid);
Environment.Exit(5); // ERROR_ACCESS_DENIED
}
else if (httpResponse.IsSuccessStatusCode)
{
Console.WriteLine(Resources.Push_Complete, packageFileName);
// Response is not reported (at the moment)
// var apiReponse = await httpResponse.Content.ReadAsStringAsync();
// Console.WriteLine(apiReponse);
}
}
}
catch (HttpRequestException ex)
{
// Could get network error or our.umb down
Console.WriteLine(Resources.Error, ex);
throw;
}
}
/// <summary>
/// 浠庢暣浣撳瓧鑺傛暟缁勮幏寰楀疄浣撲笂涓嬫枃鐨勫叿浣撴暟鎹?
/// </summary>
/// <param name="dataBuffer"></param>
/// <returns></returns>
public static SMsgPropCreateEntity_SC_Monster ParsePackage(byte[] dataBuffer, int offset)
{
Package package = PackageHelper.ParseReceiveData(dataBuffer);
return(ParsePackage(package, offset));
}
/// <summary>
///
/// </summary>
/// <param name="archivePath"></param>
/// <param name="uri"></param>
/// <param name="iconFilePath"></param>
/// <param name="fileInfo"></param>
/// <returns></returns>
public static bool TryGetPEFileInfo(string archivePath, string uri, string iconFilePath, out PEFileInfo fileInfo)
{
fileInfo = new PEFileInfo();
fileInfo.Subsystem = SubsystemTypes.Unknown;
try
{
Package package = PackageHelper.GetPackage(archivePath, false, FileAccess.Read);
{
byte[] bytes;
Uri pathUri = new Uri(uri, UriKind.Relative);
using (Stream stream = package.GetPart(pathUri).GetStream())
{
bytes = new byte[(int)stream.Length];
stream.Read(bytes, 0, bytes.Length);
}
SubsystemTypes SubsystemType;
bool succsess = TryGetSubsystemType(bytes, out SubsystemType);
if (!succsess)
{
return(false);
}
fileInfo.Subsystem = SubsystemType;
if (Helper.IsNotNullOrEmpty(iconFilePath))
{
succsess = TryExtractIcon(bytes, iconFilePath);
}
if (!succsess)
{
RC.WriteLine(ConsoleVerbosity.Verbose, ConsoleThemeColor.SubTextNutral, " - " + Rpx.Strings.Reflection_NoIconFound);
return(true);
}
if (File.Exists(iconFilePath))
{
fileInfo.IconPath = iconFilePath;
fileInfo.HasIcon = true;
}
else
{
RC.WriteLine(ConsoleVerbosity.Verbose, ConsoleThemeColor.SubTextNutral, " - " + Rpx.Strings.Reflection_NoIconFound);
}
return(true);
}
}
catch (Exception ex)
{
RC.WriteException(0112, Rpx.Strings.Error_0112, ex);
return(false);
}
finally
{
PackageHelper.ReleasePackage(archivePath);
}
}
public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
{
Package package;
MasterMsgType masterMsgType = (MasterMsgType)cmdtype;
package = PackageHelper.ParseReceiveData(dataBuffer);
switch (masterMsgType)
{
case MasterMsgType.NET_ROOT_TEAM:
{
switch (package.GetSubMsgType())
{
case TeamDefineManager.MSG_TEAM_TEAMLIST:
this.AddToInvoker(this.ReceiveTeamListHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_CREATE:
this.AddToInvoker(this.ReceiveTeamCreateHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_DISBAND:
this.AddToInvoker(this.ReceiveTeamDisbandHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_UPDATEPROP:
this.AddToInvoker(this.ReceiveTeamUpdatePropHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_MEMBER_UPDATEPROP:
this.AddToInvoker(this.ReceiveTeamMemberUpdatePropHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_MEMBER_JOIN:
this.AddToInvoker(this.ReceiveTeamMemberJoinHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_CAPTAIN_JOIN:
this.AddToInvoker(this.ReceiveTeamMemberJoinHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_MEMBER_LEAVE:
this.AddToInvoker(this.ReceiveTeamMemberLeaveHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_MEMBER_KICK:
this.AddToInvoker(this.ReceiveMemberKickHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_MEMBER_INVITE:
this.AddToInvoker(this.ReceiveTeamMemberInviteHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_MEMBER_READY:
this.AddToInvoker(this.ReceiveMemberReadyHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_ERROR_CODE:
this.AddToInvoker(this.ReceiveTeamErrorCodeHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_TEAM_INVITER_FAILED:
this.AddToInvoker(this.ReceiveTeamInviterFailedHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_GET_TEAMNUMLIST:
this.AddToInvoker(this.ReceiveCrusadeTeamNumListHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_MATCHING_CANCEL:
this.AddToInvoker(this.ReceiveMatchingCancelHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_MATCHING_CONFIRM:
this.AddToInvoker(ConfirmMatchindHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_PVP_INVITE_FRIEND: //收到邀请PvpReceiveInviteFriendHandle
this.AddToInvoker(PvpReceiveInviteFriendHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_PVP_ENTER_CONFIRM: //收到加入成功
this.AddToInvoker(PvpReceiveEnterConfirmHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_PVP_MATCHING_BEGIN: //收到开始匹配通知
this.AddToInvoker(PvpReceiveBeginMatchHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_PVP_MATCHING_CANCEL: //收到取消匹配通知
this.AddToInvoker(PvpReceiveCancelMatchHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_PVP_MATCHING_LEAVE: //收到队友离开通知
this.AddToInvoker(PvpReceiveCancelTeamHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_PVP_MATCHING_SYNINFO: //收到同步队伍通知
this.AddToInvoker(PvpMatchindSyncHandle, package.Data, socketId);
break;
case TeamDefineManager.MSG_PVP_MATCHING_SUCESS: //匹配成功
this.AddToInvoker(PvpMatchindSyncHandle, package.Data, socketId);
break;
}
} break;
default:
//TraceUtil.Log("不能识别的主消息:" + package.GetMasterMsgType());
break;
}
}
/// <summary>
/// 从整体字节数组获得实体上下文的具体数据
/// </summary>
/// <param name="dataBuffer"></param>
/// <returns></returns>
public static BoxSubMsgEntity ParsePackage(byte[] dataBuffer, int offset)
{
Package package = PackageHelper.ParseReceiveData(dataBuffer);
return(ParsePackage(package, offset));
}
private static IEnumerable <string> GetValidPackageItems(IEnumerable <string> items)
{
// Assume nupkg and nuspec as the save mode for identifying valid package files
return(items?.Where(i => PackageHelper.IsPackageFile(i, PackageSaveMode.Defaultv3)) ?? Enumerable.Empty <string>());
}
public uint dwLeaderID; // 组长ID
public static SMsgPVPMathingLeave_SC ParsePackage(byte[] dataBuffer)
{
return(PackageHelper.BytesToStuct <SMsgPVPMathingLeave_SC>(dataBuffer));
}
public uint dwActorID; // 邀请者的ActorID
public static SMsgPVPFriendConfirm_CS ParsePackage(byte[] dataBuffer)
{
return(PackageHelper.BytesToStuct <SMsgPVPFriendConfirm_CS>(dataBuffer));
}
public void PrepareUrlForRenderingTest(string input, bool alwaysRewriteHttp, string expectedOutput, bool expectConversion)
{
Assert.Equal(expectConversion, PackageHelper.TryPrepareUrlForRendering(input, out string readyUriString, alwaysRewriteHttp));
Assert.Equal(expectedOutput, readyUriString);
}
public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
{
MasterMsgType masterMsgType = (MasterMsgType)cmdtype;
Package package = PackageHelper.ParseReceiveData(dataBuffer);
//TraceUtil.Log("收到副本主消息" + masterMsgType + "收到子消息。" + package.GetSubMsgType());
switch (masterMsgType)
{
case MasterMsgType.NET_ROOT_ECTYPE:
switch (package.GetSubMsgType())
{
//case EctypeDefineManager.MSG_ECTYPE_WORLDMAP_SELECT:
// //TraceUtil.Log("收到世界地图创建选择消息");
// this.AddToInvoker(WorldMapSelectHandle, dataBuffer, socketId);
// break;
//case EctypeDefineManager.MSG_ECTYPE_ECTYPECONTAINER_LEVELDATAS:
// this.AddToInvoker(EctypeLevelDataHandle, dataBuffer, socketId);
// //TraceUtil.Log("回应关卡信息！！！！！");
// break;
//case EctypeDefineManager.MSG_ECTYPE_SETTLEACCOUNTS:
// this.AddToInvoker(EctypeSettleAccountHandle, dataBuffer, socketId);
// //TraceUtil.Log("收到副本结算消息！");
// break;
//case EctypeDefineManager.MSG_ECTYPE_SYN_SKILLDATA:
// this.AddToInvoker(ReceiveSkillDataHandle, dataBuffer, socketId);
// break;
//case EctypeDefineManager.MSG_ECTYPE_CREATEERROR:
// this.AddToInvoker(EctypeRequestError, dataBuffer, socketId);
// //TraceUtil.Log("创建副本失败！！");
// break ;
case ECTYPE_DefineManager.MSG_ECTYPE_SYN_SKILLDATA:
//TraceUtil.Log("收到技能同步消息");
this.AddToInvoker(ReceiveSkillDataHandle, dataBuffer, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_SELECT:
//TraceUtil.Log("收到跳转副本界面消息");
this.AddToInvoker(EctypeSelectHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_LEVELDATA:
//TraceUtil.Log("收到单个副本信息");
this.AddToInvoker(EctypeLevelDataHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_CANENTER_ECTYPE:
//TraceUtil.Log("所有队友加入副本成功");
this.AddToInvoker(ResponeTeamateEnterEctype, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_SETTLEACCOUNTS:
this.AddToInvoker(EctypeSettleAccountHandle, dataBuffer, socketId);
//TraceUtil.Log("收到副本结算消息！");
break;
case ECTYPE_DefineManager.MSG_ECTYPE_PLAYERREVIVE:
this.AddToInvoker(sMSGEctypePlayerReviveHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_TREASUREAWARD:
//TraceUtil.Log("收到宝箱奖励消息 ");
this.AddToInvoker(sMSGEctypeTreasureReward_SCHandel, package.Data, socketId);
break;
//\
case ECTYPE_DefineManager.MSG_TEST_BEGIN_LOG:
this.AddToInvoker(StartPrintHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_TEST_END_LOG:
this.AddToInvoker(EndPrintHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_ERRORCODE:
this.AddToInvoker(EctypeErrorCodeHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_CLEARANCE:
this.AddToInvoker(ECTYPE_CLEARANCEHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_PVP_FINDPLAYER:
this.AddToInvoker(PVPFindPlayerHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_PVP_READY:
this.AddToInvoker(PVPReadyHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_PVP_FIGHTING:
this.AddToInvoker(PVPFightingHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_PVP_SETTLEACCOUNTS:
this.AddToInvoker(PVPSettleAccountHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_INITIALIZE:
this.AddToInvoker(InitializeEctypeHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_YAOQIPROP:
this.AddToInvoker(UpdateYaoqiHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_PRACTICE_LIST: //练功房列表
this.AddToInvoker(ReceiveMartialArtsRoomList, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_ALLSEAT_INFO: //同步房间座位信息
this.AddToInvoker(ReceiveEctypeAllSeatInfo, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_SET_INFO: //同步座位信息
this.AddToInvoker(ReceiveUpdateEctypeSeatInfo, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_TRIALS_INFO: //试炼副本列表
this.AddToInvoker(ReceiveTrialsEctypeList, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_TRIALS_SUBRESULT: //试炼副本波数结算
this.AddToInvoker(ReceiveSingleTrialsSettlement, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_TRIALS_TOTALRESULT: //试炼副本结算
this.AddToInvoker(ReceiveTrialsSettlement, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_PRACIICE_YAONVUPDATE:
//TraceUtil.Log("[ReceivePracticeYaoNvUpdateHandle]");
this.AddToInvoker(ReceivePracticeYaoNvUpdateHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_SHOW_TIPS:
this.AddToInvoker(ReceiveMissionFailSettement, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_FIGHT_MODE:
this.AddToInvoker(EctypeFightModeHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_NORMAL_RESULT:
this.AddToInvoker(ReceiveBossDeadSettement, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_YAONVSKILL_USETIME:
this.AddToInvoker(ReceiveYaoNvSkillUseTime, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_OPEN_CHEST:
this.AddToInvoker(ReceiveTreasureThestsOpenMsg, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_DEFINE_LOOPNUM:
this.AddToInvoker(ReceiveLoopNumMsg, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_DEFINE_LOOPMAX:
this.AddToInvoker(ReceiveMaxLoopNUmMsg, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_FINISH:
this.AddToInvoker(ReceiveEctypeFinishMsg, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_DEFINE_INFO:
this.AddToInvoker(ReceiveEctypeDefineInfoMsg, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_DEFINE_UPDATA:
this.AddToInvoker(ReceiveEctypeDefineUpdateMsg, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_MEMBER_UPDATEPROP:
this.AddToInvoker(ReceiveEctypePropsHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_DEFINE_RESULT:
this.AddToInvoker(ReceiveDefenceEctypeResultHandle, package.Data, socketId);
break;
//常规副本信息
case ECTYPE_DefineManager.MSG_ECTYPE_NORMAL_INFO:
this.AddToInvoker(ReceiveEctypeNomalDataHandle, package.Data, socketId);
break;
//常规副本信息更新
case ECTYPE_DefineManager.MSG_ECTYPE_NORMAL_UPDATA:
this.AddToInvoker(ReceiveEctypeNomalUpdateHandle, package.Data, socketId);
break;
//更新副本宝箱信息
case ECTYPE_DefineManager.MSG_ECTYPE_NORMAL_UPDATACHEST:
this.AddToInvoker(ReceiveChessInfoUpdateHandle, package.Data, socketId);
break;
//无尽副本波数
case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_LOOPNUM:
this.AddToInvoker(ReceiveEndlessLoopNumHandle, package.Data, socketId);
break;
//无尽副本获得奖励(无尽副本闯过的波数)
case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_REWARD:
this.AddToInvoker(ReceiveEndlessPassLoopHandle, package.Data, socketId);
break;
//无尽副本结算
case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_RESULT:
this.AddToInvoker(ReceiveEndlessFinishPassLoopHandle, package.Data, socketId);
break;
//无尽副本界面数据
case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_INFO:
this.AddToInvoker(ReceiveEndlessBestDataHandle, package.Data, socketId);
break;
//无尽副本界面数据更新
case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_UPDATA:
this.AddToInvoker(ReceiveEndlessBestDataUpdateHandle, package.Data, socketId);
break;
//无尽副本断线重连
case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_LOOPTIME:
this.AddToInvoker(ReceiveEndlessAgainConnectHandle, package.Data, socketId);
break;
//无尽副本跳转场景
case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_MAPJUMPTIME:
this.AddToInvoker(ReceiveEndlessSceneTimeHandle, package.Data, socketId);
break;
//讨伐副本结算
case ECTYPE_DefineManager.MSG_ECTYPE_CRUSADE_RESULT:
this.AddToInvoker(ReceiveEctypeCrusadeResultHandle, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_CRUSADE_TIME:
this.AddToInvoker(ReceiveEctypeCrusadeTime, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_UPDATE_BLOCK:
this.AddToInvoker(ReceiveEctypeUpdateBlock, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_RESULT_SWEEP:
this.AddToInvoker(ReceiveEctypeSweepReward, package.Data, socketId);
break;
case ECTYPE_DefineManager.MSG_ECTYPE_RANDOM_REWARD:
this.AddToInvoker(ReceiveEctypeRandomReward, package.Data, socketId);
break;
//case ECTYPE_DefineManager.MSG_ECTYPE_PVP_RESULT:
// this.AddToInvoker(ReceiveEctypePVPSettlement, package.Data, socketId);
break;
default:
//TraceUtil.Log("NET_ROOT_ECTYPE" + package.GetSubMsgType());
break;
}
break;
default:
//TraceUtil.Log("不能识别的主消息" + package.GetMasterMsgType());
break;
}
}
internal static string PillarOrElevationName(string packageName, string fullName) => packageName + "." + PackageHelper.StripName(fullName);
private static void PackagesWatcher_Created(object sender, FileSystemEventArgs e)
{
string filePath = e.FullPath;
EditorApplication.update += InstallPackage;
void InstallPackage()
{
try
{
EditorApplication.update -= InstallPackage;
AssetDatabase.StartAssetEditing();
string fileNameNoExt = Path.GetFileNameWithoutExtension(filePath);
var dependencyPath = Path.Combine(Packages, fileNameNoExt);
if (Directory.Exists(dependencyPath))
{
Directory.Delete(dependencyPath, true);
}
if (File.Exists($"{dependencyPath}.meta"))
{
File.Delete($"{dependencyPath}.meta");
}
Directory.CreateDirectory(dependencyPath);
using (var fileStream = File.OpenRead(filePath))
using (var archive = new ZipArchive(fileStream))
foreach (var entry in archive.Entries)
{
if (entry.FullName.ToLower().EndsWith("/") || entry.FullName.ToLower().EndsWith("\\"))
{
continue;
}
var outputPath = Path.Combine(dependencyPath, entry.FullName);
var outputDir = Path.GetDirectoryName(outputPath);
var fileName = Path.GetFileName(outputPath);
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
entry.ExtractToFile(outputPath);
if (Path.GetExtension(fileName).Equals(".dll"))
{
string assemblyPath = outputPath;
PackageHelper.WriteAssemblyMetaData(assemblyPath, $"{assemblyPath}.meta");
}
if ("manifest.json".Equals(fileName.ToLower()))
{
var stubManifest = CreateThunderstoreManifest.LoadStub(outputPath);
var authorAlias = fileNameNoExt.Substring(0, fileNameNoExt.IndexOf('-'));
PackageHelper.GeneratePackageManifest(
stubManifest.name.ToLower(), outputDir,
stubManifest.name, authorAlias,
stubManifest.version_number,
stubManifest.description,
stubManifest.website_url);
}
}
File.Delete(filePath);
}
finally
{
AssetDatabase.StopAssetEditing();
AssetDatabase.Refresh();
}
}
}
public IndexModel(IWebHostEnvironment env)
{
_helper = new PackageHelper(env.WebRootPath);
}
internal static object CustomDeserialize(Package p, Type t, PackageReader r)
{
// Props and trees in buildings and parks.
if (t == typeof(BuildingInfo.Prop))
{
PropInfo pi = Get <PropInfo>(r.ReadString()); // old name format (without package name) is possible
TreeInfo ti = Get <TreeInfo>(r.ReadString()); // old name format (without package name) is possible
if (instance.report && UsedAssets.instance.GotAnyContainer())
{
if (pi != null)
{
string n = pi.gameObject.name;
if (!string.IsNullOrEmpty(n) && n.IndexOf('.') >= 0)
{
UsedAssets.instance.IndirectProps.Add(n);
}
}
if (ti != null)
{
string n = ti.gameObject.name;
if (!string.IsNullOrEmpty(n) && n.IndexOf('.') >= 0)
{
UsedAssets.instance.IndirectTrees.Add(n);
}
}
}
return(new BuildingInfo.Prop
{
m_prop = pi,
m_tree = ti,
m_position = r.ReadVector3(),
m_angle = r.ReadSingle(),
m_probability = r.ReadInt32(),
m_fixedHeight = r.ReadBoolean()
});
}
// Paths (nets) in buildings.
if (t == typeof(BuildingInfo.PathInfo))
{
string fullName = r.ReadString();
NetInfo ni = Get <NetInfo>(fullName);
BuildingInfo.PathInfo path = new BuildingInfo.PathInfo();
path.m_netInfo = ni;
path.m_nodes = r.ReadVector3Array();
path.m_curveTargets = r.ReadVector3Array();
path.m_invertSegments = r.ReadBoolean();
path.m_maxSnapDistance = r.ReadSingle();
if (p.version >= 5)
{
path.m_forbidLaneConnection = r.ReadBooleanArray();
path.m_trafficLights = (BuildingInfo.TrafficLights[])(object) r.ReadInt32Array();
path.m_yieldSigns = r.ReadBooleanArray();
}
return(path);
}
if (t == typeof(Package.Asset))
{
return(r.ReadAsset(p));
}
// It seems that trailers are listed in the save game so this is not necessary. Better to be safe however
// because a missing trailer reference is fatal for the simulation thread.
if (t == typeof(VehicleInfo.VehicleTrailer))
{
string name = r.ReadString();
string fullName = p.packageName + "." + name;
VehicleInfo vi = Get <VehicleInfo>(p, fullName, name, false);
VehicleInfo.VehicleTrailer trailer;
trailer.m_info = vi;
trailer.m_probability = r.ReadInt32();
trailer.m_invertProbability = r.ReadInt32();
return(trailer);
}
if (t == typeof(NetInfo.Lane))
{
return(new NetInfo.Lane
{
m_position = r.ReadSingle(),
m_width = r.ReadSingle(),
m_verticalOffset = r.ReadSingle(),
m_stopOffset = r.ReadSingle(),
m_speedLimit = r.ReadSingle(),
m_direction = (NetInfo.Direction)r.ReadInt32(),
m_laneType = (NetInfo.LaneType)r.ReadInt32(),
m_vehicleType = (VehicleInfo.VehicleType)r.ReadInt32(),
m_stopType = (VehicleInfo.VehicleType)r.ReadInt32(),
m_laneProps = GetNetLaneProps(p, r),
m_allowConnect = r.ReadBoolean(),
m_useTerrainHeight = r.ReadBoolean(),
m_centerPlatform = r.ReadBoolean(),
m_elevated = r.ReadBoolean()
});
}
if (t == typeof(NetInfo.Segment))
{
NetInfo.Segment segment = new NetInfo.Segment();
string checksum = r.ReadString();
segment.m_mesh = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMesh(checksum, p, true);
checksum = r.ReadString();
segment.m_material = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMaterial(checksum, p, true);
checksum = r.ReadString();
segment.m_lodMesh = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMesh(checksum, p, false);
checksum = r.ReadString();
segment.m_lodMaterial = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMaterial(checksum, p, false);
segment.m_forwardRequired = (NetSegment.Flags)r.ReadInt32();
segment.m_forwardForbidden = (NetSegment.Flags)r.ReadInt32();
segment.m_backwardRequired = (NetSegment.Flags)r.ReadInt32();
segment.m_backwardForbidden = (NetSegment.Flags)r.ReadInt32();
segment.m_emptyTransparent = r.ReadBoolean();
segment.m_disableBendNodes = r.ReadBoolean();
return(segment);
}
if (t == typeof(NetInfo.Node))
{
NetInfo.Node node = new NetInfo.Node();
string checksum = r.ReadString();
node.m_mesh = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMesh(checksum, p, true);
checksum = r.ReadString();
node.m_material = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMaterial(checksum, p, true);
checksum = r.ReadString();
node.m_lodMesh = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMesh(checksum, p, false);
checksum = r.ReadString();
node.m_lodMaterial = string.IsNullOrEmpty(checksum) ? null : Sharing.instance.GetMaterial(checksum, p, false);
node.m_flagsRequired = (NetNode.Flags)r.ReadInt32();
node.m_flagsForbidden = (NetNode.Flags)r.ReadInt32();
node.m_connectGroup = (NetInfo.ConnectGroup)r.ReadInt32();
node.m_directConnect = r.ReadBoolean();
node.m_emptyTransparent = r.ReadBoolean();
return(node);
}
if (t == typeof(NetInfo))
{
string name = r.ReadString();
CustomAssetMetaData.Type type = AssetLoader.instance.GetMetaType(AssetLoader.instance.Current);
if (type == CustomAssetMetaData.Type.Road || type == CustomAssetMetaData.Type.RoadElevation)
{
return(Get <NetInfo>(p, name)); // elevations, bridges, slopes, tunnels in nets
}
else
{
return(Get <NetInfo>(name)); // train lines, metro lines in buildings (stations)
}
}
if (t == typeof(BuildingInfo))
{
string name = r.ReadString();
CustomAssetMetaData.Type type = AssetLoader.instance.GetMetaType(AssetLoader.instance.Current);
if (type == CustomAssetMetaData.Type.Road || type == CustomAssetMetaData.Type.RoadElevation)
{
return(Get <BuildingInfo>(p, name)); // pillars in nets
}
else
{
return(Get <BuildingInfo>(name)); // do these exist?
}
}
// Sub-buildings in buildings.
if (t == typeof(BuildingInfo.SubInfo))
{
string name = r.ReadString();
string fullName = p.packageName + "." + name;
BuildingInfo bi = null;
if (fullName == AssetLoader.instance.Current.fullName || name == AssetLoader.instance.Current.fullName)
{
Util.DebugPrint("Warning:", fullName, "wants to be a sub-building for itself");
}
else
{
bi = Get <BuildingInfo>(p, fullName, name, true);
}
BuildingInfo.SubInfo subInfo = new BuildingInfo.SubInfo();
subInfo.m_buildingInfo = bi;
subInfo.m_position = r.ReadVector3();
subInfo.m_angle = r.ReadSingle();
subInfo.m_fixedHeight = r.ReadBoolean();
return(subInfo);
}
// Prop variations in props.
if (t == typeof(PropInfo.Variation))
{
string name = r.ReadString();
string fullName = p.packageName + "." + name;
PropInfo pi = null;
if (fullName == AssetLoader.instance.Current.fullName)
{
Util.DebugPrint("Warning:", fullName, "wants to be a prop variation for itself");
}
else
{
pi = Get <PropInfo>(p, fullName, name, false);
}
return(new PropInfo.Variation
{
m_prop = pi,
m_probability = r.ReadInt32()
});
}
// Tree variations in trees.
if (t == typeof(TreeInfo.Variation))
{
string name = r.ReadString();
string fullName = p.packageName + "." + name;
TreeInfo ti = null;
if (fullName == AssetLoader.instance.Current.fullName)
{
Util.DebugPrint("Warning:", fullName, "wants to be a tree variation for itself");
}
else
{
ti = Get <TreeInfo>(p, fullName, name, false);
}
return(new TreeInfo.Variation
{
m_tree = ti,
m_probability = r.ReadInt32()
});
}
if (t == typeof(VehicleInfo.MeshInfo))
{
VehicleInfo.MeshInfo meshinfo = new VehicleInfo.MeshInfo();
string checksum = r.ReadString();
if (!string.IsNullOrEmpty(checksum))
{
Package.Asset asset = p.FindByChecksum(checksum);
GameObject go = AssetDeserializer.Instantiate(asset) as GameObject;
meshinfo.m_subInfo = go.GetComponent <VehicleInfoBase>();
go.SetActive(false);
if (meshinfo.m_subInfo.m_lodObject != null)
{
meshinfo.m_subInfo.m_lodObject.SetActive(false);
}
}
else
{
meshinfo.m_subInfo = null;
}
meshinfo.m_vehicleFlagsForbidden = (Vehicle.Flags)r.ReadInt32();
meshinfo.m_vehicleFlagsRequired = (Vehicle.Flags)r.ReadInt32();
meshinfo.m_parkedFlagsForbidden = (VehicleParked.Flags)r.ReadInt32();
meshinfo.m_parkedFlagsRequired = (VehicleParked.Flags)r.ReadInt32();
return(meshinfo);
}
return(PackageHelper.CustomDeserialize(p, t, r));
}
public static async Task <int> RunAndReturn(PushOptions options, PackageHelper packageHelper)
{
// --package=MyFile.zip
// --package=./MyFile.zip
// --package=../MyParentFolder.zip
var filePath = options.Package;
var apiKey = options.ApiKey;
var keyParts = packageHelper.SplitKey(apiKey);
// Check we can find the file
packageHelper.EnsurePackageExists(filePath);
// Check File is a ZIP
packageHelper.EnsureIsZip(filePath);
// Check zip contains valid package.xml
packageHelper.EnsureContainsPackageXml(filePath);
// gets a package list from our.umbraco
// if the api key is invalid we will also find out here.
var packages = await packageHelper.GetPackageList(keyParts);
var currentPackageId = await packageHelper.GetCurrentPackageFileId(keyParts);
if (packages != null)
{
packageHelper.EnsurePackageDoesntAlreadyExists(packages, filePath);
}
// Archive packages
var archivePatterns = new List <string>();
var packagesToArchive = new List <int>();
if (options.Archive != null)
{
archivePatterns.AddRange(options.Archive);
}
if (archivePatterns.Count > 0)
{
foreach (var archivePattern in archivePatterns)
{
if (archivePattern == "current")
{
// If the archive option is "current", then archive the current package
if (currentPackageId != "0")
{
packagesToArchive.Add(int.Parse(currentPackageId));
}
}
else
{
// Convert the archive option to a regex
var archiveRegex = new Regex("^" + archivePattern.Replace(".", "\\.").Replace("*", "(.*)") + "$", RegexOptions.IgnoreCase);
// Find packages that match the regex and extract their IDs
var archiveIds = packages.Where(x => archiveRegex.IsMatch(x.Value <string>("Name"))).Select(x => x.Value <int>("Id")).ToArray();
packagesToArchive.AddRange(archiveIds);
}
}
}
if (packagesToArchive.Count > 0)
{
await packageHelper.ArchivePackages(keyParts, packagesToArchive.Distinct());
Console.WriteLine($"Archived {packagesToArchive.Count} packages matching the archive pattern.");
}
// Parse package.xml before upload to print out info
// and to use for comparison on what is already uploaded
var packageInfo = Parse.PackageXml(filePath);
// OK all checks passed - time to upload it
await UploadPackage(options, packageHelper, packageInfo);
return(0);
}
/// <summary>
/// Asynchronously deletes a package.
/// </summary>
/// <param name="packageIdentity">A package identity.</param>
/// <param name="nuGetProjectContext">A NuGet project context.</param>
/// <param name="token">A cancellation token.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns a <see cref="bool" />
/// indication successfulness of the operation.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="packageIdentity" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="nuGetProjectContext" />
/// is <c>null</c>.</exception>
public async Task <bool> DeletePackage(PackageIdentity packageIdentity,
INuGetProjectContext nuGetProjectContext,
CancellationToken token)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (nuGetProjectContext == null)
{
throw new ArgumentNullException(nameof(nuGetProjectContext));
}
var packageFilePath = GetInstalledPackageFilePath(packageIdentity);
if (File.Exists(packageFilePath))
{
var packageDirectoryPath = Path.GetDirectoryName(packageFilePath);
using (var packageReader = new PackageArchiveReader(packageFilePath))
{
var installedSatelliteFilesPair = await PackageHelper.GetInstalledSatelliteFilesAsync(
packageReader,
PackagePathResolver,
GetPackageSaveMode(nuGetProjectContext),
token);
var runtimePackageDirectory = installedSatelliteFilesPair.Item1;
var installedSatelliteFiles = installedSatelliteFilesPair.Item2;
if (!string.IsNullOrEmpty(runtimePackageDirectory))
{
try
{
// Delete all the package files now
FileSystemUtility.DeleteFiles(installedSatelliteFiles, runtimePackageDirectory, nuGetProjectContext);
}
catch (Exception ex)
{
nuGetProjectContext.Log(MessageLevel.Warning, ex.Message);
// Catch all exception with delete so that the package file is always deleted
}
}
// Get all the package files before deleting the package file
var installedPackageFiles = await PackageHelper.GetInstalledPackageFilesAsync(
packageReader,
packageIdentity,
PackagePathResolver,
GetPackageSaveMode(nuGetProjectContext),
token);
try
{
// Delete all the package files now
FileSystemUtility.DeleteFiles(installedPackageFiles, packageDirectoryPath, nuGetProjectContext);
}
catch (Exception ex)
{
nuGetProjectContext.Log(MessageLevel.Warning, ex.Message);
// Catch all exception with delete so that the package file is always deleted
}
}
// Delete the package file
FileSystemUtility.DeleteFile(packageFilePath, nuGetProjectContext);
// Delete the package directory if any
FileSystemUtility.DeleteDirectorySafe(packageDirectoryPath, recursive: true, nuGetProjectContext: nuGetProjectContext);
// If this is the last package delete the package directory
// If this is the last package delete the package directory
if (!FileSystemUtility.GetFiles(Root, string.Empty, "*.*").Any() &&
!FileSystemUtility.GetDirectories(Root, string.Empty).Any())
{
FileSystemUtility.DeleteDirectorySafe(Root, recursive: false, nuGetProjectContext: nuGetProjectContext);
}
}
return(true);
}
public void ResolveSpecificVersionOfUnknownPackageThrows()
{
ExceptionAssert.Throws <InvalidOperationException>(
() => PackageHelper.ResolvePackage(new MockPackageRepository(), new MockPackageRepository(), "elmah", new SemanticVersion("1.1"), allowPrereleaseVersions: false),
"Unable to find version '1.1' of package 'elmah'.");
}
public FeedController(IWebHostEnvironment env)
{
_helper = new PackageHelper(env.WebRootPath);
_feed = new FeedWriter();
}
public void Execute()
{
var parser = new FluentCommandLineParser();
IFile outputFile = null;
parser.Setup <string>('o', "output")
.WithDescription("Output report html file path to be created.")
.Required()
.Callback(x => outputFile = FileSystem.ParseFile(x));
var fileDialog = false;
parser.Setup <bool>('f', "fileDiaog")
.WithDescription("Show popup dialog to choose mega SSPG file")
.Callback(x => fileDialog = x);
var dirDialog = false;
parser.Setup <bool>('d', "directoryDiaog")
.WithDescription("Show popup dialog to choose extracted mega SSPG file")
.Callback(x => dirDialog = x);
var openReport = false;
parser.Setup <bool>('e', "open")
.WithDescription("Open report after generating")
.Callback(x => openReport = x);
IFile mega = null;
parser.Setup <string>('p', "package")
.WithDescription("Path to the mega SSPG package file")
.Callback(x => mega = FileSystem.ParseFile(x));
var workplaceName = "";
parser.Setup <string>('n', "name")
.WithDescription("Workplace name.")
.Callback(x => workplaceName = x);
var result = parser.Parse(Options);
if (result.HelpCalled)
{
return;
}
var assemblyName = Assembly.GetExecutingAssembly().GetName().ToString();
var system = new SystemContext(assemblyName);
IFile workplaceFile = null;
SupportPackageDataProvider[] packages = null;
if (fileDialog)
{
var dialog = new OpenFileDialog
{
Filter = "Mega Support Package|*.zip|Diagnostics Tool Workspace|*.sdt",
Multiselect = false,
};
IFile file;
while (true)
{
var dialogResult = dialog.ShowDialog();
if (dialogResult == DialogResult.Cancel)
{
return;
}
file = FileSystem.ParseFile(dialog.FileName);
if (file.Exists)
{
break;
}
}
if (file.Extension.Equals(".sdt", StringComparison.OrdinalIgnoreCase))
{
mega = null;
workplaceFile = file;
}
else
{
mega = file;
}
}
else if (dirDialog)
{
var dialog = new FolderBrowserDialog();
IDirectory dir;
while (true)
{
var dialogResult = dialog.ShowDialog();
if (dialogResult == DialogResult.Cancel)
{
return;
}
dir = FileSystem.ParseDirectory(dialog.SelectedPath);
if (dir.Exists)
{
break;
}
}
packages = dir.GetDirectories()
.ToArray(x =>
new SupportPackageDataProvider(x, null, null));
}
if (packages == null)
{
if (mega != null)
{
if (!mega.Exists)
{
Console.WriteLine($"File does not exist: {mega}");
return;
}
packages = PackageHelper.ExtractMegaPackage(mega)
.ToArray(x =>
new SupportPackageDataProvider(x, null, null));
}
}
if (packages == null)
{
workplaceFile = workplaceFile ?? FileSystem.GetWorkplaceFile(workplaceName);
if (!workplaceFile.Exists)
{
Program.ShowHelp();
return;
}
packages = workplaceFile.ReadAllLines()
.Select(x => x.Split('?'))
.Select(x => new
{
Path = x[0],
Roles = x[1].Split('|')
.Select(r => (ServerRole)Enum.Parse(typeof(ServerRole), r))
.ToArray()
})
.Select(x =>
{
Console.WriteLine($"Parsing {x.Path}");
var file = FileSystem.ParseFile(x.Path);
var dir = FileSystem.ParseDirectory(x.Path);
Assert.IsTrue(file.Exists || dir.Exists, "Neither file nor dir exists: " + x.Path);
var fileSystemEntry = file.Exists ? (IFileSystemEntry)file : dir;
return(new SupportPackageDataProvider(fileSystemEntry, x.Roles, null));
})
.ToArray();
}
try
{
Console.WriteLine("Running tests...");
var resultsFile = TestRunner.TestRunner.RunTests(packages, system, (test, index, count) => Console.WriteLine($"Running {test?.Name}..."));
outputFile.Directory.Create();
Console.WriteLine("Building report...");
outputFile.WriteAllText(ReportBuilder.GenerateReport(resultsFile));
if (openReport)
{
Process.Start("explorer", $"\"{outputFile}\"");
}
}
finally
{
foreach (var package in packages)
{
package?.Dispose();
}
}
}
public void GetDepthTest(int depth, string name)
{
Assert.Equal(depth, PackageHelper.GetDepth(name));
}
public void Basic()
{
PackageHelper.CreatePackage(Settings, "mypackage");
(bool, string)result = this.IndexReader.VerifyPackage("mypackage");
Assert.True(result.Item1);
}
public void ShouldRenderUrlTests(string url, bool secureOnly, bool shouldRender)
{
Assert.Equal(shouldRender, PackageHelper.ShouldRenderUrl(url, secureOnly: secureOnly));
}
private void RestartApp_Click(object sender, RoutedEventArgs e)
{
PackageHelper.RestartApp();
}
public int dwEctypeContainerID; //副本id
public static SMsgConfirmMatching_SC ParsePackage(byte[] dataBuffer)
{
return(PackageHelper.BytesToStuct <SMsgConfirmMatching_SC>(dataBuffer));
}
