Example #1
0
        /// <summary>
        /// Creates the metadata layer.
        /// </summary>
        /// <param name="layerName">Name of the layer.</param>
        /// <param name="layerLevel">The layer level.</param>
        /// <returns>A <see cref="Pillar.Common.Metadata.MetadataLayer"/></returns>
        public MetadataLayer CreateMetadataLayer( string layerName, int layerLevel )
        {
            var entity = new MetadataLayer ( layerName, layerLevel );
            _metadataLayerRepository.MakePersistent ( entity );

            return entity;
        }
Example #2
0
        /// <summary>
        /// Creates the metadata layer.
        /// </summary>
        /// <param name="layerName">Name of the layer.</param>
        /// <param name="layerLevel">The layer level.</param>
        /// <returns>A <see cref="Pillar.Common.Metadata.MetadataLayer"/></returns>
        public MetadataLayer CreateMetadataLayer(string layerName, int layerLevel)
        {
            var entity = new MetadataLayer(layerName, layerLevel);

            _metadataLayerRepository.MakePersistent(entity);

            return(entity);
        }
Example #3
0
        /// <summary>
        /// Creates the metadata root.
        /// </summary>
        /// <param name="resourceName">Name of the resource.</param>
        /// <param name="metadataLayer">The metadata layer.</param>
        /// <returns>A <see cref="Pillar.Common.Metadata.IMetadata"/></returns>
        public IMetadata CreateMetadataRoot( string resourceName, MetadataLayer metadataLayer )
        {
            if ( metadataLayer == null )
            {
                throw new ArgumentNullException ( "metadataLayer" );
            }

            var metadataRoot = new MetadataRoot ( resourceName, metadataLayer.Id );
            _metadataRepository.MakePersistent ( metadataRoot );

            return metadataRoot;
        }
        private MetadataLayer CreateMetadataLayer(string layerName, int layerLevel)
        {
            using (var session = Store.OpenSession())
            {
                var metadataLayer = new MetadataLayer(layerName, layerLevel);

                session.Store(metadataLayer);
                session.SaveChanges();

                return metadataLayer;
            }
        }
Example #5
0
        /// <summary>
        /// Creates the metadata root.
        /// </summary>
        /// <param name="resourceName">Name of the resource.</param>
        /// <param name="metadataLayer">The metadata layer.</param>
        /// <returns>A <see cref="Pillar.Common.Metadata.IMetadata"/></returns>
        public IMetadata CreateMetadataRoot(string resourceName, MetadataLayer metadataLayer)
        {
            if (metadataLayer == null)
            {
                throw new ArgumentNullException("metadataLayer");
            }

            var metadataRoot = new MetadataRoot(resourceName, metadataLayer.Id);

            _metadataRepository.MakePersistent(metadataRoot);

            return(metadataRoot);
        }
        public void InitializeTestDataToRavenDb_Succeed()
        {
            var metadataLayer = new MetadataLayer ( "Default", 1 );
            using (var session = Store.OpenSession())
            {
                session.Store ( metadataLayer );
                session.SaveChanges ();
            }

            var metadataRoot = new MetadataRoot ( "Rem.Ria.PatientModule.Web.Common.PatientProfileDto", metadataLayer.Id );

            var firstNameNode = metadataRoot.AddChild ( "FirstName" );
            firstNameNode.MetadataItems = new List<IMetadataItem>
                                              {
                                                  new DisplayNameMetadataItem { Name = "The Patient's First Name" },
                                                  new ReadonlyMetadataItem { IsReadonly = true }
                                              };

            var middleNameNode = metadataRoot.AddChild ( "MiddleName" );
            middleNameNode.MetadataItems = new List<IMetadataItem>
                                               {
                                                   new HiddenMetadataItem { IsHidden = true }
                                               };

            var lastNameNode = metadataRoot.AddChild ( "LastName" );
            lastNameNode.MetadataItems = new List<IMetadataItem>
                                             {
                                                 new RequiredMetadataItem { IsRequired = true }
                                             };

            using ( var sesssion = Store.OpenSession() )
            {
                sesssion.Store ( metadataRoot );
                sesssion.SaveChanges ();
            }
        }
Example #7
0
        /// <summary>
        /// Destroys the metadata layer.
        /// </summary>
        /// <param name="metadataLayer">The metadata layer.</param>
        public void DestroyMetadataLayer( MetadataLayer metadataLayer )
        {
            Check.IsNotNull ( metadataLayer, "metadataLayer is required." );

            _metadataLayerRepository.MakeTransient ( metadataLayer );
        }
        private MetadataRoot CreateMetadataRoot(string resourceName, MetadataLayer metadataLayer)
        {
            using (IDocumentSession session = Store.OpenSession())
            {
                var metadata = new MetadataRoot ( resourceName, metadataLayer.Id );
                session.Store ( metadata );
                session.SaveChanges();

                return metadata;
            }
        }
        private MetadataLayer CreateMetadataLayer(string name)
        {
            using (IDocumentSession session = Store.OpenSession())
            {
                var metadataLayer = new MetadataLayer(name, 1);
                session.Store(metadataLayer);
                session.SaveChanges();

                return metadataLayer;
            }
        }
Example #10
0
        /// <summary>
        /// Destroys the metadata layer.
        /// </summary>
        /// <param name="metadataLayer">The metadata layer.</param>
        public void DestroyMetadataLayer(MetadataLayer metadataLayer)
        {
            Check.IsNotNull(metadataLayer, "metadataLayer is required.");

            _metadataLayerRepository.MakeTransient(metadataLayer);
        }
        public void DestroyMetadataLayer_WithCorrectMetadataLayer_MetadataLayerIsTransient()
        {
            bool isTransient = false;

            var metadataLayerRepository = new Mock<IMetadataLayerRepository>();
            metadataLayerRepository
                .Setup(a => a.MakeTransient(It.IsAny<MetadataLayer>()))
                .Callback(() => isTransient = true);
            var factory = new MetadataLayerFactory ( metadataLayerRepository.Object );
            var metadataLayer = new MetadataLayer ( "Default", 1 );

            factory.DestroyMetadataLayer ( metadataLayer );

            Assert.IsTrue(isTransient);
        }