Ejemplo n.º 1
0
        public IEnumerable<JObject> Post(string id, FilterViewModel model) {
            var pluralService = PluralizationService.CreateService(new CultureInfo("en-US"));
            if (pluralService.IsPlural(id)) {
                id = pluralService.Singularize(id);
            }
            FilterGroupRecord groupRecord;
            if (model.Id == 0) {
                groupRecord = new FilterGroupRecord();
                _filterGroupRepository.Create(groupRecord);
                _entityFilterRepository.Create(new EntityFilterRecord {
                    EntityName = id,
                    FilterGroupRecord = groupRecord,
                    Title = model.Title
                });
            }
            else {
                var entityFilterRecord = _entityFilterRepository.Get(model.Id);
                entityFilterRecord.Title = model.Title;
                groupRecord = entityFilterRecord.FilterGroupRecord;
                groupRecord.Filters.Clear();
            }

            foreach (var filter in model.Filters) {
                if (filter.FormData.Length == 0) {
                    continue;
                }
                var record = new FilterRecord {
                    Category = id + "ContentFields",
                    Type = filter.Type,
                };
                var dictionary = filter.FormData.ToDictionary(x => x.Name, x => x.Value);
                record.State = FormParametersHelper.ToString(dictionary);
                groupRecord.Filters.Add(record);
            }

            return Get(id);
        }
Ejemplo n.º 2
0
        public IEnumerable<JObject> Post(string id, FilterViewModel model) {
            var pluralService = PluralizationService.CreateService(new CultureInfo("en-US"));
            if (pluralService.IsPlural(id)) {
                id = pluralService.Singularize(id);
            }

            var groupRecord = new FilterGroupRecord();
                _filterGroupRepository.Create(groupRecord);
                _entityFilterRepository.Create(new EntityFilterRecord {
                    EntityName = id,
                    FilterGroupRecord = groupRecord,
                    Title = model.Title
                });

            foreach (var filter in model.Filters) {
                if (filter.FormData.Length == 0) {
                    continue;
                }
                var record = new FilterRecord {
                    Category = id + "ContentFields",
                    Type = filter.Type,
                };
                var dictionary = new Dictionary<string, string>();
                foreach (var data in filter.FormData) {
                    if (dictionary.ContainsKey(data.Name)) {
                        dictionary[data.Name] += "&" + data.Value;
                    }
                    else {
                        dictionary.Add(data.Name, data.Value);
                    }
                }
                record.State = FormParametersHelper.ToString(dictionary);
                groupRecord.Filters.Add(record);
            }

            return Get(id);
        }
Ejemplo n.º 3
0
        public ActionResult EditPost(int id, string category, string type, [DefaultValue(-1)] int filterId, FormCollection formCollection) {
            var group = _groupRepository.Get(id);

            var filter = _projectionManager.DescribeFilters().SelectMany(x => x.Descriptors).Where(x => x.Category == category && x.Type == type).FirstOrDefault();

            var model = new FilterEditViewModel();
            TryUpdateModel(model);

            // validating form values
            _formManager.Validate(new ValidatingContext { FormName = filter.Form, ModelState = ModelState, ValueProvider = ValueProvider });

            if (ModelState.IsValid) {
                var filterRecord = group.Filters.Where(f => f.Id == filterId).FirstOrDefault();

                // add new filter record if it's a newly created filter
                if (filterRecord == null) {
                    filterRecord = new FilterRecord {
                        Category = category, 
                        Type = type, 
                        Position = group.Filters.Count
                    };
                    group.Filters.Add(filterRecord);
                }

                var dictionary = formCollection.AllKeys.ToDictionary(key => key, formCollection.Get);

                // save form parameters
                filterRecord.State = FormParametersHelper.ToString(dictionary);
                filterRecord.Description = model.Description;

                return RedirectToAction("Edit", "Admin", new { group.QueryPartRecord.Id });
            }

            // model is invalid, display it again
            var form = _formManager.Build(filter.Form);

            _formManager.Bind(form, formCollection);
            var viewModel = new FilterEditViewModel { Id = id, Description = model.Description, Filter = filter, Form = form };

            return View(viewModel);
        }
Ejemplo n.º 4
0
        public int CreateProjection(string entityType) {
            var projectionItem = _contentManager.New("ProjectionPage");
            var queryItem = _contentManager.New("Query");
            var projectionPart = projectionItem.As<ProjectionPart>();
            var queryPart = queryItem.As<QueryPart>();
            queryPart.As<TitlePart>().Title = entityType;
            projectionPart.As<TitlePart>().Title = entityType;
            _contentManager.Create(queryItem);
            projectionPart.Record.QueryPartRecord = queryPart.Record;
            _contentManager.Create(projectionItem);

            var layoutRecord = new LayoutRecord {
                Category = "Html",
                Type = "ngGrid",
                Description = "DefaultLayoutFor" + queryPart.Name,
                Display = 1
            };
            queryPart.Layouts.Add(layoutRecord);
            projectionPart.Record.LayoutRecord = layoutRecord;

            var filterGroup = new FilterGroupRecord();
            queryPart.Record.FilterGroups.Clear();
            queryPart.Record.FilterGroups.Add(filterGroup);
            var filterRecord = new FilterRecord {
                Category = "Content",
                Type = "ContentTypes",
                Position = filterGroup.Filters.Count,
                State = GetContentTypeFilterState(entityType)
            };
            filterGroup.Filters.Add(filterRecord);
            return projectionItem.Id;
        }
Ejemplo n.º 5
0
 private int CreateQuery(string entityType) {
     var queryPart = _contentManager.New<QueryPart>("Query");
     var filterGroup = new FilterGroupRecord();
     queryPart.Record.FilterGroups.Add(filterGroup);
     var filterRecord = new FilterRecord {
         Category = "Content",
         Type = "ContentTypes",
         Position = filterGroup.Filters.Count,
         State = GetContentTypeFilterState(entityType)
     };
     filterGroup.Filters.Add(filterRecord);
     _contentManager.Create(queryPart);
     return queryPart.Id;
 }
Ejemplo n.º 6
0
        private IList<FilterRecord> CreateFilters(string entityName, ListQueryModel model, out string filterDescription) {
            IList<FilterRecord> filterRecords;
            filterDescription = string.Empty;
            if (model.FilterGroupId == 0) {
                var filterDescriptors = _projectionManager.DescribeFilters()
                    .Where(x => x.Category == entityName + "ContentFields")
                    .SelectMany(x => x.Descriptors).ToList();
                filterRecords = new List<FilterRecord>();
                if (model.IsRelationList) {
                    if (model.RelationType == "OneToMany") {
                        var settings = new Dictionary<string, string> {
                            {"Operator","MatchesAny"},
                            {"Value",model.CurrentItem.ToString("D")}
                        };
                        var relationFilter = new FilterRecord {
                            Category = entityName + "ContentFields",
                            Type = entityName + "." + model.RelationId + ".",
                            State = FormParametersHelper.ToString(settings),
                            Description = "Only show entries related to current item."
                        };
                        filterRecords.Add(relationFilter);
                        var descriptor = filterDescriptors.First(x => x.Type == relationFilter.Type);
                        filterDescription += descriptor.Display(new FilterContext { State = FormParametersHelper.ToDynamic(relationFilter.State) }).Text;
                    }
                }

                foreach (var filter in model.Filters) {
                    if (filter.FormData.Length == 0) {
                        continue;
                    }
                    var record = new FilterRecord {
                        Category = entityName + "ContentFields",
                        Type = filter.Type,
                    };
                    var dictionary = new Dictionary<string, string>();
                    foreach (var data in filter.FormData) {
                        if (dictionary.ContainsKey(data.Name)) {
                            dictionary[data.Name] += "&" + data.Value;
                        }
                        else {
                            dictionary.Add(data.Name, data.Value);
                        }
                    }
                    record.State = FormParametersHelper.ToString(dictionary);
                    filterRecords.Add(record);
                    var descriptor = filterDescriptors.First(x => x.Type == filter.Type);
                    filterDescription += descriptor.Display(new FilterContext {State = FormParametersHelper.ToDynamic(record.State)}).Text;
                }
            }
            else {
                filterRecords = _filterGroupRepository.Get(model.FilterGroupId).Filters;
            }
            return filterRecords;
        }
Ejemplo n.º 7
0
        private ProjectionPart CreateProjection(string typeName, IEnumerable<string> properties) {
            var projectionItem = _contentManager.New("ProjectionPage");
            var queryItem = _contentManager.New("Query");
            var projectionPart = projectionItem.As<ProjectionPart>();
            var queryPart = queryItem.As<QueryPart>();
            _contentManager.Create(queryItem);

            projectionPart.Record.QueryPartRecord = queryPart.Record;
            _contentManager.Create(projectionItem);

            var layoutRecord = new LayoutRecord {Category = "Html", Type = "ngGrid"};
            queryPart.Record.Layouts.Add(layoutRecord);
            projectionPart.Record.LayoutRecord = layoutRecord;

            var filterGroup = new FilterGroupRecord();
            queryPart.Record.FilterGroups.Clear();
            queryPart.Record.FilterGroups.Add(filterGroup);
            var filterRecord = new FilterRecord {
                Category = "Content",
                Type = "ContentTypes",
                Position = filterGroup.Filters.Count,
                State = string.Format("<Form><ContentTypes>{0}</ContentTypes></Form>", typeName)
            };
            filterGroup.Filters.Add(filterRecord);

            UpdateLayoutProperties(typeName, layoutRecord, properties);
            return projectionPart;
        }
Ejemplo n.º 8
0
        public int EditPost(int id, ProjectionEditViewModel viewModel, IEnumerable<string> pickedFileds) {
            ListViewPart listViewPart;
            ProjectionPart projectionPart;
            QueryPart queryPart;
            if (id == 0) {
                listViewPart = _contentManager.New<ListViewPart>("ListViewPage");
                listViewPart.ItemContentType = viewModel.ItemContentType;
                queryPart = _contentManager.New<QueryPart>("Query");

                var layout = new LayoutRecord {
                    Category = "Html",
                    Type = "ngGrid",
                    Description = "DefaultLayoutFor" + queryPart.Name,
                    Display = 1
                };

                queryPart.Layouts.Add(layout);
                projectionPart = listViewPart.As<ProjectionPart>();
                projectionPart.Record.LayoutRecord = layout;
                projectionPart.Record.QueryPartRecord = queryPart.Record;

                var filterGroup = new FilterGroupRecord();
                queryPart.Record.FilterGroups.Add(filterGroup);
                var filterRecord = new FilterRecord {
                    Category = "Content",
                    Type = "ContentTypes",
                    Position = filterGroup.Filters.Count,
                    State = GetContentTypeFilterState(viewModel.ItemContentType)
                };
                filterGroup.Filters.Add(filterRecord);

                _contentManager.Create(queryPart.ContentItem);
                _contentManager.Create(projectionPart.ContentItem);
            }
            else {
                listViewPart = _contentManager.Get<ListViewPart>(id, VersionOptions.Latest);
                projectionPart = listViewPart.As<ProjectionPart>();
                var queryId = projectionPart.Record.QueryPartRecord.Id;
                queryPart = _contentManager.Get<QueryPart>(queryId, VersionOptions.Latest);
            }

            if (pickedFileds == null) {
                pickedFileds = new List<string>();
            }

            listViewPart.VisableTo = viewModel.VisableTo;
            listViewPart.As<TitlePart>().Title = viewModel.DisplayName;
            listViewPart.IsDefault = viewModel.IsDefault;
            queryPart.Name = "Query for Public View";

            projectionPart.Record.ItemsPerPage = viewModel.PageRowCount;
            //Post Selected Fields
            var layoutRecord = projectionPart.Record.LayoutRecord;
            layoutRecord.Properties.Clear();

            var category = viewModel.ItemContentType + "ContentFields";
            const string settingName = "CoeveryTextFieldSettings.IsDispalyField";
            try {
                UpdateLayoutProperties(viewModel.ItemContentType, ref layoutRecord, category, settingName, pickedFileds);
            }
            catch (Exception exception) {
                Services.Notifier.Add(NotifyType.Error,T(exception.Message));
            }
            layoutRecord.State = GetLayoutState(queryPart.Id, layoutRecord.Properties.Count, layoutRecord.Description);
            // sort
            queryPart.SortCriteria.Clear();
            if (!string.IsNullOrEmpty(viewModel.SortedBy)) {
                var sortCriterionRecord = new SortCriterionRecord {
                    Category = category,
                    Type = viewModel.SortedBy,
                    Position = queryPart.SortCriteria.Count,
                    State = GetSortState(viewModel.SortedBy, viewModel.SortMode),
                    Description = viewModel.SortedBy + " " + viewModel.SortMode
                };
                queryPart.SortCriteria.Add(sortCriterionRecord);
            }
            return listViewPart.Id;
        }
Ejemplo n.º 9
0
 private IList<FilterRecord> CreateFilters(string entityName, ListQueryModel model) {
     IList<FilterRecord> filterRecords;
     if (model.FilterGroupId == 0) {
         filterRecords = new List<FilterRecord>();
         foreach (var filter in model.Filters) {
             if (filter.FormData.Length == 0) {
                 continue;
             }
             var record = new FilterRecord {
                 Category = entityName + "ContentFields",
                 Type = filter.Type,
             };
             var dictionary = filter.FormData.ToDictionary(x => x.Name, x => x.Value);
             record.State = FormParametersHelper.ToString(dictionary);
             filterRecords.Add(record);
         }
     }
     else {
         filterRecords = _filterGroupRepository.Get(model.FilterGroupId).Filters;
     }
     return filterRecords;
 }