diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolverControllerVersionEndpointsIntegrationTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolverControllerVersionEndpointsIntegrationTests.groovy
index f23ea333d..aaa0a1095 100644
--- a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolverControllerVersionEndpointsIntegrationTests.groovy
+++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolverControllerVersionEndpointsIntegrationTests.groovy
@@ -1,5 +1,7 @@
 package edu.internet2.tier.shibboleth.admin.ui.controller
 
+import edu.internet2.tier.shibboleth.admin.ui.domain.filters.EntityAttributesFilter
+import edu.internet2.tier.shibboleth.admin.ui.domain.filters.EntityAttributesFilterTarget
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicHttpMetadataResolver
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FileBackedHttpMetadataResolver
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FilesystemMetadataResolver
@@ -103,6 +105,37 @@ class MetadataResolverControllerVersionEndpointsIntegrationTests extends Specifi
         mrv2.body.name == 'resolverUPDATED'
     }
 
+    def "SHIBUI-1386"() {
+        MetadataResolver mr = new FileBackedHttpMetadataResolver(name: 'testme')
+        mr = repository.save(mr)
+
+        when: 'add a filter'
+        // def filterValue = '''{"type":"EntityAttributes","@type":"EntityAttributes","filterEnabled":true,"entityAttributesFilterTarget":{"entityAttributesFilterTargetType":"ENTITY","value":["https://idp.unicon.net/idp/shibboleth"]},"relyingPartyOverrides":{"signAssertion":false,"dontSignResponse":false,"turnOffEncryption":false,"useSha":false,"ignoreAuthenticationMethod":false,"omitNotBefore":false,"nameIdFormats":[],"authenticationMethods":[],"forceAuthn":false},"attributeRelease":[],"name":"Test Filter 1"}'''
+        def filter = new EntityAttributesFilter(
+                name: 'testme',
+                filterEnabled: true
+        ).with {
+            it.relyingPartyOverrides = [
+                    'signAssertion': true
+            ]
+            it.setEntityAttributesFilterTarget(new EntityAttributesFilterTarget().with {
+                it.entityAttributesFilterTargetType = EntityAttributesFilterTarget.EntityAttributesFilterTargetType.ENTITY
+                it.value = ['https://testme/sp']
+                it
+            })
+            it
+        }
+        mr.metadataFilters.add(filter)
+        mr = repository.save(mr)
+
+        def allVersions = getAllMetadataResolverVersions(mr.resourceId, List)
+        def mrv1 = getMetadataResolverForVersion(mr.resourceId, allVersions.body[0].id, MetadataResolver)
+        def mrv2 = getMetadataResolverForVersion(mr.resourceId, allVersions.body[1].id, MetadataResolver)
+
+        then:
+        noExceptionThrown()
+    }
+
     private getAllMetadataResolverVersions(String resourceId, responseType) {
         this.restTemplate.getForEntity(resourceUriFor(ALL_VERSIONS_URI, resourceId), responseType)
     }
diff --git a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversVersioningMetadataTests.groovy b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversVersioningMetadataTests.groovy
index 9eed8e2bc..3bc1a2f98 100644
--- a/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversVersioningMetadataTests.groovy
+++ b/backend/src/enversTest/groovy/edu/internet2/tier/shibboleth/admin/ui/service/envers/EnversVersioningMetadataTests.groovy
@@ -60,9 +60,9 @@ class EnversVersioningMetadataTests extends Specification {
 
         then:
         mrVersions[0].creator == mr.createdBy
-        mrVersions[0].date == mr.createdDateAsZonedDateTime()
+        mrVersions[0].date == mr.modifiedDateAsZonedDateTime()
         edVersions[0].creator == ed.createdBy
-        edVersions[0].date == ed.createdDateAsZonedDateTime()
+        edVersions[0].date == ed.modifiedDateAsZonedDateTime()
 
         when: 'new version due to update'
         mr.name = 'UPDATED'
diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilterTarget.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilterTarget.java
index 0abbbd11c..ffff2ca30 100644
--- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilterTarget.java
+++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/filters/EntityAttributesFilterTarget.java
@@ -1,5 +1,6 @@
 package edu.internet2.tier.shibboleth.admin.ui.domain.filters;
 
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import edu.internet2.tier.shibboleth.admin.ui.domain.AbstractAuditable;
 import lombok.EqualsAndHashCode;
 import org.hibernate.envers.AuditOverride;
@@ -9,6 +10,7 @@
 
 import javax.persistence.ElementCollection;
 import javax.persistence.Entity;
+import javax.persistence.FetchType;
 import javax.persistence.OrderColumn;
 import java.util.ArrayList;
 import java.util.List;
@@ -17,6 +19,7 @@
 @EqualsAndHashCode(callSuper = true)
 @Audited
 @AuditOverride(forClass = AbstractAuditable.class)
+@JsonIgnoreProperties({"handler", "hibernateLazyInitializer"})
 public class EntityAttributesFilterTarget extends AbstractAuditable {
     public enum EntityAttributesFilterTargetType {
         ENTITY, CONDITION_SCRIPT, CONDITION_REF, REGEX
diff --git a/ui/src/app/metadata/configuration/component/history-list.component.html b/ui/src/app/metadata/configuration/component/history-list.component.html
index 82a275060..db658f453 100644
--- a/ui/src/app/metadata/configuration/component/history-list.component.html
+++ b/ui/src/app/metadata/configuration/component/history-list.component.html
@@ -23,7 +23,7 @@
             </td>
             <td *ngIf="i === 0"><translate-i18n key="label.current">Current</translate-i18n> (v{{ history.length - i }})</td>
             <td *ngIf="i > 0">v{{ history.length - (i) }}</td>
-            <td>{{ version.date | date:'medium' }}</td>
+            <td>{{ version.date | date:DATE_FORMAT }}</td>
             <td>{{ version.creator }}</td>
             <td>
                 <button class="btn btn-link" (click)="restore.emit(version)">
diff --git a/ui/src/app/metadata/configuration/component/history-list.component.ts b/ui/src/app/metadata/configuration/component/history-list.component.ts
index 7e03468e2..68e596ab5 100644
--- a/ui/src/app/metadata/configuration/component/history-list.component.ts
+++ b/ui/src/app/metadata/configuration/component/history-list.component.ts
@@ -1,6 +1,7 @@
 import { Component, Input, EventEmitter, ChangeDetectionStrategy, Output } from '@angular/core';
 import { MetadataHistory } from '../model/history';
 import { MetadataVersion } from '../model/version';
+import { CONFIG_DATE_FORMAT } from '../configuration.values';
 
 @Component({
     selector: 'history-list',
@@ -15,6 +16,8 @@ export class HistoryListComponent {
 
     selected: MetadataVersion[] = [];
 
+    DATE_FORMAT = CONFIG_DATE_FORMAT;
+
     constructor() {}
 
     toggleVersionSelected(version: MetadataVersion): void {
diff --git a/ui/src/app/metadata/configuration/component/metadata-configuration.component.html b/ui/src/app/metadata/configuration/component/metadata-configuration.component.html
index e45530ebf..f5ab2814b 100644
--- a/ui/src/app/metadata/configuration/component/metadata-configuration.component.html
+++ b/ui/src/app/metadata/configuration/component/metadata-configuration.component.html
@@ -23,7 +23,7 @@ <h2 class="title h4 m-0 flex-grow-1">
                     <strong [ngStyle]="{'width': width}" translate="label.option">Option</strong>
                     <strong *ngFor="let date of configuration.dates" [ngStyle]="{'width': width}">
                         <translate-i18n key="label.value" *ngIf="configuration.dates.length <= 1">Value</translate-i18n>
-                        <span *ngIf="configuration.dates.length > 1">{{ date | date:'medium' }}</span>
+                        <span *ngIf="configuration.dates.length > 1">{{ date | date:DATE_FORMAT }}</span>
                     </strong>
                 </div>
                 <object-property
diff --git a/ui/src/app/metadata/configuration/component/metadata-configuration.component.ts b/ui/src/app/metadata/configuration/component/metadata-configuration.component.ts
index 86e8bd23b..280c362a6 100644
--- a/ui/src/app/metadata/configuration/component/metadata-configuration.component.ts
+++ b/ui/src/app/metadata/configuration/component/metadata-configuration.component.ts
@@ -2,6 +2,7 @@ import { Component, ChangeDetectionStrategy, Input, Output, EventEmitter } from
 import { Router, ActivatedRoute } from '@angular/router';
 import { MetadataConfiguration } from '../model/metadata-configuration';
 import { Metadata } from '../../domain/domain.type';
+import { CONFIG_DATE_FORMAT } from '../configuration.values';
 
 @Component({
     selector: 'metadata-configuration',
@@ -18,6 +19,8 @@ export class MetadataConfigurationComponent {
 
     @Output() preview: EventEmitter<any> = new EventEmitter();
 
+    DATE_FORMAT = CONFIG_DATE_FORMAT;
+
     constructor(
         private router: Router,
         private activatedRoute: ActivatedRoute
diff --git a/ui/src/app/metadata/configuration/configuration.values.ts b/ui/src/app/metadata/configuration/configuration.values.ts
index 383486cfd..53c2279e9 100644
--- a/ui/src/app/metadata/configuration/configuration.values.ts
+++ b/ui/src/app/metadata/configuration/configuration.values.ts
@@ -13,3 +13,5 @@ export enum TYPES {
 export const DEFINITIONS = {
     resolver: MetadataSourceEditor
 };
+
+export const CONFIG_DATE_FORMAT = 'MMM dd, yyyy HH:mm:ss';
diff --git a/ui/src/app/metadata/configuration/container/metadata-options.component.html b/ui/src/app/metadata/configuration/container/metadata-options.component.html
index d99166c11..972e0e4da 100644
--- a/ui/src/app/metadata/configuration/container/metadata-options.component.html
+++ b/ui/src/app/metadata/configuration/container/metadata-options.component.html
@@ -48,7 +48,6 @@ <h2 class="title h4 m-0 ml-2 flex-grow-1">
             (onUpdateOrderDown)="updateOrderDown($event)"
             (onUpdateOrderUp)="updateOrderUp($event)"
             (onRemove)="removeFilter($event)"
-            (preview)="onPreview($event)"
             [filters]="filters$ | async"></filter-configuration-list>
     </div>
     <button class="btn btn-link" (click)="onScrollTo('header')">
diff --git a/ui/src/app/metadata/domain/entity/resolver/file-backed-http-metadata-resolver.spec.ts b/ui/src/app/metadata/domain/entity/resolver/file-backed-http-metadata-resolver.spec.ts
index 669033c19..627a22571 100644
--- a/ui/src/app/metadata/domain/entity/resolver/file-backed-http-metadata-resolver.spec.ts
+++ b/ui/src/app/metadata/domain/entity/resolver/file-backed-http-metadata-resolver.spec.ts
@@ -1,4 +1,5 @@
 import { FileBackedHttpMetadataResolver } from './file-backed-http-metadata-resolver';
+import { MetadataResolver } from '../../model';
 
 describe('Resolver construct', () => {
 
@@ -60,8 +61,8 @@ describe('Resolver construct', () => {
             }
         ],
         serviceEnabled: true,
-        createdDate: 'string (date)',
-        modifiedDate: 'string (date)',
+        createdDate: 'December 17, 1995 03:24:00',
+        modifiedDate: 'December 17, 1995 03:24:00',
         relyingPartyOverrides: {
             'signAssertion': true,
             'dontSignResponse': true,
@@ -83,11 +84,51 @@ describe('Resolver construct', () => {
             'mail'
         ]
     };
-    const entity = new FileBackedHttpMetadataResolver(config);
 
     it('should populate its own values', () => {
+        const entity = new FileBackedHttpMetadataResolver(config);
         Object.keys(config).forEach(key => {
             expect(entity[key]).toEqual(config[key]);
         });
     });
+
+    describe('isDraft method', () => {
+        it('should return false if no createDate defined', () => {
+            const entity = new FileBackedHttpMetadataResolver(config);
+            expect(entity.isDraft()).toBe(false);
+        });
+
+        it('should return false if no createDate defined', () => {
+            const { createdDate, ...rest } = config;
+            const entity = new FileBackedHttpMetadataResolver(rest as MetadataResolver);
+            expect(entity.isDraft()).toBe(true);
+        });
+    });
+
+    describe('getCreationDate method', () => {
+        it('should return false if no createDate defined', () => {
+            const entity = new FileBackedHttpMetadataResolver(config);
+            expect(entity.getCreationDate()).toBeDefined();
+        });
+
+        it('should return false if no createDate defined', () => {
+            const { createdDate, ...rest } = config;
+            const entity = new FileBackedHttpMetadataResolver(rest as MetadataResolver);
+            expect(entity.getCreationDate()).toBeNull();
+        });
+    });
+
+    describe('enabled getter', () => {
+        it('should return the serviceEnabled attribute', () => {
+            const entity = new FileBackedHttpMetadataResolver(config);
+            expect(entity.enabled).toBe(config.serviceEnabled);
+        });
+    });
+
+    describe('serialize method', () => {
+        it('should return itself', () => {
+            const entity = new FileBackedHttpMetadataResolver(config);
+            expect(entity.serialize()).toBe(entity);
+        });
+    });
 });
diff --git a/ui/src/app/metadata/domain/service/draft.service.spec.ts b/ui/src/app/metadata/domain/service/draft.service.spec.ts
index 199a301d9..f03da6906 100644
--- a/ui/src/app/metadata/domain/service/draft.service.spec.ts
+++ b/ui/src/app/metadata/domain/service/draft.service.spec.ts
@@ -1,6 +1,7 @@
 import { TestBed } from '@angular/core/testing';
 import { EntityDraftService } from './draft.service';
 import { FileBackedHttpMetadataResolver } from '../entity';
+import { MetadataResolver } from '../model';
 
 describe(`EntityDraftService`, () => {
     let service: EntityDraftService;
@@ -36,5 +37,71 @@ describe(`EntityDraftService`, () => {
                 done();
             });
         });
+
+        it(`should return a 404 error if not found`, (done: DoneFn) => {
+            let id = null;
+            service.find(id).subscribe(null, err => {
+                expect(err).toEqual(404);
+                done();
+            });
+        });
+    });
+
+    describe('exists', () => {
+        it('should check if the provided id exists in storage', () => {
+            spyOn(service.storage, 'query').and.returnValue([{id: 'bar'} as MetadataResolver]);
+            expect(service.exists('foo')).toBe(false);
+            expect(service.exists('bar')).toBe(true);
+        });
+
+        it('should use the provided attr', () => {
+            spyOn(service.storage, 'query').and.returnValue([
+                { id: 'bar', serviceProviderName: 'foo' } as MetadataResolver
+            ]);
+            expect(service.exists('foo', 'serviceProviderName')).toBe(true);
+            expect(service.exists('bar', 'serviceProviderName')).toBe(false);
+        });
+    });
+
+    describe('save', () => {
+        it('should add the provider to storage', () => {
+            const resolver = { id: 'bar' } as MetadataResolver;
+            spyOn(service.storage, 'add');
+            service.save(resolver).subscribe();
+            expect(service.storage.add).toHaveBeenCalledWith(resolver);
+        });
+    });
+
+    describe('remove', () => {
+        it('should remove the provider from storage', () => {
+            const resolver = { id: 'bar' } as MetadataResolver;
+            spyOn(service.storage, 'removeByAttr');
+            service.remove(resolver).subscribe();
+            expect(service.storage.removeByAttr).toHaveBeenCalledWith(resolver.id, 'id');
+        });
+    });
+
+    describe('update', () => {
+        it('should remove the provider from storage', () => {
+            const resolver = { id: 'bar' } as MetadataResolver;
+            const updates = { id: 'foo', serviceProviderName: 'bar' }; 
+            spyOn(service.storage, 'findByAttr').and.returnValue(resolver);
+            spyOn(service.storage, 'add');
+            spyOn(service.storage, 'removeByAttr');
+            service.update(resolver).subscribe();
+            expect(service.storage.removeByAttr).toHaveBeenCalled();
+            expect(service.storage.add).toHaveBeenCalled();
+            expect(service.storage.findByAttr).toHaveBeenCalled();
+        });
+
+        it('should return a 404 if not found', () => {
+            const resolver = { id: 'bar' } as MetadataResolver;
+            const updates = { id: 'foo', serviceProviderName: 'bar' };
+            spyOn(service.storage, 'findByAttr').and.returnValue(null);
+            service.update(resolver).subscribe(null, (err) => {
+                expect(err).toBe(404);
+                expect(service.storage.findByAttr).toHaveBeenCalled();
+            });
+        });
     });
 });
diff --git a/ui/src/app/metadata/domain/service/resolver.service.spec.ts b/ui/src/app/metadata/domain/service/resolver.service.spec.ts
index 71d7686e2..c11bb0dd5 100644
--- a/ui/src/app/metadata/domain/service/resolver.service.spec.ts
+++ b/ui/src/app/metadata/domain/service/resolver.service.spec.ts
@@ -30,13 +30,36 @@ describe(`Resolver Service`, () => {
             }
         )));
 
-        xit(`should emit 'true' for 200 Ok`, async(inject([ResolverService, HttpTestingController],
+        it(`should emit 'true' for 200 Ok`, async(inject([ResolverService, HttpTestingController],
             (service: ResolverService, backend: HttpTestingController) => {
                 service.query().subscribe((next) => {
                     expect(next).toBeTruthy();
                 });
 
-                backend.expectOne('/api/EntityDescriptors').flush([], { status: 200, statusText: 'Ok' });
+                backend.expectOne('/api/EntityDescriptors').flush(['foo'], { status: 200, statusText: 'Ok' });
+            }
+        )));
+    });
+
+    describe('queryForAdmin', () => {
+        it(`should send an expected query request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.queryForAdmin().subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === '/api/EntityDescriptor/disabledNonAdmin'
+                        && req.method === 'GET';
+                }, `GET EntityDescriptors collection for an admin`);
+            }
+        )));
+
+        it(`should emit 'true' for 200 Ok`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.queryForAdmin().subscribe((next) => {
+                    expect(next).toBeTruthy();
+                });
+
+                backend.expectOne('/api/EntityDescriptor/disabledNonAdmin').flush(['foo'], { status: 200, statusText: 'Ok' });
             }
         )));
     });
@@ -55,4 +78,103 @@ describe(`Resolver Service`, () => {
             }
         )));
     });
+
+    describe('update', () => {
+        let id = 'foo',
+            serviceProviderName = 'Test Provider',
+            createdBy = 'admin';
+
+        it(`should send an expected PUT request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.update({id, serviceProviderName, createdBy}).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor/${id}`
+                        && req.method === 'PUT';
+                }, `PUT EntityDescriptor by id`);
+            }
+        )));
+    });
+
+    describe('create', () => {
+        let id = 'foo',
+            serviceProviderName = 'Test Provider',
+            createdBy = 'admin';
+
+        it(`should send an expected POST request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.save({ id, serviceProviderName, createdBy }).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor`
+                        && req.method === 'POST';
+                }, `POST new EntityDescriptor`);
+            }
+        )));
+    });
+
+    describe('remove', () => {
+        let id = 'foo',
+            serviceProviderName = 'Test Provider',
+            createdBy = 'admin';
+
+        it(`should send an expected PUT request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.remove({ id, serviceProviderName, createdBy }).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor/${id}`
+                        && req.method === 'DELETE';
+                }, `DELETE an EntityDescriptor`);
+            }
+        )));
+    });
+
+    describe('preview', () => {
+        let id = 'foo';
+
+        it(`should send an expected GET request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                service.preview(id).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor/${id}`
+                        && req.method === 'GET'
+                        && req.headers.get('Accept') === 'application/xml'
+                        && req.responseType === 'text';
+                }, `GET an EntityDescriptor (xml)`);
+            }
+        )));
+    });
+
+    describe('upload', () => {
+        it(`should send an expected POST request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                const name = 'foo', xml = '<foo></foo>';
+                service.upload(name, xml).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor`
+                        && req.method === 'POST'
+                        && req.headers.get('Content-Type') === 'application/xml';
+                }, `POST new EntityDescriptor`);
+            }
+        )));
+    });
+
+    describe('createFromUrl', () => {
+        it(`should send an expected POST request`, async(inject([ResolverService, HttpTestingController],
+            (service: ResolverService, backend: HttpTestingController) => {
+                const name = 'foo', url = 'http://goo.gle';
+                service.createFromUrl(name, url).subscribe();
+
+                backend.expectOne((req: HttpRequest<any>) => {
+                    return req.url === `/api/EntityDescriptor`
+                        && req.method === 'POST'
+                        && req.headers.get('Content-Type') === 'application/x-www-form-urlencoded'
+                        && req.body === `metadataUrl=${url}`;
+                }, `POST new EntityDescriptor`);
+            }
+        )));
+    });
 });
diff --git a/ui/src/app/metadata/domain/service/resolver.service.ts b/ui/src/app/metadata/domain/service/resolver.service.ts
index 2a158f75f..cae3a5ed8 100644
--- a/ui/src/app/metadata/domain/service/resolver.service.ts
+++ b/ui/src/app/metadata/domain/service/resolver.service.ts
@@ -15,24 +15,15 @@ export class ResolverService {
     ) {}
 
     query(): Observable<MetadataResolver[]> {
-        return this.http.get<MetadataResolver[]>(`${ this.base }${ this.endpoint }s`, {})
-            .pipe(
-                catchError(err => throwError([]))
-            );
+        return this.http.get<MetadataResolver[]>(`${ this.base }${ this.endpoint }s`, {});
     }
 
     queryForAdmin(): Observable<MetadataResolver[]> {
-        return this.http.get<MetadataResolver[]>(`${this.base}${this.endpoint}/disabledNonAdmin`, {})
-            .pipe(
-                catchError(err => throwError([]))
-            );
+        return this.http.get<MetadataResolver[]>(`${this.base}${this.endpoint}/disabledNonAdmin`, {});
     }
 
     find(id: string): Observable<MetadataResolver> {
-        return this.http.get<MetadataResolver>(`${ this.base }${ this.endpoint }/${ id }`)
-            .pipe(
-                catchError(err => throwError(err))
-            );
+        return this.http.get<MetadataResolver>(`${ this.base }${ this.endpoint }/${ id }`);
     }
 
     update(provider: MetadataResolver): Observable<MetadataResolver> {
@@ -52,9 +43,10 @@ export class ResolverService {
         return this.http.post<MetadataResolver>(`${this.base}${this.endpoint}`, xml, {
             headers: new HttpHeaders().set('Content-Type', 'application/xml'),
             params: new HttpParams().set('spName', name)
-        }).pipe(catchError(error => {
-            return throwError({ errorCode: error.status, errorMessage: `Unable to upload file ... ${error.error.errorMessage}` });
-        }));
+        }).pipe(catchError(error => throwError({
+            errorCode: error.status,
+            errorMessage: `Unable to upload file ... ${error.error.errorMessage}`
+        })));
     }
 
     createFromUrl(name: string, url: string): Observable<MetadataResolver> {
@@ -62,9 +54,12 @@ export class ResolverService {
         return this.http.post<MetadataResolver>(`${this.base}${this.endpoint}`, body, {
             headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded'),
             params: new HttpParams().set('spName', name)
-        }).pipe(catchError(error => {
-            return throwError({ errorCode: error.status, errorMessage: `Unable to upload file ... ${error.error.errorMessage}` });
-        }));
+        }).pipe(catchError(error => throwError(
+            {
+                errorCode: error.status,
+                errorMessage: `Unable to upload file ... ${error.error.errorMessage}`
+            }
+        )));
     }
 
     preview(id: string): Observable<string> {