Merged in feature/SHIBUI-580 (pull request #107)

SHIBUI-580 Implemented summary and save of a provider

Approved-by: Shibui Jenkins <shibui.jenkins@gmail.com>
Approved-by: Ryan Mathis <rmathis@unicon.net>

backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/ErrorResponse.java

@@ -0,0 +1,18 @@
+package edu.internet2.tier.shibboleth.admin.ui.controller;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+/**
+ * @author Bill Smith (wsmith@unicon.net)
+ */
+@AllArgsConstructor
+@Getter
+@Setter
+@ToString
+public class ErrorResponse {
+    private String errorCode;
+    private String errorMessage;
+}

backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolversController.java

@@ -1,15 +1,16 @@
 package edu.internet2.tier.shibboleth.admin.ui.controller;
 
+import com.fasterxml.jackson.databind.exc.InvalidTypeIdException;
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver;
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolverValidationService;
-import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolverValidator;
 import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository;
-
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.http.converter.HttpMessageNotReadableException;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -19,6 +20,7 @@
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
 
+import java.io.IOException;
 import java.net.URI;
 
 import static edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolverValidator.ValidationResult;
@@ -34,6 +36,11 @@ public class MetadataResolversController {
     @Autowired
     MetadataResolverValidationService metadataResolverValidationService;
 
+    @ExceptionHandler({InvalidTypeIdException.class, IOException.class, HttpMessageNotReadableException.class})
+    public ResponseEntity<?> unableToParseJson(Exception ex) {
+        return ResponseEntity.badRequest().body(new ErrorResponse(HttpStatus.BAD_REQUEST.toString(), ex.getMessage()));
+    }
+
     @GetMapping("/MetadataResolvers")
     @Transactional(readOnly = true)
     public ResponseEntity<?> getAll() {
@@ -56,6 +63,10 @@ public ResponseEntity<?> getOne(@PathVariable String resourceId) {
     @PostMapping("/MetadataResolvers")
     @Transactional
     public ResponseEntity<?> create(@RequestBody MetadataResolver newResolver) {
+        if (resolverRepository.findByName(newResolver.getName()) != null) {
+            return ResponseEntity.status(HttpStatus.CONFLICT).build();
+        }
+
         //TODO: we are disregarding attached filters if any sent from UI.
         //Only deal with filters via filters endpoints?
         newResolver.clearAllFilters();

backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/MetadataResolverValidationService.java

@@ -8,7 +8,7 @@
 
 /**
  * A facade that aggregates {@link MetadataResolverValidator}s available to call just one of them supporting the type of a given resolver.
- * If no {@link MetadataResolverValidator}s are configured, conciders provided MetadataResolver as valid.
+ * If no {@link MetadataResolverValidator}s are configured, considers provided MetadataResolver as valid.
  * <p>
  * Uses chain-of-responsibility design pattern
  *
@@ -22,7 +22,7 @@ public MetadataResolverValidationService(List<MetadataResolverValidator<T>> vali
         this.validators = validators != null ? validators : new ArrayList<>();
     }
 
-    @SuppressWarnings("Uncheked")
+    @SuppressWarnings("Unchecked")
     public ValidationResult validateIfNecessary(T metadataResolver) {
         Optional<MetadataResolverValidator<T>> validator =
                 this.validators

ui/src/app/metadata/domain/domain.module.ts

@@ -12,6 +12,7 @@ import { EntityDraftService } from './service/draft.service';
 import { MetadataProviderService } from './service/provider.service';
 import { EntityEffects } from './effect/entity.effect';
 import { PreviewDialogComponent } from './component/preview-dialog.component';
+import { MetadataFilterService } from './service/filter.service';
 
 export const COMPONENTS = [
     PreviewDialogComponent
@@ -42,7 +43,8 @@ export class DomainModule {
                 ListValuesService,
                 ProviderStatusEmitter,
                 ProviderValueEmitter,
-                MetadataProviderService
+                MetadataProviderService,
+                MetadataFilterService
             ]
         };
     }

ui/src/app/metadata/domain/domain.type.ts

@@ -6,9 +6,11 @@ import {
 
 import {
     EntityAttributesFilter,
-    FileBackedHttpMetadataResolver,
-    FileBackedHttpMetadataProvider
+    FileBackedHttpMetadataResolver
 } from './entity';
+import {
+    FileBackedHttpMetadataProvider
+} from './model/providers';
 
 export type Filter =
     | EntityAttributesFilter;

ui/src/app/metadata/domain/entity/index.ts

@@ -1,3 +1,2 @@
 export * from './filter/entity-attributes-filter';
-export * from './provider/file-backed-http-metadata-provider';
 export * from './resolver/file-backed-http-metadata-resolver';

ui/src/app/metadata/domain/model/metadata-provider.ts

@@ -1,16 +1,10 @@
 import {
     MetadataBase,
-    Organization,
-    Contact,
-    MDUI,
-    SecurityInfo,
-    SsoService,
-    IdpSsoDescriptor,
-    LogoutEndpoint,
-    RelyingPartyOverrides
 } from '../model';
 
 export interface MetadataProvider extends MetadataBase {
     name: string;
     '@type': string;
+    enabled: boolean;
+    resourceId: string;
 }

ui/src/app/metadata/domain/model/providers/file-backed-http-metadata-provider.ts

@@ -0,0 +1,5 @@
+import { MetadataProvider } from '../metadata-provider';
+
+export interface FileBackedHttpMetadataProvider extends MetadataProvider {
+    metadataFilters: any[];
+}

ui/src/app/metadata/domain/model/providers/index.ts

@@ -0,0 +1 @@
+export * from './file-backed-http-metadata-provider';

ui/src/app/metadata/domain/service/filter.service.spec.ts

@@ -0,0 +1,74 @@
+import { TestBed, async, inject } from '@angular/core/testing';
+import { HttpTestingController, HttpClientTestingModule } from '@angular/common/http/testing';
+import { HttpClientModule, HttpRequest } from '@angular/common/http';
+import { MetadataFilterService } from './filter.service';
+import { EntityAttributesFilter } from '../entity';
+
+describe(`Metadata Filter Service`, () => {
+
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            imports: [
+                HttpClientModule,
+                HttpClientTestingModule
+            ],
+            providers: [
+                MetadataFilterService
+            ]
+        });
+    });
+
+    describe('query method', () => {
+        it(`should send an expected GET[] request`, async(inject([MetadataFilterService, HttpTestingController],
+            (service: MetadataFilterService, backend: HttpTestingController) => {
+                service.query().subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `${service.base}${service.endpoint}`
+                        && req.method === 'GET';
+                }, `GET MetadataResolvers collection`);
+            }
+        )));
+    });
+    describe('find method', () => {
+        it(`should send an expected GET request`, async(inject([MetadataFilterService, HttpTestingController],
+            (service: MetadataFilterService, backend: HttpTestingController) => {
+                const id = 'foo';
+                service.find(id).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `${service.base}${service.endpoint}/${id}`
+                        && req.method === 'GET';
+                }, `GET MetadataResolvers collection`);
+            }
+        )));
+    });
+    describe('update method', () => {
+        it(`should send an expected PUT request`, async(inject([MetadataFilterService, HttpTestingController],
+            (service: MetadataFilterService, backend: HttpTestingController) => {
+                const id = 'foo';
+                const filter = new EntityAttributesFilter({ id });
+                service.update(filter).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `${service.base}${service.endpoint}/${id}`
+                        && req.method === 'PUT';
+                }, `PUT (update) MetadataResolvers collection`);
+            }
+        )));
+    });
+    describe('save method', () => {
+        it(`should send an expected POST request`, async(inject([MetadataFilterService, HttpTestingController],
+            (service: MetadataFilterService, backend: HttpTestingController) => {
+                const id = 'foo';
+                const filter = new EntityAttributesFilter({ id });
+                service.save(filter).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `${service.base}${service.endpoint}`
+                        && req.method === 'POST';
+                }, `POST MetadataResolvers collection`);
+            }
+        )));
+    });
+});

ui/src/app/metadata/domain/service/filter.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+import { MetadataFilter } from '../../domain/model';
+
+@Injectable()
+export class MetadataFilterService {
+
+    readonly endpoint = '/MetadataResolvers';
+    readonly base = '/api';
+
+    constructor(
+        private http: HttpClient
+    ) { }
+    query(): Observable<MetadataFilter[]> {
+        return this.http.get<MetadataFilter[]>(`${this.base}${this.endpoint}`, {});
+    }
+
+    find(id: string): Observable<MetadataFilter> {
+        // console.log(id);
+        return this.http.get<MetadataFilter>(`${this.base}${this.endpoint}/${id}`);
+    }
+
+    update(filter: MetadataFilter): Observable<MetadataFilter> {
+        return this.http.put<MetadataFilter>(`${this.base}${this.endpoint}/${filter.id}`, filter);
+    }
+
+    save(filter: MetadataFilter): Observable<MetadataFilter> {
+        return this.http.post<MetadataFilter>(`${this.base}${this.endpoint}`, filter);
+    }
+}