tsai
/
squidex
mirror of https://github.com/Squidex/squidex.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

UI fixed and simplified.

pull/247/head
Sebastian Stehle 8 years ago
parent
a13943bf18
commit
91c5053ff8
7 changed files with 134 additions and 197 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 15
      src/Squidex/Areas/Api/Controllers/Content/Models/ContentDto.cs
  2. 35
      src/Squidex/app/features/content/pages/content/content-page.component.ts
  3. 70
      src/Squidex/app/features/content/pages/contents/contents-page.component.ts
  4. 11
      src/Squidex/app/features/content/pages/messages.ts
  5. 94
      src/Squidex/app/shared/services/contents.service.spec.ts
  6. 88
      src/Squidex/app/shared/services/contents.service.ts

15
src/Squidex/Areas/Api/Controllers/Content/Models/ContentDto.cs
View File

@ -40,6 +40,21 @@ namespace Squidex.Areas.Api.Controllers.Contents.Models
[Required] [Required]
public object Data { get; set; } public object Data { get; set; }
/// <summary>
/// The scheduled status.
/// </summary>
public Status? ScheduledTo { get; }
/// <summary>
/// The scheduled date.
/// </summary>
public Instant? ScheduledAt { get; }
/// <summary>
/// The user that has scheduled the content.
/// </summary>
public RefToken ScheduledBy { get; }
/// <summary> /// <summary>
/// The date and time when the content item has been created. /// The date and time when the content item has been created.
/// </summary> /// </summary>

35
src/Squidex/app/features/content/pages/content/content-page.component.ts
View File

@ -12,9 +12,8 @@ import { Observable, Subscription } from 'rxjs';
import { import {
ContentCreated, ContentCreated,
ContentPublished,
ContentRemoved, ContentRemoved,
ContentUnpublished, ContentStatusChanged,
ContentUpdated, ContentUpdated,
ContentVersionSelected ContentVersionSelected
} from './../messages'; } from './../messages';
@ -39,8 +38,7 @@ import {
] ]
}) })
export class ContentPageComponent implements CanComponentDeactivate, OnDestroy, OnInit { export class ContentPageComponent implements CanComponentDeactivate, OnDestroy, OnInit {
private contentPublishedSubscription: Subscription; private contentStatusChangedSubscription: Subscription;
private contentUnpublishedSubscription: Subscription;
private contentDeletedSubscription: Subscription; private contentDeletedSubscription: Subscription;
private contentVersionSelectedSubscription: Subscription; private contentVersionSelectedSubscription: Subscription;
@ -63,8 +61,7 @@ export class ContentPageComponent implements CanComponentDeactivate, OnDestroy,
public ngOnDestroy() { public ngOnDestroy() {
this.contentVersionSelectedSubscription.unsubscribe(); this.contentVersionSelectedSubscription.unsubscribe();
this.contentUnpublishedSubscription.unsubscribe(); this.contentStatusChangedSubscription.unsubscribe();
this.contentPublishedSubscription.unsubscribe();
this.contentDeletedSubscription.unsubscribe(); this.contentDeletedSubscription.unsubscribe();
} }
@ -75,27 +72,25 @@ export class ContentPageComponent implements CanComponentDeactivate, OnDestroy,
this.loadVersion(message.version); this.loadVersion(message.version);
}); });
this.contentPublishedSubscription = this.contentDeletedSubscription =
this.ctx.bus.of(ContentPublished) this.ctx.bus.of(ContentRemoved)
.subscribe(message => {
if (this.content && message.content.id === this.content.id) {
this.content = this.content.publish(message.content.lastModifiedBy, message.content.version, message.content.lastModified);
}
});
this.contentUnpublishedSubscription =
this.ctx.bus.of(ContentUnpublished)
.subscribe(message => { .subscribe(message => {
if (this.content && message.content.id === this.content.id) { if (this.content && message.content.id === this.content.id) {
this.content = this.content.unpublish(message.content.lastModifiedBy, message.content.version, message.content.lastModified); this.router.navigate(['../'], { relativeTo: this.ctx.route });
} }
}); });
this.contentDeletedSubscription = this.contentStatusChangedSubscription =
this.ctx.bus.of(ContentRemoved) this.ctx.bus.of(ContentStatusChanged)
.subscribe(message => { .subscribe(message => {
if (this.content && message.content.id === this.content.id) { if (this.content && message.content.id === this.content.id) {
this.router.navigate(['../'], { relativeTo: this.ctx.route }); this.content =
this.content.changeStatus(
message.content.scheduledTo || message.content.status,
message.content.lastModifiedBy,
message.content.version,
message.content.lastModified,
message.content.scheduledAt);
} }
}); });

70
src/Squidex/app/features/content/pages/contents/contents-page.component.ts
View File

@ -11,9 +11,8 @@ import { Observable, Subscription } from 'rxjs';
import { import {
ContentCreated, ContentCreated,
ContentPublished,
ContentRemoved, ContentRemoved,
ContentUnpublished, ContentStatusChanged,
ContentUpdated ContentUpdated
} from './../messages'; } from './../messages';
@ -27,7 +26,8 @@ import {
ImmutableArray, ImmutableArray,
ModalView, ModalView,
Pager, Pager,
SchemaDetailsDto SchemaDetailsDto,
DateTime
} from 'shared'; } from 'shared';
@Component({ @Component({
@ -118,7 +118,7 @@ export class ContentsPageComponent implements OnDestroy, OnInit {
} }
public publishContent(content: ContentDto) { public publishContent(content: ContentDto) {
this.publishContentItem(content).subscribe(); this.changeContentItem(content, 'publish', 'Published').subscribe();
} }
public publishSelected() { public publishSelected() {
@ -126,29 +126,15 @@ export class ContentsPageComponent implements OnDestroy, OnInit {
this.contentItems.values this.contentItems.values
.filter(c => this.selectedItems[c.id]) .filter(c => this.selectedItems[c.id])
.filter(c => c.status !== 'Published') .filter(c => c.status !== 'Published')
.map(c => this.publishContentItem(c))) .map(c => this.changeContentItem(c, 'publish', 'Published')))
.finally(() => { .finally(() => {
this.updateSelectionSummary(); this.updateSelectionSummary();
}) })
.subscribe(); .subscribe();
} }
private publishContentItem(content: ContentDto): Observable<any> {
return this.contentsService.publishContent(this.ctx.appName, this.schema.name, content.id, content.version)
.catch(error => {
this.ctx.notifyError(error);
return Observable.throw(error);
})
.do(dto => {
this.contentItems = this.contentItems.replaceBy('id', content.publish(this.ctx.userToken, dto.version));
this.emitContentPublished(content);
});
}
public unpublishContent(content: ContentDto) { public unpublishContent(content: ContentDto) {
this.unpublishContentItem(content).subscribe(); this.changeContentItem(content, 'unpublish', 'Draft').subscribe();
} }
public unpublishSelected() { public unpublishSelected() {
@ -156,31 +142,31 @@ export class ContentsPageComponent implements OnDestroy, OnInit {
this.contentItems.values this.contentItems.values
.filter(c => this.selectedItems[c.id]) .filter(c => this.selectedItems[c.id])
.filter(c => c.status !== 'Unpublished') .filter(c => c.status !== 'Unpublished')
.map(c => this.unpublishContentItem(c))) .map(c => this.changeContentItem(c, 'unpublish', 'Draft')))
.finally(() => { .finally(() => {
this.updateSelectionSummary(); this.updateSelectionSummary();
}) })
.subscribe(); .subscribe();
} }
private unpublishContentItem(content: ContentDto): Observable<any> { private changeContentItem(content: ContentDto, action: string, status: string): Observable<any> {
return this.contentsService.unpublishContent(this.ctx.appName, this.schema.name, content.id, content.version) return this.contentsService.changeContentStatus(this.ctx.appName, this.schema.name, content.id, action, content.version)
.catch(error => { .catch(error => {
this.ctx.notifyError(error); this.ctx.notifyError(error);
return Observable.throw(error); return Observable.throw(error);
}) })
.do(dto => { .do(dto => {
this.contentItems = this.contentItems.replaceBy('id', content.unpublish(this.ctx.userToken, dto.version)); this.contentItems = this.contentItems.replaceBy('id', content.changeStatus(status, this.ctx.userToken, dto.version));
this.emitContentUnpublished(content); this.emitContentStatusChanged(content);
}); });
} }
public archiveSelected() { public archiveSelected() {
Observable.forkJoin( Observable.forkJoin(
this.contentItems.values.filter(c => this.selectedItems[c.id]) this.contentItems.values.filter(c => this.selectedItems[c.id])
.map(c => this.archiveContentItem(c))) .map(c => this.changeContentItem(c, 'archive', 'Archived')))
.finally(() => { .finally(() => {
this.load(); this.load();
}) })
@ -188,26 +174,17 @@ export class ContentsPageComponent implements OnDestroy, OnInit {
} }
public archiveContent(content: ContentDto) { public archiveContent(content: ContentDto) {
this.archiveContentItem(content) this.changeContentItem(content, 'archive', 'Archived')
.finally(() => { .finally(() => {
this.load(); this.load();
}) })
.subscribe(); .subscribe();
} }
public archiveContentItem(content: ContentDto): Observable<any> {
return this.contentsService.archiveContent(this.ctx.appName, this.schema.name, content.id, content.version)
.catch(error => {
this.ctx.notifyError(error);
return Observable.throw(error);
});
}
public restoreSelected() { public restoreSelected() {
Observable.forkJoin( Observable.forkJoin(
this.contentItems.values.filter(c => this.selectedItems[c.id]) this.contentItems.values.filter(c => this.selectedItems[c.id])
.map(c => this.restoreContentItem(c))) .map(c => this.changeContentItem(c, 'restore', 'Draft')))
.finally(() => { .finally(() => {
this.load(); this.load();
}) })
@ -215,22 +192,13 @@ export class ContentsPageComponent implements OnDestroy, OnInit {
} }
public restoreContent(content: ContentDto) { public restoreContent(content: ContentDto) {
this.restoreContentItem(content) this.changeContentItem(content, 'restore', 'Draft')
.finally(() => { .finally(() => {
this.load(); this.load();
}) })
.subscribe(); .subscribe();
} }
public restoreContentItem(content: ContentDto): Observable<any> {
return this.contentsService.restoreContent(this.ctx.appName, this.schema.name, content.id, content.version)
.catch(error => {
this.ctx.notifyError(error);
return Observable.throw(error);
});
}
public deleteSelected(content: ContentDto) { public deleteSelected(content: ContentDto) {
Observable.forkJoin( Observable.forkJoin(
this.contentItems.values.filter(c => this.selectedItems[c.id]) this.contentItems.values.filter(c => this.selectedItems[c.id])
@ -359,12 +327,8 @@ export class ContentsPageComponent implements OnDestroy, OnInit {
this.languageSelected = language; this.languageSelected = language;
} }
private emitContentPublished(content: ContentDto) { private emitContentStatusChanged(content: ContentDto) {
this.ctx.bus.emit(new ContentPublished(content)); this.ctx.bus.emit(new ContentStatusChanged(content));
}
private emitContentUnpublished(content: ContentDto) {
this.ctx.bus.emit(new ContentUnpublished(content));
} }
private emitContentRemoved(content: ContentDto) { private emitContentRemoved(content: ContentDto) {

11
src/Squidex/app/features/content/pages/messages.ts
View File

@ -5,7 +5,7 @@
* Copyright (c) Squidex UG (haftungsbeschränkt). All rights reserved. * Copyright (c) Squidex UG (haftungsbeschränkt). All rights reserved.
*/ */
import { ContentDto } from 'shared'; import { ContentDto, DateTime } from 'shared';
export class ContentCreated { export class ContentCreated {
constructor( constructor(
@ -35,14 +35,7 @@ export class ContentVersionSelected {
} }
} }
export class ContentPublished { export class ContentStatusChanged {
constructor(
public readonly content: ContentDto
) {
}
}
export class ContentUnpublished {
constructor( constructor(
public readonly content: ContentDto public readonly content: ContentDto
) { ) {

94
src/Squidex/app/shared/services/contents.service.spec.ts
View File

@ -23,11 +23,12 @@ describe('ContentDto', () => {
const creator = 'not-me'; const creator = 'not-me';
const modified = DateTime.now(); const modified = DateTime.now();
const modifier = 'me'; const modifier = 'me';
const dueTime = DateTime.now().addDays(1);
const version = new Version('1'); const version = new Version('1');
const newVersion = new Version('2'); const newVersion = new Version('2');
it('should update data property and user info when updating', () => { it('should update data property and user info when updating', () => {
const content_1 = new ContentDto('1', 'Published', creator, creator, creation, creation, { data: 1 }, version); const content_1 = new ContentDto('1', 'Published', creator, creator, creation, creation, null, null, null, { data: 1 }, version);
const content_2 = content_1.update({ data: 2 }, modifier, newVersion, modified); const content_2 = content_1.update({ data: 2 }, modifier, newVersion, modified);
expect(content_2.data).toEqual({ data: 2 }); expect(content_2.data).toEqual({ data: 2 });
@ -36,9 +37,9 @@ describe('ContentDto', () => {
expect(content_2.version).toEqual(newVersion); expect(content_2.version).toEqual(newVersion);
}); });
it('should update status property and user info when publishing', () => { it('should update status property and user info when changing status', () => {
const content_1 = new ContentDto('1', 'Draft', creator, creator, creation, creation, { data: 1 }, version); const content_1 = new ContentDto('1', 'Draft', creator, creator, creation, creation, null, null, null, { data: 1 }, version);
const content_2 = content_1.publish(modifier, newVersion, modified); const content_2 = content_1.changeStatus('Published', modifier, newVersion, modified);
expect(content_2.status).toEqual('Published'); expect(content_2.status).toEqual('Published');
expect(content_2.lastModified).toEqual(modified); expect(content_2.lastModified).toEqual(modified);
@ -46,40 +47,23 @@ describe('ContentDto', () => {
expect(content_2.version).toEqual(newVersion); expect(content_2.version).toEqual(newVersion);
}); });
it('should update status property and user info when unpublishing', () => { it('should update schedules property and user info when changing status with due time', () => {
const content_1 = new ContentDto('1', 'Published', creator, creator, creation, creation, { data: 1 }, version); const content_1 = new ContentDto('1', 'Draft', creator, creator, creation, creation, null, null, null, { data: 1 }, version);
const content_2 = content_1.unpublish(modifier, newVersion, modified); const content_2 = content_1.changeStatus('Published', modifier, newVersion, modified, dueTime);
expect(content_2.status).toEqual('Draft');
expect(content_2.lastModified).toEqual(modified);
expect(content_2.lastModifiedBy).toEqual(modifier);
expect(content_2.version).toEqual(newVersion);
});
it('should update status property and user info when archiving', () => {
const content_1 = new ContentDto('1', 'Draft', creator, creator, creation, creation, { data: 1 }, version);
const content_2 = content_1.archive(modifier, newVersion, modified);
expect(content_2.status).toEqual('Archived');
expect(content_2.lastModified).toEqual(modified);
expect(content_2.lastModifiedBy).toEqual(modifier);
expect(content_2.version).toEqual(newVersion);
});
it('should update status property and user info when restoring', () => {
const content_1 = new ContentDto('1', 'Archived', creator, creator, creation, creation, { data: 1 }, version);
const content_2 = content_1.restore(modifier, newVersion, modified);
expect(content_2.status).toEqual('Draft'); expect(content_2.status).toEqual('Draft');
expect(content_2.lastModified).toEqual(modified); expect(content_2.lastModified).toEqual(modified);
expect(content_2.lastModifiedBy).toEqual(modifier); expect(content_2.lastModifiedBy).toEqual(modifier);
expect(content_2.scheduledAt).toEqual(dueTime);
expect(content_2.scheduledBy).toEqual(modifier);
expect(content_2.scheduledTo).toEqual('Published');
expect(content_2.version).toEqual(newVersion); expect(content_2.version).toEqual(newVersion);
}); });
it('should update data property when setting data', () => { it('should update data property when setting data', () => {
const newData = {}; const newData = {};
const content_1 = new ContentDto('1', 'Published', creator, creator, creation, creation, { data: 1 }, version); const content_1 = new ContentDto('1', 'Published', creator, creator, creation, creation, null, null, null, { data: 1 }, version);
const content_2 = content_1.setData(newData); const content_2 = content_1.setData(newData);
expect(content_2.data).toBe(newData); expect(content_2.data).toBe(newData);
@ -130,6 +114,9 @@ describe('ContentsService', () => {
createdBy: 'Created1', createdBy: 'Created1',
lastModified: '2017-12-12T10:10', lastModified: '2017-12-12T10:10',
lastModifiedBy: 'LastModifiedBy1', lastModifiedBy: 'LastModifiedBy1',
scheduledTo: 'Draft',
scheduledBy: 'Scheduler1',
scheduledAt: '2018-12-12T10:10',
version: 11, version: 11,
data: {} data: {}
}, },
@ -151,11 +138,17 @@ describe('ContentsService', () => {
new ContentDto('id1', 'Published', 'Created1', 'LastModifiedBy1', new ContentDto('id1', 'Published', 'Created1', 'LastModifiedBy1',
DateTime.parseISO_UTC('2016-12-12T10:10'), DateTime.parseISO_UTC('2016-12-12T10:10'),
DateTime.parseISO_UTC('2017-12-12T10:10'), DateTime.parseISO_UTC('2017-12-12T10:10'),
'Draft',
'Scheduler1',
DateTime.parseISO_UTC('2018-12-12T10:10'),
{}, {},
new Version('11')), new Version('11')),
new ContentDto('id2', 'Published', 'Created2', 'LastModifiedBy2', new ContentDto('id2', 'Published', 'Created2', 'LastModifiedBy2',
DateTime.parseISO_UTC('2016-10-12T10:10'), DateTime.parseISO_UTC('2016-10-12T10:10'),
DateTime.parseISO_UTC('2017-10-12T10:10'), DateTime.parseISO_UTC('2017-10-12T10:10'),
null,
null,
null,
{}, {},
new Version('22')) new Version('22'))
])); ]));
@ -221,6 +214,9 @@ describe('ContentsService', () => {
createdBy: 'Created1', createdBy: 'Created1',
lastModified: '2017-12-12T10:10', lastModified: '2017-12-12T10:10',
lastModifiedBy: 'LastModifiedBy1', lastModifiedBy: 'LastModifiedBy1',
scheduledTo: 'Draft',
scheduledBy: 'Scheduler1',
scheduledAt: '2018-12-12T10:10',
data: {} data: {}
}, { }, {
headers: { headers: {
@ -232,6 +228,9 @@ describe('ContentsService', () => {
new ContentDto('id1', 'Published', 'Created1', 'LastModifiedBy1', new ContentDto('id1', 'Published', 'Created1', 'LastModifiedBy1',
DateTime.parseISO_UTC('2016-12-12T10:10'), DateTime.parseISO_UTC('2016-12-12T10:10'),
DateTime.parseISO_UTC('2017-12-12T10:10'), DateTime.parseISO_UTC('2017-12-12T10:10'),
'Draft',
'Scheduler1',
DateTime.parseISO_UTC('2018-12-12T10:10'),
{}, {},
new Version('2'))); new Version('2')));
})); }));
@ -270,6 +269,9 @@ describe('ContentsService', () => {
new ContentDto('id1', 'Published', 'Created1', 'LastModifiedBy1', new ContentDto('id1', 'Published', 'Created1', 'LastModifiedBy1',
DateTime.parseISO_UTC('2016-12-12T10:10'), DateTime.parseISO_UTC('2016-12-12T10:10'),
DateTime.parseISO_UTC('2017-12-12T10:10'), DateTime.parseISO_UTC('2017-12-12T10:10'),
null,
null,
null,
{}, {},
new Version('2'))); new Version('2')));
})); }));
@ -310,10 +312,10 @@ describe('ContentsService', () => {
req.flush({}); req.flush({});
})); }));
it('should make put request to publish content', it('should make put request to change content status',
inject([ContentsService, HttpTestingController], (contentsService: ContentsService, httpMock: HttpTestingController) => { inject([ContentsService, HttpTestingController], (contentsService: ContentsService, httpMock: HttpTestingController) => {
contentsService.publishContent('my-app', 'my-schema', 'content1', version).subscribe(); contentsService.changeContentStatus('my-app', 'my-schema', 'content1', 'publish', version).subscribe();
const req = httpMock.expectOne('http://service/p/api/content/my-app/my-schema/content1/publish'); const req = httpMock.expectOne('http://service/p/api/content/my-app/my-schema/content1/publish');
@ -323,38 +325,14 @@ describe('ContentsService', () => {
req.flush({}); req.flush({});
})); }));
it('should make put request to unpublish content', it('should make put request with due time when status change is scheduled',
inject([ContentsService, HttpTestingController], (contentsService: ContentsService, httpMock: HttpTestingController) => {
contentsService.unpublishContent('my-app', 'my-schema', 'content1', version).subscribe();
const req = httpMock.expectOne('http://service/p/api/content/my-app/my-schema/content1/unpublish');
expect(req.request.method).toEqual('PUT');
expect(req.request.headers.get('If-Match')).toEqual(version.value);
req.flush({});
}));
it('should make put request to archive content',
inject([ContentsService, HttpTestingController], (contentsService: ContentsService, httpMock: HttpTestingController) => { inject([ContentsService, HttpTestingController], (contentsService: ContentsService, httpMock: HttpTestingController) => {
contentsService.archiveContent('my-app', 'my-schema', 'content1', version).subscribe(); const dueTime = DateTime.parseISO_UTC('2016-12-12T10:10');
const req = httpMock.expectOne('http://service/p/api/content/my-app/my-schema/content1/archive');
expect(req.request.method).toEqual('PUT');
expect(req.request.headers.get('If-Match')).toEqual(version.value);
req.flush({});
}));
it('should make put request to restore content',
inject([ContentsService, HttpTestingController], (contentsService: ContentsService, httpMock: HttpTestingController) => {
contentsService.restoreContent('my-app', 'my-schema', 'content1', version).subscribe(); contentsService.changeContentStatus('my-app', 'my-schema', 'content1', 'publish', version, dueTime).subscribe();
const req = httpMock.expectOne('http://service/p/api/content/my-app/my-schema/content1/restore'); const req = httpMock.expectOne('http://service/p/api/content/my-app/my-schema/content1/publish?dueTime=2016-12-12T10:10:00.000Z');
expect(req.request.method).toEqual('PUT'); expect(req.request.method).toEqual('PUT');
expect(req.request.headers.get('If-Match')).toEqual(version.value); expect(req.request.headers.get('If-Match')).toEqual(version.value);

88
src/Squidex/app/shared/services/contents.service.ts
View File

@ -36,6 +36,9 @@ export class ContentDto {
public readonly lastModifiedBy: string, public readonly lastModifiedBy: string,
public readonly created: DateTime, public readonly created: DateTime,
public readonly lastModified: DateTime, public readonly lastModified: DateTime,
public readonly scheduledTo: string | null,
public readonly scheduledBy: string | null,
public readonly scheduledAt: DateTime | null,
public readonly data: any, public readonly data: any,
public readonly version: Version public readonly version: Version
) { ) {
@ -49,35 +52,38 @@ export class ContentDto {
this.lastModifiedBy, this.lastModifiedBy,
this.created, this.created,
this.lastModified, this.lastModified,
this.scheduledTo,
this.scheduledBy,
this.scheduledAt,
data, data,
this.version); this.version);
} }
public publish(user: string, version: Version, now?: DateTime): ContentDto { public changeStatus(status: string, user: string, version: Version, now?: DateTime, dueTime: DateTime | null = null): ContentDto {
return this.changeStatus('Published', user, version, now); if (dueTime) {
} return new ContentDto(
this.id,
public unpublish(user: string, version: Version, now?: DateTime): ContentDto { this.status,
return this.changeStatus('Draft', user, version, now); this.createdBy, user,
} this.created, now || DateTime.now(),
status,
public archive(user: string, version: Version, now?: DateTime): ContentDto { user,
return this.changeStatus('Archived', user, version, now); dueTime,
} this.data,
version);
public restore(user: string, version: Version, now?: DateTime): ContentDto { } else {
return this.changeStatus('Draft', user, version, now);
}
private changeStatus(status: string, user: string, version: Version, now?: DateTime): ContentDto {
return new ContentDto( return new ContentDto(
this.id, this.id,
status, status,
this.createdBy, user, this.createdBy, user,
this.created, now || DateTime.now(), this.created, now || DateTime.now(),
null,
null,
null,
this.data, this.data,
version); version);
} }
}
public update(data: any, user: string, version: Version, now?: DateTime): ContentDto { public update(data: any, user: string, version: Version, now?: DateTime): ContentDto {
return new ContentDto( return new ContentDto(
@ -85,6 +91,9 @@ export class ContentDto {
this.status, this.status,
this.createdBy, user, this.createdBy, user,
this.created, now || DateTime.now(), this.created, now || DateTime.now(),
this.scheduledTo,
this.scheduledBy,
this.scheduledAt,
data, data,
version); version);
} }
@ -146,6 +155,9 @@ export class ContentsService {
item.lastModifiedBy, item.lastModifiedBy,
DateTime.parseISO_UTC(item.created), DateTime.parseISO_UTC(item.created),
DateTime.parseISO_UTC(item.lastModified), DateTime.parseISO_UTC(item.lastModified),
item.scheduledTo || null,
item.scheduledBy || null,
item.scheduledAt ? DateTime.parseISO_UTC(item.scheduledAt) : null,
item.data, item.data,
new Version(item.version.toString())); new Version(item.version.toString()));
})); }));
@ -167,6 +179,9 @@ export class ContentsService {
body.lastModifiedBy, body.lastModifiedBy,
DateTime.parseISO_UTC(body.created), DateTime.parseISO_UTC(body.created),
DateTime.parseISO_UTC(body.lastModified), DateTime.parseISO_UTC(body.lastModified),
body.scheduledTo || null,
body.scheduledBy || null,
body.scheduledAt || null ? DateTime.parseISO_UTC(body.scheduledAt) : null,
body.data, body.data,
response.version); response.version);
}) })
@ -197,6 +212,9 @@ export class ContentsService {
body.lastModifiedBy, body.lastModifiedBy,
DateTime.parseISO_UTC(body.created), DateTime.parseISO_UTC(body.created),
DateTime.parseISO_UTC(body.lastModified), DateTime.parseISO_UTC(body.lastModified),
null,
null,
null,
body.data, body.data,
response.version); response.version);
}) })
@ -231,43 +249,17 @@ export class ContentsService {
.pretifyError('Failed to delete content. Please reload.'); .pretifyError('Failed to delete content. Please reload.');
} }
public publishContent(appName: string, schemaName: string, id: string, version: Version): Observable<Versioned<any>> { public changeContentStatus(appName: string, schemaName: string, id: string, action: string, version: Version, dueTime?: DateTime): Observable<Versioned<any>> {
const url = this.apiUrl.buildUrl(`/api/content/${appName}/${schemaName}/${id}/publish`); let url = this.apiUrl.buildUrl(`/api/content/${appName}/${schemaName}/${id}/${action}`);
return HTTP.putVersioned(this.http, url, {}, version) if (dueTime) {
.do(() => { url += `?dueTime=${dueTime.toISOString()}`;
this.analytics.trackEvent('Content', 'Published', appName);
})
.pretifyError('Failed to publish content. Please reload.');
} }
public unpublishContent(appName: string, schemaName: string, id: string, version: Version): Observable<Versioned<any>> {
const url = this.apiUrl.buildUrl(`/api/content/${appName}/${schemaName}/${id}/unpublish`);
return HTTP.putVersioned(this.http, url, {}, version)
.do(() => {
this.analytics.trackEvent('Content', 'Unpublished', appName);
})
.pretifyError('Failed to unpublish content. Please reload.');
}
public archiveContent(appName: string, schemaName: string, id: string, version: Version): Observable<Versioned<any>> {
const url = this.apiUrl.buildUrl(`/api/content/${appName}/${schemaName}/${id}/archive`);
return HTTP.putVersioned(this.http, url, {}, version) return HTTP.putVersioned(this.http, url, {}, version)
.do(() => { .do(() => {
this.analytics.trackEvent('Content', 'Archived', appName); this.analytics.trackEvent('Content', 'Archived', appName);
}) })
.pretifyError('Failed to archive content. Please reload.'); .pretifyError(`Failed to ${action} content. Please reload.`);
}
public restoreContent(appName: string, schemaName: string, id: string, version: Version): Observable<Versioned<any>> {
const url = this.apiUrl.buildUrl(`/api/content/${appName}/${schemaName}/${id}/restore`);
return HTTP.putVersioned(this.http, url, {}, version)
.do(() => {
this.analytics.trackEvent('Content', 'Restored', appName);
})
.pretifyError('Failed to restore content. Please reload.');
} }
} }
Write Preview
Loading…
Cancel
Save