/// <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> /// Loads an assembly to check for its references and activities. /// </summary> /// <param name="assemblyPath">Location of the assembly</param> /// <param name="item">Assembly item loaded with reflection and xaml buildtask analysis</param> public void LoadReflectedInfoInSubdomain(string assemblyPath, out ActivityAssemblyItem item) { List<AssemblyName> xamlReferences = new List<AssemblyName>(); item = null; if (string.IsNullOrEmpty(assemblyPath)) { throw new ArgumentNullException("assemblyPath"); } assemblyFullPath = assemblyPath; // Get assembly and use it to compute activities and references. // Any exception in this method should be caught in the inspection service for exception bubbling. var assembly = Assembly.ReflectionOnlyLoadFrom(assemblyFullPath); item = new ActivityAssemblyItem(assembly); if (assembly.GetType("XamlStaticHelperNamespace._XamlStaticHelper") != null) { xamlReferences = GetXamlReferences(); } var reflectedReferencedAssemblies = (from assemblyName in assembly.GetReferencedAssemblies() select assemblyName) .Union(xamlReferences); //Store the references of the current assembly item.ReferencedAssemblies = new ObservableCollection<AssemblyName>(reflectedReferencedAssemblies); }
public static void AddToCaching(string assemblyFilePath) { AssemblyInspectionService.CheckAssemblyPath(assemblyFilePath); var assemblyItem = new ActivityAssemblyItem(AssemblyName.GetAssemblyName(assemblyFilePath)) { Location = assemblyFilePath, Category = "Unassigned", }; var inspection = Utility.GetAssemblyInspectionService(); if (!inspection.Inspect(assemblyFilePath)) { throw new UserFacingException(inspection.OperationException.Message, inspection.OperationException); } assemblyItem.ReferencedAssemblies = new ObservableCollection<AssemblyName>(inspection.ReferencedAssemblies.Select(r => r.AssemblyName)); assemblyItem.ActivityItems = inspection.SourceAssembly.ActivityItems; assemblyItem.UserSelected = true; assemblyItem.ActivityItems.ToList().ForEach(i => { i.UserSelected = true; i.Category = "Unassigned"; }); Caching.CacheAssembly(new [] { assemblyItem }.ToList()); Caching.Refresh(); }
private bool isResolved = false; // Backing for the IsResolved property, which determines if the Location was missing at the start but is now filled in. #endregion Fields #region Constructors public ActivityAssemblyItemViewModel(ActivityAssemblyItem item) { assemblyItem = item; activityItems = new ReadOnlyObservableCollection<ActivityItem>(new ObservableCollection<ActivityItem>(item.ActivityItems)); referencedAssemblies = new ReadOnlyObservableCollection<AssemblyName>(new ObservableCollection<AssemblyName>(item.ReferencedAssemblies)); ReviewAssemblyCommand = new DelegateCommand(ReviewAssemblyCommandExecute, CanReviewAssemblyCommandExecute); }
/// <summary> /// Prepare to query for an assembly's dependencies /// </summary> /// <param name="assembly"></param> /// <returns></returns> public static StoreActivityLibrariesDependenciesDC ActivityAssemblyItemToStoreActivityLibrariesDependenciesDC(ActivityAssemblyItem assembly) { // Create the request return new StoreActivityLibrariesDependenciesDC() { Incaller = Utility.GetCallerName(), IncallerVersion = Utility.GetCallerVersion(), StoreDependenciesRootActiveLibrary = new StoreDependenciesRootActiveLibrary { activityLibraryName = assembly.Name, activityLibraryVersionNumber = assembly.Version.ToString() } }; }
private string selectedCategory = String.Empty; // Selected category (default) for the assemblies to import #endregion Fields #region Constructors /// <summary> /// Default constructor for the class /// </summary> public ImportAssemblyViewModel(string assemblyFilePath) { Utility.DoTaskWithBusyCaption("Loading", () => { if (string.IsNullOrEmpty(assemblyFilePath)) { throw new ArgumentNullException("assemblyFilePath"); } AssemblyInspectionService.CheckAssemblyPath(assemblyFilePath); StartAddingCategoryCommand = new DelegateCommand(() => { IsAddingCategory = true; }); StopAddingCategoryCommand = new DelegateCommand(() => { IsAddingCategory = false; }); ImportCommand = new DelegateCommand(ImportCommandExecute, CanImportCommandExecute); AddNewCategoryCommand = new DelegateCommand(AddNewCategoryCommandExecute, CanAddNewCategoryCommandExecute); var item = new ActivityAssemblyItem(AssemblyName.GetAssemblyName(assemblyFilePath)) { Location = assemblyFilePath }; mainAssemblyItem = item; Initialize(); }); }
/// <summary> /// Opens a store activity from server and checks if messages should be popped up /// </summary> /// <param name="workflowDC"></param> /// <param name="fakeLibrary"></param> public void OpenStoreActivitiesDC( StoreActivitiesDC workflowDC, ActivityAssemblyItem fakeLibrary, List<ActivityAssemblyItem> references = null, bool isTask = false) { bool isReadOnly = false; bool isAdministrator = AuthorizationService.IsAdministrator(AuthorizationService.CurrentPrincipalFunc()); if (!workflowDC.Locked || (isAdministrator) || (!isAdministrator && workflowDC.Locked && workflowDC.LockedBy == Environment.UserName)) { MessageBoxResult result = MessageBoxService.OpenActivity(workflowDC.Name); if (result == MessageBoxResult.Yes) { //open workflow for edit mode isReadOnly = false; } else if (result == MessageBoxResult.No) { //open worflow for readonly mode isReadOnly = true; } else //cancel { return; } } else { if (MessageBoxService.OpenLockedActivityByNonAdmin(workflowDC.LockedBy) == MessageBoxResult.OK) isReadOnly = true; else return; } Utility.DoTaskWithBusyCaption("UI may not respond. Please wait...", () => { if (!isReadOnly) { StoreActivitesSetLock(workflowDC); } CheckIsAlreadyInListOrAdd(DataContractTranslator.StoreActivitiyDCToWorkflowItem(workflowDC, fakeLibrary, references, isTask: isTask)); }, false); FocusedWorkflowItem.IsReadOnly = isReadOnly; FocusedWorkflowItem.IsSavedToServer = true; FocusedWorkflowItem.IsDataDirty = false; }
/// <summary> /// Compute ActivityAssemblyItem dependencies /// </summary> /// <param name="client"></param> /// <param name="assembly"></param> /// <returns></returns> public static List<ActivityAssemblyItem> ComputeDependencies(IWorkflowsQueryService client, ActivityAssemblyItem assembly) { return ComputeDependencies(client, new[] { assembly }.ToList()); }
/// <summary> /// Try to retrieve a cached assembly /// </summary> /// <param name="assemblyName"></param> /// <param name="cachedAssembly"></param> /// <returns></returns> public static bool LoadCachedAssembly( IEnumerable<ActivityAssemblyItem> activityAssemblyItems, AssemblyName assemblyName, out ActivityAssemblyItem cachedAssembly) { cachedAssembly = activityAssemblyItems.FirstOrDefault(assembly => assembly.Matches(assemblyName)); return cachedAssembly != null; }
public static WorkflowItem StoreActivitiyDCToWorkflowItem( StoreActivitiesDC dc, ActivityAssemblyItem parentAssemblyItem, List<ActivityAssemblyItem> references = null, bool isTask = false) { var workflowItem = new WorkflowItem(dc.Name, dc.Name, dc.Xaml, dc.WorkflowTypeName, references); workflowItem.CachingStatus = CachingStatus.None; workflowItem.Category = dc.ActivityCategoryName; workflowItem.CreateDateTime = dc.InsertedDateTime; workflowItem.CreatedBy = dc.InsertedByUserAlias; workflowItem.Description = dc.Description; workflowItem.FullName = dc.Name; workflowItem.Name = dc.Name; workflowItem.DisplayName = dc.ShortName ?? dc.Name; workflowItem.HasCodeBehind = dc.IsCodeBeside; workflowItem.ParentAssemblyItem = parentAssemblyItem; workflowItem.Status = dc.StatusCodeName; workflowItem.UpdatedBy = dc.UpdatedByUserAlias; workflowItem.UpdateDateTime = dc.UpdatedDateTime; workflowItem.IsSavedToServer = true; workflowItem.Version = workflowItem.OldVersion = dc.Version; workflowItem.IsDataDirty = false; workflowItem.Tags = dc.MetaTags; workflowItem.XamlCode = dc.Xaml; workflowItem.WorkflowType = dc.WorkflowTypeName; workflowItem.IsOpenFromServer = true; workflowItem.IsTask = isTask; return workflowItem; }
/// <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> /// Save downloaded projects to local machine /// </summary> /// <param name="wfs"></param> /// <param name="filePath"></param> public void SaveProjectsToLocal(StoreActivitiesDC activity, List<ActivityAssemblyItem> references) { if (activity == null) return; try { string targetFileName = Utility.GetProjectsDirectoryPath() + "\\" + activity.ActivityLibraryName + "_" + activity.ActivityLibraryVersion + ".wf"; using (var stream = File.Open(targetFileName, FileMode.Create)) { var formatter = new BinaryFormatter(); WorkflowItem wfItem = null; ActivityAssemblyItem assembly = new ActivityAssemblyItem { Name = activity.Name, Version = System.Version.Parse(activity.Version) }; wfItem = DataContractTranslator.StoreActivitiyDCToWorkflowItem(activity, assembly, references); formatter.Serialize(stream, wfItem); } } catch (Exception ex)//net work exception { MarketplaceExceptionHandler.HandleSaveProjectsException(ex); } }
/// <summary> /// The assembly name local location location to activity library dc. /// </summary> /// <param name="aai"> /// The assemblyLocationItems. /// </param> /// <returns> /// Converted ActivityLibraryDC instance /// </returns> public static ActivityLibraryDC AssemblyItemToActivityLibraryDataContract(ActivityAssemblyItem aai) { var activityLibrary = new ActivityLibraryDC(); activityLibrary.Name = aai.AssemblyName.Name; activityLibrary.VersionNumber = aai.Version.ToString(); // TODO: remove these activityLibrary.Incaller = Utility.GetCallerName(); activityLibrary.IncallerVersion = Utility.GetCallerVersion(); activityLibrary.Guid = Guid.NewGuid(); activityLibrary.AuthGroupName = aai.AuthorityGroup; activityLibrary.CategoryName = aai.Category ?? "OAS Basic Controls"; activityLibrary.Category = Guid.Empty; activityLibrary.Executable = new byte[4]; activityLibrary.HasActivities = false; activityLibrary.ImportedBy = Utility.GetCurrentUserName(); activityLibrary.Description = aai.Description; activityLibrary.Status = 1; return activityLibrary; }
public bool Matches(ActivityAssemblyItem item) { return this.Name == item.Name && this.Version == item.Version; }
/// <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; }
/// <summary> /// The register metadata in assembly. /// </summary> /// <param name="assembly"> /// The assembly. /// </param> private static void RegisterMetadtaInAssembly(ActivityAssemblyItem activityAssemblyItem) { var allMetadataTypes = activityAssemblyItem.Assembly .GetAsManyTypesAsPossible(activityAssemblyItem) .Where(t => t.GetInterface("IRegisterMetadata") != null) .ToArray(); foreach (var type in allMetadataTypes) { object instance = Activator.CreateInstance(type, null); MethodInfo registerMethodInfo = type.GetMethod("Register"); registerMethodInfo.Invoke(instance, null); } }
private ActivityAssemblyItem GetActivityAssemblyItem(string activityLibraryName, string versionNumber) { Version version; ActivityAssemblyItem activityAssemblyItem = new ActivityAssemblyItem(); activityAssemblyItem.Assembly = null; activityAssemblyItem.AssemblyName = new AssemblyName(activityLibraryName); System.Version.TryParse(versionNumber, out version); activityAssemblyItem.Version = version; return activityAssemblyItem; }
private bool CheckIfConflict(ActivityAssemblyItem item) { if (item.Name == focusedWorkflow.Name) { MessageBoxService.CannotCheckAssemblyForItselfSelected(item.Name); return true; } ActivityAssemblyItem conflictAssembly = Assemblies.SingleOrDefault(a => a.UserSelected && a.Name == item.Name && a.Version != item.Version); if (conflictAssembly != null) { MessageBoxService.CannotCheckAssemblyForAnotherVersionSelected( item.Name, item.Version.ToString(), conflictAssembly.Version.ToString()); return true; } return false; }
private bool CheckIfAnyConflict(ActivityAssemblyItem item) { if (CheckIfConflict(item)) return true; bool hasConflicts = false; if (item.ReferencedAssemblies != null && item.ReferencedAssemblies.Count > 0) { foreach (AssemblyName assemblyName in item.ReferencedAssemblies) { if (!Utility.AssemblyIsBuiltIn(assemblyName)) { ActivityAssemblyItem refItem = Assemblies.Single(i => i.Name == assemblyName.Name && i.Version == assemblyName.Version); if (CheckIfConflict(refItem)) { hasConflicts = true; break; } } } } return hasConflicts; }
private void CheckAssemblyDependencies(ActivityAssemblyItem item) { if (item == null) { throw new ArgumentNullException(); } if (item.UserSelected) { if (CheckIfAnyConflict(item)) { item.UserSelected = false; } else { if (item.ReferencedAssemblies != null && item.ReferencedAssemblies.Count > 0) { foreach (AssemblyName assemblyName in item.ReferencedAssemblies) { if (!Utility.AssemblyIsBuiltIn(assemblyName)) { ActivityAssemblyItem refItem = Assemblies.Single(i => i.Name == assemblyName.Name && i.Version == assemblyName.Version); if (referencedAssemblies.ContainsKey(refItem)) { if (!referencedAssemblies[refItem].Contains(item)) referencedAssemblies[refItem].Add(item); } else { referencedAssemblies.Add(refItem, new[] { item }.ToList()); } refItem.UserSelected = true; } } } } } else { if (referencedAssemblies.ContainsKey(item) && referencedAssemblies[item].Any()) { MessageBoxService.CannotUncheckAssemblyForReferenced(item.AssemblyName, referencedAssemblies[item].Select(a => a.AssemblyName).ToArray()); item.UserSelected = true; } else { if (item.ReferencedAssemblies != null && item.ReferencedAssemblies.Count > 0) { foreach (AssemblyName assemblyName in item.ReferencedAssemblies) { if (!Utility.AssemblyIsBuiltIn(assemblyName)) { ActivityAssemblyItem refItem = Assemblies.Single(i => i.Name == assemblyName.Name && i.Version == assemblyName.Version); if (referencedAssemblies.ContainsKey(refItem)) referencedAssemblies[refItem].Remove(item); } } } } } }
/// <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); } }
private void OpenActivityFromServer(StoreActivitiesDC activity, bool ShouldDownloadDependencies, bool isTask = false) { StoreActivitiesDC selectedWorkflowDC; ActivityAssemblyItem assembly = null; string activityLibraryName; string version; selectedWorkflowDC = activity; if (selectedWorkflowDC != null) // will be null if user cancelled { activityLibraryName = selectedWorkflowDC.ActivityLibraryName; version = selectedWorkflowDC.ActivityLibraryVersion; assembly = new ActivityAssemblyItem { Name = activityLibraryName, Version = System.Version.Parse(version) }; List<ActivityAssemblyItem> references = new List<ActivityAssemblyItem>(); Utility.WithContactServerUI(() => { using (var client = WorkflowsQueryServiceUtility.GetWorkflowQueryServiceClient()) { List<ActivityAssemblyItem> referencedItems = Caching.ComputeDependencies(client, assembly); if (ShouldDownloadDependencies) { references = Caching.CacheAndDownloadAssembly(client, referencedItems); } else { references = Caching.Match(referencedItems); } } }); OpenStoreActivitiesDC(selectedWorkflowDC, assembly, references, isTask: isTask); } }
/// <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(); } } }
/// <summary> /// Resolve the references of an assembly using the assembly loader /// </summary> /// <param name="assemblyLoader">Assembly loader object created in the app domain</param> /// <param name="assemblyPath">Path to the assembly</param> /// <param name="assemblyVersion">Version of the assembly to search for</param> /// <param name="isRootAssembly">Indicates if the assembly to analize is the main assembly of this inspection.</param> /// <returns></returns> private void ResolveReferences(AssemblyLoader assemblyLoader, string assemblyPath, Version assemblyVersion, bool isRootAssembly) { try { //Load the assembly in subdomain to analyze it with reflection. ActivityAssemblyItem assemblyItem; assemblyLoader.LoadReflectedInfoInSubdomain(assemblyPath, out assemblyItem); //Store root assembly information to return it to the main app domain if (isRootAssembly) { sourceAssembly = assemblyItem; } else { referencedAssemblies.Add(assemblyItem); } //Add the list of references discovered through reflection //to analyze them as part of the import process. foreach (var item in assemblyItem.ReferencedAssemblies.Where(item => !AssemblyIsBuiltIn(item))) { if (!referencesToCheck.ContainsKey(Tuple.Create(item.Name, item.Version)) && (!analyzedReferences.ContainsKey(Tuple.Create(item.Name, item.Version)))) { referencesToCheck.Add(Tuple.Create(item.Name, item.Version), null); } } //if the inspection produced some references that were not resolved, add them too. if (assemblyLoader.ReferencedAssemblies.Any()) { foreach (var item in assemblyLoader.ReferencedAssemblies.Where(item => !AssemblyIsBuiltIn(item))) { if (!referencesToCheck.ContainsKey(Tuple.Create(item.Name, item.Version)) && (!analyzedReferences.ContainsKey(Tuple.Create(item.Name, item.Version)))) { referencesToCheck.Add(Tuple.Create(item.Name, item.Version), null); } } } } catch (FileNotFoundException ex) { // assemblyName was not found. throw new AssemblyInspectionException(ex.Message, ex); } catch (TypeLoadException ex) { //typeName was not found in assemblyName. throw new AssemblyInspectionException(ex.Message, ex); } catch (BadImageFormatException ex) { //assemblyName is not a valid assembly. throw new AssemblyInspectionException(ex.Message, ex); } catch (FileLoadException ex) { //An assembly or module was loaded twice with two different evidences. throw new AssemblyInspectionException(ex.Message, ex); } catch (PathTooLongException ex) { //An assembly or module was loaded twice with two different evidences. throw new AssemblyInspectionException(ex.Message, ex); } }
/// <summary> /// The activity library dc to activity assembly item. /// </summary> /// <param name="activityLibraryDC"> /// The activity library dc. /// </param> /// <param name="assemblyReferences"> /// Referenced assemblies for this ActivityLibraryDC. Use this parameter when you are actually downloading the library /// to cache and use, vs. just displaying it in a Select screen. It would be great if this info were actually part of /// ActivityLibraryDC but it isn't so we have to collect it separately. /// </param> /// <returns> /// Converted ActivityAssemblyItem instance /// </returns> public static ActivityAssemblyItem ActivityLibraryDCToActivityAssemblyItem(ActivityLibraryDC activityLibraryDC, IEnumerable<AssemblyName> assemblyReferences = null) { var activityAssemblyItem = new ActivityAssemblyItem(); Version version; activityAssemblyItem.ActivityItems = new ObservableCollection<ActivityItem>(); activityAssemblyItem.Assembly = null; activityAssemblyItem.AssemblyName = new AssemblyName(activityLibraryDC.Name); System.Version.TryParse(activityLibraryDC.VersionNumber, out version); activityAssemblyItem.Version = version; activityAssemblyItem.AuthorityGroup = activityLibraryDC.AuthGroupName; activityAssemblyItem.CachingStatus = CachingStatus.None; activityAssemblyItem.Category = activityLibraryDC.CategoryName; activityAssemblyItem.Description = activityLibraryDC.Description; activityAssemblyItem.DisplayName = activityLibraryDC.Name; activityAssemblyItem.Status = activityLibraryDC.StatusName; activityAssemblyItem.Tags = activityLibraryDC.MetaTags; if (assemblyReferences != null) { activityAssemblyItem.SetDatabaseReferences(assemblyReferences); } activityAssemblyItem.UserSelected = false; activityAssemblyItem.ReleaseNotes = activityLibraryDC.ReleaseNotes; activityAssemblyItem.FriendlyName = activityLibraryDC.FriendlyName; return activityAssemblyItem; }
/// <summary> /// Prevent adding multiple version of an activity in add-in /// </summary> /// <returns></returns> private static bool CheckVersionForConflict(ActivityAssemblyItem left, ActivityAssemblyItem right) { return left.Name == right.Name && left.Version != right.Version; }
/// <summary> /// The store activity dc to activity item. /// </summary> /// <param name="dc"> /// The StoreActivitiesDC data contract instance. /// </param> /// <param name="parentAssemblyItem"> /// The parent assembly item. /// </param> /// <returns> /// Converted ActivityItem instance /// </returns> public static ActivityItem StoreActivitiyDCToActivityItem( StoreActivitiesDC dc, ActivityAssemblyItem parentAssemblyItem) { var activityItem = new ActivityItem(); activityItem.CachingStatus = CachingStatus.None; activityItem.Category = dc.ActivityCategoryName; activityItem.CreateDateTime = dc.InsertedDateTime; activityItem.CreatedBy = dc.InsertedByUserAlias; activityItem.Description = dc.Description; activityItem.FullName = dc.Name; activityItem.Name = dc.ShortName ?? dc.Name; activityItem.DisplayName = dc.ShortName ?? dc.Name; activityItem.HasCodeBehind = dc.IsCodeBeside; activityItem.IsReadOnly = true; // TODO: Need to find out where this is in the Model activityItem.IsUserFavorite = false; // TODO: This needs to be added to the Database, DAL, BAL and/or DataContract reply activityItem.ParentAssemblyItem = parentAssemblyItem; activityItem.Status = dc.StatusCodeName; activityItem.UpdatedBy = dc.UpdatedByUserAlias; activityItem.UpdateDateTime = dc.UpdatedDateTime; activityItem.UserSelected = true; // TODO: Why is this set to true? activityItem.Version = activityItem.OldVersion = dc.Version; activityItem.XamlCode = dc.Xaml; return activityItem; }
private static bool CheckVersionForConflicts(IEnumerable<ActivityAssemblyItem> collection, ActivityAssemblyItem obj) { return (from c in collection where CheckVersionForConflict(c, obj) select c).Any(); }
/// <summary> /// Analizes an assembly (specified in the parameter), to discover all its references and /// the activities contained on it. /// </summary> /// <param name="assemblyPath">Path of the assembly to analize</param> public bool Inspect(string assemblyPath) { if (string.IsNullOrEmpty(assemblyPath)) { throw new ArgumentNullException("assemblyPath"); } //Create a new appdomain, so we don't load assemblies in the main app domain and //we can unload the assemblies from memory when the operation finishes. var appDomain = CreateTempAppDomain(AppDomain.CurrentDomain); // Setup var typeName = typeof(AssemblyLoader).FullName; var location = typeof(AssemblyLoader).Assembly.Location; if (!String.IsNullOrEmpty(typeName) && !String.IsNullOrEmpty(location)) { // Run computation and tear down AppDomain var subloader = (AssemblyLoader)appDomain.CreateInstanceFromAndUnwrap(location, typeName); try { ResolveReferences(subloader, assemblyPath, null, true); } catch (AssemblyInspectionException ex) { //Could not analyze the main assembly, so we encapsulate the exception to return it as a result. OperationException = ex; return false; } string directory = Path.GetDirectoryName(assemblyPath); while (referencesToCheck.Any()) { Tuple<string, Version> element = referencesToCheck.First().Key; string referenceName = element.Item1; string referencePath = referenceName+".dll"; //referenceName + ".dll"; string referenceVersion = element.Item2.ToString(); if (!string.IsNullOrEmpty(directory)) { //Look for the missing assembly in the selected location and the subfolders var matchesInDirectory = Directory.EnumerateFiles(directory, referencePath, SearchOption.AllDirectories); if (matchesInDirectory.Any()) { referencePath = Path.Combine(matchesInDirectory.First()); } else { //var matchesInTargetDirectory = Directory.EnumerateFiles(FileService.GetAssembliesDirectoryPath(), referencePath, SearchOption.AllDirectories); //if (matchesInTargetDirectory.Any()) //{ // referencePath = Path.Combine(matchesInDirectory.First()); //} referencePath = FileService.GetAssembliesDirectoryPath() + "\\" + referenceName + "\\" + referenceVersion + "\\" + referencePath; } } try { if (File.Exists(referencePath)) { ResolveReferences(subloader, referencePath, element.Item2, false); analyzedReferences.Add(element, referencePath); } else { analyzedReferences.Add(element, null); string name = Path.GetFileNameWithoutExtension(referencePath); if (!string.IsNullOrEmpty(name)) { var item = new ActivityAssemblyItem(new AssemblyName(name)) { Version = element.Item2 }; referencedAssemblies.Add(item); } } } catch (AssemblyInspectionException) { //Error resolving one reference, in this case we can continue the analysis because it's not the //main assembly being analyzed. We add the assembly with an empty location to the collection. analyzedReferences.Add(element, null); //Assembly is not the main element being analyzed, so we just add it with empty properties to the list //(the inspection should continue for the other references). string name = Path.GetFileNameWithoutExtension(referencePath); if (!string.IsNullOrEmpty(name)) { var item = new ActivityAssemblyItem(new AssemblyName(name)) { Version = element.Item2 }; referencedAssemblies.Add(item); } } referencesToCheck.Remove(element); } AppDomain.Unload(appDomain); } return true; }
/// <summary> /// Try to retrieve a cached assembly /// </summary> /// <param name="assemblyName"></param> /// <param name="cachedAssembly"></param> /// <returns></returns> public static bool LoadCachedAssembly(AssemblyName assemblyName,out ActivityAssemblyItem cachedAssembly) { return Utility.LoadCachedAssembly(ActivityAssemblyItems, assemblyName, out cachedAssembly); }