public async Task UpdateValidationStatusAsync(PackageValidation packageValidation, IValidationResult validationResult)
{
packageValidation = packageValidation ?? throw new ArgumentNullException(nameof(packageValidation));
if (packageValidation.ValidationStatus == validationResult.Status)
{
_logger.LogInformation("Validation {ValidationName} {ValidationId} {PackageId} {PackageVersion} already has status {ValidationStatus}",
packageValidation.Type,
packageValidation.PackageValidationSet.ValidationTrackingId,
packageValidation.PackageValidationSet.PackageId,
packageValidation.PackageValidationSet.PackageNormalizedVersion,
validationResult.Status);
return;
}
_logger.LogInformation("Updating the status of the validation {ValidationName} {ValidationId} {PackageId} {PackageVersion} to {ValidationStatus}",
packageValidation.Type,
packageValidation.PackageValidationSet.ValidationTrackingId,
packageValidation.PackageValidationSet.PackageId,
packageValidation.PackageValidationSet.PackageNormalizedVersion,
validationResult.Status);
await SetValidationStatusAsync(packageValidation, validationResult, DateTime.UtcNow);
}
private async Task SetValidationStatusAsync(
PackageValidation packageValidation,
IValidationResult validationResult,
DateTime now)
{
if (validationResult.Status != ValidationStatus.Incomplete)
{
AddValidationIssues(packageValidation, validationResult.Issues);
}
if (validationResult.Status == ValidationStatus.Succeeded &&
validationResult.NupkgUrl != null)
{
if (!_validatorProvider.IsProcessor(packageValidation.Type))
{
throw new InvalidOperationException(
$"The validator '{packageValidation.Type}' is not a processor but returned a .nupkg URL as " +
$"part of the validation result.");
}
await _packageFileService.CopyPackageUrlForValidationSetAsync(
packageValidation.PackageValidationSet,
validationResult.NupkgUrl);
}
packageValidation.ValidationStatus = validationResult.Status;
packageValidation.ValidationStatusTimestamp = now;
await _validationContext.SaveChangesAsync();
TrackValidationStatus(packageValidation);
}
public async Task MarkValidationStartedAsync(PackageValidation packageValidation, IValidationResult validationResult)
{
packageValidation = packageValidation ?? throw new ArgumentNullException(nameof(packageValidation));
_logger.LogInformation("Marking validation {ValidationName} {ValidationId} {PackageId} {PackageVersion} as started with status {ValidationStatus}",
packageValidation.Type,
packageValidation.PackageValidationSet.ValidationTrackingId,
packageValidation.PackageValidationSet.PackageId,
packageValidation.PackageValidationSet.PackageNormalizedVersion,
validationResult.Status);
if (validationResult.Status == ValidationStatus.NotStarted)
{
throw new ArgumentOutOfRangeException(
nameof(validationResult),
$"Cannot mark validation {packageValidation.Type} for " +
$"{packageValidation.PackageValidationSet.PackageId} " +
$"{packageValidation.PackageValidationSet.PackageNormalizedVersion} as started " +
$"with status {ValidationStatus.NotStarted}");
}
var now = DateTime.UtcNow;
packageValidation.Started = now;
await SetValidationStatusAsync(packageValidation, validationResult, now);
}
private void PerformValidation()
{
var canBuildCompleteName = true;
if (!PackageValidation.ValidateOrganizationName(m_OrganizationName.stringValue) && !string.IsNullOrWhiteSpace(m_OrganizationName.stringValue))
{
canBuildCompleteName = false;
errorMessages.Add($"Invalid Package Organization Name '{m_OrganizationName.stringValue}'");
}
if (!PackageValidation.ValidateName(m_Name.stringValue))
{
canBuildCompleteName = false;
errorMessages.Add($"Invalid Package Name '{m_Name.stringValue}'");
}
if (canBuildCompleteName)
{
var completePackageName = BuildCompletePackageName(packageState.info.packageName.domain, m_OrganizationName.stringValue, m_Name.stringValue);
if (!PackageValidation.ValidateCompleteName(completePackageName))
{
errorMessages.Add($"Invalid Complete Package Name '{completePackageName}'");
}
}
ValidateVersion(null, m_Version.stringValue, errorMessages, warningMessages);
if (m_UnityVersionEnabled.boolValue)
{
if (!PackageValidation.ValidateUnityVersion(m_UnityMajor.stringValue, m_UnityMinor.stringValue,
m_UnityRelease.stringValue))
{
var unityVersion = string.Join(".", new[] { m_UnityMajor.stringValue, m_UnityMinor.stringValue });
if (!string.IsNullOrWhiteSpace(m_UnityRelease.stringValue))
{
unityVersion += "." + m_UnityRelease.stringValue.Trim();
}
errorMessages.Add($"Invalid Unity Version '{unityVersion}'");
}
}
if (string.IsNullOrWhiteSpace(m_DisplayName.stringValue) || m_DisplayName.stringValue.Trim().Length == 0)
{
warningMessages.Add("Display name should be provided.");
}
if (string.IsNullOrWhiteSpace(m_Description.stringValue) || m_Description.stringValue.Trim().Length == 0)
{
warningMessages.Add("Package description should be provided.");
}
if ((PackageVisibility)m_Visibility.intValue == PackageVisibility.AlwaysHidden)
{
warningMessages.Add("This package and all its assets will be hidden by default in Editor because its visibility is set to 'Always Hidden'");
}
if ((PackageVisibility)m_Visibility.intValue == PackageVisibility.AlwaysVisible)
{
warningMessages.Add("This package and all its assets will be visible by default in Editor because its visibility is set to 'Always Visible'");
}
}
private async Task OnUnknownValidation(PackageValidation packageValidation)
{
_logger.LogWarning("Failing validation {Validation} for package {PackageId} {PackageVersion} for which we don't have a configuration",
packageValidation.Type,
packageValidation.PackageValidationSet.PackageId,
packageValidation.PackageValidationSet.PackageNormalizedVersion);
await _validationStorageService.UpdateValidationStatusAsync(packageValidation, ValidationResult.Failed);
}
private void AddValidationIssues(PackageValidation packageValidation, IReadOnlyList <IValidationIssue> validationIssues)
{
foreach (var validationIssue in validationIssues)
{
packageValidation.PackageValidationIssues.Add(new PackageValidationIssue
{
IssueCode = validationIssue.IssueCode,
Data = validationIssue.Serialize(),
});
}
}
private bool ArePrerequisitesMet(PackageValidation packageValidation, PackageValidationSet packageValidationSet)
{
var completeValidations = new HashSet <string>(packageValidationSet
.PackageValidations
.Where(v => v.ValidationStatus == ValidationStatus.Succeeded)
.Select(v => v.Type));
var requiredValidations = _validationConfiguration
.Validations
.Single(v => v.Name == packageValidation.Type).RequiredValidations;
return(completeValidations.IsSupersetOf(requiredValidations));
}
internal static void ValidateVersion(string packageName, string version, List <string> errorMessages, List <string> warningMessages)
{
if (!PackageValidation.ValidateVersion(version, out var majorStr, out var minorStr, out var patchStr))
{
if (string.IsNullOrEmpty(packageName))
{
errorMessages.Add($"Invalid version '{version}'");
}
else
{
errorMessages.Add($"Invalid version '{version}' for dependency '{packageName}'");
}
}
public Task <PackageValidation> ValidatePackageAsync(string packageUrl, string sha1HashToValidate, int submissionId, string workingFolder)
{
lock (Lock_Verify_Package)
{
if (string.IsNullOrWhiteSpace(packageUrl))
{
return(Task.FromResult(PackageValidation.Fail(packageUrl, sha1HashToValidate, workingFolder, "The package URL is empty or contains white space(s).")));
}
var packageFileName = Guid.NewGuid().ToString() + "package.zip";
var tempPackagePath = Path.Combine(workingFolder, $@"SIR\temp\{packageFileName}");
// download this package and save it under ~\SIR\temp\
var packageZipFile = StreamHelper.DownloadFrom(packageUrl, tempPackagePath);
if (packageZipFile == null)
{
logger.Info($"Package: {packageUrl} download fail.");
return(Task.FromResult(PackageValidation.Fail(packageUrl, sha1HashToValidate, workingFolder, "This package can't be downloaded for validating.")));
}
// update FileSize for the package specified by the url
UpdateFileSizeForPackage(packageUrl, (int)packageZipFile.Length, submissionId);
// start SIR validation
var packageValidation = new PackageValidation(tempPackagePath, sha1HashToValidate, workingFolder);
var validator = new SirPackageValidator(packageValidation);
try
{
validator.Validate();
}
catch (Exception ex)
{
packageValidation.ErrorMessage = ex.Message;
packageValidation.Result = AppGallery.SIR.ILog.ValidationResult.Fail;
logger.Error(ex, $"An error happened in validating package. Package Url: {packageUrl}");
}
// try to delete the package zip file
try
{
packageZipFile.Delete();
}
catch (Exception ex)
{
logger.Error(ex, $"An error happened in deleting package. Package Url: {packageUrl}");
} // it's okay if deleting throws exceptions.
return(Task.FromResult(packageValidation));
}
}
//add data to the database
private void btnAddPkg_Click(object sender, EventArgs e)
{
DateTime newStartDate = new DateTime();
DateTime newEndDate = new DateTime();
decimal newBasePrice;
decimal newCommission;
// Check that the input data can be parsed
if (!DateTime.TryParse(textBoxAddStartDate.Text, out newStartDate))
{
MessageBox.Show("Please enter a date for the start date", "Error");
}
if (!DateTime.TryParse(textBoxAddEndDate.Text, out newEndDate))
{
MessageBox.Show("Please enter a date for the end date", "Error");
}
if (!Decimal.TryParse(textBoxAddBasePrice.Text, out newBasePrice))
{
MessageBox.Show("Please enter a decimal value for the base price", "Error");
}
if (!Decimal.TryParse(textBoxAddComission.Text, out newCommission))
{
MessageBox.Show("Please enter a decimal value for the agency commission", "Error");
}
// Create the package object to be added
Package newPkg = new Package(0, textBoxAddPkgName.Text, newStartDate, newEndDate, textBoxAddDesc.Text, newBasePrice, newCommission);
// Validate the values of the input data. If the input is valid, add the new package
// to the Packages table in the database.
try
{
if (PackageValidation.ValidatePackageData(newPkg))
{
PackageDB.AddPackage(newPkg);
}
LoadUIforPackages();
comboBoxPkgName.SelectedIndex = (packages.Count() - 1);
panelDetailPkg.Visible = true;
panelAddPkg.Visible = false;
btnEditPkgClick.Enabled = true;
btnDeletePkgClick.Enabled = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ex.GetType().ToString());
}
}
public FactsBase()
{
_packageKey = 42;
_symbolPackageKey = 420;
_package = new Package {
Key = _packageKey
};
_symbolPackage = new SymbolPackage()
{
Key = _symbolPackageKey
};
_validationKey = new Guid("ae05c5f9-eb2a-415b-ae42-92829bf201a7");
_validation = new PackageValidation
{
Key = _validationKey
};
_validationSetKey = 1001;
_validationSetTrackingId = new Guid("490e8d72-967a-485f-a035-67d5bba0af9f");
_validationSet = new PackageValidationSet
{
Key = _validationSetKey,
ValidationTrackingId = _validationSetTrackingId,
PackageValidations = new[] { _validation },
};
_validation.PackageValidationSet = _validationSet;
_validationSets = new Mock <IEntityRepository <PackageValidationSet> >();
_validations = new Mock <IEntityRepository <PackageValidation> >();
_packages = new Mock <IEntityRepository <Package> >();
_symbolPackages = new Mock <IEntityRepository <SymbolPackage> >();
_packages
.Setup(x => x.GetAll())
.Returns(() => new[] { _package }.AsQueryable());
_symbolPackages
.Setup(x => x.GetAll())
.Returns(() => new[] { _symbolPackage }.AsQueryable());
_validations
.Setup(x => x.GetAll())
.Returns(() => new[] { _validation }.AsQueryable());
_validationSets
.Setup(x => x.GetAll())
.Returns(() => new[] { _validationSet }.AsQueryable());
_target = new ValidationAdminService(
_validationSets.Object,
_validations.Object,
_packages.Object,
_symbolPackages.Object);
}
private void TrackValidationStatus(PackageValidation packageValidation)
{
if (packageValidation.ValidationStatus != ValidationStatus.Failed &&
packageValidation.ValidationStatus != ValidationStatus.Succeeded)
{
return;
}
var isSuccess = packageValidation.ValidationStatus == ValidationStatus.Succeeded;
TimeSpan validatorDuration = TimeSpan.Zero;
if (packageValidation.Started.HasValue)
{
validatorDuration = packageValidation.ValidationStatusTimestamp - packageValidation.Started.Value;
}
var validationSet = packageValidation.PackageValidationSet;
_telemetryService.TrackValidatorDuration(
validationSet.PackageId,
validationSet.PackageNormalizedVersion,
validationSet.ValidationTrackingId,
validatorDuration,
packageValidation.Type,
isSuccess);
var issues = (packageValidation.PackageValidationIssues ?? Enumerable.Empty <PackageValidationIssue>()).ToList();
_telemetryService.TrackValidationIssueCount(
validationSet.PackageId,
validationSet.PackageNormalizedVersion,
validationSet.ValidationTrackingId,
issues.Count,
packageValidation.Type,
isSuccess);
foreach (var issue in issues)
{
_telemetryService.TrackValidationIssue(validationSet.PackageId, validationSet.PackageNormalizedVersion, validationSet.ValidationTrackingId, packageValidation.Type, issue.IssueCode);
var deserializedIssue = ValidationIssue.Deserialize(issue.IssueCode, issue.Data);
if (issue.IssueCode == ValidationIssueCode.ClientSigningVerificationFailure &&
deserializedIssue is ClientSigningVerificationFailure typedIssue)
{
_telemetryService.TrackClientValidationIssue(validationSet.PackageId, validationSet.PackageNormalizedVersion, validationSet.ValidationTrackingId, packageValidation.Type, typedIssue.ClientCode);
}
}
}
private async Task <IValidationRequest> CreateValidationRequest(
PackageValidationSet packageValidationSet,
PackageValidation packageValidation,
Package package,
ValidationConfigurationItem validationConfiguration)
{
var validationRequest = new ValidationRequest(
validationId: packageValidation.Key,
packageKey: packageValidationSet.PackageKey,
packageId: packageValidationSet.PackageId,
packageVersion: packageValidationSet.PackageNormalizedVersion,
nupkgUrl: (await GetNupkgUrl(package, validationConfiguration)).AbsoluteUri
);
return(validationRequest);
}
private async Task ProcessIncompleteValidation(PackageValidation packageValidation, ValidationConfigurationItem validationConfiguration)
{
// need to check validation timeout
var duration = DateTime.UtcNow - packageValidation.Started;
if (duration > validationConfiguration.FailAfter)
{
_logger.LogWarning("Failing validation {Validation} for package {PackageId} {PackageVersion} that runs longer than configured failure timout {FailAfter}",
packageValidation.Type,
packageValidation.PackageValidationSet.PackageId,
packageValidation.PackageValidationSet.PackageNormalizedVersion,
validationConfiguration.FailAfter);
await _validationStorageService.UpdateValidationStatusAsync(packageValidation, ValidationStatus.Failed);
return;
}
}
private async Task <IValidationRequest> CreateValidationRequest(
PackageValidationSet packageValidationSet,
PackageValidation packageValidation)
{
var nupkgUrl = await _packageFileService.GetPackageForValidationSetReadUriAsync(
packageValidationSet,
DateTimeOffset.UtcNow.Add(_validationConfiguration.TimeoutValidationSetAfter));
var validationRequest = new ValidationRequest(
validationId: packageValidation.Key,
packageKey: packageValidationSet.PackageKey,
packageId: packageValidationSet.PackageId,
packageVersion: packageValidationSet.PackageNormalizedVersion,
nupkgUrl: nupkgUrl.AbsoluteUri);
return(validationRequest);
}
public async Task UpdateValidationStatusAsync(PackageValidation packageValidation, ValidationStatus validationStatus)
{
packageValidation = packageValidation ?? throw new ArgumentNullException(nameof(packageValidation));
_logger.LogInformation("Updating the status of the validation {ValidationName} {ValidationId} {PackageId} {PackageVersion} to {ValidationStatus}",
packageValidation.Type,
packageValidation.PackageValidationSet.ValidationTrackingId,
packageValidation.PackageValidationSet.PackageId,
packageValidation.PackageValidationSet.PackageNormalizedVersion,
validationStatus);
if (packageValidation.ValidationStatus == validationStatus)
{
return;
}
packageValidation.ValidationStatus = validationStatus;
packageValidation.ValidationStatusTimestamp = DateTime.UtcNow;
await _validationContext.SaveChangesAsync();
}
protected PackageValidation AddValidationToSet(
string type,
ValidationStatus validationStatus = ValidationStatus.NotStarted,
DateTime?startTime = null)
{
var validation = new PackageValidation
{
Type = type,
PackageValidationSet = ValidationSet,
Key = Guid.NewGuid(),
ValidationStatus = validationStatus,
PackageValidationSetKey = ValidationSet.Key,
ValidationStatusTimestamp = DateTime.UtcNow,
Started = startTime.HasValue ? startTime : (validationStatus == ValidationStatus.NotStarted ? (DateTime?)null : DateTime.UtcNow)
};
ValidationSet.PackageValidations.Add(validation);
return(validation);
}
private PackageValidationSet InitializeValidationSet(ProcessValidationSetData message, IValidatingEntity <T> validatingEntity)
{
// If message would have the package Key the package will not need to be passed as an argument
_logger.LogInformation("Initializing validation set {ValidationSetId} for package {PackageId} {PackageVersion} (package key {PackageKey})",
message.ValidationTrackingId,
message.PackageId,
message.PackageVersion,
validatingEntity.Key);
var now = DateTime.UtcNow;
var validationSet = new PackageValidationSet
{
Created = now,
PackageId = message.PackageId,
PackageNormalizedVersion = message.PackageNormalizedVersion,
PackageKey = validatingEntity.Key,
PackageValidations = new List <PackageValidation>(),
Updated = now,
ValidationTrackingId = message.ValidationTrackingId,
ValidatingType = message.ValidatingType,
ValidationSetStatus = ValidationSetStatus.InProgress,
};
var validationsToStart = _validationConfiguration
.Validations
.Where(v => v.ShouldStart);
foreach (var validation in validationsToStart)
{
var packageValidation = new PackageValidation
{
PackageValidationSet = validationSet,
ValidationStatus = ValidationStatus.NotStarted,
Type = validation.Name,
ValidationStatusTimestamp = now,
};
validationSet.PackageValidations.Add(packageValidation);
}
return(validationSet);
}
public Facts(ITestOutputHelper output)
{
_packageKey = 23;
_validatorType = "ExampleValidator";
_packageValidation = new PackageValidation
{
Key = Guid.Parse("dc10bf5a-0557-459c-b33f-ea6738b8a044"),
Type = _validatorType,
ValidationStatus = ValidationStatus.Incomplete,
Started = new DateTime(2017, 1, 1, 8, 30, 0, DateTimeKind.Utc),
PackageValidationIssues = new List <PackageValidationIssue>(),
PackageValidationSet = new PackageValidationSet(),
};
var package = new Package()
{
Key = _packageKey
};
_packageValidatingEntity = new PackageValidatingEntity(package);
_nupkgUrl = "https://example/nuget.versioning.4.3.0.nupkg";
_entitiesContext = new Mock <IValidationEntitiesContext>();
_entitiesContext
.Setup(x => x.PackageValidationSets)
.Returns(DbSetMockFactory.Create <PackageValidationSet>());
_entitiesContext
.Setup(x => x.PackageValidations)
.Returns(DbSetMockFactory.Create <PackageValidation>());
_packageFileService = new Mock <IValidationFileService>();
_validatorProvider = new Mock <IValidatorProvider>();
_telemetryService = new Mock <ITelemetryService>();
_loggerFactory = new LoggerFactory();
_loggerFactory.AddXunit(output);
InitializeTarget();
}
private void DrawDependencyListElement(Rect rect, int index, bool isActive, bool isFocused)
{
var list = m_DependenciesList.serializedProperty;
var dependency = list.GetArrayElementAtIndex(index);
var packageName = dependency.FindPropertyRelative("packageName");
var version = dependency.FindPropertyRelative("version");
var w = rect.width;
if (!isFeatureSet)
{
rect.x += 4;
rect.width = w / 3 * 2 - 2;
}
rect.height -= EditorGUIUtility.standardVerticalSpacing;
packageName.stringValue = EditorGUI.DelayedTextField(rect, packageName.stringValue);
if (!string.IsNullOrWhiteSpace(packageName.stringValue) && !PackageValidation.ValidateName(packageName.stringValue))
{
errorMessages.Add($"Invalid Dependency Package Name '{packageName.stringValue}'");
}
if (isFeatureSet)
{
return;
}
using (new EditorGUI.DisabledScope(string.IsNullOrWhiteSpace(packageName.stringValue)))
{
rect.x += w / 3 * 2;
rect.width = w / 3 - 4;
version.stringValue = EditorGUI.DelayedTextField(rect, version.stringValue);
if (!string.IsNullOrWhiteSpace(version.stringValue))
{
ValidateVersion(packageName.stringValue, version.stringValue, errorMessages, warningMessages);
}
}
}
private async Task <PackageValidationSet> CreateValidationSet(Guid validationTrackingId, Package package)
{
_logger.LogInformation("Creating validation set {ValidationSetId} for package {PackageId} {PackageVersion}",
validationTrackingId,
package.PackageRegistration.Id,
package.NormalizedVersion);
PackageValidationSet validationSet;
var packageValidations = new List <PackageValidation>();
var now = DateTime.UtcNow;
validationSet = new PackageValidationSet
{
Created = now,
PackageId = package.PackageRegistration.Id,
PackageNormalizedVersion = package.NormalizedVersion,
PackageKey = package.Key,
PackageValidations = packageValidations,
Updated = now,
ValidationTrackingId = validationTrackingId,
};
foreach (var validation in _validationConfiguration.Validations)
{
var packageValidation = new PackageValidation
{
PackageValidationSet = validationSet,
ValidationStatus = ValidationStatus.NotStarted,
Type = validation.Name,
ValidationStatusTimestamp = now,
};
packageValidations.Add(packageValidation);
}
return(await _validationStorageService.CreateValidationSetAsync(validationSet));
}
private PackageValidationSet InitializeValidationSet(Guid validationTrackingId, Package package)
{
_logger.LogInformation("Initializing validation set {ValidationSetId} for package {PackageId} {PackageVersion} (package key {PackageKey})",
validationTrackingId,
package.PackageRegistration.Id,
package.NormalizedVersion,
package.Key);
var now = DateTime.UtcNow;
var validationSet = new PackageValidationSet
{
Created = now,
PackageId = package.PackageRegistration.Id,
PackageNormalizedVersion = package.NormalizedVersion,
PackageKey = package.Key,
PackageValidations = new List <PackageValidation>(),
Updated = now,
ValidationTrackingId = validationTrackingId,
};
foreach (var validation in _validationConfiguration.Validations)
{
var packageValidation = new PackageValidation
{
PackageValidationSet = validationSet,
ValidationStatus = ValidationStatus.NotStarted,
Type = validation.Name,
ValidationStatusTimestamp = now,
};
validationSet.PackageValidations.Add(packageValidation);
}
return(validationSet);
}
public void FetchesValidationIssues()
{
// Arrange
_package.Key = 123;
_package.PackageStatusKey = PackageStatus.FailedValidation;
// This is the latest failed validation set. Its issues should be fetched.
var packageValidationSet1 = new PackageValidationSet
{
PackageKey = 123,
Updated = DateTime.UtcNow.AddDays(-5),
};
// This is an old validation set. Its issues should be ignored.
var packageValidationSet2 = new PackageValidationSet
{
PackageKey = 123,
Updated = DateTime.UtcNow.AddDays(-10),
};
// This is a validation set for anotehr package. Its issues should be ignored.
var packageValidationSet3 = new PackageValidationSet
{
PackageKey = 456,
Updated = DateTime.UtcNow,
};
var packageValidation1 = new PackageValidation {
ValidationStatus = ValidationStatus.Failed
};
var packageValidation2 = new PackageValidation {
ValidationStatus = ValidationStatus.Failed
};
var packageValidation3 = new PackageValidation {
ValidationStatus = ValidationStatus.Failed
};
var validationIssue1 = new PackageValidationIssue
{
IssueCode = ValidationIssueCode.PackageIsSigned,
Data = "{}",
};
var validationIssue2 = new PackageValidationIssue
{
IssueCode = ValidationIssueCode.PackageIsSigned,
Data = "{}",
};
var validationIssue3 = new PackageValidationIssue
{
IssueCode = ValidationIssueCode.PackageIsSigned,
Data = "{}",
};
packageValidationSet1.PackageValidations = new[] { packageValidation1 };
packageValidationSet2.PackageValidations = new[] { packageValidation2 };
packageValidationSet3.PackageValidations = new[] { packageValidation3 };
packageValidation1.PackageValidationIssues = new[] { validationIssue1 };
packageValidation2.PackageValidationIssues = new[] { validationIssue2 };
packageValidation3.PackageValidationIssues = new[] { validationIssue3 };
_validationSets.Setup(x => x.GetAll())
.Returns(new[] { packageValidationSet1, packageValidationSet2, packageValidationSet3 }.AsQueryable());
// Act
var issues = _target.GetLatestValidationIssues(_package);
// Assert
_validationSets.Verify(x => x.GetAll(), Times.Once());
Assert.Single(issues);
Assert.Equal(ValidationIssueCode.PackageIsSigned, issues.First().IssueCode);
}
private void PerformValidation()
{
if (!PackageValidation.ValidateOrganizationName(m_OrganizationName.stringValue) && !IsNullOrEmptyTrim(m_OrganizationName.stringValue))
{
errorMessages.Add($"Invalid Package Organization Name '{m_OrganizationName.stringValue}'");
}
if (!PackageValidation.ValidateName(m_Name.stringValue))
{
errorMessages.Add($"Invalid Package Name '{m_Name.stringValue}'");
}
if (!PackageValidation.ValidateVersion(m_Version.stringValue))
{
errorMessages.Add($"Invalid Version '{m_Version.stringValue}'");
}
if (m_UnityVersionEnabled.boolValue)
{
if (!PackageValidation.ValidateUnityVersion(m_UnityMajor.stringValue, m_UnityMinor.stringValue,
m_UnityRelease.stringValue))
{
var unityVersion = string.Join(".", new[] { m_UnityMajor.stringValue, m_UnityMinor.stringValue });
if (!IsNullOrEmptyTrim(m_UnityRelease.stringValue))
{
unityVersion += "." + m_UnityRelease.stringValue.Trim();
}
errorMessages.Add($"Invalid Unity Version '{unityVersion}'");
}
}
if (IsNullOrEmptyTrim(m_DisplayName.stringValue) || m_DisplayName.stringValue.Trim().Length == 0)
{
warningMessages.Add("Display name should be provided.");
}
if (IsNullOrEmptyTrim(m_Description.stringValue) || m_Description.stringValue.Trim().Length == 0)
{
warningMessages.Add("Package description should be provided.");
}
if ((PackageVisibility)m_Visibility.intValue == PackageVisibility.AlwaysHidden)
{
warningMessages.Add("This package and all its assets will be hidden by default in Editor because its visibility is set to 'Always Hidden'");
}
if ((PackageVisibility)m_Visibility.intValue == PackageVisibility.AlwaysVisible)
{
warningMessages.Add("This package and all its assets will be visible by default in Editor because its visibility is set to 'Always Visible'");
}
else
{
if (IsNullOrEmptyTrim(packageState.info.type))
{
warningMessages.Add("This package and all its assets will be hidden by default in Editor because its type is empty");
}
else if (PackageInfo.GetPredefinedHiddenByDefaultPackageTypes().Contains(packageState.info.type))
{
warningMessages.Add($"This package and all its assets will be hidden by default in Editor because its type is '{packageState.info.type}'");
}
else
{
warningMessages.Add($"This package and all its assets will be visible by default in Editor because its type is '{packageState.info.type}'");
}
}
}
//edit the selected package
private void btnEditPkg_Click(object sender, EventArgs e)
{
// ------ Corinne Mullan ------
// Obtain the original package data for the package currently selected in
// the combo box.
// If the nth index is selected in the combo box, the current package
// is the nth entry in the "packages" list
int curCboIndex = comboBoxPkgName.SelectedIndex;
Package currPkg = packages[curCboIndex];
// Next, obtain and verify the edited data entered by the user
DateTime edStartDate = new DateTime();
DateTime edEndDate = new DateTime();
decimal edBasePrice;
decimal edCommission;
// Check that the input data can be parsed
if (!DateTime.TryParse(textBoxEditStartDate.Text, out edStartDate))
{
MessageBox.Show("Please enter a date for the start date", "Error");
}
if (!DateTime.TryParse(textBoxEditEndDate.Text, out edEndDate))
{
MessageBox.Show("Please enter a date for the end date", "Error");
}
if (!Decimal.TryParse(textBoxEditBasePrice.Text, out edBasePrice))
{
MessageBox.Show("Please enter a decimal value for the base price", "Error");
}
if (!Decimal.TryParse(textBoxEditComission.Text, out edCommission))
{
MessageBox.Show("Please enter a decimal value for the agency commission", "Error");
}
// Create the edited package object. The package ID will be the same as the original
// package.
Package edPkg = new Package(currPkg.PackageId, textBoxEditPkgName.Text, edStartDate, edEndDate, textBoxEditDesc.Text, edBasePrice, edCommission);
// Validate the values of the input data. If the input is valid, add the new package
// to the Packages table in the database.
try
{
if (PackageValidation.ValidatePackageData(edPkg))
{
PackageDB.UpdatePackage(currPkg, edPkg);
}
LoadUIforPackages();
comboBoxPkgName.SelectedIndex = curCboIndex;
panelDetailPkg.Visible = true;
panelEditPkg.Visible = false;
btnAddPkgClick.Enabled = true;
btnDeletePkgClick.Enabled = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ex.GetType().ToString());
}
// ----------------------------
}
