/// <inheritdoc />
        public virtual async Task <OperationContainer> ProcessAsync(OperationContainer operation, CancellationToken cancellationToken)
        {
            ArgumentGuard.NotNull(operation, nameof(operation));

            var primaryId = (TId)operation.Resource.GetTypedId();
            ISet <IIdentifiable> secondaryResourceIds = operation.GetSecondaryResources();

            await _service.AddToToManyRelationshipAsync(primaryId, operation.Request.Relationship.PublicName, secondaryResourceIds, cancellationToken);

            return(null);
        }
예제 #2
0
        protected override void DoFileInteraction(FileInfo fi)
        {
            if (!fi.Exists)
            {
                return;
            }

            OperationContainer container = new OperationContainer(Pawn);

            container.Load(fi);
            base.Close();
        }
        /// <summary>
        /// Computes a <see cref="OperationContainer"/> that contains update operations on value-sets
        /// </summary>
        /// <param name="context">
        /// The route of the <see cref="CDP4Common.DTO.SiteDirectory"/> or <see cref="Iteration"/> for which the current <see cref="OperationContainer"/> is valid.
        /// </param>
        /// <param name="dtos">The returned <see cref="Dto.Thing"/>s</param>
        /// <param name="copyThingMap">The copy map containing the original <see cref="Thing"/> associated to their copy</param>
        /// <returns>The <see cref="OperationContainer"/></returns>
        public OperationContainer CreateValueSetsUpdateOperations(string context, IEnumerable <Dto.Thing> dtos, IReadOnlyDictionary <Thing, Thing> copyThingMap)
        {
            var dtolist = dtos.ToList();

            var topContainer = dtolist.SingleOrDefault(x => x is Dto.TopContainer);

            if (topContainer == null)
            {
                throw new InvalidOperationException("No Top container were found in the returned list of dtos.");
            }

            // Gets the parameter base which value set shall be updated
            var copyParameterBases    = dtolist.OfType <Dto.ParameterBase>().ToList();
            var copyParameterBasesIds = copyParameterBases.Select(p => p.Iid).ToList();
            var valuesets             = dtolist.Where(dto => dto.ClassKind == ClassKind.ParameterValueSet ||
                                                      dto.ClassKind == ClassKind.ParameterSubscriptionValueSet ||
                                                      dto.ClassKind == ClassKind.ParameterOverrideValueSet).ToList();

            this.ComputeRoutes(valuesets, dtolist);
            var valueSetsClones = valuesets.Select(dto => dto.DeepClone <Dto.Thing>()).ToList();

            // The original of the copy are normally in the map
            var originalParameterBases = copyThingMap.Where(x => copyParameterBasesIds.Contains(x.Value.Iid)).ToList();

            // set the values
            foreach (var copyPair in originalParameterBases)
            {
                var copyId            = copyPair.Value.Iid;
                var originalParameter = (ParameterBase)copyPair.Key;
                var copyDto           = copyParameterBases.Single(x => x.Iid == copyId);

                // value sets to update
                var copyValueSets   = valueSetsClones.Where(x => copyDto.ValueSets.Contains(x.Iid)).ToList();
                var defaultValueSet = this.GetDefaultValueSet(originalParameter);
                if (defaultValueSet == null)
                {
                    continue;
                }

                this.SetValueSetValues(copyValueSets, defaultValueSet);
            }

            var operationContainer = new OperationContainer(context, topContainer.RevisionNumber);

            foreach (var valueSetsClone in valueSetsClones)
            {
                var valuesetToUpdate = valuesets.Single(x => x.Iid == valueSetsClone.Iid);
                var operation        = new Operation(valuesetToUpdate, valueSetsClone, OperationKind.Update);
                operationContainer.AddOperation(operation);
            }

            return(operationContainer);
        }
예제 #4
0
        private object GetRelationshipRightValue(OperationContainer operation)
        {
            RelationshipAttribute relationship = operation.Request.Relationship;
            object rightValue = relationship.GetValue(operation.Resource);

            if (relationship is HasManyAttribute)
            {
                ICollection <IIdentifiable> rightResources = _collectionConverter.ExtractResources(rightValue);
                return(rightResources.ToHashSet(IdentifiableComparer.Instance));
            }

            return(rightValue);
        }
        /// <inheritdoc />
        public virtual async Task <OperationContainer> ProcessAsync(OperationContainer operation,
                                                                    CancellationToken cancellationToken)
        {
            if (operation == null)
            {
                throw new ArgumentNullException(nameof(operation));
            }

            var resource = (TResource)operation.Resource;
            var updated  = await _service.UpdateAsync(resource.Id, resource, cancellationToken);

            return(updated == null ? null : operation.WithResource(updated));
        }
        protected virtual async Task <OperationContainer> ProcessOperationAsync(OperationContainer operation, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            TrackLocalIdsForOperation(operation);

            _targetedFields.Attributes    = operation.TargetedFields.Attributes;
            _targetedFields.Relationships = operation.TargetedFields.Relationships;

            _request.CopyFrom(operation.Request);

            return(await _operationProcessorAccessor.ProcessAsync(operation, cancellationToken));
        }
예제 #7
0
        private static object GetRelationshipRightValue(OperationContainer operation)
        {
            var relationship = operation.Request.Relationship;
            var rightValue   = relationship.GetValue(operation.Resource);

            if (relationship is HasManyAttribute)
            {
                var rightResources = TypeHelper.ExtractResources(rightValue);
                return(rightResources.ToHashSet(IdentifiableComparer.Instance));
            }

            return(rightValue);
        }
        /// <inheritdoc />
        public virtual async Task <OperationContainer> ProcessAsync(OperationContainer operation,
                                                                    CancellationToken cancellationToken)
        {
            if (operation == null)
            {
                throw new ArgumentNullException(nameof(operation));
            }

            var id = (TId)operation.Resource.GetTypedId();
            await _service.DeleteAsync(id, cancellationToken);

            return(null);
        }
예제 #9
0
        /// <inheritdoc />
        public virtual async Task <OperationContainer> ProcessAsync(OperationContainer operation,
                                                                    CancellationToken cancellationToken)
        {
            ArgumentGuard.NotNull(operation, nameof(operation));

            var    primaryId  = (TId)operation.Resource.GetTypedId();
            object rightValue = GetRelationshipRightValue(operation);

            await _service.SetRelationshipAsync(primaryId, operation.Request.Relationship.PublicName, rightValue,
                                                cancellationToken);

            return(null);
        }
예제 #10
0
        public void VerifyThatDryCopyDoesNotCopySubscriptionWithInactiveDomain()
        {
            this.permissionService.Setup(x => x.CanWrite(It.IsAny <ClassKind>(), It.IsAny <Thing>())).Returns(true);
            this.session.Setup(x => x.OpenIterations).Returns(
                new Dictionary <Iteration, Tuple <DomainOfExpertise, Participant> >
            {
                { this.iteration1, new Tuple <DomainOfExpertise, Participant>(domain1, null) },
                { this.iteration2, new Tuple <DomainOfExpertise, Participant>(domain1, null) }
            });
            this.subscription1.Owner = this.domain3;

            var iteration2Clone = this.iteration2.Clone(false);
            var defClone        = this.rootDef.Clone(false);

            defClone.Iid = Guid.NewGuid();
            iteration2Clone.Element.Add(defClone);

            var transactionContext = TransactionContextResolver.ResolveContext(this.iteration2);
            var context            = transactionContext.ContextRoute();

            var operationContainer = new OperationContainer(context, this.model2.RevisionNumber);

            operationContainer.AddOperation(new Operation(this.iteration2.ToDto(), iteration2Clone.ToDto(), OperationKind.Update));
            operationContainer.AddOperation(new Operation(this.rootDef.ToDto(), defClone.ToDto(), OperationKind.CopyDefaultValuesChangeOwner));

            var copyHandler = new CopyOperationHandler(this.session.Object);

            copyHandler.ModifiedCopyOperation(operationContainer);

            var operations = operationContainer.Operations.ToList();

            Assert.AreEqual(13, operations.Count);
            Assert.IsNotEmpty(operationContainer.Context); // check that operation container is correctly built

            var ownedThings =
                operationContainer.Operations.Select(x => x.ModifiedThing)
                .Where(x => x.ClassKind != ClassKind.ParameterSubscription)
                .OfType <Dto.IOwnedThing>()
                .ToList();

            var dtoOwner = ownedThings.Select(x => x.Owner).Distinct().Single();

            Assert.AreEqual(dtoOwner, this.domain1.Iid);

            var subCount =
                operationContainer.Operations.Select(x => x.ModifiedThing)
                .OfType <Dto.ParameterSubscription>().Count();

            Assert.AreEqual(0, subCount);
        }
        protected void TrackLocalIdsForOperation(OperationContainer operation)
        {
            if (operation.Kind == OperationKind.CreateResource)
            {
                DeclareLocalId(operation.Resource);
            }
            else
            {
                AssignStringId(operation.Resource);
            }

            foreach (var secondaryResource in operation.GetSecondaryResources())
            {
                AssignStringId(secondaryResource);
            }
        }
        /// <inheritdoc />
        public virtual async Task <OperationContainer> ProcessAsync(OperationContainer operation, CancellationToken cancellationToken)
        {
            ArgumentGuard.NotNull(operation, nameof(operation));

            TResource newResource = await _service.CreateAsync((TResource)operation.Resource, cancellationToken);

            if (operation.Resource.LocalId != null)
            {
                string          serverId        = newResource != null ? newResource.StringId : operation.Resource.StringId;
                ResourceContext resourceContext = _resourceContextProvider.GetResourceContext <TResource>();

                _localIdTracker.Assign(operation.Resource.LocalId, resourceContext.PublicName, serverId);
            }

            return(newResource == null ? null : operation.WithResource(newResource));
        }
예제 #13
0
        /// <inheritdoc />
        public virtual async Task <OperationContainer> ProcessAsync(OperationContainer operation,
                                                                    CancellationToken cancellationToken)
        {
            if (operation == null)
            {
                throw new ArgumentNullException(nameof(operation));
            }

            var primaryId            = (TId)operation.Resource.GetTypedId();
            var secondaryResourceIds = operation.GetSecondaryResources();

            await _service.AddToToManyRelationshipAsync(primaryId, operation.Request.Relationship.PublicName,
                                                        secondaryResourceIds, cancellationToken);

            return(null);
        }
        public void VerifyExecutionOfOperationAddAndRemove()
        {
            var elementDefinition = new ElementDefinition(Guid.NewGuid(), 0);

            elementDefinition.PartialRoutes.Add("iteration/b58ea73d-350d-4520-b9d9-a52c75ac2b5d");
            elementDefinition.PartialRoutes.Add("EngineeringModel/5e5dc7f8-833d-4331-b421-eb2c64fcf64b");

            var clone     = elementDefinition.DeepClone <ElementDefinition>();
            var operation = new Operation(elementDefinition, clone, OperationKind.Update);

            var operationContainer = new OperationContainer(this.iterationContext);

            operationContainer.AddOperation(operation);
            Assert.AreEqual(1, operationContainer.Operations.Count());

            operationContainer.RemoveOperation(operation);
            Assert.AreEqual(0, operationContainer.Operations.Count());
        }
예제 #15
0
        /// <summary>
        /// Executes the Ok Command
        /// </summary>
        private async void ExecuteOk()
        {
            this.IsBusy         = true;
            this.LoadingMessage = "Exporting...";

            try
            {
                var creds = new Credentials(this.selectedSession.Credentials.UserName, this.Password, new Uri(this.Path));

                // TODO: change this to allow (file) dal selection for export
                var dal         = this.dals.Single(x => x.Metadata.DalType == DalType.File);
                var dalInstance = (IDal)Activator.CreateInstance(dal.Value.GetType());

                var fileExportSession = new Session(dalInstance, creds);

                // create write
                var operationContainers = new List <OperationContainer>();

                // TODO: allow iteration setup selection by user
                var openIterations = this.selectedSession.OpenIterations.Select(x => x.Key);
                foreach (var iteration in openIterations)
                {
                    var transactionContext = TransactionContextResolver.ResolveContext(iteration);
                    var operationContainer = new OperationContainer(transactionContext.ContextRoute());
                    var dto       = iteration.ToDto();
                    var operation = new Operation(null, dto, OperationKind.Create);
                    operationContainer.AddOperation(operation);
                    operationContainers.Add(operationContainer);
                }

                var result = await dalInstance.Write(operationContainers);

                this.DialogResult = new BaseDialogResult(true);
            }
            catch (Exception ex)
            {
                this.ErrorMessage = ex.Message;
            }
            finally
            {
                this.IsBusy = false;
            }
        }
예제 #16
0
        public void VerifyThatWritingMultipleOperationContainersIsNotSupported()
        {
            var dal = new WspDal();

            this.SetDalToBeOpen(dal);

            var contextOne = $"/EngineeringModel/{Guid.NewGuid()}/iteration/{Guid.NewGuid()}";
            var contextTwo = $"/EngineeringModel/{Guid.NewGuid()}/iteration/{Guid.NewGuid()}";

            var operationContainerOne = new OperationContainer(contextOne);
            var operationContainerTwo = new OperationContainer(contextTwo);

            var operationContainers = new List <OperationContainer> {
                operationContainerOne, operationContainerTwo
            };

            Assert.Throws <NotSupportedException>(() => dal.Write(operationContainers));

            Assert.Throws <NotSupportedException>(() => dal.Write(operationContainers));
        }
예제 #17
0
        private void ValidateOperation(OperationContainer operation)
        {
            if (operation.Kind == OperationKind.CreateResource)
            {
                DeclareLocalId(operation.Resource);
            }
            else
            {
                AssertLocalIdIsAssigned(operation.Resource);
            }

            foreach (var secondaryResource in operation.GetSecondaryResources())
            {
                AssertLocalIdIsAssigned(secondaryResource);
            }

            if (operation.Kind == OperationKind.CreateResource)
            {
                AssignLocalId(operation);
            }
        }
        /// <summary>
        /// Modify the <see cref="OperationContainer"/> to compensate for operations
        /// that should be performed by the data-source but is not by the WSP.
        /// </summary>
        /// <param name="operationContainer">The <see cref="OperationContainer"/> to modify</param>
        public void ModifyOperationContainer(OperationContainer operationContainer)
        {
            var operationsToAdd = new List <Operation>();

            foreach (var operation in operationContainer.Operations)
            {
                if (operation.OperationKind == OperationKind.Update)
                {
                    var possibleStateList = operation.ModifiedThing as PossibleFiniteStateList;
                    if (possibleStateList != null)
                    {
                        operationsToAdd.AddRange(this.ModifyActualStateKindOnDefaultPossibleStateUpdate(possibleStateList));
                    }
                }
            }

            foreach (var operation in operationsToAdd)
            {
                operationContainer.AddOperation(operation);
            }
        }
예제 #19
0
        public void VerifyThatModifyShiftCopyOperationsWorks()
        {
            this.permissionService.Setup(x => x.CanWrite(It.IsAny <ClassKind>(), It.IsAny <Thing>())).Returns(true);
            this.session.Setup(x => x.OpenIterations).Returns(
                new Dictionary <Iteration, Tuple <DomainOfExpertise, Participant> >
            {
                { this.iteration1, new Tuple <DomainOfExpertise, Participant>(domain1, null) },
                { this.iteration2, new Tuple <DomainOfExpertise, Participant>(domain2, null) }
            });

            var iteration2Clone = this.iteration2.Clone(false);
            var defClone        = this.rootDef.Clone(false);

            defClone.Iid = Guid.NewGuid();
            iteration2Clone.Element.Add(defClone);


            var transactionContext = TransactionContextResolver.ResolveContext(this.iteration2);
            var context            = transactionContext.ContextRoute();

            var operationContainer = new OperationContainer(context, this.model2.RevisionNumber);

            operationContainer.AddOperation(new Operation(this.iteration2.ToDto(), iteration2Clone.ToDto(), OperationKind.Update));
            operationContainer.AddOperation(new Operation(this.rootDef.ToDto(), defClone.ToDto(), OperationKind.Copy));

            var copyHandler = new CopyOperationHandler(this.session.Object);

            copyHandler.ModifiedCopyOperation(operationContainer);

            var operations = operationContainer.Operations.ToList();

            Assert.IsNotEmpty(operationContainer.Context);
            Assert.AreEqual(14, operations.Count);

            var operation = operations.Single(x => x.OperationKind == OperationKind.Update);
            var iteration = (CDP4Common.DTO.Iteration)operation.ModifiedThing;

            Assert.AreEqual(3, iteration.Element.Count);
        }
        /// <summary>
        /// Creates <see cref="HttpContent"/> that is added to a POST request
        /// </summary>
        /// <param name="token">
        /// The POST token that is used to track the POST request in a logger
        /// </param>
        /// <param name="operationContainer">
        /// The <see cref="OperationContainer"/> that contains the <see cref="Operation"/>s that are part of
        /// the transaction that is sent to the DAL
        /// </param>
        /// <param name="files">
        /// A list of file-paths that is used to construct the <see cref="MultipartFormDataContent"/>
        /// </param>
        /// <returns>
        /// An instance of <see cref="StringContent"/> or <see cref="MultipartFormDataContent"/>
        /// </returns>
        private HttpContent CreateHttpContent(string token, OperationContainer operationContainer, IEnumerable <string> files = null)
        {
            var stream = new MemoryStream();

            this.ConstructPostRequestBodyStream(token, operationContainer, stream);
            var jsonContent = new StreamContent(stream);

            jsonContent.Headers.Add(Headers.ContentType, "application/json");
            jsonContent.Headers.Add(Headers.CDPToken, token);

            if (files == null)
            {
                return(jsonContent);
            }
            else
            {
                var multipartContent = new MultipartFormDataContent();
                multipartContent.Add(jsonContent);

                foreach (var file in files)
                {
                    var fileName = Path.GetFileName(file);

                    using (var filestream = System.IO.File.OpenRead(file))
                    {
                        var contentStream = new MemoryStream();
                        filestream.CopyTo(contentStream);
                        contentStream.Position = 0;

                        var fileContent = new StreamContent(contentStream);
                        fileContent.Headers.Add("Content-Type", "application/octet-stream");
                        fileContent.Headers.Add("Content-Disposition", $"attachment; filename=\"{fileName}\"");
                        multipartContent.Add(fileContent);
                    }
                }

                return(multipartContent);
            }
        }
        /// <summary>
        /// Modify the <see cref="OperationContainer"/> if it contains copy <see cref="Operation"/>
        /// </summary>
        /// <param name="operationContainer">The <see cref="OperationContainer"/> to modify</param>
        public void ModifiedCopyOperation(OperationContainer operationContainer)
        {
            var operationsToAdd = new List <Operation>();

            var copyOperationCount = operationContainer.Operations.Count(x => x.OperationKind.IsCopyOperation());

            if (copyOperationCount > 1)
            {
                // TODO: support this if needed
                throw new NotSupportedException("Only one copy operation per transaction is supported.");
            }

            var copyOperation = operationContainer.Operations.SingleOrDefault(x => x.OperationKind.IsCopyOperation());

            if (copyOperation == null)
            {
                return;
            }

            this.ComputeOperations(copyOperation);
            operationsToAdd.AddRange(this.operations);

            foreach (var operation in operationsToAdd)
            {
                operationContainer.AddOperation(operation);
            }

            // remove the copy operations
            operationContainer.RemoveOperation(copyOperation);

            // update the update iteration operation
            var iterationOperation = operationContainer.Operations.Single(x => x.OperationKind == OperationKind.Update);
            var updatedIteration   = iterationOperation.ModifiedThing.QuerySourceThing();
            var originalIteration  = iterationOperation.OriginalThing.QuerySourceThing();

            operationContainer.RemoveOperation(iterationOperation);
            operationContainer.AddOperation(new Operation(originalIteration.ToDto(), updatedIteration.ToDto(), OperationKind.Update));
        }
예제 #22
0
        public void ShowDialog(OperationContainer parent)
        {
            if (parent == null)
            {
                return;
            }

            this.parent = parent;
            this.Text   = parent.Name;
            Changed     = false;

            FillCollections(parent.Language);
            FillMembersList();
            if (lstMembers.Items.Count > 0)
            {
                lstMembers.Items[0].Focused  = true;
                lstMembers.Items[0].Selected = true;
            }

            toolNewField.Visible = (parent is IFieldAllower);

            if (parent.Language == Language.CSharp)
            {
                accessOrder   = csharpAccessOrder;
                modifierOrder = csharpModifierOrder;
            }
            else
            {
                accessOrder   = javaAccessOrder;
                modifierOrder = javaModifierOrder;
            }

            errorProvider.SetError(txtSyntax, null);
            errorProvider.SetError(txtName, null);
            errorProvider.SetError(cboType, null);

            base.ShowDialog();
        }
예제 #23
0
        public async Task Verify_that_person_can_be_Posted()
        {
            var uri         = new Uri("http://ocdt-dev.rheagroup.com");
            var credentials = new Credentials("admin", "pass", uri);

            var wspdal = new WspDal();
            var dtos   = await wspdal.Open(credentials, this.cancelationTokenSource.Token);

            var siteDirectory = (CDP4Common.DTO.SiteDirectory)dtos.Single(x => x.ClassKind == ClassKind.SiteDirectory);

            var context            = siteDirectory.Route;
            var operationContainer = new OperationContainer(context, siteDirectory.RevisionNumber);

            var person = new CDP4Common.DTO.Person(Guid.NewGuid(), 1);

            person.ShortName = Guid.NewGuid().ToString();
            person.Surname   = Guid.NewGuid().ToString();
            person.GivenName = Guid.NewGuid().ToString();
            person.AddContainer(ClassKind.SiteDirectory, Guid.Parse("eb77f3e1-a0f3-412d-8ed6-b8ce881c0145"));

            var operation1 = new Operation(null, person, OperationKind.Create);

            operationContainer.AddOperation(operation1);

            var siteDirectoryClone = siteDirectory.DeepClone <CDP4Common.DTO.SiteDirectory>();

            siteDirectoryClone.Person.Add(person.Iid);
            var operation2 = new Operation(siteDirectory, siteDirectoryClone, OperationKind.Update);

            operationContainer.AddOperation(operation2);

            var result = await wspdal.Write(operationContainer);

            var resultPerson = (CDP4Common.DTO.Person)result.Single(x => x.Iid == person.Iid);

            Assert.NotNull(resultPerson);
        }
예제 #24
0
        /// <summary>
        /// Write all the <see cref="Operation"/>s from an <see cref="OperationContainer"/> asynchronously.
        /// </summary>
        /// <param name="operationContainer">
        /// The provided <see cref="OperationContainer"/> to write
        /// </param>
        /// <param name="files">List of file paths for files to be sent to the datastore</param>
        /// <returns>
        /// an await-able <see cref="Task"/>
        /// </returns>
        public async Task Write(OperationContainer operationContainer, IEnumerable <string> files)
        {
            if (this.ActivePerson == null)
            {
                throw new InvalidOperationException("The Write operation cannot be performed when the ActivePerson is null; The Open method must be called prior to performing a Write.");
            }

            var filesList = files?.ToList();

            if (filesList != null && filesList.Any())
            {
                foreach (var file in filesList)
                {
                    if (!System.IO.File.Exists(file))
                    {
                        throw new FileNotFoundException($"File {file} was not found.");
                    }
                }
            }

            var eventArgs = new BeforeWriteEventArgs(operationContainer, filesList);

            this.BeforeWrite?.Invoke(this, eventArgs);

            if (eventArgs.Cancelled)
            {
                throw new OperationCanceledException("The Write operation was canceled.");
            }

            this.Dal.Session = this;
            var dtoThings = await this.Dal.Write(operationContainer, filesList);

            var enumerable = dtoThings as IList <CDP4Common.DTO.Thing> ?? dtoThings.ToList();

            await this.AfterReadOrWriteOrUpdate(enumerable);
        }
예제 #25
0
        public async Task VerifyThatFileCanBeUploaded()
        {
            this.dal = new WspDal {
                Session = this.session
            };

            var filename  = @"TestData\testfile.pdf";
            var directory = TestContext.CurrentContext.TestDirectory;
            var filepath  = Path.Combine(directory, filename);
            var files     = new List <string> {
                filepath
            };

            var contentHash = "F73747371CFD9473C19A0A7F99BCAB008474C4CA";
            var uri         = new Uri("https://cdp4services-test.cdp4.org");

            this.credentials = new Credentials("admin", "pass", uri);

            var returned = await this.dal.Open(this.credentials, this.cancelationTokenSource.Token);

            var engineeringModeliid  = Guid.Parse("9ec982e4-ef72-4953-aa85-b158a95d8d56");
            var iterationiid         = Guid.Parse("e163c5ad-f32b-4387-b805-f4b34600bc2c");
            var domainFileStoreIid   = Guid.Parse("da7dddaa-02aa-4897-9935-e8d66c811a96");
            var fileIid              = Guid.NewGuid();
            var fileRevisionIid      = Guid.NewGuid();
            var domainOfExpertiseIid = Guid.Parse("0e92edde-fdff-41db-9b1d-f2e484f12535");
            var fileTypeIid          = Guid.Parse("b16894e4-acb5-4e81-a118-16c00eb86d8f"); //PDF
            var participantIid       = Guid.Parse("284334dd-e8e5-42d6-bc8a-715c507a7f02");

            var originalDomainFileStore = new CDP4Common.DTO.DomainFileStore(domainFileStoreIid, 0);

            originalDomainFileStore.AddContainer(ClassKind.Iteration, iterationiid);
            originalDomainFileStore.AddContainer(ClassKind.EngineeringModel, engineeringModeliid);

            var modifiedDomainFileStore = new CDP4Common.DTO.DomainFileStore(domainFileStoreIid, 0);

            modifiedDomainFileStore.File.Add(fileIid);
            modifiedDomainFileStore.AddContainer(ClassKind.Iteration, iterationiid);
            modifiedDomainFileStore.AddContainer(ClassKind.EngineeringModel, engineeringModeliid);

            var file = new CDP4Common.DTO.File(fileIid, 0)
            {
                Owner = domainOfExpertiseIid
            };

            file.FileRevision.Add(fileRevisionIid);
            file.AddContainer(ClassKind.DomainFileStore, domainFileStoreIid);
            file.AddContainer(ClassKind.Iteration, iterationiid);
            file.AddContainer(ClassKind.EngineeringModel, engineeringModeliid);

            var fileRevision = new CDP4Common.DTO.FileRevision(fileRevisionIid, 0);

            fileRevision.Name        = "testfile";
            fileRevision.ContentHash = contentHash;
            fileRevision.FileType.Add(new OrderedItem()
            {
                K = 1, V = fileTypeIid
            });
            fileRevision.Creator = participantIid;
            fileRevision.AddContainer(ClassKind.File, fileIid);
            fileRevision.AddContainer(ClassKind.DomainFileStore, domainFileStoreIid);
            fileRevision.AddContainer(ClassKind.Iteration, iterationiid);
            fileRevision.AddContainer(ClassKind.EngineeringModel, engineeringModeliid);

            var context            = $"/EngineeringModel/{engineeringModeliid}/iteration/{iterationiid}";
            var operationContainer = new OperationContainer(context);

            var updateCommonFileStoreOperation = new Operation(originalDomainFileStore, modifiedDomainFileStore, OperationKind.Update);

            operationContainer.AddOperation(updateCommonFileStoreOperation);

            var createFileOperation = new Operation(null, file, OperationKind.Create);

            operationContainer.AddOperation(createFileOperation);

            var createFileRevisionOperation = new Operation(null, fileRevision, OperationKind.Create);

            operationContainer.AddOperation(createFileRevisionOperation);

            Assert.DoesNotThrowAsync(async() => await dal.Write(operationContainer, files));
        }
예제 #26
0
        public void VerifyThatWSPPostBodyIsCorrectlyResolves()
        {
            var siteDirecortoryIid   = Guid.Parse("f289023d-41e8-4aaf-aae5-1be1ecf24bac");
            var domainOfExpertiseIid = Guid.NewGuid();

            var context            = "/SiteDirectory/f289023d-41e8-4aaf-aae5-1be1ecf24bac";
            var operationContainer = new OperationContainer(context);

            var testDtoOriginal = new CDP4Common.DTO.Alias(iid: Guid.NewGuid(), rev: 1)
            {
                Content      = "content",
                IsSynonym    = false,
                LanguageCode = "en",
            };

            testDtoOriginal.AddContainer(ClassKind.DomainOfExpertise, domainOfExpertiseIid);
            testDtoOriginal.AddContainer(ClassKind.SiteDirectory, siteDirecortoryIid);

            var testDtoModified = new CDP4Common.DTO.Alias(iid: testDtoOriginal.Iid, rev: 1)
            {
                Content      = "content2",
                IsSynonym    = true,
                LanguageCode = "en",
            };

            testDtoModified.AddContainer(ClassKind.DomainOfExpertise, domainOfExpertiseIid);
            testDtoModified.AddContainer(ClassKind.SiteDirectory, siteDirecortoryIid);

            var testDtoOriginal2 = new CDP4Common.DTO.Definition(iid: Guid.NewGuid(), rev: 1)
            {
                Content      = "somecontent",
                LanguageCode = "en",
            };

            testDtoOriginal2.AddContainer(ClassKind.DomainOfExpertise, domainOfExpertiseIid);
            testDtoOriginal2.AddContainer(ClassKind.SiteDirectory, siteDirecortoryIid);

            var testDtoModified2 = new CDP4Common.DTO.Definition(iid: testDtoOriginal2.Iid, rev: 1)
            {
                Content      = "somecontent2",
                LanguageCode = "en",
            };

            testDtoModified2.AddContainer(ClassKind.DomainOfExpertise, domainOfExpertiseIid);
            testDtoModified2.AddContainer(ClassKind.SiteDirectory, siteDirecortoryIid);

            testDtoModified2.Citation.Add(Guid.NewGuid());
            testDtoModified2.Citation.Add(Guid.NewGuid());
            testDtoModified2.Citation.Add(Guid.NewGuid());
            testDtoModified2.Citation.Add(Guid.NewGuid());

            testDtoOriginal2.Citation.Add(testDtoModified2.Citation[0]);
            testDtoOriginal2.Citation.Add(testDtoModified2.Citation[1]);
            testDtoOriginal2.Citation.Add(testDtoModified2.Citation[2]);

            testDtoModified2.Citation.Remove(testDtoModified2.Citation[1]);

            testDtoOriginal2.Note.Add(new OrderedItem()
            {
                K = 1234,
                V = Guid.NewGuid()
            });

            testDtoOriginal2.Note.Add(new OrderedItem()
            {
                K = 2345,
                V = Guid.NewGuid()
            });

            testDtoModified2.Note.Add(new OrderedItem()
            {
                K = 234,
                V = Guid.NewGuid()
            });

            testDtoModified2.Note.Add(new OrderedItem()
            {
                K = 2346,
                V = testDtoOriginal2.Note[1].V
            });

            // make a few operations
            var operation1 = new Operation(null, testDtoModified, OperationKind.Create);
            var operation2 = new Operation(null, testDtoModified, OperationKind.Delete);
            var operation3 = new Operation(testDtoOriginal, testDtoModified, OperationKind.Update);
            var operation4 = new Operation(testDtoOriginal2, testDtoModified2, OperationKind.Update);

            operationContainer.AddOperation(operation1);
            operationContainer.AddOperation(operation2);
            operationContainer.AddOperation(operation3);
            operationContainer.AddOperation(operation4);

            var stream = new MemoryStream();

            this.dal.ConstructPostRequestBodyStream(string.Empty, operationContainer, stream);

            Assert.AreNotEqual(0, stream.Length);
        }
        /// <summary>
        /// Write all the <see cref="Operation"/>s from an <see cref="OperationContainer"/> asynchronously.
        /// </summary>
        /// <param name="operationContainer">
        /// The provided <see cref="OperationContainer"/> to write
        /// </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 async Task <IEnumerable <Thing> > Write(OperationContainer operationContainer, IEnumerable <string> files = null)
        {
            if (this.Credentials == null || this.Credentials.Uri == null)
            {
                throw new InvalidOperationException("The CDP4 DAL is not open.");
            }

            if (operationContainer == null)
            {
                throw new ArgumentNullException(nameof(operationContainer), $"The {nameof(operationContainer)} may not be null");
            }

            if (operationContainer.Operations.Count() == 0)
            {
                Logger.Debug("The operationContainer is empty, no round trip to the datasource is made");
                return(Enumerable.Empty <Thing>());
            }

            var watch = Stopwatch.StartNew();

            var result = new List <Thing>();

            if (files != null && files.Any())
            {
                this.OperationContainerFileVerification(operationContainer, files);
            }

            var attribute = new QueryAttributes
            {
                RevisionNumber = operationContainer.TopContainerRevisionNumber
            };

            var postToken    = operationContainer.Token;
            var resourcePath = $"{operationContainer.Context}{attribute}";

            var uriBuilder = this.GetUriBuilder(this.Credentials.Uri, ref resourcePath);

            Logger.Debug("Resource Path {0}: {1}", postToken, resourcePath);
            Logger.Debug("CDP4 Services POST: {0} - {1}", postToken, uriBuilder);

            var requestContent = this.CreateHttpContent(postToken, operationContainer, files);

            var requestsw = Stopwatch.StartNew();

            using (var httpResponseMessage = await this.httpClient.PostAsync(resourcePath, requestContent))
            {
                Logger.Info("CDP4 Services responded in {0} [ms] to POST {1}", requestsw.ElapsedMilliseconds, postToken);
                requestsw.Stop();

                if (httpResponseMessage.StatusCode != HttpStatusCode.OK)
                {
                    var errorResponse = await httpResponseMessage.Content.ReadAsStringAsync();

                    var msg = $"The CDP4 Services replied with code {httpResponseMessage.StatusCode}: {httpResponseMessage.ReasonPhrase}: {errorResponse}";
                    Logger.Error(msg);
                    throw new DalWriteException(msg);
                }

                this.ProcessHeaders(httpResponseMessage);

                using (var resultStream = await httpResponseMessage.Content.ReadAsStreamAsync())
                {
                    result.AddRange(this.Serializer.Deserialize(resultStream));

                    Guid iterationId;
                    if (this.TryExtractIterationIdfromUri(httpResponseMessage.RequestMessage.RequestUri, out iterationId))
                    {
                        this.SetIterationContainer(result, iterationId);
                    }
                }
            }

            watch.Stop();
            Logger.Info("Write Operation completed in {0} [ms]", watch.ElapsedMilliseconds);

            return(result);
        }
        public void VerifyThatCreatingOverrideCreateSubscriptions()
        {
            var domain1 = new CDP4Common.SiteDirectoryData.DomainOfExpertise(Guid.NewGuid(), this.assembler.Cache,
                                                                             this.uri);
            var domain2 = new CDP4Common.SiteDirectoryData.DomainOfExpertise(Guid.NewGuid(), this.assembler.Cache,
                                                                             this.uri);
            var model      = new EngineeringModel(Guid.NewGuid(), this.assembler.Cache, this.uri);
            var iteration  = new Iteration(Guid.NewGuid(), this.assembler.Cache, this.uri);
            var elementDef = new ElementDefinition(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                Owner = domain1
            };
            var defForUsage = new ElementDefinition(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                Owner = domain1
            };
            var usage = new ElementUsage(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                ElementDefinition = defForUsage
            };

            var parameter = new Parameter(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                Owner = domain1
            };
            var parameterSubscription = new ParameterSubscription(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                Owner = domain2
            };

            parameter.ParameterSubscription.Add(parameterSubscription);

            this.assembler.Cache.TryAdd(new CacheKey(parameter.Iid, iteration.Iid), new Lazy <Thing>(() => parameter));
            this.assembler.Cache.TryAdd(new CacheKey(parameterSubscription.Iid, iteration.Iid), new Lazy <Thing>(() => parameterSubscription));
            this.assembler.Cache.TryAdd(new CacheKey(usage.Iid, iteration.Iid), new Lazy <Thing>(() => usage));

            var parameterOverride = new ParameterOverride(Guid.NewGuid(), this.assembler.Cache, this.uri)
            {
                Owner     = domain1,
                Parameter = parameter
            };

            usage.ParameterOverride.Add(parameterOverride);

            model.Iteration.Add(iteration);
            iteration.Element.Add(elementDef);
            iteration.Element.Add(defForUsage);
            elementDef.ContainedElement.Add(usage);
            defForUsage.Parameter.Add(parameter);

            var transactionContext = TransactionContextResolver.ResolveContext(iteration);
            var context            = transactionContext.ContextRoute();

            var operationContainer = new OperationContainer(context, model.RevisionNumber);

            operationContainer.AddOperation(new Operation(null, parameterOverride.ToDto(), OperationKind.Create));
            operationContainer.AddOperation(new Operation(usage.ToDto(), usage.ToDto(), OperationKind.Update));

            var modifier = new OperationModifier(this.session.Object);

            modifier.ModifyOperationContainer(operationContainer);

            Assert.AreEqual(3, operationContainer.Operations.Count());
        }
예제 #29
0
		private void AdornOperationContainer (OperationContainer container, ITextSnapshot snapshot, LineMap lineMap, CancellationToken cancelToken)
		{
			foreach (Operation operation in container.Operations)
			{
				SnapshotSpan span;
				if (!lineMap.TryGetSpan (this.view.TextSnapshot, operation.Id, out span))
					continue;

				Geometry g = this.view.TextViewLines.GetMarkerGeometry (span);
				if (g == null)
					continue;

				Type opType = operation.GetType();

				OperationVisuals vs;
				if (!Mapping.TryGetValue (opType, out vs))
					continue;

				ViewCache viewCache;
				if (!views.TryGetValue (opType, out viewCache))
					views[opType] = viewCache = new ViewCache (vs);

				InstantView adorner;
				bool preexisted = viewCache.TryGetView (out adorner);
				if (!preexisted)
				{
					adorner.FontSize = FontSize - 1;
					adorner.FontFamily = FontFamily;
					adorner.BorderBrush = BorderBrush;
					adorner.Foreground = Foreground;
				}

				adorner.Tag = operation.Id;

				OperationViewModel model = adorner.DataContext as OperationViewModel;
				if (model == null)
					adorner.DataContext = model = vs.CreateViewModel();

				model.Operation = operation;

				if (operation is Loop)
				{
					var loopModel = (LoopViewModel)model;

					LoopIteration[] iterations = loopModel.Iterations;
					if (!preexisted || loopModel.Iteration > iterations.Length)
						loopModel.Iteration = iterations.Length;

					if (!preexisted)
						loopModel.IterationChanged += OnIterationChanged;

					if (iterations.Length > 0)
						AdornOperationContainer (iterations[loopModel.Iteration - 1], snapshot, lineMap, cancelToken);
				}

				Canvas.SetLeft (adorner, g.Bounds.Right + 10);
				Canvas.SetTop (adorner, g.Bounds.Top + 1);
				adorner.Height = g.Bounds.Height - 2;
				adorner.MaxHeight = g.Bounds.Height - 2;

				if (!preexisted)
					this.layer.AddAdornment (AdornmentPositioningBehavior.TextRelative, span, null, adorner, OperationAdornerRemoved);
			}
		}
예제 #30
0
 internal void TestOperationContainerFileVerification(OperationContainer operationContainer, IEnumerable <string> files)
 {
     this.OperationContainerFileVerification(operationContainer, files);
 }
예제 #31
0
 public override Task <IEnumerable <Thing> > Write(OperationContainer operationContainer, IEnumerable <string> files = null)
 {
     throw new NotImplementedException();
 }
예제 #32
0
        private void AdornOperationContainer(OperationContainer container, IDictionary<int, int> lineMap, AdornerLayer layer)
        {
            foreach (Operation operation in container.Operations)
            {
                int ln;
                if (!lineMap.TryGetValue (operation.Id, out ln))
                    continue;

                ln -= 1;

                int ch = GetCharacterIndexFromLineIndex (ln);
                int len = GetLineLength (ln);
                var endRect = GetRectFromCharacterIndex (ch + len - 1, true);

                Adorner adorner = null;

                if (operation is Loop)
                {
                    var loop = (Loop)operation;

                    int iteration;
                    if (!this.currentIterations.TryGetValue (loop.Id, out iteration))
                        iteration = 0;

                    var loopadorner = new LoopAdorner (this, loop);
                    if (iteration >= loopadorner.Iterations.Length)
                        this.currentIterations[loop.Id] = iteration = 0;

                    loopadorner.CurrentIteration = iteration;
                    loopadorner.IterationChanged += (s, e) =>
                    {
                        this.currentIterations[loop.Id] = loopadorner.CurrentIteration;
                        OnMethodCallChanged();
                    };

                    adorner = loopadorner;

                    if (loopadorner.Iterations.Length > 0)
                        AdornOperationContainer (loopadorner.Iterations[iteration], lineMap, layer);
                }
                else if (operation is StateChange)
                {
                    adorner = new StateChangeAdorner (this, (StateChange)operation);
                }
                else if (operation is ReturnValue)
                {
                    adorner = new ReturnAdorner (this, (ReturnValue)operation);
                }

                if (adorner != null)
                {
                    double delta = endRect.Height - (endRect.Height * 0.8);

                    adorner.Margin = new Thickness (endRect.X + 2, endRect.Y + (delta / 2), 0, 0);
                    adorner.MaxHeight = endRect.Height;

                    this.adorners.Add (operation.Id, adorner);
                    layer.Add (adorner);
                }
            }
        }