// Token: 0x06000BF7 RID: 3063 RVA: 0x00031E60 File Offset: 0x00030060
private void WriteAppStatuesToMailbox()
{
if (this.appStatuses.Count == 0)
{
return;
}
GetUpdates.Tracer.TraceDebug <int>(0L, "GetUpdates.ConfigAppStatus: Config app status for {0} extensions.", this.appStatuses.Count);
Exception ex = InstalledExtensionTable.RunClientExtensionAction(delegate
{
using (MailboxSession mailboxSession = MailboxSession.OpenAsSystemService(this.queryContext.ExchangePrincipal, this.queryContext.CultureInfo, this.queryContext.ClientInfoString))
{
using (InstalledExtensionTable installedExtensionTable = InstalledExtensionTable.CreateInstalledExtensionTable(this.queryContext.Domain, this.queryContext.IsUserScope, this.queryContext.OrgEmptyMasterTableCache, mailboxSession))
{
foreach (KeyValuePair <string, string> keyValuePair in this.appStatuses)
{
installedExtensionTable.ConfigureAppStatus(keyValuePair.Key, keyValuePair.Value);
}
installedExtensionTable.SaveXML();
}
}
});
if (ex != null)
{
GetUpdates.Tracer.TraceError <Exception>(0L, "GetUpdates.ConfigAppStatus: Config app status failed. Exception: {0}", ex);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_FailedToConfigAppStatus, null, new object[]
{
"ProcessUpdates",
ExtensionDiagnostics.GetLoggedMailboxIdentifier(this.queryContext.ExchangePrincipal),
ExtensionDiagnostics.GetLoggedExceptionString(ex)
});
}
}
internal static void RunAction(Action action)
{
Exception ex = InstalledExtensionTable.RunClientExtensionAction(action);
if (ex != null)
{
throw (ex is LocalizedException) ? ex : new OwaExtensionOperationException(new LocalizedString(ex.Message), ex);
}
}
protected override IEnumerable <T> InternalFindPaged <T>(QueryFilter filter, ObjectId rootId, bool deepSearch, SortBy sortBy, int pageSize)
{
AppId owaExtensionId = rootId as AppId;
if (sortBy != null)
{
throw new NotSupportedException("sortBy");
}
if (rootId != null && owaExtensionId == null)
{
throw new NotSupportedException("rootId");
}
InstalledExtensionTable installedList = null;
OWAExtensionDataProvider.RunAction(delegate
{
installedList = InstalledExtensionTable.CreateInstalledExtensionTable(this.domain, this.isUserScope, null, this.MailboxSession);
});
if (owaExtensionId == null || (owaExtensionId.DisplayName == null && owaExtensionId.AppIdValue == null))
{
List <ExtensionData> extensions = null;
OWAExtensionDataProvider.RunAction(delegate
{
extensions = installedList.GetExtensions(null, false, this.isDebug, out this.rawOrgMasterTableXml);
this.rawMasterTableXml = (this.isDebug ? installedList.MasterTableXml.InnerXml : string.Empty);
});
foreach (ExtensionData extensionData2 in extensions)
{
yield return((T)((object)this.ConvertStoreObjectToPresentationObject(extensionData2)));
}
}
else if (!string.IsNullOrEmpty(owaExtensionId.AppIdValue))
{
ExtensionData extensionData = null;
OWAExtensionDataProvider.RunAction(delegate
{
installedList.TryGetExtension(owaExtensionId.AppIdValue, out extensionData, this.isDebug, out this.rawOrgMasterTableXml);
this.rawMasterTableXml = (this.isDebug ? installedList.MasterTableXml.InnerXml : string.Empty);
});
if (extensionData != null)
{
yield return((T)((object)this.ConvertStoreObjectToPresentationObject(extensionData)));
}
}
yield break;
yield break;
}
// Token: 0x06000BF5 RID: 3061 RVA: 0x00031C20 File Offset: 0x0002FE20
internal void InstallExtensionUpdates(List <ExtensionData> updates, UpdateQueryContext queryContext)
{
GetUpdates.Tracer.TraceDebug <int>(0L, "GetUpdates.InstallExtensionUpdates: Installing {0} extensions.", updates.Count);
ExtensionData currentExtensionData = null;
Exception ex = InstalledExtensionTable.RunClientExtensionAction(delegate
{
using (MailboxSession mailboxSession = MailboxSession.OpenAsSystemService(queryContext.ExchangePrincipal, queryContext.CultureInfo, queryContext.ClientInfoString))
{
using (InstalledExtensionTable installedExtensionTable = InstalledExtensionTable.CreateInstalledExtensionTable(queryContext.Domain, queryContext.IsUserScope, queryContext.OrgEmptyMasterTableCache, mailboxSession))
{
foreach (ExtensionData currentExtensionData in updates)
{
currentExtensionData = currentExtensionData;
GetUpdates.Tracer.TraceDebug <string>(0L, "GetUpdates.InstallExtensionUpdates: Installing asset {0}", currentExtensionData.MarketplaceAssetID);
installedExtensionTable.AddExtension(currentExtensionData, true);
currentExtensionData = null;
}
installedExtensionTable.SaveXML();
}
}
});
string text = (currentExtensionData == null) ? string.Empty : currentExtensionData.MarketplaceAssetID;
if (ex != null)
{
GetUpdates.Tracer.TraceError <string, Exception>(0L, "GetUpdates.InstallExtensionUpdates: Installation failed for extension {0}. Exception: {1}", text, ex);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_ExtensionUpdateFailed, null, new object[]
{
"UpdateExtension",
ExtensionDiagnostics.GetLoggedMailboxIdentifier(queryContext.ExchangePrincipal),
text,
ExtensionDiagnostics.GetLoggedExceptionString(ex)
});
}
else
{
ExtensionDiagnostics.LogToDatacenterOnly(ApplicationLogicEventLogConstants.Tuple_ExtensionUpdateSuccess, null, new object[]
{
"UpdateExtension",
ExtensionDiagnostics.GetLoggedMailboxIdentifier(queryContext.ExchangePrincipal),
text
});
}
this.ExecuteNextUpdateQuery();
}
protected override void InternalSave(ConfigurableObject instance)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
App owaExtension = instance as App;
if (owaExtension == null)
{
throw new NotSupportedException("Save: " + instance.GetType().FullName);
}
OWAExtensionDataProvider.RunAction(delegate
{
using (InstalledExtensionTable installedExtensionTable = InstalledExtensionTable.CreateInstalledExtensionTable(this.domain, this.isUserScope, null, this.MailboxSession))
{
switch (owaExtension.ObjectState)
{
case ObjectState.New:
if (!owaExtension.IsDownloadOnly)
{
installedExtensionTable.InstallExtension(owaExtension.GetExtensionDataForInstall(this.adRecipientSession), false);
}
break;
case ObjectState.Changed:
if (this.isUserScope)
{
installedExtensionTable.ConfigureUserExtension(owaExtension.AppId, owaExtension.Enabled);
}
else
{
OrgApp orgApp = instance as OrgApp;
if (orgApp == null)
{
throw new NotSupportedException("Save: " + instance.GetType().FullName);
}
installedExtensionTable.ConfigureOrgExtension(orgApp.AppId, orgApp.Enabled, orgApp.DefaultStateForUser == DefaultStateForUser.AlwaysEnabled, orgApp.DefaultStateForUser == DefaultStateForUser.Enabled, orgApp.ProvidedTo, OrgApp.ConvertPresentationFormatToWireUserList(this.adRecipientSession, orgApp.UserList));
}
break;
}
}
});
}
private void WriteTokensToMailbox()
{
if (this.downloadedTokens.Count == 0 && this.appStatuses.Count == 0)
{
return;
}
GetTokens.Tracer.TraceDebug <int, int>(0L, "GetTokens.WriteTokensToMailbox: Writing renewed tokens for {0} apps, failure error codes for {0} apps.", this.downloadedTokens.Count, this.appStatuses.Count);
Exception ex = InstalledExtensionTable.RunClientExtensionAction(delegate
{
using (MailboxSession mailboxSession = MailboxSession.OpenAsSystemService(this.queryContext.ExchangePrincipal, this.queryContext.CultureInfo, this.queryContext.ClientInfoString))
{
using (InstalledExtensionTable installedExtensionTable = InstalledExtensionTable.CreateInstalledExtensionTable(this.queryContext.Domain, this.queryContext.IsUserScope, this.queryContext.OrgEmptyMasterTableCache, mailboxSession))
{
foreach (KeyValuePair <string, string> keyValuePair in this.downloadedTokens)
{
installedExtensionTable.ConfigureEtoken(keyValuePair.Key, keyValuePair.Value, true);
}
foreach (KeyValuePair <string, string> keyValuePair2 in this.appStatuses)
{
installedExtensionTable.ConfigureAppStatus(keyValuePair2.Key, keyValuePair2.Value);
}
installedExtensionTable.SaveXML();
}
}
});
if (ex != null)
{
GetTokens.Tracer.TraceError <Exception>(0L, "GetTokens.WriteTokensToMailbox: Writing renewed tokens failed. Exception: {0}", ex);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_FailedToWritebackRenewedTokens, null, new object[]
{
"ProcessTokenRenew",
ExtensionDiagnostics.GetLoggedMailboxIdentifier(this.queryContext.ExchangePrincipal),
ExtensionDiagnostics.GetLoggedExceptionString(ex)
});
return;
}
ExtensionDiagnostics.LogToDatacenterOnly(ApplicationLogicEventLogConstants.Tuple_ProcessTokenRenewCompleted, null, new object[]
{
"ProcessTokenRenew",
ExtensionDiagnostics.GetLoggedMailboxIdentifier(this.queryContext.ExchangePrincipal)
});
}
protected override void InternalDelete(ConfigurableObject instance)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
App owaExtension = instance as App;
if (owaExtension == null)
{
throw new NotSupportedException("Save: " + instance.GetType().FullName);
}
OWAExtensionDataProvider.RunAction(delegate
{
using (InstalledExtensionTable installedExtensionTable = InstalledExtensionTable.CreateInstalledExtensionTable(this.domain, this.isUserScope, null, this.MailboxSession))
{
if (this.isUserScope)
{
if (ExtensionInstallScope.User != owaExtension.Scope)
{
throw new OwaExtensionOperationException(Strings.ErrorUninstallProvidedExtension(owaExtension.DisplayName));
}
if (this.TryRemovePerExtensionFai(owaExtension.AppId, owaExtension.AppVersion))
{
installedExtensionTable.UninstallExtension(owaExtension.AppId);
}
else
{
installedExtensionTable.ConfigureUserExtension(owaExtension.AppId, false);
}
}
else
{
if (ExtensionInstallScope.Default == owaExtension.Scope)
{
throw new OwaExtensionOperationException(Strings.ErrorUninstallDefaultExtension(owaExtension.DisplayName));
}
installedExtensionTable.UninstallExtension(owaExtension.AppId);
}
}
});
}
internal static string[] ConvertPresentationFormatToWireUserList(IRecipientSession adRecipientSession, MultiValuedProperty <ADObjectId> userList)
{
if (userList != null && userList.Count > 0)
{
Result <ADRawEntry>[] array = adRecipientSession.ReadMultiple(userList.ToArray(), new PropertyDefinition[]
{
ADObjectSchema.Guid,
ADRecipientSchema.ExternalDirectoryObjectId
});
if (array != null && array.Length > 0)
{
string[] array2 = new string[array.Length];
for (int i = 0; i < array.Length; i++)
{
array2[i] = InstalledExtensionTable.GetWireUserId(array[i].Data, array[i].Data.Id);
}
return(array2);
}
}
return(null);
}
// Token: 0x06000BF4 RID: 3060 RVA: 0x00031770 File Offset: 0x0002F970
internal bool IsValidUpdate(ExtensionData extensionData, Uri downloadAppUri, out UpdateRequestAsset requestAsset)
{
bool flag = false;
bool flag2 = false;
UpdateRequestAsset updateRequestAsset = null;
if (!this.updateRequestAssets.TryGetValue(extensionData.MarketplaceAssetID, out updateRequestAsset))
{
GetUpdates.Tracer.TraceError <string, string>(0L, "GetUpdates.IsValidUpdate: Asset returned in AppState response will not be downloaded. Asset ID does not match any value requested. Response Asset ID: {0} Response Extension ID: {1}", extensionData.MarketplaceAssetID, extensionData.ExtensionId);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_InvalidAssetIDReturnedInDownload, extensionData.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
extensionData.MarketplaceAssetID,
downloadAppUri
});
}
else if (extensionData.ExtensionId != updateRequestAsset.ExtensionID)
{
GetUpdates.Tracer.TraceError <string, string, string>(0L, "GetUpdates.IsValidUpdate: Asset returned in download response will not be installed. Extension ID does not match expected value. Asset ID: {0} Response: {1} Expected: {2}", extensionData.MarketplaceAssetID, extensionData.ExtensionId, updateRequestAsset.ExtensionID);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_MismatchedExtensionIDReturnedInDownload, extensionData.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
extensionData.MarketplaceAssetID,
downloadAppUri,
updateRequestAsset.ExtensionID,
extensionData.ExtensionId
});
}
else if (extensionData.Version == null || extensionData.Version <= updateRequestAsset.Version)
{
GetUpdates.Tracer.TraceError <string, string, Version>(0L, "GetUpdates.IsValidUpdate: Asset returned in download response will not be installed. Version is not newer. Asset ID: {0} Response: {1} Request: {2}", extensionData.MarketplaceAssetID, extensionData.VersionAsString, updateRequestAsset.Version);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_OldVersionReturnedInDownload, extensionData.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
extensionData.MarketplaceAssetID,
downloadAppUri,
updateRequestAsset.Version,
extensionData.VersionAsString
});
}
else if (ExtensionData.CompareCapabilities(extensionData.RequestedCapabilities.Value, updateRequestAsset.RequestedCapabilities) > 0)
{
GetUpdates.Tracer.TraceError <string, RequestedCapabilities?, RequestedCapabilities>(0L, "GetUpdates.IsValidUpdate: Asset update requires more capabilities than installed asset. Asset ID: {0} Update: {1} Installed: {2}", extensionData.MarketplaceAssetID, extensionData.RequestedCapabilities, updateRequestAsset.RequestedCapabilities);
flag2 = true;
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_MoreCapabilitiesReturnedInDownload, extensionData.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
extensionData.MarketplaceAssetID,
downloadAppUri,
updateRequestAsset.RequestedCapabilities,
extensionData.RequestedCapabilities.Value
});
}
else if (!InstalledExtensionTable.ValidateAndRemoveManifestSignature(extensionData.Manifest, extensionData.ExtensionId, false))
{
GetUpdates.Tracer.TraceError <string>(0L, "GetUpdates.IsValidUpdate: Asset doesn't have valid Signature. Asset ID: {0}.", extensionData.MarketplaceAssetID);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_InvalidAssetSignatureReturnedInDownload, extensionData.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
extensionData.MarketplaceAssetID,
downloadAppUri
});
}
else if (!ExtensionData.ValidateManifestSize((long)extensionData.Manifest.OuterXml.Length, false))
{
GetUpdates.Tracer.TraceError <string>(0L, "GetUpdates.IsValidUpdate: Asset exceeds the allowed maximum size. Asset ID: {0}.", extensionData.MarketplaceAssetID);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_ManifestExceedsAllowedSize, extensionData.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
extensionData.Manifest.OuterXml.Length,
256
});
}
else
{
flag = true;
}
if (!flag)
{
string value = "1.0";
if (flag2)
{
value = "1.1";
}
this.appStatuses[extensionData.ExtensionId] = value;
}
requestAsset = (flag ? updateRequestAsset : null);
return(flag);
}
// Token: 0x06000BED RID: 3053 RVA: 0x00031178 File Offset: 0x0002F378
internal bool CacheSatisfiesRequest(UpdateRequestAsset requestAsset, List <ExtensionData> updates)
{
bool result = false;
ExtensionsCacheEntry extensionsCacheEntry = null;
if (this.extensionsCache.TryGetEntry(requestAsset.MarketplaceAssetID, out extensionsCacheEntry) && requestAsset.Version <= extensionsCacheEntry.Version && extensionsCacheEntry.Manifest != null)
{
if (requestAsset.ExtensionID != extensionsCacheEntry.ExtensionID)
{
GetUpdates.Tracer.TraceError <string, string, string>(0L, "GetUpdates.CacheSatisfiesRequest: Asset {0} extension ID {1} does not match the cache entry {2}", requestAsset.MarketplaceAssetID, requestAsset.ExtensionID, extensionsCacheEntry.ExtensionID);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_MismatchedCacheMailboxExtensionId, requestAsset.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
requestAsset.MarketplaceAssetID,
requestAsset.ExtensionID,
extensionsCacheEntry.ExtensionID
});
result = true;
}
else if (requestAsset.Version == extensionsCacheEntry.Version)
{
GetUpdates.Tracer.TraceDebug <string>(0L, "GetUpdates.CacheSatisfiesRequest: Asset {0} version matches the cache entry", requestAsset.MarketplaceAssetID);
result = true;
}
else if (requestAsset.Version < extensionsCacheEntry.Version && extensionsCacheEntry.Manifest != null)
{
if (ExtensionData.CompareCapabilities(extensionsCacheEntry.RequestedCapabilities.Value, requestAsset.RequestedCapabilities) > 0)
{
GetUpdates.Tracer.TraceDebug <string, RequestedCapabilities, RequestedCapabilities>(0L, "GetUpdates.CacheSatisfiesRequest: Asset cache entry requires more capabilities than installed asset. Asset ID: {0} Update: {1} Installed: {2}", requestAsset.MarketplaceAssetID, extensionsCacheEntry.RequestedCapabilities.Value, requestAsset.RequestedCapabilities);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_MoreCapabilitiesSkipUpdate, requestAsset.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
requestAsset.MarketplaceAssetID,
requestAsset.RequestedCapabilities,
extensionsCacheEntry.RequestedCapabilities.Value
});
result = true;
}
else if (!GetUpdates.IsValidUpdateState(new OmexConstants.AppState?(extensionsCacheEntry.State)))
{
GetUpdates.Tracer.TraceDebug <string, OmexConstants.AppState>(0L, "GetUpdates.CacheSatisfiesRequest: Asset {0} cache entry AppState {1} is not valid for updates", requestAsset.MarketplaceAssetID, extensionsCacheEntry.State);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_InvalidStateSkipUpdate, requestAsset.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
requestAsset.MarketplaceAssetID,
extensionsCacheEntry.State
});
result = true;
}
else
{
GetUpdates.Tracer.TraceDebug <string>(0L, "GetUpdates.CacheSatisfiesRequest: Asset {0} will be updated from the cache", requestAsset.MarketplaceAssetID);
ExtensionData updatedExtension = null;
Exception ex = InstalledExtensionTable.RunClientExtensionAction(delegate
{
updatedExtension = ExtensionData.ParseOsfManifest(extensionsCacheEntry.Manifest, extensionsCacheEntry.Manifest.Length, requestAsset.MarketplaceAssetID, requestAsset.MarketplaceContentMarket, ExtensionType.MarketPlace, requestAsset.Scope, requestAsset.Enabled, requestAsset.DisableReason, string.Empty, requestAsset.Etoken);
});
if (ex == null)
{
updates.Add(updatedExtension);
result = true;
}
else
{
GetUpdates.Tracer.TraceError <string, Exception>(0L, "GetUpdates.CacheSatisfiesRequest: Parse of manifest failed for extension {0}. Exception: {1}", requestAsset.MarketplaceAssetID, ex);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_CachedManifestParseFailed, requestAsset.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
requestAsset.MarketplaceAssetID,
ExtensionDiagnostics.GetLoggedExceptionString(ex)
});
}
}
}
}
return(result);
}
internal bool TryGetEntry(string marketplaceAssetID, out ExtensionsCacheEntry extensionCacheEntry)
{
ExtensionsCacheEntry extensionsCacheEntry = null;
if (this.extensionsDictionary.TryGetValue(marketplaceAssetID, out extensionsCacheEntry) && !InstalledExtensionTable.IsUpdateCheckTimeExpired(extensionsCacheEntry.LastUpdateCheckTime))
{
extensionCacheEntry = extensionsCacheEntry;
}
else
{
extensionCacheEntry = null;
}
return(extensionCacheEntry != null);
}
internal void SubmitUpdateQuery(ICollection <ExtensionData> extensions, UpdateQueryContext queryContext)
{
if (extensions == null)
{
throw new ArgumentNullException("extensions");
}
if (extensions.Count == 0)
{
throw new ArgumentException("extensions must contain one or more extensions");
}
if (this.SkipSubmitUpdateQueryForTest)
{
this.SubmitCount = 0;
}
Dictionary <string, UpdateRequestAsset> dictionary = new Dictionary <string, UpdateRequestAsset>(extensions.Count);
foreach (ExtensionData extensionData in extensions)
{
if (extensionData.Version == null)
{
ExtensionsCache.Tracer.TraceDebug <string>(0L, "ExtensionsCache.SubmitUpdateQuery: Extension {0} not added to query list because version is invalid", extensionData.MarketplaceAssetID);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_InvalidVersionSubmitUpdateQuery, extensionData.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
ExtensionDiagnostics.GetLoggedMailboxIdentifier(queryContext.ExchangePrincipal),
extensionData.MarketplaceAssetID
});
}
else
{
if (extensionData.Scope == null)
{
throw new ArgumentNullException("extensionData.Scope");
}
if (extensionData.RequestedCapabilities == null)
{
throw new ArgumentNullException("extensionData.RequestedCapabilities");
}
ExtensionsCacheEntry extensionsCacheEntry = null;
if (this.extensionsDictionary.TryGetValue(extensionData.MarketplaceAssetID, out extensionsCacheEntry) && !InstalledExtensionTable.IsUpdateCheckTimeExpired(extensionsCacheEntry.LastUpdateCheckTime) && extensionsCacheEntry.Version == extensionData.Version)
{
ExtensionsCache.Tracer.TraceDebug <string>(0L, "ExtensionsCache.SubmitUpdateQuery: Extension {0} not added to query list because version matches recent cache entry", extensionData.MarketplaceAssetID);
}
else
{
UpdateRequestAsset updateRequestAsset = null;
if (dictionary.TryGetValue(extensionData.MarketplaceAssetID, out updateRequestAsset))
{
ExtensionsCache.Tracer.TraceDebug <string, string, string>(0L, "ExtensionsCache.SubmitUpdateQuery: Extension {0} not added to query list because asset with same MarketplaceAssetID is already in list. ExtensionIds with same asset id: {1} {2}", extensionData.MarketplaceAssetID, extensionData.ExtensionId, updateRequestAsset.ExtensionID);
}
else
{
dictionary.Add(extensionData.MarketplaceAssetID, new UpdateRequestAsset
{
MarketplaceContentMarket = extensionData.MarketplaceContentMarket,
ExtensionID = extensionData.ExtensionId,
MarketplaceAssetID = extensionData.MarketplaceAssetID,
RequestedCapabilities = extensionData.RequestedCapabilities.Value,
Version = extensionData.Version,
DisableReason = extensionData.DisableReason,
Enabled = extensionData.Enabled,
Scope = extensionData.Scope.Value,
Etoken = extensionData.Etoken
});
}
}
}
}
if (dictionary.Count == 0)
{
ExtensionsCache.Tracer.TraceDebug(0L, "ExtensionsCache.SubmitUpdateQuery: UpdateRequestAssets count is 0. Updates query will not be started.");
return;
}
queryContext.UpdateRequestAssets = dictionary;
queryContext.DeploymentId = ExtensionDataHelper.GetDeploymentId(queryContext.Domain);
this.QueueQueryItem(queryContext);
}
