ucap/next-ucap-messenger
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Notification is implemented

Browse Source
This commit is contained in:
병준 박 2019-10-10 10:43:06 +09:00
parent fad0787266
commit 817efad9df
9 changed files with 390 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
projects/ucap-webmessenger-app/src/app/pages/messenger/components/main.page.component.html
View File

@ -13,7 +13,7 @@
></app-layout-messenger-messages>
</div>
<mat-drawer #drawer mode="side" position="end">
<p>sidenav</p>
<p>Auto-resizing sidenav</p>
</mat-drawer>
</mat-drawer-container>

181
projects/ucap-webmessenger-app/src/app/services/notification.service.ts
View File

@ -12,13 +12,53 @@ import {
LogoutRemoteNotification
} from '@ucap-webmessenger/protocol-authentication';
import * as AuthenticationStore from '../store/account/authentication';
import * as AuthenticationStore from '@app/store/account/authentication';
import { NGXLogger } from 'ngx-logger';
import {
EventProtocolService,
SSVC_TYPE_EVENT_SEND_NOTI,
SendNotification,
SSVC_TYPE_EVENT_READ_NOTI,
SSVC_TYPE_EVENT_CANCEL_NOTI,
SSVC_TYPE_EVENT_DEL_RES
} from '@ucap-webmessenger/protocol-event';
import {
InfoProtocolService,
SSVC_TYPE_INFO_USER_NOTI,
UserNotification
} from '@ucap-webmessenger/protocol-info';
import {
RoomProtocolService,
SSVC_TYPE_ROOM_INVITE_NOTI,
SSVC_TYPE_ROOM_EXIT_NOTI,
SSVC_TYPE_ROOM_EXIT_FORCING_NOTI,
SSVC_TYPE_ROOM_FONT_UPD_NOTI,
InviteNotification
} from '@ucap-webmessenger/protocol-room';
import {
StatusProtocolService,
SSVC_TYPE_STATUS_NOTI,
StatusNotification
} from '@ucap-webmessenger/protocol-status';
import {
ReadNotification,
CancelNotification,
DelNotification
} from '@ucap-webmessenger/protocol-event';
import {
ExitNotification,
ExitForcingNotification,
UpdateFontNotification
} from '@ucap-webmessenger/protocol-room';
@Injectable()
export class AppNotificationService {
constructor(
private authenticationProtocolService: AuthenticationProtocolService,
private eventProtocolService: EventProtocolService,
private infoProtocolService: InfoProtocolService,
private roomProtocolService: RoomProtocolService,
private statusProtocolService: StatusProtocolService,
private store: Store<any>,
private logger: NGXLogger
) {}
@ -31,11 +71,19 @@ export class AppNotificationService {
case SSVC_TYPE_LOGOUT_RES:
{
const res = notiOrRes as LogoutResponse;
this.logger.debug(
'Notification::authenticationProtocolService::LogoutResponse',
res
);
}
break;
case SSVC_TYPE_LOGOUT_REMOTE_NOTI:
{
const noti = notiOrRes as LogoutRemoteNotification;
this.logger.debug(
'Notification::authenticationProtocolService::LogoutRemoteNotification',
noti
);
}
break;
default:
@ -45,5 +93,136 @@ export class AppNotificationService {
})
)
.subscribe();
this.eventProtocolService.notification$
.pipe(
tap(notiOrRes => {
switch (notiOrRes.Type) {
case SSVC_TYPE_EVENT_SEND_NOTI:
{
const noti = notiOrRes as SendNotification;
this.logger.debug(
'Notification::eventProtocolService::SendNotification',
noti
);
}
break;
case SSVC_TYPE_EVENT_READ_NOTI:
{
const noti = notiOrRes as ReadNotification;
this.logger.debug(
'Notification::eventProtocolService::ReadNotification',
noti
);
}
break;
case SSVC_TYPE_EVENT_CANCEL_NOTI:
{
const noti = notiOrRes as CancelNotification;
this.logger.debug(
'Notification::eventProtocolService::CancelNotification',
noti
);
}
break;
case SSVC_TYPE_EVENT_DEL_RES:
{
const noti = notiOrRes as DelNotification;
this.logger.debug(
'Notification::eventProtocolService::DelNotification',
noti
);
}
break;
default:
break;
}
})
)
.subscribe();
this.infoProtocolService.notification$
.pipe(
tap(notiOrRes => {
switch (notiOrRes.Type) {
case SSVC_TYPE_INFO_USER_NOTI:
{
const noti = notiOrRes as UserNotification;
this.logger.debug(
'Notification::infoProtocolService::UserNotification',
noti
);
}
break;
default:
break;
}
})
)
.subscribe();
this.roomProtocolService.notification$
.pipe(
tap(notiOrRes => {
switch (notiOrRes.Type) {
case SSVC_TYPE_ROOM_INVITE_NOTI:
{
const noti = notiOrRes as InviteNotification;
this.logger.debug(
'Notification::roomProtocolService::InviteNotification',
noti
);
}
break;
case SSVC_TYPE_ROOM_EXIT_NOTI:
{
const noti = notiOrRes as ExitNotification;
this.logger.debug(
'Notification::roomProtocolService::ExitNotification',
noti
);
}
break;
case SSVC_TYPE_ROOM_EXIT_FORCING_NOTI:
{
const noti = notiOrRes as ExitForcingNotification;
this.logger.debug(
'Notification::roomProtocolService::ExitForcingNotification',
noti
);
}
break;
case SSVC_TYPE_ROOM_FONT_UPD_NOTI:
{
const noti = notiOrRes as UpdateFontNotification;
this.logger.debug(
'Notification::roomProtocolService::UpdateFontNotification',
noti
);
}
break;
default:
break;
}
})
)
.subscribe();
this.statusProtocolService.notification$
.pipe(
tap(notiOrRes => {
switch (notiOrRes.Type) {
case SSVC_TYPE_STATUS_NOTI:
{
const noti = notiOrRes as StatusNotification;
this.logger.debug(
'Notification::statusProtocolService::StatusNotification',
noti
);
}
break;
default:
break;
}
})
)
.subscribe();
}
}

10
projects/ucap-webmessenger-protocol-authentication/src/lib/services/authentication-protocol.service.ts
View File

@ -34,16 +34,14 @@ import {
LogoutRemoteNotification
} from '../protocols/logout-remote';
type Notifications = LogoutResponse | LogoutRemoteNotification;
@Injectable({
providedIn: 'root'
})
export class AuthenticationProtocolService {
private logoutNotificationSubject: Subject<
LogoutResponse | LogoutRemoteNotification
>;
public logoutNotification$: Observable<
LogoutResponse | LogoutRemoteNotification
>;
private logoutNotificationSubject: Subject<Notifications>;
public logoutNotification$: Observable<Notifications>;
constructor(private protocolService: ProtocolService) {
this.logoutNotificationSubject = new Subject();

56
projects/ucap-webmessenger-protocol-event/src/lib/services/event-protocol.service.ts
View File

@ -31,20 +31,27 @@ import {
SSVC_TYPE_EVENT_READ_REQ,
SSVC_TYPE_EVENT_DEL_REQ,
SSVC_TYPE_EVENT_CANCEL_REQ,
SSVC_TYPE_EVENT_CANCEL_NOTI
SSVC_TYPE_EVENT_CANCEL_NOTI,
SSVC_TYPE_EVENT_SEND_NOTI,
SSVC_TYPE_EVENT_READ_NOTI,
SSVC_TYPE_EVENT_DEL_RES
} from '../types/service';
import {
SendRequest,
SendResponse,
decodeSend,
encodeSend
encodeSend,
decodeSendNotification,
SendNotification
} from '../protocols/send';
import { PushRequest, encodePush } from '../protocols/push';
import {
ReadResponse,
ReadRequest,
encodeRead,
decodeRead
decodeRead,
decodeReadNotification,
ReadNotification
} from '../protocols/read';
import {
DelRequest,
@ -60,33 +67,62 @@ import {
CancelNotification,
decodeCancelNotification
} from '../protocols/cancel';
import { decodeDelNotification, DelNotification } from '../protocols/del';
type Notifications =
| SendNotification
| ReadNotification
| CancelNotification
| DelNotification;
@Injectable({
providedIn: 'root'
})
export class EventProtocolService {
private eventNotificationSubject: Subject<CancelNotification>;
public eventNotification$: Observable<CancelNotification>;
private notificationSubject: Subject<Notifications>;
public notification$: Observable<Notifications>;
constructor(private protocolService: ProtocolService) {
this.eventNotificationSubject = new Subject();
this.eventNotification$ = this.eventNotificationSubject
.asObservable()
.pipe(share());
this.notificationSubject = new Subject();
this.notification$ = this.notificationSubject.asObservable().pipe(share());
this.protocolService.serverMessage
.pipe(
filter(message => message.serviceType === SVC_TYPE_EVENT),
tap(message => {
switch (message.subServiceType) {
case SSVC_TYPE_EVENT_SEND_NOTI:
{
this.notificationSubject.next({
...decodeSendNotification(message),
Type: SSVC_TYPE_EVENT_SEND_NOTI
});
}
break;
case SSVC_TYPE_EVENT_READ_NOTI:
{
this.notificationSubject.next({
...decodeReadNotification(message),
Type: SSVC_TYPE_EVENT_READ_NOTI
});
}
break;
case SSVC_TYPE_EVENT_CANCEL_NOTI:
{
this.eventNotificationSubject.next({
this.notificationSubject.next({
...decodeCancelNotification(message),
Type: SSVC_TYPE_EVENT_CANCEL_NOTI
});
}
break;
case SSVC_TYPE_EVENT_DEL_RES:
{
this.notificationSubject.next({
...decodeDelNotification(message),
Type: SSVC_TYPE_EVENT_DEL_RES
});
}
break;
default:
break;
}

8
projects/ucap-webmessenger-protocol-event/src/public-api.ts
View File

@ -4,14 +4,18 @@
export * from './lib/models/info';
export * from './lib/protocols/cancel';
export * from './lib/protocols/del';
export * from './lib/protocols/info';
export * from './lib/protocols/push';
export * from './lib/protocols/read';
export * from './lib/protocols/send';
export * from './lib/services/event-protocol.service';
export * from './lib/ucap-event-protocol.module';
export * from './lib/types/event.type';
export * from './lib/types/push-cl.type';
export * from './lib/types/push-status.type';
export * from './lib/types/service';
export * from './lib/ucap-event-protocol.module';

42
projects/ucap-webmessenger-protocol-info/src/lib/services/info-protocol.service.ts
View File

@ -1,7 +1,7 @@
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { map, take } from 'rxjs/operators';
import { Observable, Subject } from 'rxjs';
import { map, take, share, filter, tap } from 'rxjs/operators';
import { ProtocolService } from '@ucap-webmessenger/protocol';
import {
@ -9,13 +9,16 @@ import {
SSVC_TYPE_INFO_USER_REQ,
SSVC_TYPE_INFO_STATE_REQ,
SSVC_TYPE_INFO_USER_OPTION_REQ,
SSVC_TYPE_INFO_USER_OPTION_UPD_REQ
SSVC_TYPE_INFO_USER_OPTION_UPD_REQ,
SSVC_TYPE_INFO_USER_NOTI
} from '../types/service';
import {
UserRequest,
encodeUser,
UserResponse,
decodeUser
decodeUser,
decodeUserNotification,
UserNotification
} from '../protocols/user';
import {
StatusRequest,
@ -32,11 +35,40 @@ import {
decodeUserOptionUpdate
} from '../protocols/user-option';
type Notifications = UserNotification;
@Injectable({
providedIn: 'root'
})
export class InfoProtocolService {
constructor(private protocolService: ProtocolService) {}
private notificationSubject: Subject<Notifications>;
public notification$: Observable<Notifications>;
constructor(private protocolService: ProtocolService) {
this.notificationSubject = new Subject();
this.notification$ = this.notificationSubject.asObservable().pipe(share());
this.protocolService.serverMessage
.pipe(
filter(message => message.serviceType === SVC_TYPE_INFO),
tap(message => {
switch (message.subServiceType) {
case SSVC_TYPE_INFO_USER_NOTI:
{
this.notificationSubject.next({
...decodeUserNotification(message),
Type: SSVC_TYPE_INFO_USER_NOTI
});
}
break;
default:
break;
}
})
)
.subscribe();
}
public user(req: UserRequest): Observable<UserResponse> {
return this.protocolService

83
projects/ucap-webmessenger-protocol-room/src/lib/services/room-protocol.service.ts
View File

@ -1,7 +1,7 @@
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { map, take, takeWhile } from 'rxjs/operators';
import { Observable, Subject } from 'rxjs';
import { map, take, takeWhile, share, tap, filter } from 'rxjs/operators';
import { ProtocolService } from '@ucap-webmessenger/protocol';
import {
@ -22,7 +22,11 @@ import {
SSVC_TYPE_ROOM_USER_STATUS_REQ,
SSVC_TYPE_ROOM_UPD_REQ,
SSVC_TYPE_ROOM_INFO_UPD_REQ,
SSVC_TYPE_ROOM_FONT_UPD_REQ
SSVC_TYPE_ROOM_FONT_UPD_REQ,
SSVC_TYPE_ROOM_INVITE_NOTI,
SSVC_TYPE_ROOM_EXIT_NOTI,
SSVC_TYPE_ROOM_EXIT_FORCING_NOTI,
SSVC_TYPE_ROOM_FONT_UPD_NOTI
} from '../types/service';
import {
OpenRequest,
@ -46,7 +50,9 @@ import {
InviteRequest,
InviteResponse,
encodeInvite,
decodeInvite
decodeInvite,
decodeInviteNotification,
InviteNotification
} from '../protocols/invite';
import {
InfoRequest,
@ -76,7 +82,11 @@ import {
encodeExitForcing,
decodeExitForcing,
decodeAllExit,
ExitAllResponse
ExitAllResponse,
decodeExitForcingNotification,
decodeExitNotification,
ExitNotification,
ExitForcingNotification
} from '../protocols/exit';
import {
UpdateRequest,
@ -90,14 +100,73 @@ import {
UpdateFontRequest,
UpdateFontResponse,
encodeUpdateFont,
decodeUpdateFont
decodeUpdateFont,
decodeUpdateFontNotification,
UpdateFontNotification
} from '../protocols/update';
type Notifications =
| UpdateFontNotification
| InviteNotification
| ExitNotification
| ExitForcingNotification;
@Injectable({
providedIn: 'root'
})
export class RoomProtocolService {
constructor(private protocolService: ProtocolService) {}
private notificationSubject: Subject<Notifications>;
public notification$: Observable<Notifications>;
constructor(private protocolService: ProtocolService) {
this.notificationSubject = new Subject();
this.notification$ = this.notificationSubject.asObservable().pipe(share());
this.protocolService.serverMessage
.pipe(
filter(message => message.serviceType === SVC_TYPE_ROOM),
tap(message => {
switch (message.subServiceType) {
case SSVC_TYPE_ROOM_INVITE_NOTI:
{
this.notificationSubject.next({
...decodeInviteNotification(message),
Type: SSVC_TYPE_ROOM_INVITE_NOTI
});
}
break;
case SSVC_TYPE_ROOM_EXIT_NOTI:
{
this.notificationSubject.next({
...decodeExitNotification(message),
Type: SSVC_TYPE_ROOM_EXIT_NOTI
});
}
break;
case SSVC_TYPE_ROOM_EXIT_FORCING_NOTI:
{
this.notificationSubject.next({
...decodeExitForcingNotification(message),
Type: SSVC_TYPE_ROOM_EXIT_FORCING_NOTI
});
}
break;
case SSVC_TYPE_ROOM_FONT_UPD_NOTI:
{
this.notificationSubject.next({
...decodeUpdateFontNotification(message),
Type: SSVC_TYPE_ROOM_FONT_UPD_NOTI
});
}
break;
default:
break;
}
})
)
.subscribe();
}
public open(req: OpenRequest): Observable<OpenResponse> {
return this.protocolService

3
projects/ucap-webmessenger-protocol-room/src/public-api.ts
View File

@ -6,11 +6,14 @@ export * from './lib/models/room-info';
export * from './lib/models/user-info';
export * from './lib/models/user-info-short';
export * from './lib/protocols/exit';
export * from './lib/protocols/info';
export * from './lib/protocols/invite';
export * from './lib/protocols/open';
export * from './lib/protocols/update';
export * from './lib/services/room-protocol.service';
export * from './lib/types/employee.type';
export * from './lib/types/room.type';
export * from './lib/types/service';

42
projects/ucap-webmessenger-protocol-status/src/lib/services/status-protocol.service.ts
View File

@ -1,14 +1,16 @@
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { map, take, takeWhile } from 'rxjs/operators';
import { Observable, Subject } from 'rxjs';
import { map, take, takeWhile, share, filter, tap } from 'rxjs/operators';
import { ProtocolService } from '@ucap-webmessenger/protocol';
import {
StatusRequest,
encodeStatus,
decodeStatus,
StatusResponse
StatusResponse,
decodeStatusNotification,
StatusNotification
} from '../protocols/status';
import {
SVC_TYPE_STATUS,
@ -19,7 +21,8 @@ import {
SSVC_TYPE_STATUS_BUDDY_REQ,
SSVC_TYPE_STATUS_MSG_UPD_REQ,
SSVC_TYPE_STATUS_SUBSCRIPT_REQ,
SSVC_TYPE_STATUS_UNSUBSCRIPT_REQ
SSVC_TYPE_STATUS_UNSUBSCRIPT_REQ,
SSVC_TYPE_STATUS_NOTI
} from '../types/service';
import {
BulkInfoRequest,
@ -47,11 +50,40 @@ import {
encodeUnSubscribe
} from '../protocols/unsubscribe';
type Notifications = StatusNotification;
@Injectable({
providedIn: 'root'
})
export class StatusProtocolService {
constructor(private protocolService: ProtocolService) {}
private notificationSubject: Subject<Notifications>;
public notification$: Observable<Notifications>;
constructor(private protocolService: ProtocolService) {
this.notificationSubject = new Subject();
this.notification$ = this.notificationSubject.asObservable().pipe(share());
this.protocolService.serverMessage
.pipe(
filter(message => message.serviceType === SVC_TYPE_STATUS),
tap(message => {
switch (message.subServiceType) {
case SSVC_TYPE_STATUS_NOTI:
{
this.notificationSubject.next({
...decodeStatusNotification(message),
Type: SSVC_TYPE_STATUS_NOTI
});
}
break;
default:
break;
}
})
)
.subscribe();
}
public status(req: StatusRequest): Observable<StatusResponse> {
return this.protocolService