1012 lines
36 KiB
TypeScript
1012 lines
36 KiB
TypeScript
import { Injectable, Inject } from '@angular/core';
|
|
|
|
import {
|
|
tap,
|
|
withLatestFrom,
|
|
take,
|
|
map,
|
|
catchError,
|
|
finalize
|
|
} from 'rxjs/operators';
|
|
|
|
import { Store, select } from '@ngrx/store';
|
|
|
|
import {
|
|
SSVC_TYPE_LOGOUT_RES,
|
|
SSVC_TYPE_LOGOUT_REMOTE_NOTI,
|
|
AuthenticationProtocolService,
|
|
LogoutResponse,
|
|
LogoutRemoteNotification,
|
|
LogoutNotification,
|
|
LoginResponse
|
|
} from '@ucap-webmessenger/protocol-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,
|
|
SSVC_TYPE_EVENT_SEND_RES,
|
|
SSVC_TYPE_EVENT_READ_RES,
|
|
EventType
|
|
} 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,
|
|
UpdateNotification as RoomUpdateNotification,
|
|
SSVC_TYPE_ROOM_UPD_RES,
|
|
SSVC_TYPE_ROOM_EXIT_FORCING_RES,
|
|
SSVC_TYPE_ROOM_EXIT_RES,
|
|
SSVC_TYPE_ROOM_INVITE_RES,
|
|
ExitForcingResponse,
|
|
RoomInfo
|
|
} 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';
|
|
import {
|
|
GroupProtocolService,
|
|
SSVC_TYPE_GROUP_UPD_RES2,
|
|
UpdateNotification as GroupUpdateNotification,
|
|
SSVC_TYPE_GROUP_ADD_RES,
|
|
AddNotification as GroupAddNotification,
|
|
SSVC_TYPE_GROUP_DEL_RES,
|
|
DelNotification as GroupDelNotification
|
|
} from '@ucap-webmessenger/protocol-group';
|
|
import {
|
|
BuddyProtocolService,
|
|
SSVC_TYPE_BUDDY_UPD_RES,
|
|
UpdateNotification as BuddyUpdateNotification,
|
|
SSVC_TYPE_BUDDY_ADD_RES,
|
|
AddNotification as BuddyAddNotification,
|
|
SSVC_TYPE_BUDDY_DEL_RES,
|
|
DelNotification as BuddyDelNotification
|
|
} from '@ucap-webmessenger/protocol-buddy';
|
|
|
|
import * as AuthenticationStore from '@app/store/account/authentication';
|
|
import * as InfoStore from '@app/store/account/info';
|
|
import * as EventStore from '@app/store/messenger/event';
|
|
import * as MessageStore from '@app/store/messenger/message';
|
|
import * as SyncStore from '@app/store/messenger/sync';
|
|
import * as RoomStore from '@app/store/messenger/room';
|
|
import * as StatusStore from '@app/store/messenger/status';
|
|
import {
|
|
NotificationRequest,
|
|
NativeService,
|
|
UCAP_NATIVE_SERVICE,
|
|
NotificationType,
|
|
WindowState
|
|
} from '@ucap-webmessenger/native';
|
|
import {
|
|
StringUtil,
|
|
DialogService,
|
|
TranslateService as UcapTranslateService
|
|
} from '@ucap-webmessenger/ui';
|
|
import {
|
|
UmgProtocolService,
|
|
SSVC_TYPE_UMG_NOTI,
|
|
UmgNotiNotification,
|
|
SSVC_TYPE_UMG_DELETE_NOTI,
|
|
UmgDeleteNotiNotification
|
|
} from '@ucap-webmessenger/protocol-umg';
|
|
import {
|
|
LocalStorageService,
|
|
SessionStorageService
|
|
} from '@ucap-webmessenger/web-storage';
|
|
import { AppUserInfo, KEY_APP_USER_INFO } from '@app/types/app-user-info.type';
|
|
|
|
import { environment } from '../../environments/environment';
|
|
import { NotificationMethod, LocaleCode } from '@ucap-webmessenger/core';
|
|
import { Dictionary } from '@ngrx/entity';
|
|
import { MessageType } from '@ucap-webmessenger/api-message';
|
|
import {
|
|
LogoutInfo,
|
|
KEY_LOGOUT_INFO,
|
|
KEY_VER_INFO,
|
|
KEY_LOGIN_RES_INFO,
|
|
MainMenu
|
|
} from '@app/types';
|
|
import { TranslateService } from '@ngx-translate/core';
|
|
import { deleteMessageSuccess } from '@app/store/messenger/message';
|
|
import { ServerErrorCode } from '@ucap-webmessenger/protocol';
|
|
import {
|
|
OptionProtocolService,
|
|
SSVC_TYPE_OPTION_REG_UPD_RES,
|
|
RegUpdateResponse,
|
|
RegUpdateNotification
|
|
} from '@ucap-webmessenger/protocol-option';
|
|
import {
|
|
GeneralSetting,
|
|
Settings,
|
|
NotificationSetting,
|
|
ChatSetting
|
|
} from '@ucap-webmessenger/ui-settings';
|
|
import clone from 'clone';
|
|
import { ElectronBrowserWindowChannel } from '@ucap-webmessenger/electron-core';
|
|
import { UserInfo, RoomUserData } from '@ucap-webmessenger/protocol-sync';
|
|
import { VersionInfo2Response } from '@ucap-webmessenger/api-public';
|
|
import { QueryProtocolService } from '@ucap-webmessenger/protocol-query';
|
|
import { UserInfoListState } from '@app/store/messenger/room';
|
|
import { DaesangProtocolService } from '@ucap-webmessenger/daesang';
|
|
import { of } from 'rxjs';
|
|
|
|
@Injectable()
|
|
export class AppNotificationService {
|
|
constructor(
|
|
private authenticationProtocolService: AuthenticationProtocolService,
|
|
private eventProtocolService: EventProtocolService,
|
|
private infoProtocolService: InfoProtocolService,
|
|
private roomProtocolService: RoomProtocolService,
|
|
private groupProtocolService: GroupProtocolService,
|
|
private buddyProtocolService: BuddyProtocolService,
|
|
private queryProtocolService: QueryProtocolService,
|
|
private daesangProtocolService: DaesangProtocolService,
|
|
private statusProtocolService: StatusProtocolService,
|
|
private translateService: TranslateService,
|
|
private ucapTranslateService: UcapTranslateService,
|
|
private optionProtocolService: OptionProtocolService,
|
|
private umgProtocolService: UmgProtocolService,
|
|
private localStorageService: LocalStorageService,
|
|
private sessionStorageService: SessionStorageService,
|
|
@Inject(UCAP_NATIVE_SERVICE) private nativeService: NativeService,
|
|
private dialogService: DialogService,
|
|
private store: Store<any>,
|
|
private logger: NGXLogger
|
|
) {}
|
|
|
|
public subscribe(): void {
|
|
this.authenticationProtocolService.logoutNotification$
|
|
.pipe(
|
|
tap(notiOrRes => {
|
|
switch (notiOrRes.SSVC_TYPE) {
|
|
case SSVC_TYPE_LOGOUT_RES:
|
|
{
|
|
const res = notiOrRes as LogoutNotification;
|
|
this.logger.debug(
|
|
'Notification::authenticationProtocolService::LogoutResponse',
|
|
res
|
|
);
|
|
|
|
this.sessionStorageService.set<LogoutInfo>(KEY_LOGOUT_INFO, {
|
|
personLogout: true,
|
|
reasonCode: res.reasonCode,
|
|
ip: res.ip,
|
|
mac: res.mac
|
|
} as LogoutInfo);
|
|
}
|
|
break;
|
|
case SSVC_TYPE_LOGOUT_REMOTE_NOTI:
|
|
{
|
|
const noti = notiOrRes as LogoutRemoteNotification;
|
|
this.logger.debug(
|
|
'Notification::authenticationProtocolService::LogoutRemoteNotification',
|
|
noti
|
|
);
|
|
|
|
this.sessionStorageService.set<LogoutInfo>(KEY_LOGOUT_INFO, {
|
|
personLogout: true,
|
|
reasonCode: ServerErrorCode.ERRCD_FORCE_INIT,
|
|
forceType: noti.requestDeviceType
|
|
} as LogoutInfo);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
this.dialogService.closeAll();
|
|
|
|
this.store.dispatch(AuthenticationStore.loginRedirect());
|
|
})
|
|
)
|
|
.subscribe();
|
|
|
|
this.eventProtocolService.notification$
|
|
.pipe(
|
|
withLatestFrom(
|
|
this.store.pipe(
|
|
select((state: any) => state.messenger.room.roomInfo as RoomInfo)
|
|
),
|
|
this.store.pipe(
|
|
select(
|
|
(state: any) =>
|
|
state.messenger.room.userInfoList.entities as Dictionary<
|
|
UserInfoListState
|
|
>
|
|
)
|
|
),
|
|
this.store.pipe(
|
|
select(
|
|
(state: any) =>
|
|
state.messenger.sync.room.entities as Dictionary<RoomInfo>
|
|
)
|
|
),
|
|
this.store.pipe(
|
|
select(
|
|
(state: any) =>
|
|
state.messenger.sync.buddy2.entities as Dictionary<UserInfo>
|
|
)
|
|
),
|
|
this.store.pipe(
|
|
select(
|
|
(state: any) => state.messenger.settings.gnbMenuIndex as MainMenu
|
|
)
|
|
)
|
|
),
|
|
tap(
|
|
([
|
|
notiOrRes,
|
|
curRoomInfo,
|
|
curRoomUserInfo,
|
|
roomList,
|
|
buddyList,
|
|
gnbMenuIndex
|
|
]) => {
|
|
switch (notiOrRes.SSVC_TYPE) {
|
|
case SSVC_TYPE_EVENT_SEND_RES:
|
|
case SSVC_TYPE_EVENT_SEND_NOTI:
|
|
{
|
|
const noti = notiOrRes as SendNotification;
|
|
this.logger.debug(
|
|
'Notification::eventProtocolService::SendNotification',
|
|
noti
|
|
);
|
|
|
|
// Event..
|
|
this.store.dispatch(
|
|
EventStore.sendNotification({
|
|
noti
|
|
})
|
|
);
|
|
|
|
// unread count..
|
|
if (
|
|
!!curRoomInfo &&
|
|
!!curRoomInfo.roomSeq &&
|
|
curRoomInfo.roomSeq === noti.roomSeq &&
|
|
gnbMenuIndex !== MainMenu.Organization
|
|
) {
|
|
// 현재 방이 열려 있고, 조직도탭을 보고 있지 않다면 대화방을 보고 있다고 판단하고 event_read_req 한다.
|
|
this.store.dispatch(
|
|
EventStore.read({
|
|
roomSeq: noti.roomSeq,
|
|
lastReadSeq: noti.info.seq
|
|
})
|
|
);
|
|
} else {
|
|
// not opened room :: unread count increased
|
|
if (notiOrRes.SSVC_TYPE === SSVC_TYPE_EVENT_SEND_RES) {
|
|
/**
|
|
* 다른 디바이스에서 대화를 송신 할경우 RES 가 noti 로 유입될 수 있다.
|
|
* 이때 unread count 를 중가하지 않는다.
|
|
*/
|
|
} else {
|
|
if (
|
|
!!roomList &&
|
|
!!roomList[noti.roomSeq] &&
|
|
noti.info.type !== EventType.Join &&
|
|
noti.info.type !== EventType.Exit &&
|
|
noti.info.type !== EventType.ForcedExit
|
|
) {
|
|
const noReadCnt = roomList[noti.roomSeq].noReadCnt;
|
|
this.store.dispatch(
|
|
SyncStore.updateUnreadCount({
|
|
roomSeq: noti.roomSeq,
|
|
noReadCnt: noReadCnt + 1
|
|
})
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// notification..
|
|
if (notiOrRes.SSVC_TYPE === SSVC_TYPE_EVENT_SEND_NOTI) {
|
|
let doNoti = true;
|
|
|
|
const windowState = this.nativeService.getWindowState();
|
|
|
|
// 현재 열려 있는 방일경우 노티 안함.
|
|
if (
|
|
!!curRoomInfo &&
|
|
!!curRoomInfo.roomSeq &&
|
|
curRoomInfo.roomSeq === noti.roomSeq &&
|
|
!!windowState &&
|
|
windowState.windowState !== WindowState.Minimized &&
|
|
windowState.windowState !== WindowState.Hidden
|
|
) {
|
|
doNoti = false;
|
|
}
|
|
|
|
// 포커스 아웃일때 무조건 노티.
|
|
// Case 1 : 단순 포커스 아웃.
|
|
// Case 2 : hidden 시 포커스 인 상태이지만 위에서 필터링 됨.
|
|
if (
|
|
windowState.windowFocusState !==
|
|
ElectronBrowserWindowChannel.Focus
|
|
) {
|
|
doNoti = true;
|
|
}
|
|
|
|
// 조직도 탭이 열려 있다면
|
|
if (gnbMenuIndex === MainMenu.Organization) {
|
|
doNoti = true;
|
|
}
|
|
|
|
// 방별 알림이 꺼져 있으면 노티 안함. > 우선순위 최상위.
|
|
if (
|
|
!!roomList[noti.roomSeq] &&
|
|
!roomList[noti.roomSeq].receiveAlarm
|
|
) {
|
|
doNoti = false;
|
|
}
|
|
|
|
if (doNoti) {
|
|
const appUserInfo = this.localStorageService.encGet<
|
|
AppUserInfo
|
|
>(KEY_APP_USER_INFO, environment.customConfig.appKey);
|
|
|
|
if (appUserInfo.settings.notification.use) {
|
|
if (
|
|
appUserInfo.settings.notification.method ===
|
|
NotificationMethod.Sound
|
|
) {
|
|
const audio = new Audio(
|
|
'assets/sounds/messageAlarm.mp3'
|
|
);
|
|
audio.play();
|
|
} else {
|
|
const contents = StringUtil.convertFinalEventMessage(
|
|
noti.eventType,
|
|
noti.info.sentMessageJson
|
|
);
|
|
|
|
if (!!contents) {
|
|
const notiReq: NotificationRequest = {
|
|
type: NotificationType.Event,
|
|
seq: noti.roomSeq,
|
|
title: this.translateService.instant(
|
|
'notification.titleChatEventArrived'
|
|
),
|
|
contents,
|
|
image: '',
|
|
useSound: [
|
|
NotificationMethod.Sound,
|
|
NotificationMethod.SoundAndAlert
|
|
].some(
|
|
n =>
|
|
n === appUserInfo.settings.notification.method
|
|
)
|
|
? true
|
|
: false,
|
|
displayTime:
|
|
appUserInfo.settings.notification
|
|
.alertExposureTime * 1000
|
|
};
|
|
|
|
// Sender Info setting
|
|
// STEP 1 >> In buddy group.
|
|
let senderInfo: any = buddyList[noti.SENDER_SEQ];
|
|
|
|
// STEP 2 >> In Current Room Users.
|
|
if (!senderInfo) {
|
|
senderInfo = curRoomUserInfo[noti.SENDER_SEQ];
|
|
}
|
|
|
|
// STEP 3 >> user protocol
|
|
if (!senderInfo) {
|
|
const loginRes = this.sessionStorageService.get<
|
|
LoginResponse
|
|
>(KEY_LOGIN_RES_INFO);
|
|
|
|
this.daesangProtocolService
|
|
.dataUserDaesang({
|
|
divCd: 'OPENNOTI',
|
|
seq: noti.SENDER_SEQ,
|
|
senderCompanyCode:
|
|
loginRes.userInfo.companyCode,
|
|
senderEmployeeType:
|
|
loginRes.userInfo.employeeType
|
|
})
|
|
.pipe(
|
|
take(1),
|
|
map(res => {
|
|
if (!!res && !!res.userInfo) {
|
|
senderInfo = res.userInfo;
|
|
let name = senderInfo.name;
|
|
let grade = senderInfo.grade;
|
|
|
|
switch (
|
|
this.ucapTranslateService.currentLang.toUpperCase()
|
|
) {
|
|
case LocaleCode.English:
|
|
name = senderInfo.nameEn;
|
|
grade = senderInfo.gradeEn;
|
|
break;
|
|
case LocaleCode.Chinese:
|
|
name = senderInfo.nameCn;
|
|
grade = senderInfo.gradeCn;
|
|
break;
|
|
}
|
|
|
|
notiReq.title = this.translateService.instant(
|
|
'notification.titleChatEventArrivedByUser',
|
|
{
|
|
userInfo: !!grade
|
|
? `${name} ${grade}`
|
|
: name
|
|
}
|
|
);
|
|
|
|
// Image set.
|
|
if (!!senderInfo.profileImageFile) {
|
|
const sessionVerinfo = this.sessionStorageService.get<
|
|
VersionInfo2Response
|
|
>(KEY_VER_INFO);
|
|
notiReq.image = `${sessionVerinfo.profileRoot}${senderInfo.profileImageFile}`;
|
|
}
|
|
}
|
|
}),
|
|
catchError(error => {
|
|
return of();
|
|
}),
|
|
finalize(() => {
|
|
this.nativeService.notify(notiReq);
|
|
})
|
|
)
|
|
.subscribe();
|
|
} else {
|
|
// Sender Info setting.
|
|
// name set
|
|
let name = senderInfo.name;
|
|
let grade = senderInfo.grade;
|
|
|
|
switch (
|
|
this.ucapTranslateService.currentLang.toUpperCase()
|
|
) {
|
|
case LocaleCode.English:
|
|
name = senderInfo.nameEn;
|
|
grade = senderInfo.gradeEn;
|
|
break;
|
|
case LocaleCode.Chinese:
|
|
name = senderInfo.nameCn;
|
|
grade = senderInfo.gradeCn;
|
|
break;
|
|
}
|
|
|
|
notiReq.title = this.translateService.instant(
|
|
'notification.titleChatEventArrivedByUser',
|
|
{
|
|
userInfo: !!grade ? `${name} ${grade}` : name
|
|
}
|
|
);
|
|
|
|
// Image set.
|
|
if (!!senderInfo.profileImageFile) {
|
|
const sessionVerinfo = this.sessionStorageService.get<
|
|
VersionInfo2Response
|
|
>(KEY_VER_INFO);
|
|
notiReq.image = `${sessionVerinfo.profileRoot}${senderInfo.profileImageFile}`;
|
|
}
|
|
|
|
// express noti popup
|
|
this.nativeService.notify(notiReq);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case SSVC_TYPE_EVENT_READ_RES:
|
|
case SSVC_TYPE_EVENT_READ_NOTI:
|
|
{
|
|
// 대화방 unread count 처리.
|
|
const noti = notiOrRes as ReadNotification;
|
|
this.logger.debug(
|
|
'Notification::eventProtocolService::ReadNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(EventStore.readNotification(noti));
|
|
}
|
|
break;
|
|
case SSVC_TYPE_EVENT_CANCEL_NOTI:
|
|
{
|
|
const noti = notiOrRes as CancelNotification;
|
|
this.logger.debug(
|
|
'Notification::eventProtocolService::CancelNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(
|
|
EventStore.cancelNotification({
|
|
noti
|
|
})
|
|
);
|
|
}
|
|
break;
|
|
case SSVC_TYPE_EVENT_DEL_RES:
|
|
{
|
|
const noti = notiOrRes as DelNotification;
|
|
this.logger.debug(
|
|
'Notification::eventProtocolService::DelNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(
|
|
EventStore.delNotification({
|
|
noti
|
|
})
|
|
);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
)
|
|
)
|
|
.subscribe();
|
|
this.infoProtocolService.notification$
|
|
.pipe(
|
|
tap(notiOrRes => {
|
|
switch (notiOrRes.SSVC_TYPE) {
|
|
case SSVC_TYPE_INFO_USER_NOTI:
|
|
{
|
|
const noti = notiOrRes as UserNotification;
|
|
this.logger.debug(
|
|
'Notification::infoProtocolService::UserNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(
|
|
InfoStore.userNotification({
|
|
noti
|
|
})
|
|
);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
})
|
|
)
|
|
.subscribe();
|
|
this.groupProtocolService.notification$
|
|
.pipe(
|
|
withLatestFrom(
|
|
this.store.pipe(
|
|
select(
|
|
(state: any) => state.messenger.sync.group2.syncDate as string
|
|
)
|
|
)
|
|
),
|
|
tap(([notiOrRes, syncDate]) => {
|
|
switch (notiOrRes.SSVC_TYPE) {
|
|
case SSVC_TYPE_GROUP_UPD_RES2:
|
|
{
|
|
const noti = notiOrRes as GroupUpdateNotification;
|
|
this.logger.debug(
|
|
'Notification::groupProtocolService::GroupUpdateNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(
|
|
SyncStore.group2({
|
|
syncDate
|
|
})
|
|
);
|
|
}
|
|
break;
|
|
case SSVC_TYPE_GROUP_ADD_RES:
|
|
{
|
|
const noti = notiOrRes as GroupAddNotification;
|
|
this.logger.debug(
|
|
'Notification::groupProtocolService::GroupAddNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(SyncStore.createGroupSuccess(noti));
|
|
}
|
|
break;
|
|
case SSVC_TYPE_GROUP_DEL_RES:
|
|
{
|
|
const noti = notiOrRes as GroupDelNotification;
|
|
this.logger.debug(
|
|
'Notification::groupProtocolService::GroupDelNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(SyncStore.delGroupSuccess(noti));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
})
|
|
)
|
|
.subscribe();
|
|
this.buddyProtocolService.notification$
|
|
.pipe(
|
|
withLatestFrom(
|
|
this.store.pipe(
|
|
select(
|
|
(state: any) => state.messenger.sync.buddy2.syncDate as string
|
|
)
|
|
)
|
|
),
|
|
tap(([notiOrRes, syncDate]) => {
|
|
switch (notiOrRes.SSVC_TYPE) {
|
|
case SSVC_TYPE_BUDDY_UPD_RES:
|
|
{
|
|
const noti = notiOrRes as BuddyUpdateNotification;
|
|
this.logger.debug(
|
|
'Notification::groupProtocolService::BuddyUpdateNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(SyncStore.updateBuddySuccess(noti));
|
|
}
|
|
break;
|
|
case SSVC_TYPE_BUDDY_ADD_RES:
|
|
{
|
|
const noti = notiOrRes as BuddyAddNotification;
|
|
this.logger.debug(
|
|
'Notification::groupProtocolService::BuddyAddNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(SyncStore.buddy2({ syncDate }));
|
|
}
|
|
break;
|
|
case SSVC_TYPE_BUDDY_DEL_RES:
|
|
{
|
|
const noti = notiOrRes as BuddyDelNotification;
|
|
this.logger.debug(
|
|
'Notification::groupProtocolService::BuddyDelNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(SyncStore.delBuddySuccess(noti));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
})
|
|
)
|
|
.subscribe();
|
|
this.roomProtocolService.notification$
|
|
.pipe(
|
|
withLatestFrom(
|
|
this.store.pipe(
|
|
select(
|
|
(state: any) =>
|
|
state.account.authentication.loginRes as LoginResponse
|
|
)
|
|
)
|
|
),
|
|
tap(([notiOrRes, loginResInfo]) => {
|
|
switch (notiOrRes.SSVC_TYPE) {
|
|
case SSVC_TYPE_ROOM_INVITE_RES:
|
|
case SSVC_TYPE_ROOM_INVITE_NOTI:
|
|
{
|
|
const noti = notiOrRes as InviteNotification;
|
|
this.logger.debug(
|
|
'Notification::roomProtocolService::InviteNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(
|
|
RoomStore.inviteNotification({
|
|
noti
|
|
})
|
|
);
|
|
}
|
|
break;
|
|
case SSVC_TYPE_ROOM_UPD_RES:
|
|
{
|
|
const noti = notiOrRes as RoomUpdateNotification;
|
|
this.logger.debug(
|
|
'Notification::roomProtocolService::RoomUpdateNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(
|
|
RoomStore.updateSuccess({
|
|
res: {
|
|
roomSeq: noti.roomSeq,
|
|
roomName:
|
|
noti.roomName.trim().length === 0
|
|
? ' '
|
|
: noti.roomName.trim(),
|
|
receiveAlarm: noti.receiveAlarm,
|
|
syncAll: false
|
|
}
|
|
})
|
|
);
|
|
}
|
|
break;
|
|
case SSVC_TYPE_ROOM_EXIT_RES:
|
|
case SSVC_TYPE_ROOM_EXIT_NOTI:
|
|
{
|
|
const noti = notiOrRes as ExitNotification;
|
|
this.logger.debug(
|
|
'Notification::roomProtocolService::ExitNotification',
|
|
noti
|
|
);
|
|
|
|
if (noti.SENDER_SEQ === loginResInfo.userSeq) {
|
|
this.store.dispatch(
|
|
RoomStore.exitNotification({
|
|
noti
|
|
})
|
|
);
|
|
} else {
|
|
this.store.dispatch(
|
|
RoomStore.exitNotificationOthers({
|
|
roomSeq: noti.roomSeq,
|
|
trgtUser: [noti.SENDER_SEQ]
|
|
})
|
|
);
|
|
|
|
if (!!noti && !!noti.SENDER_SEQ) {
|
|
this.store.dispatch(
|
|
SyncStore.clearRoomUsers({
|
|
roomSeq: noti.roomSeq,
|
|
userSeqs: [noti.SENDER_SEQ]
|
|
})
|
|
);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case SSVC_TYPE_ROOM_EXIT_FORCING_RES:
|
|
{
|
|
// 내가 강퇴 진행.
|
|
const res = notiOrRes as ExitForcingResponse;
|
|
this.logger.debug(
|
|
'Notification::roomProtocolService::ExitForcingNotification RES',
|
|
res
|
|
);
|
|
this.store.dispatch(
|
|
RoomStore.exitForcingSuccess({
|
|
res
|
|
})
|
|
);
|
|
}
|
|
break;
|
|
case SSVC_TYPE_ROOM_EXIT_FORCING_NOTI:
|
|
{
|
|
const noti = notiOrRes as ExitForcingNotification;
|
|
this.logger.debug(
|
|
'Notification::roomProtocolService::ExitForcingNotification NOTI',
|
|
noti
|
|
);
|
|
|
|
if (noti.userSeqs.indexOf(loginResInfo.userSeq) >= 0) {
|
|
// 강퇴 대상이 본인이면 열려 있는 대화방을 닫고, 대화리스트에서 삭제.
|
|
this.store.dispatch(
|
|
RoomStore.exitForcingNotification({
|
|
noti
|
|
})
|
|
);
|
|
} else {
|
|
// ROOM::열려 있는 대화방에서 강퇴 인원의 isJoinRoom = false 로 변경.
|
|
this.store.dispatch(
|
|
RoomStore.exitNotificationOthers({
|
|
roomSeq: noti.roomSeq,
|
|
trgtUser: noti.userSeqs
|
|
})
|
|
);
|
|
|
|
// SYNC::대화리스트의 대화자정보에서 강퇴 인원의 isJoinRoom = false 로 변경.
|
|
this.store.dispatch(
|
|
SyncStore.clearRoomUsers({
|
|
roomSeq: noti.roomSeq,
|
|
userSeqs: noti.userSeqs
|
|
})
|
|
);
|
|
}
|
|
}
|
|
break;
|
|
case SSVC_TYPE_ROOM_FONT_UPD_NOTI:
|
|
{
|
|
const noti = notiOrRes as UpdateFontNotification;
|
|
this.logger.debug(
|
|
'Notification::roomProtocolService::UpdateFontNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(
|
|
RoomStore.updateFontNotification({
|
|
noti
|
|
})
|
|
);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
})
|
|
)
|
|
.subscribe();
|
|
this.statusProtocolService.notification$
|
|
.pipe(
|
|
tap(notiOrRes => {
|
|
switch (notiOrRes.SSVC_TYPE) {
|
|
case SSVC_TYPE_STATUS_NOTI:
|
|
{
|
|
const noti = notiOrRes as StatusNotification;
|
|
this.logger.debug(
|
|
'Notification::statusProtocolService::StatusNotification',
|
|
noti
|
|
);
|
|
this.store.dispatch(
|
|
StatusStore.statusNotification({
|
|
noti
|
|
})
|
|
);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
})
|
|
)
|
|
.subscribe();
|
|
this.optionProtocolService.notification$
|
|
.pipe(
|
|
tap(notiOrRes => {
|
|
switch (notiOrRes.SSVC_TYPE) {
|
|
case SSVC_TYPE_OPTION_REG_UPD_RES:
|
|
{
|
|
const noti = notiOrRes as RegUpdateNotification;
|
|
this.logger.debug(
|
|
'Notification::optionProtocolService::RegUpdateNotification',
|
|
noti
|
|
);
|
|
|
|
const appUserInfo: AppUserInfo = this.localStorageService.encGet<
|
|
AppUserInfo
|
|
>(KEY_APP_USER_INFO, environment.customConfig.appKey);
|
|
|
|
const modifiedSettings: Settings = clone(appUserInfo.settings);
|
|
// 모바일에서 해당 값만 수정함.
|
|
modifiedSettings.notification.receiveForMobile =
|
|
noti.mobileNotification;
|
|
appUserInfo.settings = modifiedSettings;
|
|
|
|
this.localStorageService.encSet<AppUserInfo>(
|
|
KEY_APP_USER_INFO,
|
|
appUserInfo,
|
|
environment.customConfig.appKey
|
|
);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
})
|
|
)
|
|
.subscribe();
|
|
this.umgProtocolService.notification$
|
|
.pipe(
|
|
tap(notiOrRes => {
|
|
switch (notiOrRes.SSVC_TYPE) {
|
|
case SSVC_TYPE_UMG_NOTI:
|
|
{
|
|
const noti = notiOrRes as UmgNotiNotification;
|
|
this.logger.debug(
|
|
'Notification::umgProtocolService::UmgNotiNotification',
|
|
noti
|
|
);
|
|
|
|
// unreadCount refresh..
|
|
this.store.dispatch(MessageStore.retrieveUnreadCount({}));
|
|
|
|
// Receive Message List refresh..
|
|
this.store.dispatch(
|
|
MessageStore.retrieveMessage({
|
|
messageType: MessageType.Receive
|
|
})
|
|
);
|
|
|
|
// notification..
|
|
const appUserInfo = this.localStorageService.encGet<
|
|
AppUserInfo
|
|
>(KEY_APP_USER_INFO, environment.customConfig.appKey);
|
|
|
|
if (appUserInfo.settings.notification.use) {
|
|
if (
|
|
appUserInfo.settings.notification.method ===
|
|
NotificationMethod.Sound
|
|
) {
|
|
const audio = new Audio('assets/sounds/messageAlarm.mp3');
|
|
audio.play();
|
|
} else {
|
|
const notiReq: NotificationRequest = {
|
|
type: NotificationType.Message,
|
|
seq: noti.keyId,
|
|
title: this.translateService.instant(
|
|
'notification.titleMessageArrived'
|
|
),
|
|
contents: noti.text,
|
|
image: noti.senderInfo.profileImageFile,
|
|
useSound: [
|
|
NotificationMethod.Sound,
|
|
NotificationMethod.SoundAndAlert
|
|
].some(
|
|
n => n === appUserInfo.settings.notification.method
|
|
)
|
|
? true
|
|
: false,
|
|
displayTime:
|
|
appUserInfo.settings.notification.alertExposureTime *
|
|
1000
|
|
};
|
|
this.nativeService.notify(notiReq);
|
|
}
|
|
}
|
|
|
|
// direct open detail
|
|
if (appUserInfo.settings.notification.receiveForMessage) {
|
|
this.store.dispatch(
|
|
MessageStore.detailMessage({
|
|
messageType: MessageType.Receive,
|
|
msgId: Number(noti.keyId)
|
|
})
|
|
);
|
|
}
|
|
}
|
|
break;
|
|
case SSVC_TYPE_UMG_DELETE_NOTI:
|
|
{
|
|
const noti = notiOrRes as UmgDeleteNotiNotification;
|
|
this.logger.debug(
|
|
'Notification::umgProtocolService::UmgDeleteNotiNotification',
|
|
noti
|
|
);
|
|
|
|
// Remove one Receive Message
|
|
if (!!noti && !!noti.keyId) {
|
|
// clear badge in left navi
|
|
this.store.dispatch(MessageStore.retrieveUnreadCount({}));
|
|
|
|
// delete message in receive message list
|
|
this.store.dispatch(
|
|
deleteMessageSuccess({
|
|
messageType: MessageType.Receive,
|
|
msgList: [
|
|
{
|
|
msgId: Number(noti.keyId)
|
|
}
|
|
]
|
|
})
|
|
);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
})
|
|
)
|
|
.subscribe();
|
|
}
|
|
}
|