ramda#pathOr TypeScript Examples

intercept(
		request: HttpRequest<any>,
		next: HttpHandler
	): Observable<HttpEvent<any>> {
		return next.handle(request).pipe(
			catchError((error: HttpErrorResponse) => {
				this.toastr.error(pathOr('Something went wrong while trying to do that', ['error', 'message'])(error), 'Error');
				return throwError(error);
			})
		);
	}

public ngOnInit() {
		this.doSearch();
		this.control.valueChanges.pipe(
			takeUntil(this.componentDestroyed$),
		).subscribe((value) => {
			if (!this.multiple) {
				return this.propagateChange(pathOr(value, ['value'])(value));
			}

			this.propagateChange((value || []).map((roleItem) => pathOr(roleItem, ['value'])(roleItem)));
		});
	}

private ensureNoIssues(): void {
		this.slotService.verify({
			...this.form.value,
			uuid: pathOr(null, ['event', 'uuid'])(this.data),
			start: moment(this.form.value.start).unix(),
			end: moment(this.form.value.end).unix(),
		})
		.toPromise()
		.then((slots) => this.validationInfo = slots);
	}

public ngOnInit() {
		this.doSearch();
		this.control.valueChanges.pipe(
			takeUntil(this.componentDestroyed$),
		).subscribe((value) => {
			if (!this.multiple) {
				return this.propagateChange(pathOr(value, ['value'])(value));
			}

			this.propagateChange((value || []).map((roleItem) => pathOr(roleItem, ['value'])(roleItem)));
		});
	}

private buildFieldsArray(fields) {
		return fields.map((field) => {
			const fieldConfiguration = this.findFieldConfiguration(field.fieldType);

			const config = fieldConfiguration.config.reduce((acc, fieldConfig) => ({
				...acc,
				[fieldConfig.identifier]: [pathOr(null, ['config', fieldConfig.identifier])(field)]
			}), {});

			const fieldForm = this.formBuilder.group({
				uuid: [field.uuid],
				name: [field.name],
				slug: [field.slug],
				showOnOverview: [field.showOnOverview],
				multiLanguage: [field.multiLanguage],
				fieldType: [field.fieldType],
				config: this.formBuilder.group(config),
				subfields: this.formBuilder.array(this.buildFieldsArray(field.subfields || []))
			});

			if (!field.slug) {
				fieldForm.get('name').valueChanges
					.pipe(
						takeUntil(this.componentDestroyed$)
					).subscribe((value) => fieldForm.patchValue({
						slug: camelCase(value)
					}));
			}

			return fieldForm;
		});
	}

public writeValue(value: any) {
		this.originalValue = value;

		if (this.multiLanguage) {
			return setTimeout(() => this.control.setValue(pathOr('', [this.language])(value)));
		}

		setTimeout(() => this.control.setValue(value));
	}

private buildFieldsArray(fields) {
		return fields.map((field) => {
			const fieldConfiguration = this.findFieldConfiguration(field.fieldType);

			const config = fieldConfiguration.config.reduce((acc, fieldConfig) => ({
				...acc,
				[fieldConfig.identifier]: [pathOr(null, ['config', fieldConfig.identifier])(field)]
			}), {});

			const fieldForm = this.formBuilder.group({
				uuid: [field.uuid],
				name: [field.name],
				slug: [field.slug],
				showOnOverview: [field.showOnOverview],
				multiLanguage: [field.multiLanguage],
				fieldType: [field.fieldType],
				config: this.formBuilder.group(config),
			});

			fieldForm.get('name').valueChanges
				.pipe(
					takeUntil(this.componentDestroyed$)
				).subscribe((value) => fieldForm.patchValue({
					slug: camelCase(value)
				}));

			return fieldForm;
		});
	}

public ngOnInit(): void {
		this.form = this.formBuilder.group({
			name: ['', Validators.required],
			description: ['', Validators.required],
			color: ['', Validators.required],
		});

		this.slotTypeService.fetchOne(this.activatedRoute.snapshot.params.id)
			.pipe(
				takeUntil(this.componentDestroyed$)
			).subscribe((user) => {
				this.form.patchValue({
					...user,
					role: pathOr(null, ['role', 'uuid'])(user)
				});
			});
	}

private buildFieldsArray(fields) {
		return fields.map((field) => {
			const fieldConfiguration = this.findFieldConfiguration(field.fieldType);

			const config = fieldConfiguration.config.reduce((acc, fieldConfig) => ({
				...acc,
				[fieldConfig.identifier]: [pathOr(null, ['config', fieldConfig.identifier])(field)]
			}), {});

			const fieldForm = this.formBuilder.group({
				uuid: [field.uuid],
				name: [field.name],
				slug: [field.slug],
				showOnOverview: [field.showOnOverview],
				multiLanguage: [field.multiLanguage],
				fieldType: [field.fieldType],
				config: this.formBuilder.group(config),
				subfields: this.formBuilder.array(this.buildFieldsArray(field.subfields || []))
			});

			if (!field.slug) {
				fieldForm.get('name').valueChanges
					.pipe(
						takeUntil(this.componentDestroyed$)
					).subscribe((value) => fieldForm.patchValue({
						slug: camelCase(value)
					}));
			}

			return fieldForm;
		});
	}

public ngOnChanges(changes: any) {
		if (!changes.entityType) {
			return;
		}

		const entityType = changes.entityType.currentValue;
		this.form.patchValue({
			...entityType,
			workflow: pathOr('', ['workflow', 'uuid'])(entityType)
		});

		const fieldsGroup = this.form.get('fields') as FormArray;
		this.buildFieldsArray((propOr([], 'fields')(entityType) as any[])).map((formGroup) => {
			fieldsGroup.push(formGroup);
		});
	}

public ngOnInit() {
		this.doSearch();
		this.control.valueChanges.pipe(
			takeUntil(this.componentDestroyed$),
		).subscribe((value) => {
			if (!this.multiple) {
				return this.propagateChange(pathOr(value, ['value'])(value));
			}

			this.propagateChange((value || []).map((roleItem) => pathOr(roleItem, ['value'])(roleItem)));
		});
	}

private buildFieldsArray(fields) {
		return fields.map((field) => {
			const fieldConfiguration = this.findFieldConfiguration(field.fieldType);

			const config = fieldConfiguration.config.reduce((acc, fieldConfig) => ({
				...acc,
				[fieldConfig.identifier]: [pathOr(null, ['config', fieldConfig.identifier])(field)]
			}), {});

			const fieldForm = this.formBuilder.group({
				uuid: [field.uuid],
				name: [field.name],
				slug: [field.slug],
				showOnOverview: [field.showOnOverview],
				multiLanguage: [field.multiLanguage],
				fieldType: [field.fieldType],
				config: this.formBuilder.group(config),
				subfields: this.formBuilder.array(this.buildFieldsArray(field.subfields || []))
			});

			if (!field.slug) {
				fieldForm.get('name').valueChanges
					.pipe(
						takeUntil(this.componentDestroyed$)
					).subscribe((value) => fieldForm.patchValue({
						slug: camelCase(value)
					}));
			}

			return fieldForm;
		});
	}

public ngOnChanges(changes: any) {
		if (!changes.entityType) {
			return;
		}

		const entityType = changes.entityType.currentValue;
		this.form.patchValue({
			...entityType,
			workflow: pathOr('', ['workflow', 'uuid'])(entityType)
		});

		const fieldsGroup = this.form.get('fields') as FormArray;
		this.buildFieldsArray((propOr([], 'fields')(entityType) as any[])).map((formGroup) => {
			fieldsGroup.push(formGroup);
		});
	}

private buildFieldsArray(fields) {
		return fields.map((field) => {
			const fieldConfiguration = this.findFieldConfiguration(field.fieldType);

			const config = fieldConfiguration.config.reduce((acc, fieldConfig) => ({
				...acc,
				[fieldConfig.identifier]: [pathOr(null, ['config', fieldConfig.identifier])(field)]
			}), {});

			const fieldForm = this.formBuilder.group({
				uuid: [field.uuid],
				name: [field.name],
				slug: [field.slug],
				showOnOverview: [field.showOnOverview],
				multiLanguage: [field.multiLanguage],
				fieldType: [field.fieldType],
				config: this.formBuilder.group(config),
				subfields: this.formBuilder.array(this.buildFieldsArray(field.subfields || []))
			});

			if (!field.slug) {
				fieldForm.get('name').valueChanges
					.pipe(
						takeUntil(this.componentDestroyed$)
					).subscribe((value) => fieldForm.patchValue({
						slug: camelCase(value)
					}));
			}

			return fieldForm;
		});
	}

public ngOnChanges(changes: any) {
		if (!changes.entityType) {
			return;
		}

		const entityType = changes.entityType.currentValue;
		this.form.patchValue({
			...entityType,
			workflow: pathOr('', ['workflow', 'uuid'])(entityType)
		});

		const fieldsGroup = this.form.get('fields') as FormArray;
		this.buildFieldsArray((propOr([], 'fields')(entityType) as any[])).map((formGroup) => {
			fieldsGroup.push(formGroup);
		});
	}

public ngOnInit() {
		this.doSearch();
		this.control.valueChanges.pipe(
			takeUntil(this.componentDestroyed$),
		).subscribe((value) => {
			if (!this.multiple) {
				return this.propagateChange(pathOr(value, ['value'])(value));
			}

			this.propagateChange((value || []).map((tenantItem) => pathOr(tenantItem, ['value'])(tenantItem)));
		});
	}

public ngOnChanges(changes: any) {
		if (!changes.entityType) {
			return;
		}

		const entityType = changes.entityType.currentValue;
		this.form.patchValue({
			...entityType,
			workflow: pathOr('', ['workflow', 'uuid'])(entityType)
		});

		const fieldsGroup = this.form.get('fields') as FormArray;
		this.buildFieldsArray((propOr([], 'fields')(entityType) as any[])).map((formGroup) => {
			fieldsGroup.push(formGroup);
		});
	}

private buildFieldsArray(fields) {
		return fields.map((field) => {
			const fieldConfiguration = this.findFieldConfiguration(field.fieldType);

			const config = fieldConfiguration.config.reduce((acc, fieldConfig) => ({
				...acc,
				[fieldConfig.identifier]: [pathOr(null, ['config', fieldConfig.identifier])(field)]
			}), {});

			const fieldForm = this.formBuilder.group({
				uuid: [field.uuid],
				name: [field.name],
				slug: [field.slug],
				showOnOverview: [field.showOnOverview],
				multiLanguage: [field.multiLanguage],
				fieldType: [field.fieldType],
				config: this.formBuilder.group(config),
				subfields: this.formBuilder.array(this.buildFieldsArray(field.subfields || []))
			});

			if (!field.slug) {
				fieldForm.get('name').valueChanges
					.pipe(
						takeUntil(this.componentDestroyed$)
					).subscribe((value) => fieldForm.patchValue({
						slug: camelCase(value)
					}));
			}

			return fieldForm;
		});
	}

@Get('/previous')
	@Permissions('timetable/read')
	public async findPrevious(
		@Query('populate') populate = false,
	): Promise<any> {
		const [{ _embedded: slots }, tenant] = await Promise.all([
			this.slotService.find(moment().add(1, 'days').unix().toString(), moment().subtract(7, 'days').unix().toString()),
			this.tenantService.findOne()
		]);

		const currentUnixTime = moment().unix();
		const foundSlots = slots.filter((slot: Slot) => slot.end < currentUnixTime);
		const slot = pathOr(null, [foundSlots.length - 1])(foundSlots)

		if (!slot) {
			return null;
		}
		
		if (!populate || !tenant.slotFields || !tenant.slotFields.length) {
			return slot;
		}

		return {
			...slot,
			customData: await this.populateService.populateContent(slot.customData, tenant.slotFields),
		}
	}

@Get('/later')
	@Permissions('timetable/read')
	public async findLater(
		@Query('populate') populate = false,
	): Promise<any> {
		const [{ _embedded: slots }, tenant] = await Promise.all([
			this.slotService.find(moment().add(7, 'days').unix().toString(), moment().subtract(1, 'days').unix().toString()),
			this.tenantService.findOne()
		]);

		const currentUnixTime = moment().unix()
		const slot = pathOr(null, [1])(slots.filter((slot: Slot) => slot.start > currentUnixTime))

		if (!slot) {
			return null;
		}
		
		if (!populate || !tenant.slotFields || !tenant.slotFields.length) {
			return slot;
		}

		return {
			...slot,
			customData: await this.populateService.populateContent(slot.customData, tenant.slotFields),
		}
	}

@Get('next-hours/:hour')
	@Permissions('timetable/read')
	public async findInHour(
		@Query('populate') populate = false,
		@Param('hour') hour: string,
	): Promise<any> {
		const [{ _embedded: slots }, tenant] = await Promise.all([
			this.slotService.find(moment().add(7, 'days').unix().toString(), moment().subtract(1, 'days').unix().toString()),
			this.tenantService.findOne(),
		]);

		const startOfHour = moment().add(Number(hour), 'hour').startOf('hour').unix();
		const endOfHour = moment().add(Number(hour), 'hour').endOf('hour').unix();
		const slot = pathOr(null, [0])(slots.filter((slot: Slot) => slot.start >= startOfHour && slot.start < endOfHour))

		if (!slot) {
			return null;
		}
		
		if (!populate || !tenant.slotFields || !tenant.slotFields.length) {
			return slot;
		}

		return {
			...slot,
			customData: await this.populateService.populateContent(slot.customData, tenant.slotFields),
		}
	}

public async findOne(search: any): Promise<any> {
		const query = this.userRepository.createQueryBuilder('User');

		if (search.uuid) {
			query.andWhere('User.uuid = :uuid', { uuid: search.uuid })
		}

		if (search.email) {
			query.andWhere('User.email = :email', { email: search.email })
		}

		if (search.authenticationMethodUuid) {
			query.andWhere('User.authenticationMethodUuid = :authenticationMethodUuid', { authenticationMethodUuid: search.authenticationMethodUuid })
		}

		const [user, userMeta] = await Promise.all([
			query.getOne(),
			this.getMeta(search.uuid)
		]);

		if (!user) {
			return null;
		}

		const customData = userMeta.find((x) => x.key === "customData");

		return {
			...user,
			...(pathOr(null, ['value'])(customData) && { customData: pathOr(null, ['value'])(customData) }),
		};
	}

public toggleFieldExpansion(i: number) {
		this.openFields[i] = !pathOr(false, [i])(this.openFields);
	}

public ngOnInit() {
		this.control.valueChanges.pipe(
			takeUntil(this.componentDestroyed$),
		).subscribe((value) => {
			this.propagateChange(pathOr(value, ['value'])(value));
		});
	}

public ngOnInit() {
		this.control.valueChanges.pipe(
			takeUntil(this.componentDestroyed$),
		).subscribe((value) => {
			return this.propagateChange(pathOr(value, ['value'])(value));
		});
	}

public toggleSubfieldExpansion(i: number) {
        this.openFields[i] = !pathOr(false, [i])(this.openFields);
    }

public toggleFieldExpansion(i: number) {
		this.openFields[i] = !pathOr(false, [i])(this.openFields);
	}

public ngOnInit(): void {
		this.fetchData();

		this.socketService.socket.on('timetable-updated', () => {
			this.fetchData();
		});

		// TODO: add takeUntill
		this.sessionQuery.user$.subscribe((user) => this.user = user);
		this.sessionQuery.permissions$.subscribe((permissions) => this.permissions = permissions);

		this.slotTypeService
			.fetch()
			.pipe(first())
			.subscribe();

		this.slotQuery.selectAll()
			.pipe(
				map(slots => {
					return slots.map((slot) => ({
						...slot,
						id: (slot as any).uuid,
						start: moment.unix(Number(slot.start)).toDate(),
						end: moment.unix(Number(slot.end) - 1).toDate(),
						color: {
							primary: pathOr('#000', ['slotType', 'color'])(slot),
							secondary: pathOr('#000', ['slotType', 'color'])(slot)
						},
						meta: {
							...(slot as any).user,
							originalTimings: {
								start: moment.unix(Number(slot.start)).toDate(),
								end: moment.unix(Number(slot.end)).toDate(),
							},
							editable: this.permissions.includes('timetable/update-other')
								|| path(['user', 'uuid'])(slot) === prop('uuid')(this.user)
						}
					}));
				})
			).subscribe((slots) => {
				this.slots = slots;
				this.refresh();
			});
	}

public toggleFieldExpansion(i: number) {
		this.openFields[i] = !pathOr(false, [i])(this.openFields);
	}