Beispiel #1
0
        public IActionResult Create(CreateExternalRepositoryViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View("Create", model));
            }

            var filteringExpressionSets = model.FilteringExpressionSets == null
                ? new List <FilteringExpressionSetContract>()
                : model.FilteringExpressionSets.Where(x => x.IsChecked)
                                          .Select(x => new FilteringExpressionSetContract {
                Id = x.Id
            }).ToList();

            var client = GetExternalRepositoryClient();

            client.CreateExternalRepository(new ExternalRepositoryDetailContract
            {
                Name                = model.Name,
                Description         = model.Description,
                License             = model.License,
                Url                 = model.Url,
                UrlTemplate         = model.UrlTemplate,
                Configuration       = GetConfiguration(Request.Form),
                BibliographicFormat = new BibliographicFormatContract {
                    Id = model.BibliographicFormatId
                },
                ExternalRepositoryType = new ExternalRepositoryTypeContract {
                    Id = model.ExternalRepositoryTypeId
                },
                FilteringExpressionSets = filteringExpressionSets
            });
            return(RedirectToAction("List"));
        }
Beispiel #2
0
        public IActionResult Update(int id)
        {
            var client = GetFilteringExpressionSetClient();
            var externalRepositoryClient = GetExternalRepositoryClient();

            var externalRepositoryDetail = externalRepositoryClient.GetExternalRepositoryDetail(id);

            var bibliographicFormats          = client.GetAllBibliographicFormats();
            var availableBibliographicFormats = new SelectList(bibliographicFormats,
                                                               nameof(BibliographicFormatContract.Id),
                                                               nameof(BibliographicFormatContract.Name),
                                                               externalRepositoryDetail.BibliographicFormat.Id);

            ViewData[RepositoryImportConstants.AvailableBibliographicFormats] = availableBibliographicFormats;

            var externalRepositoryTypes          = externalRepositoryClient.GetAllExternalRepositoryTypes();
            var availableExternalRepositoryTypes = new SelectList(externalRepositoryTypes,
                                                                  nameof(BibliographicFormatContract.Id),
                                                                  nameof(BibliographicFormatContract.Name),
                                                                  externalRepositoryDetail.ExternalRepositoryType.Id);

            ViewData[RepositoryImportConstants.AvailableExternalRepositoryTypes] = availableExternalRepositoryTypes;

            var filteringExpressionSets          = client.GetAllFilteringExpressionSets();
            var availableFilteringExpressionSets = filteringExpressionSets.Select(x =>
                                                                                  new CheckBoxEntity(x.Id, x.Name, externalRepositoryDetail.FilteringExpressionSets.Any(y => y.Id == x.Id))).ToList();

            var model = new CreateExternalRepositoryViewModel
            {
                Name                     = externalRepositoryDetail.Name,
                Id                       = externalRepositoryDetail.Id,
                Description              = externalRepositoryDetail.Description,
                License                  = externalRepositoryDetail.License,
                Url                      = externalRepositoryDetail.Url,
                UrlTemplate              = externalRepositoryDetail.UrlTemplate,
                BibliographicFormatId    = externalRepositoryDetail.BibliographicFormat.Id,
                ExternalRepositoryTypeId = externalRepositoryDetail.ExternalRepositoryType.Id,
                Configuration            = externalRepositoryDetail.Configuration,
                FilteringExpressionSets  = availableFilteringExpressionSets
            };

            return(View(model));
        }