public Package(string name, PackageInfo info, PackageStatus status)
{
Name = name;
Id = (info != null ? info.PackageId : null);
Info = info;
Status = status;
}
public PackageStatus selectPackageStatus(String codeBar)
{
SqlConnection objConn = conn.openConnection();
//insert code
PackageStatus packageStatus = new PackageStatus();
return packageStatus;
}
public void insertPackageStatus(PackageStatus packageStatus)
{
SqlConnection objConn = conn.openConnection();
System.Data.SqlClient.SqlCommand cmd = new System.Data.SqlClient.SqlCommand();
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = "INSERT PackageStatus (PackageId, Status, CentreSource, CentreDestination) VALUES ("
+ packageStatus.Package.BarCode + ", '"
+ packageStatus.Status + "',"
+ packageStatus.CentreSource.Id + ","
+ packageStatus.CentreDestination.Id + ")";
cmd.Connection = objConn;
cmd.ExecuteNonQuery();
conn.closeConnection(objConn);
}
protected void statusButton_Click(object sender, ImageClickEventArgs e)
{
string sStatus = ((ImageButton)sender).CommandName;
PackageStatus status = (PackageStatus)Enum.Parse(typeof(PackageStatus), sStatus, true);
// chanhe user status
try
{
int result = ES.Services.Packages.ChangePackageStatus(PanelSecurity.PackageId, status);
if (result < 0)
{
ShowResultMessage(result);
return;
}
BindSpace();
}
catch (Exception ex)
{
ShowErrorMessage("PACKAGE_CHANGE_STATUS", ex);
return;
}
}
public PackageViewModel(Package package)
{
_package = package;
_fullVersion = NuGetVersionFormatter.ToFullStringOrFallback(package.Version, fallback: package.Version);
_isSemVer2 = package.SemVerLevelKey == SemVerLevelKey.SemVer2;
Version = String.IsNullOrEmpty(package.NormalizedVersion) ?
NuGetVersionFormatter.Normalize(package.Version) :
package.NormalizedVersion;
NuGetVersion = NuGetVersion.Parse(_fullVersion);
Description = package.Description;
ReleaseNotes = package.ReleaseNotes;
IconUrl = package.IconUrl;
ProjectUrl = package.ProjectUrl;
LicenseUrl = package.LicenseUrl;
HideLicenseReport = package.HideLicenseReport;
LatestVersion = package.IsLatest;
LatestVersionSemVer2 = package.IsLatestSemVer2;
LatestStableVersion = package.IsLatestStable;
LatestStableVersionSemVer2 = package.IsLatestStableSemVer2;
LastUpdated = package.Published;
Listed = package.Listed;
_packageStatus = package.PackageStatusKey;
DownloadCount = package.DownloadCount;
Prerelease = package.IsPrerelease;
LicenseReportUrl = package.LicenseReportUrl;
var licenseNames = package.LicenseNames;
if (!string.IsNullOrEmpty(licenseNames))
{
LicenseNames = licenseNames.Split(',').Select(l => l.Trim());
}
}
public static List <Package> GetPackages(this PackageManager manager, bool withRouting = false)
{
string language = "en";
List <Package> packages = new List <Package>();
foreach (PackageInfo info in manager.ServerPackages)
{
string name = info.GetNames(language)[0];
string[] split = name.Split('/');
int dashCount = info.PackageId.Split('-').Length - 1;
// If package id contains -, then it's a subdivision (province, county, oblast etc.) of a country,
// add the country as well as the subdivision.
// Routing packages also contain a dash (-routing).
// Check if it contains two dashes. Then it's a subdivision
if (dashCount == 2 && split.Length > 2)
{
name = split[split.Length - 2] + ", " + split[split.Length - 1];
}
else
{
name = split[split.Length - 1];
}
PackageStatus status = manager.GetLocalPackageStatus(info.PackageId, -1);
var package = new Package(name, info, status);
packages.Add(package);
}
// Order alphabetically
packages = packages.OrderBy(package => package.Name).ToList();
return(packages);
}
public virtual async Task UpdateStatusAsync(SymbolPackage symbolPackage, PackageStatus newPackageStatus, bool commitChanges = true)
{
if (symbolPackage == null)
{
throw new ArgumentNullException(nameof(symbolPackage));
}
// Avoid all of this work if the package status is not changing.
if (symbolPackage.StatusKey != newPackageStatus)
{
symbolPackage.StatusKey = newPackageStatus;
/// If the package is being made available.
if (newPackageStatus == PackageStatus.Available)
{
symbolPackage.Published = DateTime.UtcNow;
}
if (commitChanges)
{
await _symbolPackageRepository.CommitChangesAsync();
}
}
}
void UpdatePackage(string id)
{
if (packageAdapter == null)
{
return;
}
RunOnUiThread(delegate {
// Try to find the package that needs to be updated
for (int i = 0; i < packageArray.Count; i++)
{
Package pkg = packageArray[i];
if (id.Equals(pkg.Id))
{
PackageStatus status = packageManager.GetLocalPackageStatus(id, -1);
pkg.UpdateStatus(status);
packageArray[i] = pkg;
packageAdapter.Update(pkg);
}
}
});
}
public async Task CleansUpReadmeIfDbUpdateFails(PackageStatus packageStatus, bool expectedFileDelete)
{
_package.PackageStatusKey = packageStatus;
_package.EmbeddedLicenseType = EmbeddedLicenseFileType.PlainText;
_package.NormalizedVersion = "3.2.1";
_package.HasReadMe = true;
_package.EmbeddedReadmeType = EmbeddedReadmeFileType.Markdown;
_packageFile = GeneratePackageWithUserContent(licenseFilename: "license.txt", licenseFileContents: "some license", readmeFilename: "read.md", readmeFileContents: "readme test").Object.GetStream();
_entitiesContext
.Setup(ec => ec.SaveChangesAsync())
.ThrowsAsync(new Exception());
await Assert.ThrowsAsync <Exception>(() => _target.CommitPackageAsync(_package, _packageFile));
_licenseFileService.Verify(
lfs => lfs.DeleteLicenseFileAsync(_package.Id, _package.NormalizedVersion.ToString()),
expectedFileDelete ? Times.Once() : Times.Never());
_packageFileService.Verify(
lfs => lfs.DeleteReadMeMdFileAsync(_package),
expectedFileDelete ? Times.Once() : Times.Never());
}
public int ChangePackageStatus(int packageId, PackageStatus status) {
object[] results = this.Invoke("ChangePackageStatus", new object[] {
packageId,
status});
return ((int)(results[0]));
}
public async Task ThrowsExceptionWhenValidationSetPackageAndDestinationPackageBothExist(PackageStatus packageStatus)
{
ValidationSet.PackageETag = null;
Package.PackageStatusKey = packageStatus;
var expected = new InvalidOperationException("Duplicate!");
PackageFileServiceMock
.Setup(x => x.DoesValidationSetPackageExistAsync(It.IsAny <PackageValidationSet>()))
.ReturnsAsync(true);
PackageFileServiceMock
.Setup(x => x.CopyValidationSetPackageToPackageFileAsync(It.IsAny <PackageValidationSet>(), It.IsAny <IAccessCondition>()))
.Throws(expected);
var actual = await Assert.ThrowsAsync <InvalidOperationException>(
() => Target.SetPackageStatusAsync(Package, ValidationSet, PackageStatus.Available));
Assert.Same(expected, actual);
PackageFileServiceMock.Verify(
x => x.CopyValidationSetPackageToPackageFileAsync(ValidationSet, It.Is <IAccessCondition>(y => y.IfNoneMatchETag == "*")),
Times.Once);
PackageServiceMock.Verify(
x => x.UpdatePackageStatusAsync(It.IsAny <Package>(), It.IsAny <PackageStatus>(), It.IsAny <bool>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.DeleteValidationPackageFileAsync(It.IsAny <string>(), It.IsAny <string>()),
Times.Never);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()),
Times.Never);
}
public IQueryable <Package> GetAllByStatus(PackageStatus status)
{
var packages = this.db.Packages.Where(x => x.Status == status); // x.Recipient.Username == username
return(packages);
}
/// <summary>
/// Gets the repository's details and updates the status field in the dependencies
/// </summary>
/// <param name="repository"> A Repository object</param>
/// <returns>An updated repository object with the status field.</returns>
internal async Task <Repository> UpdateRepositoryStatus(Repository repository)
{
var vulnerabilityCount = repository?.VulnerabilityAlerts?.TotalCount;
var dependencyGraphManifests = repository?.DependencyGraphManifests?.Nodes;
if (dependencyGraphManifests == null)
{
return(repository);
}
// Go through the various dependency manifests in the repo
foreach (var dependencyManifest in dependencyGraphManifests)
{
var dependencies = dependencyManifest?.Dependencies?.Nodes;
if (dependencies == null)
{
continue;
}
PackageStatus highestStatus = PackageStatus.Unknown;
// Go through each dependency in the dependency manifest
foreach (var dependency in dependencies)
{
var currentVersion = dependency.requirements;
if (string.IsNullOrEmpty(currentVersion))
{
continue;
}
//getting latest versions from the respective packagemanagers,azure sdks and the default values from github
string latestVersion;
string azureSdkVersion = String.Empty;
switch (dependency.packageManager)
{
case "NUGET":
latestVersion = await GetLatestNugetVersion(dependency.packageName, currentVersion);
azureSdkVersion = await _azureSdkService.GetAzureSdkVersions(dependency.packageName);
break;
case "NPM":
latestVersion = await _npmService.GetLatestVersion(dependency.packageName);
break;
default:
latestVersion = dependency.repository?.releases?.nodes?.FirstOrDefault()?.tagName;
break;
}
dependency.latestVersion = latestVersion;
dependency.azureSdkVersion = azureSdkVersion;
//calculate status normally for repos without security alerts
if (vulnerabilityCount == 0)
{
dependency.status = CalculateStatus(currentVersion.Substring(2), latestVersion);
}
//check if a repo has security alerts
else if (vulnerabilityCount > 0)
{
var librariesWithAlerts = repository?.VulnerabilityAlerts.Edges.Select(p => p.Node?.SecurityVulnerability.Package.Name);
//if the name of the dependency is in the list of libraries with alerts, set status to urgent update
if (librariesWithAlerts.Contains(dependency.packageName))
{
dependency.status = PackageStatus.UrgentUpdate;
}
else
{
dependency.status = CalculateStatus(currentVersion.Substring(2), latestVersion);
}
}
}
//getting the highest status from a dependency node
highestStatus = HighestStatus(dependencies);
//comparing the highest statuses from different nodes
if (highestStatus > repository.highestStatus)
{
repository.highestStatus = highestStatus;
}
}
return(repository);
}
/// <remarks/>
public void ChangePackageStatusAsync(int packageId, PackageStatus status, object userState) {
if ((this.ChangePackageStatusOperationCompleted == null)) {
this.ChangePackageStatusOperationCompleted = new System.Threading.SendOrPostCallback(this.OnChangePackageStatusOperationCompleted);
}
this.InvokeAsync("ChangePackageStatus", new object[] {
packageId,
status}, this.ChangePackageStatusOperationCompleted, userState);
}
public PackageStatus GetPackageStatus(string status)
{
PackageStatus statusDb = this.pandaDbContext.PackageStatus.SingleOrDefault(statusEntity => statusEntity.Name == status);
return(statusDb);
}
public void UpdateStatus(PackageStatus status)
{
Status = status;
}
public async Task SendsValidatingTooLongMessageOnlyIfPackageIsInValidatingState(PackageStatus packageStatus, bool shouldSend)
{
const int postponeMinutes = 1;
AddValidation("validation1", ValidationStatus.Incomplete);
Configuration.TimeoutValidationSetAfter = TimeSpan.FromDays(1);
Configuration.ValidationSetNotificationTimeout = TimeSpan.FromMinutes(20);
Configuration.ValidationMessageRecheckPeriod = TimeSpan.FromMinutes(postponeMinutes);
ValidationSet.Created = DateTime.UtcNow - TimeSpan.FromMinutes(21);
ValidationSet.Updated = DateTime.UtcNow - TimeSpan.FromMinutes(15);
PackageValidatingEntity.EntityRecord.PackageStatusKey = packageStatus;
ValidationStorageServiceMock
.Setup(s => s.UpdateValidationSetAsync(It.IsAny <PackageValidationSet>()))
.Callback <PackageValidationSet>(s => s.Updated = DateTime.UtcNow)
.Returns(Task.FromResult(0));
ValidationStorageServiceMock
.Setup(s => s.GetValidationSetCountAsync(PackageValidatingEntity))
.Returns(Task.FromResult(1));
// Process the outcome once - the "too long to validate" message should be sent.
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
if (shouldSend)
{
TelemetryServiceMock
.Verify(t => t.TrackSentValidationTakingTooLongMessage(Package.PackageRegistration.Id, Package.NormalizedVersion, ValidationSet.ValidationTrackingId), Times.Once);
MessageServiceMock
.Verify(m => m.SendValidationTakingTooLongMessageAsync(Package), Times.Once);
ValidationEnqueuerMock
.Verify(ve => ve.StartValidationAsync(It.IsAny <PackageValidationMessageData>(), It.IsAny <DateTimeOffset>()), Times.Once);
PackageFileServiceMock
.Verify(x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Never);
}
else
{
TelemetryServiceMock
.Verify(t => t.TrackSentValidationTakingTooLongMessage(Package.PackageRegistration.Id, Package.NormalizedVersion, ValidationSet.ValidationTrackingId), Times.Never);
MessageServiceMock
.Verify(m => m.SendValidationTakingTooLongMessageAsync(Package), Times.Never);
ValidationEnqueuerMock
.Verify(ve => ve.StartValidationAsync(It.IsAny <PackageValidationMessageData>(), It.IsAny <DateTimeOffset>()), Times.Once);
PackageFileServiceMock
.Verify(x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Never);
}
TelemetryServiceMock.ResetCalls();
MessageServiceMock.ResetCalls();
ValidationEnqueuerMock.ResetCalls();
// Process the outcome again - the "too long to validate" message should NOT be sent.
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
TelemetryServiceMock
.Verify(t => t.TrackSentValidationTakingTooLongMessage(Package.PackageRegistration.Id, Package.NormalizedVersion, ValidationSet.ValidationTrackingId), Times.Never);
MessageServiceMock
.Verify(m => m.SendValidationTakingTooLongMessageAsync(Package), Times.Never);
ValidationEnqueuerMock
.Verify(ve => ve.StartValidationAsync(It.IsAny <PackageValidationMessageData>(), It.IsAny <DateTimeOffset>()), Times.Once);
PackageFileServiceMock
.Verify(x => x.DeletePackageForValidationSetAsync(It.IsAny <PackageValidationSet>()), Times.Never);
}
public void TrackPackageStatusChange(string packageId, string normalizedVersion, Guid validationTrackingId, PackageStatus fromStatus, PackageStatus toStatus)
{
_telemetryClient.TrackMetric(
PackageStatusChange,
1,
new Dictionary <string, string>
{
{ PackageId, packageId },
{ NormalizedVersion, normalizedVersion },
{ ValidationTrackingId, validationTrackingId.ToString() },
{ FromStatus, fromStatus.ToString() },
{ ToStatus, toStatus.ToString() },
});
}
/// <summary>
/// Initializes a new instance of the <see cref="InvalidPackageStateException"/> class.
/// </summary>
/// <param name="stateFrom">
/// The state from.
/// </param>
/// <param name="stateTo">
/// The state to.
/// </param>
public InvalidPackageStateException(PackageStatus stateFrom, PackageStatus stateTo)
: base(
string.Format(
PackageStatusResources.InvalidPackageStateException, stateFrom, stateTo))
{
}
/// <remarks/>
public System.IAsyncResult BeginChangePackageStatus(int packageId, PackageStatus status, System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("ChangePackageStatus", new object[] {
packageId,
status}, callback, asyncState);
}
private void RememberCurrentStatus(int packageId)
{
PackageInfo package = PackageController.GetPackage(packageId);
previousStatus = (PackageStatus)package.StatusId;
}
private void RememberCurrentStatus(PackageStatus current)
{
previousStatus = current;
}
public void AddStrategy(PackageStatus status, IPrintStrategy printStrategy)
{
_strategies.Add(status, printStrategy);
}
public List <Package> GetPackages(string folder)
{
List <Package> packages = new List <Package>();
if (folder.Equals(Package.CUSTOM_REGION_FOLDER_NAME + "/"))
{
return(GetCustomRegionPackages());
}
if (folder.Equals(""))
{
packages.Add(GetCustomRegionFolder());
}
foreach (PackageInfo info in Manager.ServerPackages)
{
string name = info.Name;
if (!name.StartsWith(folder, StringComparison.Ordinal))
{
// Belongs to a different folder,
// should not be added if name is e.g. Asia/, while folder is /Europe
continue;
}
string modified = name.Substring(folder.Length);
int index = modified.IndexOf('/');
Package package;
if (index == -1)
{
// This is an actual package
PackageStatus status = Manager.GetLocalPackageStatus(info.PackageId, -1);
string id = info.PackageId;
package = new Package(id, modified, info, status);
}
else
{
// This is a package group
modified = modified.Substring(0, index);
// Try n' find an existing package from the list.
List <Package> existing = packages.Where(i => i.Name == modified).ToList();
if (existing.Count == 0)
{
// If there are none, add a package group if we don't have an existing list item
package = new Package(modified);
}
else if (existing.Count == 1 && existing[0].Info != null)
{
// Sometimes we need to add two labels with the same name.
// One a downloadable package and the other pointing to a list of said country's counties,
// such as with Spain, Germany, France, Great Britain
// If there is one existing package and its info isn't null,
// we will add a "parent" package containing subpackages (or package group)
package = new Package(modified);
}
else
{
// Shouldn't be added, as both cases are accounted for
continue;
}
}
packages.Add(package);
}
return(packages);
}
public static string MapStatus(PackageStatus status)
{
return(PackageStatuses[status]);
}
public IList <Package> GetPackagesByStatusAndUserId(PackageStatus status, string userId)
{
return(this.context.Packages
.Where(p => p.RecipientId == userId && p.Status == status)
.ToList());
}
public override void OnPackageStatusChanged(String id, int version, PackageStatus status)
{
}
public int ChangePackageStatus(int packageId, PackageStatus status)
{
return(PackageController.ChangePackageStatus(packageId, status, true));
}
/// <remarks/>
public void ChangePackageStatusAsync(int packageId, PackageStatus status) {
this.ChangePackageStatusAsync(packageId, status, null);
}
public void UpdateStatus(PackageStatus status)
{
Status = status;
}
private async Task UpdateSymbolPackageInternalAsync(SymbolPackage symbolPackage, PackageStatus symbolPackageStatus)
{
await _symbolPackageService.UpdateStatusAsync(symbolPackage,
symbolPackageStatus,
commitChanges : false);
}
public async Task ProcessesFailedValidationAccordingToFailureBehavior(ValidationFailureBehavior failureBehavior, PackageStatus expectedPackageStatus)
{
AddValidation("validation1", ValidationStatus.Failed, failureBehavior);
var processor = CreateProcessor();
await processor.ProcessValidationOutcomeAsync(ValidationSet, PackageValidatingEntity, ProcessorStats);
PackageStateProcessorMock.Verify(
x => x.SetStatusAsync(PackageValidatingEntity, ValidationSet, expectedPackageStatus),
Times.Once);
PackageFileServiceMock.Verify(
x => x.DeletePackageForValidationSetAsync(ValidationSet),
Times.Once);
}
public async Task UpdateStatusAsync(Package entity, PackageStatus newStatus, bool commitChanges = true)
{
await _galleryEntityService.UpdatePackageStatusAsync(entity, newStatus, commitChanges);
}
public IQueryable <Package> GetAllPackagesByStatus(PackageStatus packageStatus)
{
var packages = this.db.Packages.Where(p => p.Status == packageStatus);
return(packages);
}
static IEnumerator GetDefaultSimplifier()
{
var list = Client.List(true);
while (!list.IsCompleted)
{
yield return(null);
}
PackageStatus status = PackageStatus.Unknown;
if (list.Status == StatusCode.Success)
{
foreach (var package in list.Result)
{
if (package.name == "com.whinarn.unitymeshsimplifier")
{
status = package.status;
break;
}
}
}
if (status != PackageStatus.Available &&
EditorUtility.DisplayDialog("Install Default Mesh Simplifier?",
"You are missing a default mesh simplifier. Would you like to install one?",
"Yes", "No"))
{
var request = Client.Add("https://github.com/Unity-Technologies/UnityMeshSimplifier.git");
while (!request.IsCompleted)
{
yield return(null);
}
switch (request.Status)
{
case StatusCode.Success:
status = PackageStatus.Available;
break;
case StatusCode.InProgress:
status = PackageStatus.InProgress;
break;
case StatusCode.Failure:
Debug.LogError($"AutoLOD: {request.Error.message}");
break;
}
}
if (status == PackageStatus.Available)
{
// Cribbed from ConditionalCompilationUtility
// TODO: Remove when minimum version is 2019 LTS and use define constraints instead
var buildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
if (buildTargetGroup == BuildTargetGroup.Unknown)
{
var propertyInfo = typeof(EditorUserBuildSettings).GetProperty("activeBuildTargetGroup",
BindingFlags.Static | BindingFlags.NonPublic);
if (propertyInfo != null)
{
buildTargetGroup = (BuildTargetGroup)propertyInfo.GetValue(null, null);
}
}
var previousProjectDefines = PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTargetGroup);
var projectDefines = previousProjectDefines.Split(';').ToList();
if (!projectDefines.Contains(k_DefaultMeshSimplifierDefine, StringComparer.OrdinalIgnoreCase))
{
EditorApplication.LockReloadAssemblies();
projectDefines.Add(k_DefaultMeshSimplifierDefine);
// This will trigger another re-compile, which needs to happen, so all the custom attributes will be visible
PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, string.Join(";", projectDefines.ToArray()));
// Let other systems execute before reloading assemblies
yield return(null);
EditorApplication.UnlockReloadAssemblies();
}
}
else if (status != PackageStatus.InProgress)
{
Debug.LogError("AutoLOD: You must set a valid Default Mesh Simplifier under Edit -> Preferences");
}
}
public int ChangePackageStatus(int packageId, PackageStatus status)
{
return PackageController.ChangePackageStatus(packageId, status, true);
}
protected void InsertMedicationPackage(string barcode, int type, DateTime expiredate, PackageStatus status, int?stockdc, int?sourcedc, int?destinationdc, string username, DateTime updatetime)
{
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = connectionString;
conn.Open();
string query = @"insert into MedicationPackage (Barcode, Type, ExpireDate, Status, StockDC, SourceDC, DestinationDC, Operator, UpdateTime)
values (@barcode, @type, @expiredate, @status, @stockdc, @sourcedc, @destinationdc, @operator, @updatetime)" ;
SqlCommand command = new SqlCommand(query, conn);
command.Parameters.Add(new SqlParameter("barcode", barcode));
command.Parameters.Add(new SqlParameter("type", type));
command.Parameters.Add(new SqlParameter("expiredate", expiredate));
command.Parameters.Add(new SqlParameter("status", status));
command.Parameters.Add(new SqlParameter("stockdc", (object)stockdc ?? DBNull.Value));
command.Parameters.Add(new SqlParameter("sourcedc", (object)sourcedc ?? DBNull.Value));
command.Parameters.Add(new SqlParameter("destinationdc", (object)destinationdc ?? DBNull.Value));
command.Parameters.Add(new SqlParameter("operator", username));
command.Parameters.Add(new SqlParameter("updatetime", updatetime));
command.ExecuteNonQuery();
}
}
public static int ChangeUserStatus(string taskId, int userId, UserStatus status)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
int result = 0;
// get user details
UserInfo user = GetUserInternally(userId);
// place log record
TaskManager.StartTask(taskId, "USER", "CHANGE_STATUS", user.Username, user.UserId);
// update user packages
List <PackageInfo> packages = new List <PackageInfo>();
// Add the users package(s)
packages.AddRange(PackageController.GetPackages(userId));
try
{
// change this account
result = ChangeUserStatusInternal(userId, status);
if (result < 0)
{
return(result);
}
// change peer accounts
List <UserInfo> peers = GetUserPeers(userId);
foreach (UserInfo peer in peers)
{
result = ChangeUserStatusInternal(peer.UserId, status);
if (result < 0)
{
return(result);
}
}
// change child accounts
List <UserInfo> children = GetUsers(userId, true);
foreach (UserInfo child in children)
{
// Add the child users packages
packages.AddRange(PackageController.GetPackages(child.UserId));
// change child user peers
List <UserInfo> childPeers = GetUserPeers(child.UserId);
foreach (UserInfo peer in childPeers)
{
result = ChangeUserStatusInternal(peer.UserId, status);
if (result < 0)
{
return(result);
}
}
// change child account
result = ChangeUserStatusInternal(child.UserId, status);
if (result < 0)
{
return(result);
}
}
PackageStatus packageStatus = PackageStatus.Active;
switch (status)
{
case UserStatus.Active: packageStatus = PackageStatus.Active; break;
case UserStatus.Cancelled: packageStatus = PackageStatus.Cancelled; break;
case UserStatus.Pending: packageStatus = PackageStatus.New; break;
case UserStatus.Suspended: packageStatus = PackageStatus.Suspended; break;
}
// change packages state
result = PackageController.ChangePackagesStatus(packages, packageStatus, true);
if (result < 0)
{
return(result);
}
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int ChangePackageStatus(int packageId, PackageStatus status, bool async)
{
return ChangePackageStatus(null, packageId, status, async);
}
public IQueryable <Package> GetAllPackageByStatus(PackageStatus status)
{
var packages = this.db.Packages.Where(s => s.Status == status);
return(packages);
}
public static int ChangePackageStatus(string taskId, int packageId, PackageStatus status, bool async)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
| DemandAccount.IsReseller);
if (accountCheck < 0) return accountCheck;
List<PackageInfo> packages = new List<PackageInfo>();
// load package
PackageInfo package = GetPackage(packageId);
if (package == null)
return -1;
// add "root" package
packages.Add(package);
// add "child" packages
packages.AddRange(GetPackagePackages(packageId, true));
// change packages status
ChangePackagesStatus(packages, status, async);
return 0;
}
internal void ChangePackageStatus(PackageStatus packageStatus)
{
this.PackageStatus = packageStatus;
}
public static int ChangePackagesStatus(List<PackageInfo> packages, PackageStatus status, bool async)
{
int statusId = (int)status;
List<PackageInfo> changedPackages = new List<PackageInfo>();
foreach (PackageInfo p in packages)
{
// get package details
PackageInfo package = GetPackage(p.PackageId);
if (package != null && package.StatusId != statusId)
{
bool currEnabled = (package.StatusId == (int)PackageStatus.Active);
bool enabled = (statusId == (int)PackageStatus.Active);
// change package status
package.StatusId = statusId;
// save package
UpdatePackage(package);
// add to the list of affected packages
if (currEnabled != enabled)
changedPackages.Add(package);
}
}
// change service items state asynchronously
PackageAsyncWorker packageWorker = new PackageAsyncWorker();
packageWorker.UserId = SecurityContext.User.UserId;
packageWorker.Packages = changedPackages;
packageWorker.ItemsStatus = status;
// invoke worker
if (async)
packageWorker.ChangePackagesServiceItemsStateAsync();
else
packageWorker.ChangePackagesServiceItemsState();
return 0;
}
internal PackageInfo(string packageId, string displayName = "", string category = "", string description = "", string resolvedPath = "", string tag = "", PackageStatus status = PackageStatus.Unavailable, IEnumerable <Error> errors = null, VersionsInfo versions = null)
{
this.m_OriginType = OriginType.Unknown;
this.m_PackageId = packageId;
this.m_DisplayName = displayName;
this.m_Category = category;
this.m_Description = description;
this.m_ResolvedPath = resolvedPath;
this.m_Status = status;
this.m_Errors = (errors ?? new Error[0]).ToArray <Error>();
this.m_Versions = (versions ?? new VersionsInfo(null, null, null));
string[] array = packageId.Split(new char[]
{
'@'
});
this.m_Name = array[0];
this.m_Version = array[1];
}
public IQueryable <Package> GetAllForUserByStatus(string userId, PackageStatus status)
{
return(this.dbContext.Packages.Where(x => x.RecipientId == userId && x.Status == status));
}
