public IPackage GetLastPackage(string packageId, PackageLevel packageLevel)
        {
            Logger.LogInfo(string.Format("Getting packages for {0}", packageId));
            var packages = _packageRepository.FindPackagesById(packageId).ToList();

            Logger.LogInfo(string.Format("Found {0} packages for {1}", packages.Count, packageId));

            packages.RemoveAll(val => !val.IsListed());

            if (packageLevel > PackageLevel.Beta)
            {
                packages.RemoveAll(val => val.Version.SpecialVersion.ToLowerInvariant() == "beta");
            }

            if (packageLevel > PackageLevel.RC)
            {
                packages.RemoveAll(val => val.Version.SpecialVersion.ToLowerInvariant() == "rc");
            }

            if (packages.Count == 0)
            {
                throw new ApplicationException("No update package is found");
            }

            packages.Sort((x, y) => x.Version.CompareTo(y.Version));
            var res = packages.Last();

            Logger.LogInfo(string.Format("Latest package is {0}", res.Version));

            return(res);
        }
Beispiel #2
0
        internal static VersionControl Initialize(XmlElement element, PackageLevel level, PackageType type)
        {
            var vc = new VersionControl();

            if (element == null)
            {
                return(vc);
            }

            if (level == PackageLevel.Tool)
            {
                if (GetVersion(element, "target", false) != null)
                {
                    throw new InvalidPackageException(SR.Errors.Manifest.UnexpectedTarget);
                }
            }
            else
            {
                vc.Target = GetVersion(element, "target", true);
            }

            var expectedMin = GetVersion(element, "expectedMin", false);
            var expectedMax = GetVersion(element, "expectedMax", false);
            var expected    = GetVersion(element, "expected", false);

            if (expected != null && (expectedMin != null || expectedMax != null))
            {
                throw new InvalidPackageException(SR.Errors.Manifest.UnexpectedExpectedVersion);
            }

            if (expected != null)
            {
                expectedMin = expectedMax = expected;
            }

            switch (type)
            {
            case PackageType.Product:
                vc.ExpectedProductMinimum = expectedMin;
                vc.ExpectedProductMaximum = expectedMax;
                break;

            case PackageType.Application:
                vc.ExpectedApplicationMinimum = expectedMin;
                vc.ExpectedApplicationMaximum = expectedMax;
                break;

            default:
                throw new NotImplementedException("Unknown PackageType: " + type);
            }

            return(vc);
        }
Beispiel #3
0
 public abstract bool IsPackageExist(string appId, PackageType packageType, PackageLevel packageLevel, Version version);
Beispiel #4
0
 public override bool IsPackageExist(string appId, PackageType packageType, PackageLevel packageLevel, Version version)
 {
     WriteLog(MethodInfo.GetCurrentMethod(), appId, packageType, packageLevel, version);
     return(base.IsPackageExist(appId, packageType, packageLevel, version));
 }