/// <summary>
/// The get activity items by activity assembly item.
/// </summary>
/// <param name="activityAssemblyItem">
/// The activity assembly item.
/// </param>
/// <param name="client">
/// The client.
/// </param>
/// <returns>
/// ActivityItems contained in ActivityAssembly
/// </returns>
/// <exception cref="Exception">
/// </exception>
public static List<ActivityItem> GetActivityItemsByActivityAssemblyItem(ActivityAssemblyItem activityAssemblyItem, IWorkflowsQueryService client)
{
var request = new GetActivitiesByActivityLibraryNameAndVersionRequestDC
{
Name = activityAssemblyItem.Name,
VersionNumber = activityAssemblyItem.Version.ToString(),
Incaller = Environment.UserName,
IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(),
};
var activityItems = client.GetActivitiesByActivityLibraryNameAndVersion(request).List;
var activityItemCollection = new List<ActivityItem>();
foreach (StoreActivitiesDC item in activityItems)
{
activityItemCollection.Add(DataContractTranslator.StoreActivitiyDCToActivityItem(item, activityAssemblyItem));
}
activityAssemblyItem.ActivityItems = new ObservableCollection<ActivityItem>(activityItemCollection);
foreach (ActivityItem ai in activityItemCollection)
{
ai.ParentAssemblyItem = activityAssemblyItem;
}
return activityItemCollection;
}
/// <summary>
/// This method checks if Upload method should be executed.
/// </summary>
/// <param name="workflow">WorkflowItem to save</param>
/// <returns>true if pre-condition check passed</returns>
public static Tuple<bool, StoreActivitiesDC> CheckCanUpload(IWorkflowsQueryService proxy, WorkflowItem workflow)
{
StoreActivitiesDC workflowDC = DataContractTranslator.ActivityItemToStoreActivitiyDC(workflow);
var workflowList = proxy.StoreActivitiesGetByName(workflowDC);
//a new created workflow with duplicated name to be saved.
if ((!workflow.IsOpenFromServer || workflow.Name != workflow.OriginalName) && workflowList.Count > 0)
{
MessageBoxService.CannotSaveDuplicatedNameWorkflow(workflow.Name);
return new Tuple<bool, StoreActivitiesDC>(false, null);
}
StoreActivitiesDC latestWorkflow = workflowList.FirstOrDefault();
bool shouldContinue = false;
StoreActivitiesDC workflowToOpen = null;
if (latestWorkflow == null || latestWorkflow.InsertedDateTime <= workflowDC.UpdatedDateTime)
{
if (AuthorizationService.IsAdministrator(AuthorizationService.CurrentPrincipalFunc())
|| (latestWorkflow == null)
|| (workflowDC.LockedBy == Environment.UserName))
{
shouldContinue = true;
}
else
{
MessageBoxService.CannotSaveLockedActivity();
shouldContinue = false;
}
}
else // there is a new version saved on server after user checked current one out
{
if (AuthorizationService.IsAdministrator(AuthorizationService.CurrentPrincipalFunc()))
{
if (MessageBoxService.CreateNewActivityOnSaving() == MessageBoxResult.Yes)
{
shouldContinue = true;
}
}
else
{
if (MessageBoxService.DownloadNewActivityOnSaving() == MessageBoxResult.Yes)
{
workflowToOpen = latestWorkflow;
}
}
}
return new Tuple<bool, StoreActivitiesDC>(shouldContinue, workflowToOpen);
}
public static List<ActivityAssemblyItem> CacheAndDownloadAssembly(IWorkflowsQueryService client, List<ActivityAssemblyItem> assembliesToCache)
{
DownloadAndCacheAssembly(client, assembliesToCache);
return Match(assembliesToCache);
}
/// <summary>
/// Download MarketplaceAsset assettype = Projects
/// </summary>
/// <param name="assets"></param>
/// <returns></returns>
public void DownloadProjects(IWorkflowsQueryService client)
{
List<StoreActivitiesDC> request = this.projects.Select(item =>
{
return new StoreActivitiesDC
{
Name = item.Name,
Version = item.Version,
Incaller = Environment.UserName,
IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(),
};
}).ToList<StoreActivitiesDC>();
foreach (StoreActivitiesDC item in request)
{
if (IsCancelDownload)
{
CancelDownload();
return;
}
var result = client.StoreActivitiesGet(item);
if (result.Any())
{
StoreActivitiesDC dc = result[0];
ActivityAssemblyItem assembly = new ActivityAssemblyItem { Name = dc.ActivityLibraryName, Version = System.Version.Parse(dc.Version) };
List<ActivityAssemblyItem> references = Caching.CacheAndDownloadAssembly(client, Caching.ComputeDependencies(client, assembly));
this.SaveProjectsToLocal(dc, references);
currentDownloadingNumber++;
SetDownloadProgress();
}
}
}
public void LoadLiveData(IWorkflowsQueryService client)
{
ActivitySearchRequestDC request = new ActivitySearchRequestDC();
request.SearchText = SearchFilter;
request.PageNumber = resetPageIndex ? 1 : this.DataPagingVM.PageIndex;
request.PageSize = pageSize;
request.FilterByCreator = FilterByCreatedBy;
request.FilterByDescription = FilterByDescription;
request.FilterByName = filterByName;
request.FilterByVersion = FilterByVersion;
request.FilterByTags = FilterByTags;
request.FilterByType = FilterByType;
request.FilterOlder = FilterOldVersions;
if (!string.IsNullOrEmpty(sortColumn))
{
request.SortColumn = sortColumn.ToLower().Trim();
request.SortAscending = sortDirection == ListSortDirection.Ascending;
}
try
{
ActivitySearchReplyDC searchResults = null;
Utility.DoTaskWithBusyCaption("Loading...", () =>
{
searchResults = client.SearchActivities(request);
this.DataPagingVM.ResultsLength = searchResults.ServerResultsLength;
ExistingWorkflows = new ObservableCollection<StoreActivitiesDC>(searchResults.SearchResults);
});
WorkflowsView = new CollectionViewSource();
WorkflowsView.Source = existingWorkflows;
}
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);
}
finally
{
IsBusy = false;
}
}
/// <summary>
/// Delete WorkflowType by Id
/// </summary>
/// <param name="workflowTypeId"></param>
private void DeleteWorkflowType(IWorkflowsQueryService client)
{
if (this.SelectedWorkflowType == null)
return;
if (this.SelectedWorkflowType.WorkflowsCount > 0)
{
MessageBoxService.ShowError(string.Format( "The {0} can't be deleted, because there are workflows using it.",this.SelectedWorkflowType.Name));
return;
}
WorkFlowTypeCreateOrUpdateRequestDC request = new WorkFlowTypeCreateOrUpdateRequestDC();
request.SetIncaller();
request.InId = this.SelectedWorkflowType.Id;
request.IsDeleted = true;
request.InAuthGroupId = this.SelectedWorkflowType.AuthGroupId;
request.InPublishingWorkflowId = this.SelectedWorkflowType.PublishingWorkflowId;
request.InWorkflowTemplateId = this.SelectedWorkflowType.WorkflowTemplateId;
WorkFlowTypeCreateOrUpdateReplyDC reply = client.WorkflowTypeCreateOrUpdate(request);
if (reply != null && reply.StatusReply != null)
reply.StatusReply.CheckErrors();
this.GetWorkflowTypes(client);
}
private void GetWorkflowTemplateActivityAction(IWorkflowsQueryService client)
{
try
{
CreatedItem = GetWorkflowTemplateActivityExecute(client);
CreatedItem.Name = WorkflowClassName;
CreatedItem.DisplayName = WorkflowName;
CreatedItem.Version = DefaultVersion;
CreatedItem.CreatedBy = Utility.GetCurrentUserName();
CreatedItem.UpdatedBy = Utility.GetCurrentUserName();
}
catch (Exception)
{
MessageBoxService.ShowError("Can not download the selected template.");
}
}
/// <summary>
/// Get AuthorizationGroupDCs from query service
/// </summary>
/// <param name="client"></param>
private void GetAuthGroups(IWorkflowsQueryService client)
{
AuthorizationGroupGetRequestDC request = new AuthorizationGroupGetRequestDC();
request.SetIncaller();
AuthorizationGroupGetReplyDC reply = client.GetAuthorizationGroups(request);
if (reply != null && reply.StatusReply != null)
reply.StatusReply.CheckErrors();
this.AuthGroups = reply.AuthorizationGroups;
if (this.workflowType != null)
this.SelectedAuthGroup = this.AuthGroups.SingleOrDefault(a => a.AuthGroupId == this.workflowType.AuthGroupId);
else
this.SelectedAuthGroup = new AuthorizationGroupDC();
}
private void LoadLiveData(IWorkflowsQueryService client)
{
WorkflowTypes = client.WorkflowTypeGet().WorkflowActivityType;
var categories = client.ActivityCategoryGet(new ActivityCategoryByNameGetRequestDC().SetIncaller());
ActivityCategories.Assign(from category in categories select category.Name);
var status = client.StatusCodeGet(new StatusCodeGetRequestDC().SetIncaller()).List;
StatusCodes.Assign(from item in status select item.Name);
}
/// <summary>
/// load marketplace details data for UI displaying
/// </summary>
/// <param name="client"></param>
public void SearchMarketplaceAssertDetails(IWorkflowsQueryService client)
{
if (assetItem == null)
return;
MarketplaceSearchDetail search = new MarketplaceSearchDetail();
search.AssetType = assetItem.AssetType;
search.Id = assetItem.Id;
details = client.GetMarketplaceAssetDetails(search);
RaisePropertyChanged(() => MetaDataVisible);
RaisePropertyChanged(() => ActivitiesVisible);
if (details != null)
{
this.MarketplaceAssetFieldValues.Clear();
AssetName = this.details.Name;
this.MarketplaceAssetFieldValues.Add(new FieldValue() { Field = "Type", Value = this.assetItem.AssetType.ToString() });
this.MarketplaceAssetFieldValues.Add(new FieldValue() { Field = "Version", Value = this.assetItem.Version, });
if (assetItem.AssetType == AssetType.Activities)
{
this.MarketplaceAssetFieldValues.Add(new FieldValue() { Field = "Category", Value = details.CategoryName, });
if (details.Activities != null && details.Activities.Count > 0)
{
this.MarketplaceAssetFieldValues.Add(new FieldValue() { Field = "Activities", Value = details.Activities.Count.ToString(), });
this.IncludedActivities = new ObservableCollection<ActivityQuickInfo>(details.Activities);
this.RightPaneTitle = "INCLUDED ACTIVITIES(" + this.IncludedActivities.Count + ")";
}
else
{
this.RightPaneTitle = "INCLUDED ACTIVITIES(0)";
this.MarketplaceAssetFieldValues.Add(new FieldValue() { Field = "Activities", Value = "None", });
}
}
this.MarketplaceAssetFieldValues.Add(new FieldValue() { Field = "Description", Value = details.Description, });
this.MarketplaceAssetFieldValues.Add(new FieldValue() { Field = "Tags", Value = details.MetaTages, });
this.IconUrl = details.ThumbnailUrl;
}
}
/// <summary>
/// Loads assemblies from the server, sets display names, categories, determines dependencies, and so forth.
/// </summary>
public void OkCommandExecute(IWorkflowsQueryService client)
{
string[] sections; // When we get a human readable name for an activity, we use this to find the name of the activity without namespaces.
var selected = ActivityAssemblyItemCollection
.Where(activityAssemblyItem => activityAssemblyItem.UserSelected
&& activityAssemblyItem.CachingStatus != CachingStatus.Latest).ToList();
// Make sure activities (etc.) have the category of their parent.
// Since we don't have a display name available at this point and need to make one, determine
// what might be an appropriate display name and set it.
selected
.ForEach(assembly => assembly
.ActivityItems
.ToList()
.ForEach(item =>
{
item.Category = assembly.Category;
sections = item.Name.Split(".".ToCharArray());
item.DisplayName = ToolboxControlService.GetHumanReadableName(sections[sections.Length - 1]);
}));
if (selected.Any())
{
var assemblies = Utility.WithContactServerUI(() =>
{
var dependencies = Caching.ComputeDependencies(client, selected);
// When a selected assembly is also a dependency of another selected assembly,
// be careful to always prefer the ActivityAssemblyItem from the ViewModel (selected)
// over the one newly downloaded from the database (dependencies) so client-only properties
// like UserSelected and CacheState are maintained.
var assembliesAndDependencies = selected
.Union(dependencies
.Where(dependency => !selected.Any(selectedItem => selectedItem.Matches(dependency.AssemblyName)))).ToList();
return Caching.DownloadAssemblies(client, assembliesAndDependencies);
});
Caching.CacheAssembly(assemblies);
Caching.Refresh();
}
else
{
Caching.Refresh(); // force toolbox re-load
}
}
/// <summary>
/// The initialize.
/// </summary>
public void LoadLiveData(IWorkflowsQueryService client)
{
GetAllActivityLibrariesReplyDC reply;
// gets the version for an ActivityAssemblyItem, or an empty string if it is null
Func<ActivityAssemblyItem, string> getVersion = item => null == item.Version ? string.Empty : item.Version.ToString();
// checks to see if an ActivityAssemblyItem is already in the ActivityAssemblyItemCollection
Func<ActivityLibraryDC, bool> isAlreadyInCollection =
activityLibrary => ActivityAssemblyItemCollection
.Any(activityAssemblyItem => activityAssemblyItem.Name == activityLibrary.Name
&& getVersion(activityAssemblyItem) == activityLibrary.VersionNumber);
// Load from local caching
Caching
.ActivityAssemblyItems
.ToList()
.ForEach(activityAssemblyItem => ActivityAssemblyItemCollection.Add(activityAssemblyItem));
// Get the list of libraries that are on the server
try
{
var request = new GetAllActivityLibrariesRequestDC
{
Incaller = Environment.UserName,
IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString()
};
reply = client.GetAllActivityLibraries(request);
}
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);
}
// Require a pre-check since the list is not reliably instantiated
// by the WCF service
if ((null != reply) && (null != reply.List))
{
// Each library which isn't already locally cached
// should show up on the Select screen as a library
// available on the server
reply
.List
.Where(activityLibrary => !string.IsNullOrEmpty(activityLibrary.Name)
&& activityLibrary.HasExecutable
&& !isAlreadyInCollection(activityLibrary))
.ToList()
.ForEach(activityLibrary =>
{
var item = DataContractTranslator.ActivityLibraryDCToActivityAssemblyItem(activityLibrary);
item.CachingStatus = CachingStatus.Server;
ActivityAssemblyItemCollection.Add(item);
});
}
}
/// <summary>
/// The get activity items by activity assembly item.
/// </summary>
/// <param name="client"> </param>
/// <param name="activityAssemblyItem">
/// The activity assembly item.
/// </param>
public void GetActivityItemsByActivityAssemblyItem(IWorkflowsQueryService client, ActivityAssemblyItem activityAssemblyItem)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
if (activityAssemblyItem == null)
{
throw new ArgumentNullException("activityAssemblyItem");
}
CurrentActivityAssemblyItem = activityAssemblyItem;
if (activityAssemblyItem.ActivityItems != null && activityAssemblyItem.ActivityItems.Count == 0)
{
AssemblyDownloader.GetActivityItemsByActivityAssemblyItem(activityAssemblyItem, client);
WorkflowsQueryServiceUtility.UsingClient(LoadLiveData);
}
}
/// <summary>
/// search marketplace asset from queryservice
/// </summary>
public void SearchMarketplaceAssets(IWorkflowsQueryService client)
{
try
{
this.BuildMarketplaceSearchQuery();
SetDownloadSelections();
Utility.DoTaskWithBusyCaption(loadAssetCaption, () =>
{
MarketplaceSearchResult result = null;
result = client.SearchMarketplace(this.query);
LoadMarketplace(result);
});
}
catch (Exception ex)
{
MarketplaceExceptionHandler.HandleSearchException(ex);
IsBusy = false;
}
}
private void GetActivities(IWorkflowsQueryService client)
{
TaskActivityGetRequestDC request = new TaskActivityGetRequestDC();
request.Incaller = Assembly.GetExecutingAssembly().GetName().Name;
request.IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
request.AssignedTo = Environment.UserName;
request.FilterOlder = this.FilterOldVersions;
request.PageSize = pageSize;
request.PageNumber = this.DataPagingVM.ResetPageIndex ? 1 : this.DataPagingVM.PageIndex;
request.SortColumn = SortColumn;
request.SortAscending = sortDirection == ListSortDirection.Ascending;
request.SearchText = this.SearchFilter;
request.HideUnassignedTasks = this.HideUnassignedTasks;
try
{
TaskActivityGetReplyDC searchResults = null;
searchResults = client.SearchTaskActivities(request);
this.DataPagingVM.ResultsLength = searchResults.ServerResultsLength;
if (searchResults.StatusReply.Errorcode != 0)
{
IsBusy = false;
throw new UserFacingException(searchResults.StatusReply.ErrorMessage);
}
else
this.Activities = new ObservableCollection<TaskActivityDC>(searchResults.List);
}
catch (FaultException<ServiceFault> ex)
{
IsBusy = false;
throw new CommunicationException(ex.Detail.ErrorMessage);
}
catch (FaultException<ValidationFault> ex)
{
IsBusy = false;
throw new BusinessValidationException(ex.Detail.ErrorMessage);
}
catch (Exception ex)
{
IsBusy = false;
throw new CommunicationException(ex.Message);
}
}
/// <summary>
/// ctor
/// </summary>
public NewWorkflowFromTemplateViewModel(IWorkflowsQueryService client)
{
Initialize(client);
}
/// <summary>
/// Upload workflowtype to server
/// </summary>
public void UploadWorkflowType(IWorkflowsQueryService client)
{
WorkFlowTypeCreateOrUpdateRequestDC request = new WorkFlowTypeCreateOrUpdateRequestDC();
request.SetIncaller();
request.InGuid = this.workflowType.Guid;
request.InId = this.workflowType.Id;
request.InName = this.Name;
request.InPublishingWorkflowId = this.PublishingWorkflowId;
request.InWorkflowTemplateId = this.TemplateId;
request.InAuthGroupId = this.SelectedAuthGroup != null ? this.SelectedAuthGroup.AuthGroupId : 0;
request.IsDeleted = false;
this.ValidWorkflowType(request);
WorkFlowTypeCreateOrUpdateReplyDC reply = client.WorkflowTypeCreateOrUpdate(request);
if (reply != null && reply.StatusReply != null)
{
try
{
StatusReplyDC error = reply.StatusReply.CheckErrors();
}
catch (Exception ex)
{
throw new UserFacingException(ex.Message);
}
}
}
/// <summary>
/// Compute ActivityAssemblyItem dependencies
/// </summary>
/// <param name="client"></param>
/// <param name="workflowAssembly"></param>
/// <returns></returns>
public static StoreActivityLibrariesDependenciesDC ComputeDependencies(IWorkflowsQueryService client, StoreActivitiesDC activity)
{
var dependenciesByID = client.StoreActivityLibraryDependenciesTreeGet(
new StoreActivityLibrariesDependenciesDC
{
StoreDependenciesRootActiveLibrary =
new StoreDependenciesRootActiveLibrary()
{
activityLibraryId = activity.ActivityLibraryId,
activityLibraryName = activity.ActivityLibraryName,
activityLibraryVersionNumber = activity.ActivityLibraryVersion
},
Incaller = "DeployToIIS Activity",
IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString()
});
return dependenciesByID.Single();
}
/// <summary>
/// Method to get the list of templates
/// </summary>
/// <returns></returns>
public void GetListOfTemplates(IWorkflowsQueryService client)
{
var templateList = new List<WorkflowTemplateItem>();
WorkflowTypeGetReplyDC replyDC = null;
replyDC = client.WorkflowTypeGet();
if (null != replyDC && null != replyDC.StatusReply && 0 == replyDC.StatusReply.Errorcode)
{
// Create a Workflow Template Item without XAML and add it to the Template list
if (replyDC.WorkflowActivityType.Any())
{
templateList.AddRange(
replyDC.WorkflowActivityType.Select(
workflowType => new WorkflowTemplateItem(workflowType.WorkflowTemplateId, workflowType.Name)));
}
}
this.SelectWorkflowTemplates = templateList;
}
/// <summary>
/// Download dependencies and copy them to the deploy directory's \bin subdirectory
/// </summary>
/// <param name="client"></param>
/// <param name="destinationDirectoryPath"></param>
/// <param name="dependencies"></param>
public static void DownloadDependencies(IWorkflowsQueryService client, string destinationDirectoryPath, StoreActivityLibrariesDependenciesDC dependencies)
{
// IIS needs assemblies to go under bin subdirectory whereas .xamlx goes in the root
string binPath = Path.Combine(destinationDirectoryPath, "bin");
Directory.CreateDirectory(binPath);
foreach (var dependentAssembly in dependencies.StoreDependenciesDependentActiveLibraryList)
{
var reply = client.ActivityLibraryGet(new ActivityLibraryDC
{
Incaller = "DeployToIIS Activity",
IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(),
Id = dependentAssembly.activityLibraryDependentId
}).Single();
string destFile = Path.Combine(binPath, reply.Name + ".dll");
File.WriteAllBytes(destFile, reply.Executable);
}
}
/// <summary>
/// Gets the Workflow Template Activity Item based on the Selected Workflow Template, and its dependencies
/// </summary>
/// <returns>The Activity Item that will have the XAML required to create the workflow from the specified Workflow Template</returns>
private WorkflowItem GetWorkflowTemplateActivityExecute(IWorkflowsQueryService client)
{
WorkflowItem workflowActivityTemplateItem = null;
List<StoreActivitiesDC> storeActivitiesList = null;
ActivityAssemblyItem workflowActivityTemplateItemAssembly = null;
StoreActivitiesDC targetDC = null;
ActivityLibraryDC targetLibrary = null;
List<ActivityLibraryDC> activityLibraryList;
// Throw if nothing selected. CanExecute should prevent this.
if (null == SelectedWorkflowTemplateItem)
throw new ArgumentNullException();
// Create the Activity request
var requestActivity = new StoreActivitiesDC()
{
Incaller = Assembly.GetExecutingAssembly().GetName().Name,
IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(),
Id = SelectedWorkflowTemplateItem.WorkflowTemplateId
};
// Get the List of Activities that qualify, should only be one
storeActivitiesList = client.StoreActivitiesGet(requestActivity);
storeActivitiesList[0].StatusReply.CheckErrors();
if (null != storeActivitiesList)
{
// Get the first or one and only StoreActivity
targetDC = storeActivitiesList.First();
// We have to get the Activity Library associated with the Store Activity
if (0 != targetDC.ActivityLibraryId)
{
List<ActivityAssemblyItem> references = new List<ActivityAssemblyItem>();
Utility.DoTaskWithBusyCaption("Loading...",() =>
{
// Create the Library request
var requestLibrary = new ActivityLibraryDC
{
Incaller = Assembly.GetExecutingAssembly().GetName().Name,
IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(),
Id = targetDC.ActivityLibraryId
};
// Get the list
try
{
activityLibraryList = client.ActivityLibraryGet(requestLibrary);
}
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);
}
// Get the First one or null, should only be one
targetLibrary = activityLibraryList.FirstOrDefault();
workflowActivityTemplateItemAssembly = DataContractTranslator.ActivityLibraryDCToActivityAssemblyItem(targetLibrary);
// download dependencies
references = Caching.CacheAndDownloadAssembly(client, Caching.ComputeDependencies(client, workflowActivityTemplateItemAssembly));
});
workflowActivityTemplateItem = DataContractTranslator.StoreActivitiyDCToWorkflowItem(targetDC, workflowActivityTemplateItemAssembly, references);
workflowActivityTemplateItem.WorkflowType = SelectedWorkflowTemplateItem.WorkflowTypeName;
workflowActivityTemplateItem.IsOpenFromServer = false;
}
}
return workflowActivityTemplateItem; // Return the ActivityItem
}
private void GetActivities(IWorkflowsQueryService client)
{
ActivitySearchRequestDC request = new ActivitySearchRequestDC();
request.SearchText = this.SearchFilter;
request.PageNumber = this.DataPagingVM.ResetPageIndex ? 1 : this.DataPagingVM.PageIndex;
request.PageSize = pageSize;
request.FilterByCreator = false;
request.FilterByDescription = false;
request.FilterByName = true;
request.FilterByVersion = false;
request.FilterByTags = false;
request.FilterByType = false;
request.FilterOlder = this.FilterOldVersions;
try
{
ActivitySearchReplyDC searchResults = null;
searchResults = client.SearchActivities(request);
this.DataPagingVM.ResultsLength = searchResults.ServerResultsLength;
this.Activities = new ObservableCollection<StoreActivitiesDC>(searchResults.SearchResults);
}
catch (FaultException<ServiceFault> ex)
{
IsBusy = false;
throw new CommunicationException(ex.Detail.ErrorMessage);
}
catch (FaultException<ValidationFault> ex)
{
IsBusy = false;
throw new BusinessValidationException(ex.Detail.ErrorMessage);
}
catch (Exception ex)
{
IsBusy = false;
throw new CommunicationException(ex.Message);
}
}
/// <summary>
/// Gets workflowTypes from QueryService
/// </summary>
/// <param name="client"></param>
private void GetWorkflowTypes(IWorkflowsQueryService client)
{
WorkflowTypeSearchReply replyDC = null;
WorkflowTypeSearchRequest request = new WorkflowTypeSearchRequest();
request.SearchText = this.SearchText;
request.PageSize = pageSize;
request.PageNumber = this.DataPagingVM.ResetPageIndex ? 1 : this.DataPagingVM.PageIndex;
request.SortColumn = DefaultSortColumn;
request.SortAscending = this.SortByAsceinding;
replyDC = client.SearchWorkflowTypes(request);
if (null != replyDC && null != replyDC.StatusReply && 0 == replyDC.StatusReply.Errorcode)
{
this.WorkflowTypes = new ObservableCollection<WorkflowTypeSearchDC>(replyDC.SearchResults);
DataPagingVM.ResultsLength = replyDC.ServerResultsLength;
}
else
{
this.WorkflowTypes = new ObservableCollection<WorkflowTypeSearchDC>();
DataPagingVM.ResultsLength = 0;
}
}
/// <summary>
/// Method to get the list of templates
/// </summary>
/// <returns></returns>
public static List<WorkflowTemplateItem> GetListOfTemplates(IWorkflowsQueryService client)
{
List<WorkflowTemplateItem> templateList = new List<WorkflowTemplateItem>();
WorkflowTypeGetReplyDC replyDC = null;
replyDC = client.WorkflowTypeGet();
if (null != replyDC && null != replyDC.StatusReply && 0 == replyDC.StatusReply.Errorcode)
{
foreach (WorkflowTypesGetBase wfType in replyDC.WorkflowActivityType)
{
// Create a Workflow Template Item without XAML and add it to the Template list
WorkflowTemplateItem newItem = new WorkflowTemplateItem(wfType.WorkflowTemplateId, wfType.Name);
templateList.Add(newItem);
}
}
// Return the list
return templateList;
}
/// <summary>
/// Download MarketplaceAsset that AssetType is equal to Activities
/// </summary>
/// <param name="assets"></param>
/// <param name="assetType"></param>
public void DownloadActivities(IWorkflowsQueryService client)
{
var downloadedAssemblies = new List<ActivityAssemblyItem>();
foreach (MarketplaceAssetModel model in this.activities)
{
if (IsCancelDownload)
{
CancelDownload();
return;
}
ActivityAssemblyItem toDownloadAssembly = new ActivityAssemblyItem { Name = model.Name, Version = System.Version.Parse(model.Version) };
AssemblyDownloader.GetActivityItemsByActivityAssemblyItem(toDownloadAssembly, client);
//download dependendies
var dependecies = Caching.ComputeDependencies(client, toDownloadAssembly);
dependecies.Add(toDownloadAssembly);
var toCachedAssembly = Caching.DownloadAssemblies(client, dependecies);
toCachedAssembly.ToList().ForEach(i => i.UserSelected = model.IsAddToToolbox);
downloadedAssemblies.AddRange(toCachedAssembly);
//set download progress
currentDownloadingNumber++;
SetDownloadProgress();
}
if (!IsCancelDownload)
{
Caching.CacheAssembly(downloadedAssemblies);
Caching.Refresh();
if (this.currentWorkflow != null)
{
ObservableCollection<ActivityAssemblyItem> importAssemblies = new ObservableCollection<ActivityAssemblyItem>(this.currentWorkflow.WorkflowDesigner.DependencyAssemblies);
downloadedAssemblies.ForEach(i =>
{
if (importAssemblies.SingleOrDefault(item => item.FullName != i.FullName) == null)
importAssemblies.Add(i);
});
this.currentWorkflow.WorkflowDesigner.ImportAssemblies(importAssemblies.ToList());
}
this.activities.ForEach(
m => m.Location = Caching.ActivityAssemblyItems
.Where(i => i.Name == m.Name && i.Version.ToString() == m.Version)
.First().Location);
}
}
/// <summary>
/// Initialize the ViewModel
/// </summary>
private void Initialize(IWorkflowsQueryService client)
{
GetWorkflowTemplateActivity = GetWorkflowTemplateActivityExecute;
InitializeNotifications();
InitializeData(client);
InitializeCommands();
IsInitialized = true;
}
/// <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);
}
}
}
/// <summary>
/// Get any data that we need
/// </summary>
private void InitializeData(IWorkflowsQueryService client)
{
SelectWorkflowTemplates = NewWorkflowFromTemplateViewModel.GetListOfTemplates(client);
}
/// <summary>
/// The main method of WorkflowUploader. Upload the given workflow and its dependencies to server using the default WorkflowsQueryService, as a new activityLibrary.
/// </summary>;
/// <param name="workflow">WorkflowItem to save</param>
/// <returns>true if uploaded succeeded, else CommunicationException</returns>
/// <exception cref="CommunicationException">WCF layer exceptions and error codes from the workflow query service will be wrapped as CommunicationExceptions</exception>
public static StatusReplyDC Upload(IWorkflowsQueryService proxy, WorkflowItem workflow)
{
var assemblyActivitiyItemsUsed = workflow.WorkflowDesigner.DependencyAssemblies;
// Database requires that we upload dependencies first so the DB is always in a consistent state
Upload(proxy, assemblyActivitiyItemsUsed);
// Now, upload the actual workflow
StoreActivitiesDC result = null;
if (workflow.TaskActivityGuid.HasValue) {
result = proxy.UploadActivityLibraryAndTaskActivities(
DataContractTranslator.WorkflowToStoreLibraryAndTaskActivityRequestDC(workflow, assemblyActivitiyItemsUsed)
)[0].Activity;
}
else {
List<TaskAssignment> tasks = workflow.WorkflowDesigner.Tasks;
Guid[] newTaskIds = tasks.Where(t => t.TaskStatus == TaskActivityStatus.New).Select(t => t.TaskId).ToArray();
if (newTaskIds.Any()) {
workflow.WorkflowDesigner.SetNewTasksToAssigned(newTaskIds);
workflow.SetXamlCode(); // Publication has removed all tasks from workflow
}
try {
result = proxy.UploadActivityLibraryAndDependentActivities(
DataContractTranslator.WorkflowToStoreLibraryAndActivitiesRequestDC(workflow, assemblyActivitiyItemsUsed, tasks)
)[0];
}
catch (Exception) {
if (newTaskIds.Any())
workflow.WorkflowDesigner.RollbackAssignedTasks(newTaskIds);
}
}
result.StatusReply.CheckErrors();
// No exception = success. Disable the Save button, clean up, return true to report success.
workflow.FinishTaskAssigned();
workflow.CreateDateTime = result.InsertedDateTime;
workflow.UpdateDateTime = result.UpdatedDateTime;
workflow.Version = result.Version;
workflow.IsOpenFromServer = true;
workflow.IsSavedToServer = true;
workflow.IsDataDirty = false;
return result.StatusReply;
}
/// <summary>
/// Method gets the Executable that this Activity Library represents
/// </summary>
/// <param name="client">The WCF Service</param>
/// <param name="aai">The ActivityAssemblyItem</param>
/// <returns>a Byte[]</returns>
public static byte[] GetExecutableBytes(IWorkflowsQueryService client, ActivityAssemblyItem aai)
{
List<ActivityLibraryDC> replyList;
if (aai == null)
{
throw new Exception("aai");
}
byte[] sourceFileBytes = null;
var request = new ActivityLibraryDC
{
Name = aai.Name,
VersionNumber = aai.Version.ToString(),
Incaller = Environment.UserName,
IncallerVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString()
};
try
{
replyList = client.ActivityLibraryGet(request);
}
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);
}
if ((null != replyList) && (0 < replyList.Count))
{
sourceFileBytes = replyList[0].Executable;
}
return sourceFileBytes;
}
