Use AppsAndFeaturesEntries DisplayVersion info for installed package version mapping by yao-msft · Pull Request #2213 · microsoft/winget-cli

yao-msft · 2022-06-02T19:47:49Z

For #980

Changes

Described in spec

Validation

Added unit and e2e tests. Did a local manual validation.

Microsoft Reviewers: Open in CodeFlow

github-actions · 2022-06-02T19:49:06Z

@check-spelling-bot Report

Unrecognized words, please review:

messasge

Previously acknowledged words that are now absent

activatable amd Archs dsc enr FWW Globals hackathon lww mytool OSVERSION Packagedx parametermap symlink Uninitialize WDAG whatif wsb

To accept these unrecognized words as correct (and remove the previously acknowledged and now absent words), run the following commands

... in a clone of the git@github.com:yao-msft/winget-cli.git repository
on the arpversion branch:

update_files() {
perl -e '
my @expect_files=qw('".github/actions/spelling/expect.txt"');
@ARGV=@expect_files;
my @stale=qw('"$patch_remove"');
my $re=join "|", @stale;
my $suffix=".".time();
my $previous="";
sub maybe_unlink { unlink($_[0]) if $_[0]; }
while (<>) {
if ($ARGV ne $old_argv) { maybe_unlink($previous); $previous="$ARGV$suffix"; rename($ARGV, $previous); open(ARGV_OUT, ">$ARGV"); select(ARGV_OUT); $old_argv = $ARGV; }
next if /^(?:$re)(?:(?:\r|\n)*$| .*)/; print;
}; maybe_unlink($previous);'
perl -e '
my $new_expect_file=".github/actions/spelling/expect.txt";
use File::Path qw(make_path);
use File::Basename qw(dirname);
make_path (dirname($new_expect_file));
open FILE, q{<}, $new_expect_file; chomp(my @words = <FILE>); close FILE;
my @add=qw('"$patch_add"');
my %items; @items{@words} = @words x (1); @items{@add} = @add x (1);
@words = sort {lc($a)."-".$a cmp lc($b)."-".$b} keys %items;
open FILE, q{>}, $new_expect_file; for my $word (@words) { print FILE "$word\n" if $word =~ /\w/; };
close FILE;
system("git", "add", $new_expect_file);
'
}

comment_json=$(mktemp)
curl -L -s -S \
  --header "Content-Type: application/json" \
  "https://api.github.com/repos/microsoft/winget-cli/issues/comments/1145278660" > "$comment_json"
comment_body=$(mktemp)
jq -r .body < "$comment_json" > $comment_body
rm $comment_json

patch_remove=$(perl -ne 'next unless s{^</summary>(.*)</details>$}{$1}; print' < "$comment_body")
  

patch_add=$(perl -e '$/=undef;
$_=<>;
s{<details>.*}{}s;
s{^#.*}{};
s{\n##.*}{};
s{(?:^|\n)\s*\*}{}g;
s{\s+}{ }g;
print' < "$comment_body")
  
update_files
rm $comment_body
git add -u

This reverts commit 16e925e.

JohnMcPMS · 2022-06-06T18:58:27Z

        bool IsUpdateVersionApplicable(const Utility::Version& installedVersion, const Utility::Version& updateVersion)
        {
-            return (installedVersion < updateVersion || updateVersion.IsLatest());
+            return (installedVersion < updateVersion || (installedVersion.IsLatest() && updateVersion.IsLatest()));


Why does the installed version need to be Latest in order for the update version of Latest to be applicable? #Resolved

JohnMcPMS · 2022-06-06T19:09:25Z

+
+        for (auto const& installer : Installers)
+        {
+            if (DoesInstallerTypeWriteAppsAndFeaturesEntry(installer.InstallerType) && installer.InstallerType != InstallerTypeEnum::Portable)


I would like another semantic function name here to encode the removal of portable, possibly something like DoesInstallerTypeSupportVersionRange.

Alternately, we should probably just move to a full on installer traits type to capture this information and require that all new installer types must have had this thought through. #Resolved

JohnMcPMS · 2022-06-06T21:43:26Z

+        bool IsApproximateVersion() const { return m_approximateComparator != ApproximateComparator::None; }
+
+        // Static methods to create an approximate version from a base version.
+        static Version CreateLessThanApproximateVersion(const Version& base);


Why not add an ApproximateComparator parameter to the Version constructor? I think specifically Version(const Version&, ApproximateComparator) is what you would need. #Resolved

JohnMcPMS · 2022-06-06T21:49:00Z

+        if (CaseInsensitiveStartsWith(m_version, s_Approximate_Less_Than))
+        {
+            m_approximateComparator = ApproximateComparator::LessThan;
+            baseVersion = m_version.substr(2, m_version.length() - 2);


Suggested change

baseVersion = m_version.substr(2, m_version.length() - 2);

baseVersion = m_version.substr(s_Approximate_Less_Than.length(), m_version.length() - s_Approximate_Less_Than.length());

``` #Resolved

JohnMcPMS · 2022-06-06T22:03:43Z


    bool Version::operator<(const Version& other) const
    {
+        // If base versions are same, result is based on approximate comparator


This seems like a very costly way of doing the comparison (copies and doing full equality comparison first). Why not just move the approximate comparison resolution to the end when we have decided that the base is equal? Yes, it means refactoring the flow a bit to not return on equality, but it seems feasible.

For performance it would probably even be good to move the latest/unknown to be determined at Assign, which would remove the need to create temporaries here. Then the refactored flow would be able to be cleaner. #Resolved

JohnMcPMS · 2022-06-06T22:59:47Z

            std::shared_ptr<IPackage> m_availablePackage;
            Source m_trackingSource;
            std::shared_ptr<IPackage> m_trackingPackage;
+            mutable std::atomic_bool m_isOverrideInstalledVersionInitialized = false;


Why not just initialize it in the constructor; I don't see a lot of cases where the value is going to be ignored. #Resolved

JohnMcPMS · 2022-06-06T23:14:11Z

+            std::initializer_list<SQLite::Builder::QualifiedColumn> columns,
+            std::initializer_list<std::string_view> manifestColumnNames)
        {
+            THROW_HR_IF(E_UNEXPECTED, manifestColumnNames.size() != 0 && manifestColumnNames.size() != columns.size());


Suggested change

THROW_HR_IF(E_UNEXPECTED, manifestColumnNames.size() != 0 && manifestColumnNames.size() != columns.size());

THROW_HR_IF(E_UNEXPECTED, manifestColumnNames.size() != columns.size());

I don't think this code works if manifestColumnNames is not provided along with columns. #Resolved

JohnMcPMS · 2022-06-06T23:24:17Z


+    DEFINE_ENUM_FLAG_OPERATORS(WinGetValidateManifestResult);
+
+    WINGET_UTIL_API WinGetValidateManifestV3(


Add result of discussion WinGetUtil.h...

Should we make this a little more complicated from the number of APIs, but less complicated for each?

Imagine:

WinGetCreateManifest(path, message, merge path, option, manifest handle); WinGetValidateManifestV3(manifest handle, index, result, message, operation, option); WinGetCloseManifest(manifest handle);

The create is basically V2 validate, but we return a pointer to reuse for future validations. It performs the direct manifest validations only. The returned pointer saves continually parsing the manifest and enables efficient splitting of the various validations we perform. Then the V3 validate can be "perform this one validation". #Resolved

JohnMcPMS · 2022-06-06T23:26:17Z

+        // Check arp version ranges do not overlap
+        if (result && sqliteIndex->GetVersion() >= Schema::Version{ 1, 5 })
+        {
+            result = ValidateArpVersionConsistency(sqliteIndex);


Why is this not part of CheckConsistency? #Resolved

JohnMcPMS · 2022-06-06T23:28:15Z

+        // Only validate against json schema
+        SchemaValidation = 0x1,
+        // Validate against schema and also perform semantic validation
+        SchemaAndSemanticValidation = 0x2,


Shouldn't this just be SemanticValidation and you pass both flags to get both? #Pending

Trenly · 2022-06-07T00:14:50Z

        const char* const ExceededCommandsLimit = "Only zero or one value for Commands may be specified for InstallerType portable.";
        const char* const ScopeNotSupported = "Scope is not supported for InstallerType portable.";
+        const char* const ApproximateVersionNotAllowed = "Approximate version not allowed.";
+        const char* const ArpVersionOverlapWithIndex = "DisplayVersion declared in the manifest has overlap with existing DisplayVersion range in the index. Existing DisplayVersion range in index: ";


This got me thinking - Are version ranges architecture specific, and/or should they be? I could see a scenario where a publisher uses the following -

PackageVersion: 1.0-Alpha # This is their marketing version Installers: - Architecture: x86 AppsAndFeaturesEntries: - DisplayVersion: 1.0.4.0 - Architecture: x64 AppsAndFeaturesEntries: - DisplayVersion: 1.0.5.0

According to the spec, this would result in an Version Range of [1.0.4.0, 1.0.5.0]

Suppose they release a new update -

PackageVersion: 1.1-Alpha # This is their marketing version Installers: - Architecture: x86 AppsAndFeaturesEntries: - DisplayVersion: 1.0.4.1 - Architecture: x64 AppsAndFeaturesEntries: - DisplayVersion: 1.0.5.1

According to the logic, wouldn't 1.0.4.1 overlap with [1.0.4.0, 1.0.5.0]. since 1.0.4.0 =< 1.0.4.1 =< 1.0.5.0, thereby triggering a false overlap warning? #ByDesign

Correct, this will be treated as unsupported case according to the spec previously written. Since there's no restriction on what is written to DisplayVersion entry, an installer could also write different values for different locale. The above example can be extended to scope, installertype, etc. Essentially this will end up being each installer is in its own set.

Trenly · 2022-06-07T00:16:02Z

        const char* const ScopeNotSupported = "Scope is not supported for InstallerType portable.";
+        const char* const ApproximateVersionNotAllowed = "Approximate version not allowed.";
+        const char* const ArpVersionOverlapWithIndex = "DisplayVersion declared in the manifest has overlap with existing DisplayVersion range in the index. Existing DisplayVersion range in index: ";
+        const char* const ArpVersionValidationInternalError = "Encountered internal error during DisplayVersion validation against index.";


Suggested change

const char* const ArpVersionValidationInternalError = "Encountered internal error during DisplayVersion validation against index.";

const char* const ArpVersionValidationInternalError = "Internal error while validating DisplayVersion against index.";

Nit: Passive voice #Resolved

JohnMcPMS · 2022-06-09T03:53:22Z

        Version(std::string&& version, std::string_view splitChars = DefaultSplitChars);

+        // Constructing an approximate version from a base version.
+        Version(const Version& baseVersion, ApproximateComparator approximateComparator);


Suggested change

Version(const Version& baseVersion, ApproximateComparator approximateComparator);

Version(Version baseVersion, ApproximateComparator approximateComparator);

And move its contents. This gives us both copies and moves. #Resolved

JohnMcPMS · 2022-06-09T03:58:34Z


-        // All parts tested were equal, so this is only less if there are more parts in other.
-        return m_parts.size() < other.m_parts.size();
+        // All parts tested were equal


You have to change the Latest and Unknown comparisons to only return in the cases that they are not equal so that they can fall down here. Currently they return false in the equal case, since this is operator<. #Resolved

yep, and unit tests failed for this... rushing to get a commit run in the pipeline before running tests locally

JohnMcPMS · 2022-06-09T04:02:26Z

+            for (auto const& tuple : rawVersionValues)
+            {
+                auto& [version, arpMin, arpMax] = tuple;
+                if (!arpMin.empty() && !arpMax.empty() && arpMin != version && arpMax != version)


Suggested change

if (!arpMin.empty() && !arpMax.empty() && arpMin != version && arpMax != version)

if (!arpMin.empty() && !arpMax.empty() && (arpMin != version || arpMax != version))

It is ok if one of them is the package version.

Also, why not perform the test in the loop while building the strings out? #Resolved

JohnMcPMS · 2022-06-09T05:15:45Z

-            std::vector<std::pair<std::string, Utility::VersionRange>> arpVersionMap;
+            // Stores raw versions value strings to run a preliminary check whether version mapping is needed.
+            std::vector<std::tuple<std::string, std::string, std::string>> rawVersionValues;
            auto versionKeys = availablePackage->GetAvailableVersionKeys();


I've just realized that if the available package is a composite of multiple sources, then this is flawed. Do we do that now or not? #Pending

I think composite available package may need more thinking, currently we stop when we find one from a source, I'll add a comment as a reminder when we enable composite available package one day

JohnMcPMS · 2022-06-09T05:18:14Z

        bool result = m_interface->CheckConsistency(m_dbconn, log);

+        // Check arp version ranges do not overlap
+        if ((result || log) && GetVersion() >= Schema::Version{ 1, 5 })


I think that this should be done in the versioned code. Why is it not? #Resolved

JohnMcPMS · 2022-06-09T05:19:16Z

+    WINGET_UTIL_API WinGetCreateManifest(
+        WINGET_STRING inputPath,
+        BOOL* succeeded,
+        WINGET_SQLITE_MANIFEST_HANDLE* manifest,


Suggested change

WINGET_SQLITE_MANIFEST_HANDLE* manifest,

WINGET_MANIFEST_HANDLE* manifest,

``` #Resolved

JohnMcPMS · 2022-06-09T05:20:34Z

-        if (WI_IsFlagSet(option, WinGetValidateManifestOptionV2::SchemaValidation) || WI_IsFlagSet(option, WinGetValidateManifestOptionV2::SchemaAndSemanticValidation))
+        Manifest* manifestPtr = reinterpret_cast<Manifest*>(manifest);
+        SQLiteIndex* sqliteIndex = nullptr;
+        if (index)


You can just reinterpret_cast without the null check. #Resolved

JohnMcPMS · 2022-06-09T05:21:40Z

+    // a string representing validation errors if validation failed.
+    // If mergedManifestPath is provided, this method will write a merged manifest
+    // to the location specified by mergedManifestPath
+    WINGET_UTIL_API WinGetValidateManifestV2(


Suggested change

WINGET_UTIL_API WinGetValidateManifestV2(

WINGET_UTIL_API WinGetValidateManifestV3(

And change the parameters to match. #Resolved

yao-msft · 2022-06-09T18:59:55Z

+    WINGET_UTIL_API WinGetCloseManifest(
+        WINGET_MANIFEST_HANDLE manifest);
+
+    // Validates a given manifest. Returns a bool for validation result and


Returns a bool for validation result and

update comments

Trenly · 2022-06-09T19:11:37Z

+            installerType == InstallerTypeEnum::Nullsoft ||
+            installerType == InstallerTypeEnum::Wix ||
+            installerType == InstallerTypeEnum::Burn
+            );


Is there any advantage to using ||'s here, instead of a switch statement? I would think that when compiled, a switch statement would be slightly more efficient, given that it compiles as a jump table rather than a sequential evaluation

I just copied from above similar functions. I guess it's more readable. In the end, this function will be invoked at most once for each installed package so I think I'll leave it for consistency for now.

Trenly · 2022-06-09T19:17:22Z

+        m_maxVersion = std::move(maxVersion);
+    }
+
+    bool VersionRange::HasOverlapWith(const VersionRange& other) const


Suggested change

bool VersionRange::HasOverlapWith(const VersionRange& other) const

bool VersionRange::Overlaps(const VersionRange& other) const

Why use many word, when few word do trick?

Trenly · 2022-06-09T19:20:26Z

        const std::vector<Part>& GetParts() const { return m_parts; }

+        // Returns if the version is an approximate version.
+        bool IsApproximateVersion() const { return m_approximateComparator != ApproximateComparator::None; }


Suggested change

bool IsApproximateVersion() const { return m_approximateComparator != ApproximateComparator::None; }

bool IsApproximate() const { return m_approximateComparator != ApproximateComparator::None; }

Why use many word, when few word do trick?

Trenly · 2022-06-09T19:27:33Z

+        bool thisIsUnknown = IsBaseVersionUnknown();
+        bool otherIsUnknown = other.IsBaseVersionUnknown();


Is there a reason to change this, since IsUnknown() calls IsBaseVersionUnkown()

In a previous commit, approximate to Unknown is actually supported. I disabled it after internal discussion about what we would do to Unknown. I kept it for parity. And in case we need it in the future.

Trenly · 2022-06-09T19:35:35Z

+        return m_minVersion <= other.m_maxVersion && m_maxVersion >= other.m_minVersion;
+    }
+
+    bool VersionRange::IsSameAsSingleVersion(const Version& version) const


It seems like this could be an operator overload of == instead of a separate method?

I don't feel like doing == for different objects, which may cause confusion IMO.

yao-msft added 11 commits May 30, 2022 16:18

index

780c91c

Use

b704d35

extra validation

10c87ec

Validate v3

262915a

version test

be5beb4

manifest test

846c023

sqlite test

c598339

Fix

ca3cea8

More index validation test

5a4d4ec

e2e local pass

0200aa5

spelling

e116fd1

yao-msft added 6 commits June 2, 2022 13:00

spelling..

54fb33a

fix?

16e925e

Revert "fix?"

7b816e8

This reverts commit 16e925e.

fix

e1da15b

improve validatemanifestv3 result

027c7dd

e2efix I don't know why I have that quote!

4206e2b

yao-msft marked this pull request as ready for review June 3, 2022 20:01

yao-msft requested a review from a team as a code owner June 3, 2022 20:01

JohnMcPMS reviewed Jun 6, 2022

View reviewed changes

Trenly reviewed Jun 7, 2022

View reviewed changes

comments

f3f21de

JohnMcPMS requested changes Jun 9, 2022

View reviewed changes

ghost added Needs-Author-Feedback Issue needs attention from issue or PR author and removed Needs-Author-Feedback Issue needs attention from issue or PR author labels Jun 9, 2022

more comments and test fixes

8c7e95c

yao-msft commented Jun 9, 2022

View reviewed changes

Trenly reviewed Jun 9, 2022

View reviewed changes

JohnMcPMS approved these changes Jun 10, 2022

View reviewed changes

renaming and update comment

b8a5f28

yao-msft merged commit db2014f into microsoft:master Jun 10, 2022

yao-msft deleted the arpversion branch June 10, 2022 08:11

denelon linked an issue Jun 11, 2022 that may be closed by this pull request

Add alternative version number field to manifest to make correlation with entries in Add/Remove programs more reliable #980

Closed

	baseVersion = m_version.substr(2, m_version.length() - 2);
	baseVersion = m_version.substr(s_Approximate_Less_Than.length(), m_version.length() - s_Approximate_Less_Than.length());
	``` #Resolved

	THROW_HR_IF(E_UNEXPECTED, manifestColumnNames.size() != 0 && manifestColumnNames.size() != columns.size());
	THROW_HR_IF(E_UNEXPECTED, manifestColumnNames.size() != columns.size());


		DEFINE_ENUM_FLAG_OPERATORS(WinGetValidateManifestResult);

		WINGET_UTIL_API WinGetValidateManifestV3(

	const char* const ArpVersionValidationInternalError = "Encountered internal error during DisplayVersion validation against index.";
	const char* const ArpVersionValidationInternalError = "Internal error while validating DisplayVersion against index.";

	Version(const Version& baseVersion, ApproximateComparator approximateComparator);
	Version(Version baseVersion, ApproximateComparator approximateComparator);

	if (!arpMin.empty() && !arpMax.empty() && arpMin != version && arpMax != version)
	if (!arpMin.empty() && !arpMax.empty() && (arpMin != version \|\| arpMax != version))

	WINGET_SQLITE_MANIFEST_HANDLE* manifest,
	WINGET_MANIFEST_HANDLE* manifest,
	``` #Resolved

	WINGET_UTIL_API WinGetValidateManifestV2(
	WINGET_UTIL_API WinGetValidateManifestV3(

	bool VersionRange::HasOverlapWith(const VersionRange& other) const
	bool VersionRange::Overlaps(const VersionRange& other) const

	bool IsApproximateVersion() const { return m_approximateComparator != ApproximateComparator::None; }
	bool IsApproximate() const { return m_approximateComparator != ApproximateComparator::None; }

		bool thisIsUnknown = IsBaseVersionUnknown();
		bool otherIsUnknown = other.IsBaseVersionUnknown();

Conversation

yao-msft commented Jun 2, 2022 • edited by ghost Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Changes

Validation

Microsoft Reviewers: Open in CodeFlow

Uh oh!

github-actions bot commented Jun 2, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

@check-spelling-bot Report

Unrecognized words, please review:

Uh oh!

JohnMcPMS Jun 6, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 6, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 6, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 6, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 6, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 6, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 6, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 6, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 6, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 6, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Trenly Jun 7, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Trenly Jun 7, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 9, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 9, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 9, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JohnMcPMS Jun 9, 2022 • edited by yao-msft Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

yao-msft commented Jun 2, 2022 •

edited by ghost

Loading

github-actions bot commented Jun 2, 2022 •

edited

Loading

JohnMcPMS Jun 6, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 6, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 6, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 6, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 6, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 6, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 6, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 6, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 6, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 6, 2022 •

edited by yao-msft

Loading

Trenly Jun 7, 2022 •

edited by yao-msft

Loading

Trenly Jun 7, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 9, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 9, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 9, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 9, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 9, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 9, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 9, 2022 •

edited by yao-msft

Loading

JohnMcPMS Jun 9, 2022 •

edited by yao-msft

Loading