Example #1
0
 public void UpdateMetadata(MetadataModel metadata)
 {
     if (!metadata.Title.TrimHasValue())
     {
         metadata.Title = Gallery.Title;
     }
     if (!metadata.Description.TrimHasValue())
     {
         if (Gallery.Abstract.TrimHasValue())
         {
             metadata.Description = Gallery.Abstract;
         }
         else
         {
             metadata.Description = Gallery.Title;
         }
     }
     if (!metadata.OGImage.TrimHasValue())
     {
         if (Gallery.ThumbnailUrl.TrimHasValue())
         {
             metadata.OGImage = Gallery.ThumbnailUrl;
         }
         else if (Gallery.Items.Count > 0)
         {
             metadata.OGImage = Gallery.Items[0].ImageUrl;
         }
     }
 }
Example #2
0
        public void AttachOperationsMergeTest()
        {
            MetadataModel model = GetModel();

            var context = new ModelContext(model);

            var customerOld = new Contact {
                State = TrackingState.Unchanged, Id = Guid.NewGuid(), FirstName = "First1", LastName = "Last1"
            };
            var customerNew = new Contact {
                State = TrackingState.Unchanged, Id = customerOld.Id, FirstName = "First1", LastName = "Last2"
            };
            var customerOther = new Contact {
                State = TrackingState.Unchanged, Id = Guid.NewGuid(), FirstName = "FirstOther", LastName = "LastOther"
            };

            context.AttachSingle(customerOld);

            var operations = context.Merge(new[] { customerNew, customerOther });

            Assert.Equal(2, operations.Items.Count());
            Assert.Equal(customerOld, operations.Items.First());
            Assert.Single(operations.Added);
            Assert.Equal(customerOther, operations.Added.First());
            Assert.Single(operations.Merged);
            Assert.Equal(customerOld, operations.Merged.First().Key);
            Assert.Single(operations.Merged.First().Value);
            Assert.Equal(nameof(Contact.LastName), operations.Merged.First().Value.First().Name);
        }
Example #3
0
        public ActionResult DeleteAttribute(ContainerViewModel postedModel)
        {
            MetadataModel metadata = TempData["Metadata"] as MetadataModel;

            metadata.DialogStack.Push(postedModel);

            IModelContainer eavContainer = FindContainer(metadata.CurrentContext.Containers, postedModel.ID);
            IModelAttribute eavAttribute = eavContainer.Attributes.Single(it => it.AttributeID == ID);

            if (eavAttribute.ObjectState != ObjectState.New)
            {
                eavAttribute.MarkDeleted();
            }
            else
            {
                eavContainer.Attributes.Remove(eavAttribute);
            }

            TempData["Metadata"] = metadata;

            if (eavContainer is IModelRootContainer)
            {
                return(BuildResult("Container Editor", Url.Content("~/Metadata/ContainerEditorDialog"), Url.Content("~/Metadata/UpdateRootContainer"), null));
            }
            else
            {
                return(BuildResult("Container Editor", Url.Content("~/Metadata/ContainerEditorDialog"), Url.Content("~/Metadata/UpdateChildContainer"), null));
            }
        }
Example #4
0
        public ActionResult DeleteChildContainer(ContainerViewModel postedModel)
        {
            MetadataModel metadata = TempData["Metadata"] as MetadataModel;

            metadata.DialogStack.Push(postedModel);

            IModelChildContainer eavContainer = FindContainer(metadata.CurrentContext.Containers, ID) as IModelChildContainer;

            if (eavContainer.ObjectState != ObjectState.New)
            {
                eavContainer.MarkDeleted();
            }
            else
            {
                eavContainer.ParentContainer.ChildContainers.Remove(eavContainer);
            }

            TempData["Metadata"] = metadata;

            if (eavContainer.ParentContainer is IModelRootContainer)
            {
                return(BuildResult("Container Editor", Url.Content("~/Metadata/ContainerEditorDialog"), Url.Content("~/Metadata/UpdateRootContainer"), null));
            }
            else
            {
                return(BuildResult("Container Editor", Url.Content("~/Metadata/ContainerEditorDialog"), Url.Content("~/Metadata/UpdateChildContainer"), null));
            }
        }
Example #5
0
        public ActionResult UpdateAttribute(AttributeViewModel postedModel)
        {
            MetadataModel metadata = TempData["Metadata"] as MetadataModel;

            IModelContainer eavContainer = FindContainer(metadata.CurrentContext.Containers, postedModel.ContainerID);
            IModelAttribute eavAttribute = eavContainer.Attributes.Single(it => it.AttributeID == postedModel.ID);

            if (UpdateRequested)
            {
                eavAttribute.Name        = postedModel.Name;
                eavAttribute.DataName    = postedModel.DataName;
                eavAttribute.DisplayText = postedModel.DisplayText;
                eavAttribute.DataType    = postedModel.DataType;
                eavAttribute.IsKey       = postedModel.IsKey;
            }
            else if (eavAttribute.ObjectState == ObjectState.New && (String.IsNullOrWhiteSpace(eavAttribute.Name) || (String.IsNullOrWhiteSpace(eavAttribute.DataName))))
            {
                eavContainer.Attributes.Remove(eavAttribute);
            }

            TempData["Metadata"] = metadata;

            if (eavContainer is IModelRootContainer)
            {
                return(BuildResult("Container Editor", Url.Content("~/Metadata/ContainerEditorDialog"), Url.Content("~/Metadata/UpdateRootContainer"), null));
            }
            else
            {
                return(BuildResult("Container Editor", Url.Content("~/Metadata/ContainerEditorDialog"), Url.Content("~/Metadata/UpdateChildContainer"), null));
            }
        }
Example #6
0
        public ActionResult UpdateRootContainer(ContainerViewModel postedModel)
        {
            MetadataModel metadata = TempData["Metadata"] as MetadataModel;

            IModelRootContainer eavContainer = FindContainer(metadata.CurrentContext.Containers, postedModel.ID) as IModelRootContainer;

            if (UpdateRequested)
            {
                eavContainer.Name        = postedModel.Name;
                eavContainer.DataName    = postedModel.DataName;
                eavContainer.DisplayText = postedModel.DisplayText;
                eavContainer.IsRepeating = postedModel.IsRepeating;

                foreach (AttributeViewModel attributeModel in postedModel.Attributes)
                {
                    eavContainer.Attributes.Single(it => it.AttributeID == attributeModel.ID).Sequence = attributeModel.Sequence;
                }

                foreach (ContainerViewModel containerModel in postedModel.ChildContainers)
                {
                    eavContainer.ChildContainers.Single(it => it.ContainerID == containerModel.ID).Sequence = containerModel.Sequence;
                }
            }
            else if (eavContainer.ObjectState == ObjectState.New && (String.IsNullOrWhiteSpace(eavContainer.Name) || (String.IsNullOrWhiteSpace(eavContainer.DataName))) && !eavContainer.ChildContainers.Any())
            {
                eavContainer.Context.Containers.Remove(eavContainer);
            }

            TempData["Metadata"] = metadata;

            return(BuildResult("Context Editor", Url.Content("~/Metadata/ContextEditorDialog"), Url.Content("~/Metadata/UpdateContext"), null));
        }
Example #7
0
 /// <summary>
 /// CTOR of Compass.
 /// </summary>
 public Compass()
 {
     InitializeComponent();
     MetadataModel.CreateModel();
     this.vm          = new MetadataViewModel(MetadataModel.Instance);
     this.DataContext = this.vm;
 }
Example #8
0
        public JsonResult Metadata(string entity)
        {
            var model = new List <MetadataModel>();

            var assembly =
                AppDomain.CurrentDomain.GetAssemblies()
                .SelectMany(x => x.GetTypes())
                .FirstOrDefault(x => x.Name.ToLowerInvariant() == entity.ToLowerInvariant());

            if (assembly != null)
            {
                foreach (var prop in assembly.GetProperties())
                {
                    var attrs = (MetadataAttribute[])prop.GetCustomAttributes
                                    (typeof(MetadataAttribute), false);
                    foreach (var attr in attrs)
                    {
                        var attrModel = new MetadataModel()
                        {
                            Title        = attr.Title,
                            PropertyName = prop.Name,
                            ControlType  = attr.ControlType.ToString(),
                            State        = attr.State.ToString()
                        };

                        model.Add(attrModel);
                    }
                }
            }


            return(Json(model, JsonRequestBehavior.AllowGet));
        }
Example #9
0
        /// <summary>Get SMAPI's internal mod database.</summary>
        /// <param name="metadataPath">The file path for the SMAPI metadata file.</param>
        public ModDatabase GetModDatabase(string metadataPath)
        {
            MetadataModel metadata = JsonConvert.DeserializeObject <MetadataModel>(File.ReadAllText(metadataPath));

            ModDataRecord[] records = metadata.ModData.Select(pair => new ModDataRecord(pair.Key, pair.Value)).ToArray();
            return(new ModDatabase(records, this.GetUpdateUrl));
        }
Example #10
0
        private static bool AreSameMetadata(MetadataModel source, MetadataModel target)
        {
            if (source == null && target == null)
            {
                return(true);
            }

            if (source == null || target == null || source.Count != target.Count)
            {
                return(false);
            }

            if (source.Any(entity => target.Count(c => c.Key == entity.Key) != 1))
            {
                return(false);
            }

            return(source.All(sourceData =>
            {
                var sourceDataItems = sourceData.Value;
                var targetDataItems = target[sourceData.Key];

                return sourceDataItems.Count == targetDataItems.Count &&
                sourceDataItems.All(sourceDataItem => targetDataItems.Count(targetDataItem => AreSameDataItems(sourceDataItem, targetDataItem)) == 1);
            }));
        }
Example #11
0
        public async Task <ActionResult> DeleteOnUpdate(string ProcessID, string FieldID)
        {
            _Connection.DatabaseConnection();
            _Metadata.SetDatabase(_Connection.GetDatabase());
            _Field.SetDatabase(_Connection.GetDatabase());
            _Properties.SetDatabase(_Connection.GetDatabase());

            MetadataModel metadata      = _Metadata.GetMetadata(ProcessID); //Obtem-se os metadados do processo cujo o id foi recebido como argumento de entrada;
            FieldModel    fieldToDelete = _Field.GetField(FieldID);         //Obtem-se o modelo do campo a remover da base de dados;

            _Properties.DeleteProperties(fieldToDelete.Properties);         //Apaga as propriedades agregadas ao campo;
            _Field.DeleteField(FieldID);                                    //Apaga o campo agregado ao processo;

            List <string> UpdatedFields = new List <string>();

            foreach (string field in metadata.Field)
            {
                if (!field.Equals(FieldID.ToUpper()))
                {
                    UpdatedFields.Add(field);
                }
            }
            metadata.Field = UpdatedFields;

            _Metadata.ReplaceMetadata(ProcessID, metadata);                                                 //Efetua o replace do modelo de dados MetadataModel existente pelo novo modelo atualizado;

            return(await Task.Run(() => RedirectToAction("Read", "Field", new { ProcessId = ProcessID }))); //Antes no action estava display;
        }
 // GET: Federation
 public ActionResult Index()
 {
     return(Content(
                MetadataModel.CreateFederationMetadata()
                .ToXmlString(CertificateHelper.SigningCertificate),
                "application/samlmetadata+xml"));
 }
        public void JsonSerializationDeserializationTest()
        {
            var builder = new MetadataModelBuilder();

            builder.Entity <Invoice>();
            builder.Entity <Article>().HasOne(p => p.ArticleSettings).WithPrincipal();
            builder.ApplyConventions();

            MetadataModel model = null;

            using (var ms = new MemoryStream())
            {
                var json = new JsonSerializerSettings();
                json.Converters.Add(new LucileJsonInheritanceConverter());

                var serializer = JsonSerializer.Create(json);
                using (var streamWriter = new StreamWriter(ms, Encoding.UTF8, 512, true))
                {
                    serializer.Serialize(streamWriter, builder);
                }

                ms.Seek(0, SeekOrigin.Begin);

                using (var streamReader = new StreamReader(ms))
                    using (var jsonReader = new JsonTextReader(streamReader))
                    {
                        var newBuilder = serializer.Deserialize <MetadataModelBuilder>(jsonReader);
                        model = newBuilder.ToModel();
                    }
            }

            TestModelValidations.ValidateInvoiceArticleDefaultModel(model);
        }
Example #14
0
        /// <summary>
        /// Add new entry in metadata
        /// </summary>
        /// <param name="metadataModel">metadata item</param>
        public void Add(MetadataModel metadataModel)
        {
            var metadata = _session.Query <Metadata>().FirstOrDefault() ?? GetDefaultMetadata();

            metadataModel.ApplyToMetadata(metadata);
            _session.Store(metadata);
        }
Example #15
0
        public async Task <Message <MetadataModel> > UpdateMetadata(int id, MetadataModel model)
        {
            var requestUrl = CreateRequestUri(string.Format(System.Globalization.CultureInfo.InvariantCulture,
                                                            "Metadatas/" + id.ToString()));

            return(await PutAsync <MetadataModel>(requestUrl, model));
        }
Example #16
0
        public MetadataModelBuilder FromModel(MetadataModel model)
        {
            foreach (var item in model.Entities)
            {
                var entity = this.Entity(item.ClrType);
                if (item.BaseEntity != null)
                {
                    entity.BaseEntity = this.Entity(item.BaseEntity.ClrType);
                }

                foreach (var prop in item.GetProperties().Where(p => p.Entity == item))
                {
                    var scalar = entity.Property(prop.Name, prop.PropertyType);
                    scalar.CopyFrom(prop);
                    if (prop.IsPrimaryKey)
                    {
                        entity.PrimaryKey.Add(prop.Name);
                    }
                }

                foreach (var nav in item.GetNavigations().Where(p => p.Entity == item))
                {
                    var navigation = entity.Navigation(nav.Name);
                    navigation.CopyFrom(nav);
                }
            }

            return(this);
        }
        public async Task <ActionResult> Delete(string id)
        {
            if (id != null)
            {
                _Connection.DatabaseConnection();
                _Metadata.SetDatabase(_Connection.GetDatabase()); //Estabeleçe a conexão;
                _GetBranchById.SetDatabase(_Connection.GetDatabase());
                _GetStateById.SetDatabase(_Connection.GetDatabase());
                //_Metadata.ReadFromDatabase();
                MetadataModel model = _Metadata.GetMetadata(id);

                _GetBranchById.ReadFromDatabase(model.Branch);
                _GetStateById.ReadFromDatabase(model.State);

                ViewMetadataModel ModelToDelete = new ViewMetadataModel()
                {
                    Id      = model.Id,
                    Name    = model.Name,
                    Version = model.Version.ToString(),
                    Date    = model.Date.ToString(),
                    Branch  = _GetBranchById.GetBranches(),
                    State   = _GetStateById.GetStateDescription()
                };
                return(await Task.Run(() => View("Delete", ModelToDelete)));
            }
            return(await Task.Run(() => View("Delete")));
        }
Example #18
0
        public static bool GetRotInfo(FileInfo fi, out ushort rotateme)
        {
            bool gotRotInfo = false;

            rotateme = 1;
            FIBITMAP?dibNull = GetJPGImageHandle(fi);

            if (dibNull != null)
            {
                FIBITMAP      dib       = (FIBITMAP)dibNull;
                var           iMetadata = new ImageMetadata(dib);
                MetadataModel exifMain  = iMetadata[FREE_IMAGE_MDMODEL.FIMD_EXIF_MAIN];
                if (exifMain != null)
                {
                    MetadataTag orientationTag = exifMain.GetTag("Orientation");
                    if (orientationTag != null)
                    {
                        var rotInfo = (ushort[])orientationTag.Value;
                        rotateme   = rotInfo[0];
                        gotRotInfo = true;
                    }
                }
                CleanUpResources(dib);
            }
            return(gotRotInfo);
        }
 public ActionResult BrowserFriendly()
 {
     return(Content(
                MetadataModel.CreateFederationMetadata()
                .ToXmlString(CertificateHelper.SigningCertificate),
                "text/xml"));
 }
        public async Task <IActionResult> getMetaData(string ConversationType)
        {
            string BaseUrl     = _configuration.GetSection("ApiURL:baseURL").Value;
            string metaDataUrl = _configuration.GetSection("ApiURL:metaDataURL").Value + ConversationType;

            HttpClient client = new HttpClient();

            client.BaseAddress = new Uri(BaseUrl);
            client.DefaultRequestHeaders.Accept.Clear();
            client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));

            HttpResponseMessage response = await client.GetAsync(metaDataUrl);

            MetadataModel metadata = new MetadataModel();

            if (response.IsSuccessStatusCode)
            {
                string jsonString = await response.Content.ReadAsStringAsync();

                metadata = JsonConvert.DeserializeObject <MetadataModel>(jsonString);
            }
            return(Json(metadata, new JsonSerializerSettings
            {
                Formatting = Formatting.Indented,
            }));
        }
Example #21
0
        public ActionResult UpdateContext(ContextViewModel postedModel)
        {
            MetadataModel metadata = TempData["Metadata"] as MetadataModel;

            IModelContext eavContext = metadata.CurrentContext;

            if (UpdateRequested)
            {
                eavContext.Name        = postedModel.Name;
                eavContext.DataName    = postedModel.DataName;
                eavContext.DisplayText = postedModel.DisplayText;

                foreach (ContainerViewModel containerModel in postedModel.Containers)
                {
                    eavContext.Containers.Single(it => it.ContainerID == containerModel.ID).Sequence = containerModel.Sequence;
                }
            }
            else if (eavContext.ObjectState == ObjectState.New && (String.IsNullOrWhiteSpace(eavContext.Name) || (String.IsNullOrWhiteSpace(eavContext.DataName))) && !eavContext.Containers.Any())
            {
                metadata.Contexts.Remove(eavContext);
            }

            TempData["Metadata"] = metadata;

            return(BuildResult(null, null, null, metadata.Contexts.Select(it => new { Value = it.ContextID, Text = it.Name })));
        }
Example #22
0
 /// <summary>
 ///		Muestra los metadatos de un contenedor
 /// </summary>
 private static void ShowMetadata(MetadataModel metadata)
 {
     Console.WriteLine($"Nombre: {metadata.Name}");
     Console.WriteLine($"Uri: {metadata.Uri}");
     Console.WriteLine($"Etag: {metadata.ETag}");
     Console.WriteLine($"LastModified: {metadata.LastModified}");
     ShowMetadataProperties(metadata.Properties);
 }
Example #23
0
 public void Add(MetadataModel metadata)
 {
     _dbContext.RemoveRange(_dbContext.Query <MetadataCategory>().ToArray());
     if (metadata.Any())
     {
         _dbContext.AddRange(_mapper.Map <IEnumerable <MetadataCategory> >(metadata).ToArray());
     }
 }
Example #24
0
        public ActionResult PostRedirectGetTarget(string view)
        {
            MetadataModel metadata = TempData["Metadata"] as MetadataModel;

            TempData["Metadata"] = metadata;

            return(View(view, metadata));
        }
 public override void VisitModel(MetadataModel model)
 {
     //BFS Visiting
     foreach (var convention in _modelConventions)
     {
         convention.Apply(model);
     }
 }
Example #26
0
        public ActionResult TestWebApi(MetadataModel modeloListaController, string botonSubmit)
        {
            if (modeloListaController != null && modeloListaController.Clases != null && modeloListaController.Clases.Count > 0)
            {
                ViewBag.url = MetadataService.buildWebApiUrl(modeloListaController.Clases.Where(x => x.NombreClase == botonSubmit.Split('_')[1]).FirstOrDefault());
            }

            return(View());
        }
Example #27
0
 public static MetadataModel CompleteModel(this MetadataModel model)
 {
     foreach (var entity in model.Entities)
     {
         AddIdAttribute(entity);
         AddNameAttribute(entity);
     }
     return(model);
 }
        public async Task <HttpResponseMessage> getMetaData(string ConversationType)
        {
            HttpRequestMessage request  = Request;
            MetadataModel      metaData = new MetadataModel();

            metaData = await metaDataRepository.getMetaData(ConversationType);

            return(GlobalFunctions.CreateResponse <MetadataModel>(request, HttpStatusCode.OK, metaData));
        }
Example #29
0
        public LazyLoadingManager(MetadataModel model)
        {
            if (model == null)
            {
                throw new ArgumentNullException("model");
            }

            this.Model = model;
        }
Example #30
0
 public GenericManager()
 {
     ParserService     = new JsonParserService();
     Model             = new MetadataModel();
     CreateWorkflows   = new List <WorkflowDefinition>();
     UpdateWorkflows   = new List <WorkflowDefinition>();
     DeleteWorkflows   = new List <WorkflowDefinition>();
     AssociateWorkflow = new List <WorkflowDefinition>();
 }
Example #31
0
 public void Run(MetadataModel yaml, ResolverContext context)
 {
     TreeIterator.Preorder(yaml.TocYamlViewModel, null,
         s => s.IsInvalid ? null : s.Items,
         (current, parent) =>
         {
             current.Parent = parent;
             return true;
         });
 }
Example #32
0
        public void Run(MetadataModel yaml, ResolverContext context)
        {
            TreeIterator.Preorder(yaml.TocYamlViewModel, null,
                s =>
                {
                    if (s.IsInvalid || (s.Type != MemberType.Namespace && s.Type != MemberType.Toc)) return null;
                    else return s.Items;
                },
                (member, parent) =>
                {
                    if (member.Type != MemberType.Toc)
                    {
                        yaml.Members.Add(member);
                    }

                    return true;
                });
        }
Example #33
0
        public void Run(MetadataModel yaml, ResolverContext context)
        {
            TreeIterator.Preorder(yaml.TocYamlViewModel, null,
                s => s.IsInvalid ? null : s.Items,
                (current, parent) =>
                {
                    if (current.Type != MemberType.Toc)
                    {
                        if (current.Type.IsPageLevel())
                        {
                            current.Href = current.Name + Constants.YamlExtension;
                        }
                        else
                        {
                            current.Href = parent.Href;
                        }
                    }

                    return true;
                });
        }
Example #34
0
 public void Run(MetadataModel yaml, ResolverContext context)
 {
     yaml.TocYamlViewModel = yaml.TocYamlViewModel.ShrinkToSimpleTocWithNamespaceNotEmpty();
 }