public void Setup() { this.session = new Mock <ISession>(); this.assembler = new Assembler(this.uri); this.permissionService = new Mock <IPermissionService>(); this.session.Setup(x => x.PermissionService).Returns(this.permissionService.Object); this.thingDialogNavigationService = new Mock <IThingDialogNavigationService>(); this.panelNavigationService = new Mock <IPanelNavigationService>(); this.dropinfo = new Mock <IDropInfo>(); this.cache = this.assembler.Cache; this.sitedir = new SiteDirectory(Guid.NewGuid(), this.cache, this.uri); this.modelsetup = new EngineeringModelSetup(Guid.NewGuid(), this.cache, this.uri) { Name = "model" }; this.iterationsetup = new IterationSetup(Guid.NewGuid(), this.cache, this.uri); this.person = new Person(Guid.NewGuid(), this.cache, this.uri); this.domain = new DomainOfExpertise(Guid.NewGuid(), this.cache, this.uri) { Name = "domain" }; this.participant = new Participant(Guid.NewGuid(), this.cache, this.uri) { Person = this.person, SelectedDomain = this.domain }; this.sitedir.Model.Add(this.modelsetup); this.sitedir.Person.Add(this.person); this.sitedir.Domain.Add(this.domain); this.modelsetup.IterationSetup.Add(this.iterationsetup); this.modelsetup.Participant.Add(this.participant); this.model = new EngineeringModel(Guid.NewGuid(), this.cache, this.uri) { EngineeringModelSetup = this.modelsetup }; this.iteration = new Iteration(Guid.NewGuid(), this.cache, this.uri) { IterationSetup = this.iterationsetup }; this.model.Iteration.Add(this.iteration); this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.sitedir); this.session.Setup(x => x.ActivePerson).Returns(this.person); this.session.Setup(x => x.OpenIterations).Returns(new Dictionary <Iteration, Tuple <DomainOfExpertise, Participant> >()); this.session.Setup(x => x.Assembler).Returns(this.assembler); this.cache.TryAdd(new CacheKey(this.iteration.Iid, null), new Lazy <Thing>(() => this.iteration)); }
/// <summary> /// Retrieves all data necessary for the transfer of an iteration /// </summary> /// <param name="iteration">The <see cref="Iteration"/></param> /// <param name="siteDirectoryData">All SiteDirectory DTOs</param> /// <param name="zip">The zip file</param> /// <param name="siteDir">The <see cref="SiteDirectory"/> object</param> /// <returns>List of things relevant for a particular iteration</returns> private List <Thing> RetrieveIterationThings(CDP4Common.DTO.Iteration iteration, List <Thing> siteDirectoryData, ZipFile zip, CDP4Common.SiteDirectoryData.SiteDirectory siteDir) { var engineeringModelSetup = siteDir.Model.SingleOrDefault(x => x.IterationSetup.Any(y => y.IterationIid == iteration.Iid)); if (engineeringModelSetup == null) { throw new ArgumentException("Could not locate the engineeringModel setup information"); } // read engineeringmodel var engineeringModelFilePath = $"{engineeringModelSetup.EngineeringModelIid}.json"; var engineeringModelZipEntry = zip.Entries.SingleOrDefault(x => x.FileName.EndsWith(engineeringModelFilePath)); var returned = this.ReadInfoFromArchiveEntry(engineeringModelZipEntry, this.Credentials.Password); var iterationFilePath = $"{iteration.Iid}.json"; var iterationZipEntry = zip.Entries.SingleOrDefault(x => x.FileName.EndsWith(iterationFilePath)); returned.AddRange(this.ReadIterationArchiveEntry(iterationZipEntry, this.Credentials.Password)); // use the loaded sitedirectory information to determine the required model reference data library var modelRdl = engineeringModelSetup.RequiredRdl.Single(); // add the modelRdlDto to the returned collection to make sure it's content gets dereferenced if (returned.All(x => x.Iid != modelRdl.Iid)) { var modelRdlDto = siteDirectoryData.Single(x => x.Iid == modelRdl.Iid); returned.Add(modelRdlDto); } // based on engineering model setup load rdl chain var modelRdlFilePath = $"{modelRdl.Iid}.json"; var modelRdlZipEntry = zip.Entries.SingleOrDefault(x => x.FileName.EndsWith(modelRdlFilePath)); var modelRdlItems = this.ReadInfoFromArchiveEntry(modelRdlZipEntry, this.Credentials.Password); returned.AddRange(modelRdlItems); // load the reference data libraries as per the containment chain var requiredRdl = modelRdl.RequiredRdl; while (requiredRdl != null) { // add the rdlDto to the returned collection to make sure it's content gets dereferenced var requiredRdlDto = siteDirectoryData.Single(x => x.Iid == requiredRdl.Iid); returned.Add(requiredRdlDto); var siteRdlFilePath = $"{requiredRdl.Iid}.json"; var siteRdlZipEntry = zip.Entries.SingleOrDefault(x => x.FileName.EndsWith(siteRdlFilePath)); var siteRdlItems = this.ReadInfoFromArchiveEntry(siteRdlZipEntry, this.Credentials.Password); returned.AddRange(siteRdlItems); // set the requiredRdl for the next iteration requiredRdl = requiredRdl.RequiredRdl; } return(returned); }
/// <summary> /// Retrieves all data necessary for the transfer of a SRDL /// </summary> /// <param name="siteRdl">The <see cref="SiteReferenceDataLibrary"/></param> /// <param name="siteDirectoryData">All SiteDirectory DTOs</param> /// <param name="zip">The zip file</param> /// <param name="siteDir">The <see cref="SiteDirectory"/> object</param> /// <returns>List of things contained by the particular srdl</returns> private List <Thing> RetrieveSRDLThings(CDP4Common.DTO.SiteReferenceDataLibrary siteRdl, List <Thing> siteDirectoryData, ZipFile zip, CDP4Common.SiteDirectoryData.SiteDirectory siteDir) { var returned = new List <Thing>(); var srdl = siteDir.SiteReferenceDataLibrary.FirstOrDefault(s => s.Iid.Equals(siteRdl.Iid)); // load the reference data libraries as per the containment chain var requiredRdl = srdl; while (requiredRdl != null) { // add the rdlDto to the returned collection to make sure it's content gets dereferenced var requiredRdlDto = siteDirectoryData.Single(x => x.Iid == requiredRdl.Iid); returned.Add(requiredRdlDto); var siteRdlFilePath = $"{requiredRdl.Iid}.json"; var siteRdlZipEntry = zip.Entries.SingleOrDefault(x => x.FileName.EndsWith(siteRdlFilePath)); var siteRdlItems = this.ReadInfoFromArchiveEntry(siteRdlZipEntry, this.Credentials.Password); returned.AddRange(siteRdlItems); // set the requiredRdl for the next iteration requiredRdl = requiredRdl.RequiredRdl; } return(returned); }
/// <summary> /// Retrieves all data necessary for the transfer of a DomainOfExpertise /// </summary> /// <param name="domain">The <see cref="DomainOfExpertise"/></param> /// <param name="siteDirectoryData">All SiteDirectory DTOs</param> /// <param name="siteDir">The <see cref="SiteDirectory"/> object</param> /// <returns>List of things contained by the particular srdl</returns> private List <Thing> RetrieveDomainOfExpertiseThings(CDP4Common.DTO.DomainOfExpertise domain, List <Thing> siteDirectoryData, CDP4Common.SiteDirectoryData.SiteDirectory siteDir) { var returned = new List <Thing>(); // wipe categories to avoide potential RDL irresolvable loop domain.Category.Clear(); returned.Add(domain); foreach (var refThing in domain.Alias.ToList()) { var thingDto = siteDirectoryData.FirstOrDefault(s => s.Iid.Equals(refThing)) as CDP4Common.DTO.Alias; if (thingDto != null) { thingDto.ExcludedPerson.Clear(); thingDto.ExcludedDomain.Clear(); returned.Add(thingDto); } else { domain.Alias.Remove(refThing); } } foreach (var refThing in domain.HyperLink.ToList()) { var thingDto = siteDirectoryData.FirstOrDefault(s => s.Iid.Equals(refThing)) as CDP4Common.DTO.HyperLink; if (thingDto != null) { thingDto.ExcludedPerson.Clear(); thingDto.ExcludedDomain.Clear(); returned.Add(thingDto); } else { domain.HyperLink.Remove(refThing); } } domain.ExcludedPerson.Clear(); domain.ExcludedDomain.Clear(); foreach (var refThing in domain.Definition.ToList()) { var thingDto = siteDirectoryData.FirstOrDefault(s => s.Iid.Equals(refThing)) as CDP4Common.DTO.Definition; if (thingDto != null) { thingDto.ExcludedDomain.Clear(); thingDto.ExcludedPerson.Clear(); // remove citation due to possible irresolvable loop of references thingDto.Citation.Clear(); returned.Add(thingDto); } else { domain.ExcludedPerson.Remove(refThing); } } return(returned); }
/// <summary> /// Write all the <see cref="Operation"/>s from all the <see cref="OperationContainer"/>s asynchronously. /// </summary> /// <param name="operationContainers"> /// The provided <see cref="OperationContainer"/> to write /// </param> /// <param name="extensionFiles"> /// The path to the files that need to be uploaded. If <paramref name="extensionFiles"/> is null, then no files are to be uploaded /// </param> /// <returns> /// A list of <see cref="Thing"/>s that has been created or updated since the last Read or Write operation. /// </returns> public override Task <IEnumerable <Thing> > Write(IEnumerable <OperationContainer> operationContainers, IEnumerable <string> extensionFiles = null) { this.ValidateOperationContainers(operationContainers); CDP4Common.SiteDirectoryData.SiteDirectory siteDirectory = null; var iterations = new HashSet <CDP4Common.EngineeringModelData.Iteration>(); var siteReferenceDataLibraries = new HashSet <CDP4Common.SiteDirectoryData.SiteReferenceDataLibrary>(); var modelReferenceDataLibraries = new HashSet <CDP4Common.SiteDirectoryData.ModelReferenceDataLibrary>(); var domainOfExpertises = new HashSet <CDP4Common.SiteDirectoryData.DomainOfExpertise>(); var persons = new HashSet <CDP4Common.SiteDirectoryData.Person>(); var personRoles = new HashSet <CDP4Common.SiteDirectoryData.PersonRole>(); var participantRoles = new HashSet <CDP4Common.SiteDirectoryData.ParticipantRole>(); var organizations = new HashSet <CDP4Common.SiteDirectoryData.Organization>(); var engineeringModelSetups = new HashSet <CDP4Common.SiteDirectoryData.EngineeringModelSetup>(); var iterationSetups = new HashSet <CDP4Common.SiteDirectoryData.IterationSetup>(); foreach (var operationContainer in operationContainers) { var operation = operationContainer.Operations.First(x => x.ModifiedThing is CDP4Common.DTO.Iteration); var iterationDto = (CDP4Common.DTO.Iteration)operation.ModifiedThing; var iterationPoco = (CDP4Common.EngineeringModelData.Iteration)iterationDto.QuerySourceThing(); JsonFileDalUtils.AddIteration(iterationPoco, ref iterations); var iterationSetup = iterationPoco.IterationSetup; JsonFileDalUtils.AddIterationSetup(iterationSetup, ref iterationSetups); var iterationRequiredRls = iterationPoco.RequiredRdls; JsonFileDalUtils.AddReferenceDataLibraries(iterationRequiredRls, ref siteReferenceDataLibraries, ref modelReferenceDataLibraries); var engineeringModelSetup = (CDP4Common.SiteDirectoryData.EngineeringModelSetup)iterationSetup.Container; JsonFileDalUtils.AddEngineeringModelSetup(engineeringModelSetup, ref engineeringModelSetups); if (siteDirectory == null) { siteDirectory = (CDP4Common.SiteDirectoryData.SiteDirectory)engineeringModelSetup.Container; } // add the domains-of-expertise that are to be included in the File JsonFileDalUtils.AddDomainsOfExpertise(engineeringModelSetup, ref domainOfExpertises); // add the Persons that are to be included in the File JsonFileDalUtils.AddPersons(engineeringModelSetup, ref persons, ref personRoles, ref participantRoles, ref organizations); // add organizations that are referrenced by ReferencedSource JsonFileDalUtils.AddOrganizations(iterationRequiredRls, ref organizations); } var path = this.Session.Credentials.Uri.LocalPath; var prunedSiteDirectoryDtos = JsonFileDalUtils.CreateSiteDirectoryAndPrunedContainedThingDtos( siteDirectory, siteReferenceDataLibraries, domainOfExpertises, persons, personRoles, participantRoles, organizations, engineeringModelSetups, iterationSetups); var activePerson = JsonFileDalUtils.QueryActivePerson(this.Session.Credentials.UserName, siteDirectory); var exchangeFileHeader = this.FileHeader as ExchangeFileHeader ?? JsonFileDalUtils.CreateExchangeFileHeader(activePerson); try { using (var zipFile = new ZipFile()) { zipFile.Password = this.Session.Credentials.Password; this.WriteHeaderToZipFile(exchangeFileHeader, zipFile, path); this.WriteSiteDirectoryToZipFile(prunedSiteDirectoryDtos, zipFile, path); this.WriteSiteReferenceDataLibraryToZipFile(siteReferenceDataLibraries, zipFile, path); this.WriteModelReferenceDataLibraryToZipFile(modelReferenceDataLibraries, zipFile, path); this.WriteIterationsToZipFile(iterations, zipFile, path); this.WriteExtensionFilesToZipFile(extensionFiles, zipFile, path); } Logger.Info("Successfully exported the open session {1} to {0}.", path, this.Session.Credentials.Uri); } catch (Exception ex) { Logger.Error("Failed to export the open session to {0}. Error: {1}", path, ex.Message); } return(Task.FromResult(Enumerable.Empty <Thing>())); }