/// <summary>
/// Using an existing proxy, upload any assemblies which are not already present on server as activity libraries
/// </summary>
/// <param name="assemblies"></param>
/// <param name="proxy"></param>
public static void Upload(IWorkflowsQueryService proxy, IEnumerable<ActivityAssemblyItem> assemblies)
{
List<ActivityLibraryDC> assembliesMissingInStore;
//If the assemblies list is blank or all the assemblies are built-in, there is no need to check the data store and upload dependencies.
if (assemblies.All(item => AssemblyInspectionService.AssemblyIsBuiltIn(item.AssemblyName)))
{
return;
}
try
{
var request = new GetMissingActivityLibrariesRequest();
request.Incaller = Assembly.GetExecutingAssembly().GetName().Name;
request.IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
request.ActivityLibrariesList = new List<ActivityLibraryDC>();
foreach (var assemblyItem in assemblies.Where(item => !AssemblyInspectionService.AssemblyIsBuiltIn(item.AssemblyName)))
{
request.ActivityLibrariesList.Add(DataContractTranslator.AssemblyItemToActivityLibraryDataContract(assemblyItem));
}
var reply = proxy.GetMissingActivityLibraries(request.SetIncaller());
assembliesMissingInStore = reply.MissingActivityLibraries;
}
catch (FaultException<ServiceFault> ex)
{
throw new CommunicationException(ex.Detail.ErrorMessage);
}
catch (FaultException<ValidationFault> ex)
{
throw new BusinessValidationException(ex.Detail.ErrorMessage);
}
catch (Exception ex)
{
throw new CommunicationException(ex.Message);
}
//Upload anything not already on the server
var assembliesToUpload = assemblies.Where(assembly => assembliesMissingInStore.Exists(
serverItem => serverItem.Name == assembly.Name
&& serverItem.VersionNumber == assembly.Version.ToString()))
.ToList();
// Iteratively upload assemblies with no un-uploaded dependencies until there are no more
while (assembliesToUpload.Any())
{
var assembliesWithNoDependencies = from assembly in assembliesToUpload
where assembly.ReferencedAssemblies == null
|| !assembly.ReferencedAssemblies.Any(
dependency =>
{
// if the dependency is in assembliesToUpload
// we can't upload assembly yet
bool dependencyNotUploadedYet = assembliesToUpload.Any(assembly1 => assembly1.AssemblyName.FullName == dependency.FullName);
return dependencyNotUploadedYet;
})
select assembly;
foreach (var assembly in assembliesWithNoDependencies)
{
// Get the dependencies for this particular assembly, by filtering based on ReferencedAssemblies
var referencedNames = assembly.ReferencedAssemblies.IfNotNull(refs => refs.Select(assembly1 => assembly1.FullName));
var dependencies = from cached in Caching.ActivityAssemblyItems
where referencedNames.IfNotNull(reference => reference.Contains(cached.AssemblyName.FullName))
select cached;
// Upload it to the server
var request = assembly.ToStoreLibraryAndActivitiesRequestDC(dependencies);
request.EnforceVersionRules = false;
request.StoreActivitiesList.ForEach(item => item.StatusCodeName = MarketplaceStatus.Public.ToString());
request.ActivityLibrary.StatusName = MarketplaceStatus.Public.ToString();
var result = proxy.UploadActivityLibraryAndDependentActivities(request);
result[0].StatusReply.CheckErrors();
}
// assembliesToUpload -= assemblies that were just uploaded
assembliesToUpload = assembliesToUpload.Except(assembliesWithNoDependencies).ToList();
if (!assembliesWithNoDependencies.Any())
{
throw new DevFacingException(CommonMessages.CyclicDependenciesOnUpload);
}
}
}
