@vendure/core 2.0.0-next.2 → 2.0.0-next.21

package/cli/service/services/customer.service.js

@@ -1,662 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomerService = void 0;
-const common_1 = require("@nestjs/common");
-const generated_types_1 = require("@vendure/common/lib/generated-types");
-const error_result_1 = require("../../common/error/error-result");
-const errors_1 = require("../../common/error/errors");
-const generated_graphql_admin_errors_1 = require("../../common/error/generated-graphql-admin-errors");
-const generated_graphql_shop_errors_1 = require("../../common/error/generated-graphql-shop-errors");
-const utils_1 = require("../../common/utils");
-const native_authentication_strategy_1 = require("../../config/auth/native-authentication-strategy");
-const config_service_1 = require("../../config/config.service");
-const transactional_connection_1 = require("../../connection/transactional-connection");
-const address_entity_1 = require("../../entity/address/address.entity");
-const native_authentication_method_entity_1 = require("../../entity/authentication-method/native-authentication-method.entity");
-const channel_entity_1 = require("../../entity/channel/channel.entity");
-const customer_entity_1 = require("../../entity/customer/customer.entity");
-const user_entity_1 = require("../../entity/user/user.entity");
-const event_bus_1 = require("../../event-bus/event-bus");
-const account_registration_event_1 = require("../../event-bus/events/account-registration-event");
-const account_verified_event_1 = require("../../event-bus/events/account-verified-event");
-const customer_address_event_1 = require("../../event-bus/events/customer-address-event");
-const customer_event_1 = require("../../event-bus/events/customer-event");
-const identifier_change_event_1 = require("../../event-bus/events/identifier-change-event");
-const identifier_change_request_event_1 = require("../../event-bus/events/identifier-change-request-event");
-const password_reset_event_1 = require("../../event-bus/events/password-reset-event");
-const password_reset_verified_event_1 = require("../../event-bus/events/password-reset-verified-event");
-const custom_field_relation_service_1 = require("../helpers/custom-field-relation/custom-field-relation.service");
-const list_query_builder_1 = require("../helpers/list-query-builder/list-query-builder");
-const address_to_line_1 = require("../helpers/utils/address-to-line");
-const patch_entity_1 = require("../helpers/utils/patch-entity");
-const translate_entity_1 = require("../helpers/utils/translate-entity");
-const channel_service_1 = require("./channel.service");
-const country_service_1 = require("./country.service");
-const history_service_1 = require("./history.service");
-const user_service_1 = require("./user.service");
-let CustomerService = class CustomerService {
-    constructor(connection, configService, userService, countryService, listQueryBuilder, eventBus, historyService, channelService, customFieldRelationService) {
-        this.connection = connection;
-        this.configService = configService;
-        this.userService = userService;
-        this.countryService = countryService;
-        this.listQueryBuilder = listQueryBuilder;
-        this.eventBus = eventBus;
-        this.historyService = historyService;
-        this.channelService = channelService;
-        this.customFieldRelationService = customFieldRelationService;
-    }
-    findAll(ctx, options) {
-        var _a, _b;
-        const relations = ['channels'];
-        const customPropertyMap = {};
-        const hasPostalCodeFilter = !!((_b = (_a = options) === null || _a === void 0 ? void 0 : _a.filter) === null || _b === void 0 ? void 0 : _b.postalCode);
-        if (hasPostalCodeFilter) {
-            relations.push('addresses');
-            customPropertyMap.postalCode = 'address.postalCode';
-        }
-        return this.listQueryBuilder
-            .build(customer_entity_1.Customer, options, {
-            relations,
-            channelId: ctx.channelId,
-            where: { deletedAt: null },
-            ctx,
-            customPropertyMap,
-        })
-            .getManyAndCount()
-            .then(([items, totalItems]) => ({ items, totalItems }));
-    }
-    findOne(ctx, id) {
-        return this.connection.findOneInChannel(ctx, customer_entity_1.Customer, id, ctx.channelId, {
-            where: { deletedAt: null },
-        });
-    }
-    findOneByUserId(ctx, userId, filterOnChannel = true) {
-        let query = this.connection
-            .getRepository(ctx, customer_entity_1.Customer)
-            .createQueryBuilder('customer')
-            .leftJoin('customer.channels', 'channel')
-            .leftJoinAndSelect('customer.user', 'user')
-            .where('user.id = :userId', { userId })
-            .andWhere('customer.deletedAt is null');
-        if (filterOnChannel) {
-            query = query.andWhere('channel.id = :channelId', { channelId: ctx.channelId });
-        }
-        return query.getOne();
-    }
-    findAddressesByCustomerId(ctx, customerId) {
-        return this.connection
-            .getRepository(ctx, address_entity_1.Address)
-            .createQueryBuilder('address')
-            .leftJoinAndSelect('address.country', 'country')
-            .leftJoinAndSelect('country.translations', 'countryTranslation')
-            .where('address.customer = :id', { id: customerId })
-            .getMany()
-            .then(addresses => {
-            addresses.forEach(address => {
-                address.country = translate_entity_1.translateDeep(address.country, ctx.languageCode);
-            });
-            return addresses;
-        });
-    }
-    async getCustomerGroups(ctx, customerId) {
-        const customerWithGroups = await this.connection.findOneInChannel(ctx, customer_entity_1.Customer, customerId, ctx === null || ctx === void 0 ? void 0 : ctx.channelId, {
-            relations: ['groups'],
-            where: {
-                deletedAt: null,
-            },
-        });
-        if (customerWithGroups) {
-            return customerWithGroups.groups;
-        }
-        else {
-            return [];
-        }
-    }
-    async create(ctx, input, password) {
-        var _a;
-        input.emailAddress = utils_1.normalizeEmailAddress(input.emailAddress);
-        const customer = new customer_entity_1.Customer(input);
-        const existingCustomerInChannel = await this.connection
-            .getRepository(ctx, customer_entity_1.Customer)
-            .createQueryBuilder('customer')
-            .leftJoin('customer.channels', 'channel')
-            .where('channel.id = :channelId', { channelId: ctx.channelId })
-            .andWhere('customer.emailAddress = :emailAddress', { emailAddress: input.emailAddress })
-            .andWhere('customer.deletedAt is null')
-            .getOne();
-        if (existingCustomerInChannel) {
-            return new generated_graphql_admin_errors_1.EmailAddressConflictError();
-        }
-        const existingCustomer = await this.connection.getRepository(ctx, customer_entity_1.Customer).findOne({
-            relations: ['channels'],
-            where: {
-                emailAddress: input.emailAddress,
-                deletedAt: null,
-            },
-        });
-        const existingUser = await this.connection.getRepository(ctx, user_entity_1.User).findOne({
-            where: {
-                identifier: input.emailAddress,
-                deletedAt: null,
-            },
-        });
-        if (existingCustomer && existingUser) {
-            const updatedCustomer = patch_entity_1.patchEntity(existingCustomer, input);
-            updatedCustomer.channels.push(ctx.channel);
-            return this.connection.getRepository(customer_entity_1.Customer).save(updatedCustomer);
-        }
-        else if (existingCustomer || existingUser) {
-            return new generated_graphql_admin_errors_1.EmailAddressConflictError();
-        }
-        const customerUser = await this.userService.createCustomerUser(ctx, input.emailAddress, password);
-        if (error_result_1.isGraphQlErrorResult(customerUser)) {
-            throw customerUser;
-        }
-        customer.user = customerUser;
-        if (password && password !== '') {
-            const verificationToken = customer.user.getNativeAuthenticationMethod().verificationToken;
-            if (verificationToken) {
-                const result = await this.userService.verifyUserByToken(ctx, verificationToken);
-                if (error_result_1.isGraphQlErrorResult(result)) {
-                    throw result;
-                }
-                else {
-                    customer.user = result;
-                }
-            }
-        }
-        else {
-            this.eventBus.publish(new account_registration_event_1.AccountRegistrationEvent(ctx, customer.user));
-        }
-        await this.channelService.assignToCurrentChannel(customer, ctx);
-        const createdCustomer = await this.connection.getRepository(ctx, customer_entity_1.Customer).save(customer);
-        await this.customFieldRelationService.updateRelations(ctx, customer_entity_1.Customer, input, createdCustomer);
-        await this.historyService.createHistoryEntryForCustomer({
-            ctx,
-            customerId: createdCustomer.id,
-            type: generated_types_1.HistoryEntryType.CUSTOMER_REGISTERED,
-            data: {
-                strategy: native_authentication_strategy_1.NATIVE_AUTH_STRATEGY_NAME,
-            },
-        });
-        if ((_a = customer.user) === null || _a === void 0 ? void 0 : _a.verified) {
-            await this.historyService.createHistoryEntryForCustomer({
-                ctx,
-                customerId: createdCustomer.id,
-                type: generated_types_1.HistoryEntryType.CUSTOMER_VERIFIED,
-                data: {
-                    strategy: native_authentication_strategy_1.NATIVE_AUTH_STRATEGY_NAME,
-                },
-            });
-        }
-        this.eventBus.publish(new customer_event_1.CustomerEvent(ctx, createdCustomer, 'created', input));
-        return createdCustomer;
-    }
-    async update(ctx, input) {
-        const hasEmailAddress = (i) => Object.hasOwnProperty.call(i, 'emailAddress');
-        const customer = await this.connection.getEntityOrThrow(ctx, customer_entity_1.Customer, input.id, {
-            channelId: ctx.channelId,
-        });
-        if (hasEmailAddress(input)) {
-            if (input.emailAddress !== customer.emailAddress) {
-                const existingCustomerInChannel = await this.connection
-                    .getRepository(ctx, customer_entity_1.Customer)
-                    .createQueryBuilder('customer')
-                    .leftJoin('customer.channels', 'channel')
-                    .where('channel.id = :channelId', { channelId: ctx.channelId })
-                    .andWhere('customer.emailAddress = :emailAddress', { emailAddress: input.emailAddress })
-                    .andWhere('customer.id != :customerId', { customerId: input.id })
-                    .andWhere('customer.deletedAt is null')
-                    .getOne();
-                if (existingCustomerInChannel) {
-                    return new generated_graphql_admin_errors_1.EmailAddressConflictError();
-                }
-                if (customer.user) {
-                    const existingUserWithEmailAddress = await this.userService.getUserByEmailAddress(ctx, input.emailAddress);
-                    if (existingUserWithEmailAddress &&
-                        !utils_1.idsAreEqual(customer.user.id, existingUserWithEmailAddress.id)) {
-                        return new generated_graphql_admin_errors_1.EmailAddressConflictError();
-                    }
-                    await this.userService.changeNativeIdentifier(ctx, customer.user.id, input.emailAddress);
-                }
-            }
-        }
-        const updatedCustomer = patch_entity_1.patchEntity(customer, input);
-        await this.connection.getRepository(ctx, customer_entity_1.Customer).save(updatedCustomer, { reload: false });
-        await this.customFieldRelationService.updateRelations(ctx, customer_entity_1.Customer, input, updatedCustomer);
-        await this.historyService.createHistoryEntryForCustomer({
-            customerId: customer.id,
-            ctx,
-            type: generated_types_1.HistoryEntryType.CUSTOMER_DETAIL_UPDATED,
-            data: {
-                input,
-            },
-        });
-        this.eventBus.publish(new customer_event_1.CustomerEvent(ctx, customer, 'updated', input));
-        return utils_1.assertFound(this.findOne(ctx, customer.id));
-    }
-    async registerCustomerAccount(ctx, input) {
-        if (!this.configService.authOptions.requireVerification) {
-            if (!input.password) {
-                return new generated_graphql_shop_errors_1.MissingPasswordError();
-            }
-        }
-        let user = await this.userService.getUserByEmailAddress(ctx, input.emailAddress);
-        const hasNativeAuthMethod = !!(user === null || user === void 0 ? void 0 : user.authenticationMethods.find(m => m instanceof native_authentication_method_entity_1.NativeAuthenticationMethod));
-        if (user && user.verified) {
-            if (hasNativeAuthMethod) {
-                return { success: true };
-            }
-        }
-        const customFields = input.customFields;
-        const customer = await this.createOrUpdate(ctx, Object.assign({ emailAddress: input.emailAddress, title: input.title || '', firstName: input.firstName || '', lastName: input.lastName || '', phoneNumber: input.phoneNumber || '' }, (customFields ? { customFields } : {})));
-        if (error_result_1.isGraphQlErrorResult(customer)) {
-            return customer;
-        }
-        await this.historyService.createHistoryEntryForCustomer({
-            customerId: customer.id,
-            ctx,
-            type: generated_types_1.HistoryEntryType.CUSTOMER_REGISTERED,
-            data: {
-                strategy: native_authentication_strategy_1.NATIVE_AUTH_STRATEGY_NAME,
-            },
-        });
-        if (!user) {
-            const customerUser = await this.userService.createCustomerUser(ctx, input.emailAddress, input.password || undefined);
-            if (error_result_1.isGraphQlErrorResult(customerUser)) {
-                return customerUser;
-            }
-            else {
-                user = customerUser;
-            }
-        }
-        if (!hasNativeAuthMethod) {
-            const addAuthenticationResult = await this.userService.addNativeAuthenticationMethod(ctx, user, input.emailAddress, input.password || undefined);
-            if (error_result_1.isGraphQlErrorResult(addAuthenticationResult)) {
-                return addAuthenticationResult;
-            }
-            else {
-                user = addAuthenticationResult;
-            }
-        }
-        if (!user.verified) {
-            user = await this.userService.setVerificationToken(ctx, user);
-        }
-        customer.user = user;
-        await this.connection.getRepository(ctx, user_entity_1.User).save(user, { reload: false });
-        await this.connection.getRepository(ctx, customer_entity_1.Customer).save(customer, { reload: false });
-        if (!user.verified) {
-            this.eventBus.publish(new account_registration_event_1.AccountRegistrationEvent(ctx, user));
-        }
-        else {
-            await this.historyService.createHistoryEntryForCustomer({
-                customerId: customer.id,
-                ctx,
-                type: generated_types_1.HistoryEntryType.CUSTOMER_VERIFIED,
-                data: {
-                    strategy: native_authentication_strategy_1.NATIVE_AUTH_STRATEGY_NAME,
-                },
-            });
-        }
-        return { success: true };
-    }
-    async refreshVerificationToken(ctx, emailAddress) {
-        const user = await this.userService.getUserByEmailAddress(ctx, emailAddress);
-        if (user && !user.verified) {
-            await this.userService.setVerificationToken(ctx, user);
-            this.eventBus.publish(new account_registration_event_1.AccountRegistrationEvent(ctx, user));
-        }
-    }
-    async verifyCustomerEmailAddress(ctx, verificationToken, password) {
-        const result = await this.userService.verifyUserByToken(ctx, verificationToken, password);
-        if (error_result_1.isGraphQlErrorResult(result)) {
-            return result;
-        }
-        const customer = await this.findOneByUserId(ctx, result.id, false);
-        if (!customer) {
-            throw new errors_1.InternalServerError('error.cannot-locate-customer-for-user');
-        }
-        if (ctx.channelId) {
-            await this.channelService.assignToChannels(ctx, customer_entity_1.Customer, customer.id, [ctx.channelId]);
-        }
-        await this.historyService.createHistoryEntryForCustomer({
-            customerId: customer.id,
-            ctx,
-            type: generated_types_1.HistoryEntryType.CUSTOMER_VERIFIED,
-            data: {
-                strategy: native_authentication_strategy_1.NATIVE_AUTH_STRATEGY_NAME,
-            },
-        });
-        const user = utils_1.assertFound(this.findOneByUserId(ctx, result.id));
-        this.eventBus.publish(new account_verified_event_1.AccountVerifiedEvent(ctx, customer));
-        return user;
-    }
-    async requestPasswordReset(ctx, emailAddress) {
-        const user = await this.userService.setPasswordResetToken(ctx, emailAddress);
-        if (user) {
-            this.eventBus.publish(new password_reset_event_1.PasswordResetEvent(ctx, user));
-            const customer = await this.findOneByUserId(ctx, user.id);
-            if (!customer) {
-                throw new errors_1.InternalServerError('error.cannot-locate-customer-for-user');
-            }
-            await this.historyService.createHistoryEntryForCustomer({
-                customerId: customer.id,
-                ctx,
-                type: generated_types_1.HistoryEntryType.CUSTOMER_PASSWORD_RESET_REQUESTED,
-                data: {},
-            });
-        }
-    }
-    async resetPassword(ctx, passwordResetToken, password) {
-        const result = await this.userService.resetPasswordByToken(ctx, passwordResetToken, password);
-        if (error_result_1.isGraphQlErrorResult(result)) {
-            return result;
-        }
-        const customer = await this.findOneByUserId(ctx, result.id);
-        if (!customer) {
-            throw new errors_1.InternalServerError('error.cannot-locate-customer-for-user');
-        }
-        await this.historyService.createHistoryEntryForCustomer({
-            customerId: customer.id,
-            ctx,
-            type: generated_types_1.HistoryEntryType.CUSTOMER_PASSWORD_RESET_VERIFIED,
-            data: {},
-        });
-        this.eventBus.publish(new password_reset_verified_event_1.PasswordResetVerifiedEvent(ctx, result));
-        return result;
-    }
-    async requestUpdateEmailAddress(ctx, userId, newEmailAddress) {
-        const userWithConflictingIdentifier = await this.userService.getUserByEmailAddress(ctx, newEmailAddress);
-        if (userWithConflictingIdentifier) {
-            return new generated_graphql_shop_errors_1.EmailAddressConflictError();
-        }
-        const user = await this.userService.getUserById(ctx, userId);
-        if (!user) {
-            return false;
-        }
-        const customer = await this.findOneByUserId(ctx, user.id);
-        if (!customer) {
-            return false;
-        }
-        const oldEmailAddress = customer.emailAddress;
-        await this.historyService.createHistoryEntryForCustomer({
-            customerId: customer.id,
-            ctx,
-            type: generated_types_1.HistoryEntryType.CUSTOMER_EMAIL_UPDATE_REQUESTED,
-            data: {
-                oldEmailAddress,
-                newEmailAddress,
-            },
-        });
-        if (this.configService.authOptions.requireVerification) {
-            user.getNativeAuthenticationMethod().pendingIdentifier = newEmailAddress;
-            await this.userService.setIdentifierChangeToken(ctx, user);
-            this.eventBus.publish(new identifier_change_request_event_1.IdentifierChangeRequestEvent(ctx, user));
-            return true;
-        }
-        else {
-            const oldIdentifier = user.identifier;
-            user.identifier = newEmailAddress;
-            customer.emailAddress = newEmailAddress;
-            await this.connection.getRepository(ctx, user_entity_1.User).save(user, { reload: false });
-            await this.connection.getRepository(ctx, customer_entity_1.Customer).save(customer, { reload: false });
-            this.eventBus.publish(new identifier_change_event_1.IdentifierChangeEvent(ctx, user, oldIdentifier));
-            await this.historyService.createHistoryEntryForCustomer({
-                customerId: customer.id,
-                ctx,
-                type: generated_types_1.HistoryEntryType.CUSTOMER_EMAIL_UPDATE_VERIFIED,
-                data: {
-                    oldEmailAddress,
-                    newEmailAddress,
-                },
-            });
-            return true;
-        }
-    }
-    async updateEmailAddress(ctx, token) {
-        const result = await this.userService.changeIdentifierByToken(ctx, token);
-        if (error_result_1.isGraphQlErrorResult(result)) {
-            return result;
-        }
-        const { user, oldIdentifier } = result;
-        if (!user) {
-            return false;
-        }
-        const customer = await this.findOneByUserId(ctx, user.id);
-        if (!customer) {
-            return false;
-        }
-        this.eventBus.publish(new identifier_change_event_1.IdentifierChangeEvent(ctx, user, oldIdentifier));
-        customer.emailAddress = user.identifier;
-        await this.connection.getRepository(ctx, customer_entity_1.Customer).save(customer, { reload: false });
-        await this.historyService.createHistoryEntryForCustomer({
-            customerId: customer.id,
-            ctx,
-            type: generated_types_1.HistoryEntryType.CUSTOMER_EMAIL_UPDATE_VERIFIED,
-            data: {
-                oldEmailAddress: oldIdentifier,
-                newEmailAddress: customer.emailAddress,
-            },
-        });
-        return true;
-    }
-    async createOrUpdate(ctx, input, errorOnExistingUser = false) {
-        input.emailAddress = utils_1.normalizeEmailAddress(input.emailAddress);
-        let customer;
-        const existing = await this.connection.getRepository(ctx, customer_entity_1.Customer).findOne({
-            relations: ['channels'],
-            where: {
-                emailAddress: input.emailAddress,
-                deletedAt: null,
-            },
-        });
-        if (existing) {
-            if (existing.user && errorOnExistingUser) {
-                return new generated_graphql_shop_errors_1.EmailAddressConflictError();
-            }
-            customer = patch_entity_1.patchEntity(existing, input);
-            customer.channels.push(await this.connection.getEntityOrThrow(ctx, channel_entity_1.Channel, ctx.channelId));
-        }
-        else {
-            customer = await this.connection.getRepository(ctx, customer_entity_1.Customer).save(new customer_entity_1.Customer(input));
-            await this.channelService.assignToCurrentChannel(customer, ctx);
-            this.eventBus.publish(new customer_event_1.CustomerEvent(ctx, customer, 'created', input));
-        }
-        return this.connection.getRepository(ctx, customer_entity_1.Customer).save(customer);
-    }
-    async createAddress(ctx, customerId, input) {
-        const customer = await this.connection.getEntityOrThrow(ctx, customer_entity_1.Customer, customerId, {
-            where: { deletedAt: null },
-            relations: ['addresses'],
-            channelId: ctx.channelId,
-        });
-        const country = await this.countryService.findOneByCode(ctx, input.countryCode);
-        const address = new address_entity_1.Address(Object.assign(Object.assign({}, input), { country }));
-        const createdAddress = await this.connection.getRepository(ctx, address_entity_1.Address).save(address);
-        await this.customFieldRelationService.updateRelations(ctx, address_entity_1.Address, input, createdAddress);
-        customer.addresses.push(createdAddress);
-        await this.connection.getRepository(ctx, customer_entity_1.Customer).save(customer, { reload: false });
-        await this.enforceSingleDefaultAddress(ctx, createdAddress.id, input);
-        await this.historyService.createHistoryEntryForCustomer({
-            customerId: customer.id,
-            ctx,
-            type: generated_types_1.HistoryEntryType.CUSTOMER_ADDRESS_CREATED,
-            data: { address: address_to_line_1.addressToLine(createdAddress) },
-        });
-        createdAddress.customer = customer;
-        this.eventBus.publish(new customer_address_event_1.CustomerAddressEvent(ctx, createdAddress, 'created', input));
-        return createdAddress;
-    }
-    async updateAddress(ctx, input) {
-        const address = await this.connection.getEntityOrThrow(ctx, address_entity_1.Address, input.id, {
-            relations: ['customer', 'country'],
-        });
-        const customer = await this.connection.findOneInChannel(ctx, customer_entity_1.Customer, address.customer.id, ctx.channelId);
-        if (!customer) {
-            throw new errors_1.EntityNotFoundError('Address', input.id);
-        }
-        if (input.countryCode && input.countryCode !== address.country.code) {
-            address.country = await this.countryService.findOneByCode(ctx, input.countryCode);
-        }
-        else {
-            address.country = translate_entity_1.translateDeep(address.country, ctx.languageCode);
-        }
-        let updatedAddress = patch_entity_1.patchEntity(address, input);
-        updatedAddress = await this.connection.getRepository(ctx, address_entity_1.Address).save(updatedAddress);
-        await this.customFieldRelationService.updateRelations(ctx, address_entity_1.Address, input, updatedAddress);
-        await this.enforceSingleDefaultAddress(ctx, input.id, input);
-        await this.historyService.createHistoryEntryForCustomer({
-            customerId: address.customer.id,
-            ctx,
-            type: generated_types_1.HistoryEntryType.CUSTOMER_ADDRESS_UPDATED,
-            data: {
-                address: address_to_line_1.addressToLine(updatedAddress),
-                input,
-            },
-        });
-        updatedAddress.customer = customer;
-        this.eventBus.publish(new customer_address_event_1.CustomerAddressEvent(ctx, updatedAddress, 'updated', input));
-        return updatedAddress;
-    }
-    async deleteAddress(ctx, id) {
-        const address = await this.connection.getEntityOrThrow(ctx, address_entity_1.Address, id, {
-            relations: ['customer', 'country'],
-        });
-        const customer = await this.connection.findOneInChannel(ctx, customer_entity_1.Customer, address.customer.id, ctx.channelId);
-        if (!customer) {
-            throw new errors_1.EntityNotFoundError('Address', id);
-        }
-        address.country = translate_entity_1.translateDeep(address.country, ctx.languageCode);
-        await this.reassignDefaultsForDeletedAddress(ctx, address);
-        await this.historyService.createHistoryEntryForCustomer({
-            customerId: address.customer.id,
-            ctx,
-            type: generated_types_1.HistoryEntryType.CUSTOMER_ADDRESS_DELETED,
-            data: {
-                address: address_to_line_1.addressToLine(address),
-            },
-        });
-        await this.connection.getRepository(ctx, address_entity_1.Address).remove(address);
-        address.customer = customer;
-        this.eventBus.publish(new customer_address_event_1.CustomerAddressEvent(ctx, address, 'deleted', id));
-        return true;
-    }
-    async softDelete(ctx, customerId) {
-        const customer = await this.connection.getEntityOrThrow(ctx, customer_entity_1.Customer, customerId, {
-            channelId: ctx.channelId,
-        });
-        await this.connection
-            .getRepository(ctx, customer_entity_1.Customer)
-            .update({ id: customerId }, { deletedAt: new Date() });
-        await this.userService.softDelete(ctx, customer.user.id);
-        this.eventBus.publish(new customer_event_1.CustomerEvent(ctx, customer, 'deleted', customerId));
-        return {
-            result: generated_types_1.DeletionResult.DELETED,
-        };
-    }
-    async addNoteToCustomer(ctx, input) {
-        const customer = await this.connection.getEntityOrThrow(ctx, customer_entity_1.Customer, input.id, {
-            channelId: ctx.channelId,
-        });
-        await this.historyService.createHistoryEntryForCustomer({
-            ctx,
-            customerId: customer.id,
-            type: generated_types_1.HistoryEntryType.CUSTOMER_NOTE,
-            data: {
-                note: input.note,
-            },
-        }, input.isPublic);
-        return customer;
-    }
-    async updateCustomerNote(ctx, input) {
-        return this.historyService.updateCustomerHistoryEntry(ctx, {
-            type: generated_types_1.HistoryEntryType.CUSTOMER_NOTE,
-            data: input.note ? { note: input.note } : undefined,
-            ctx,
-            entryId: input.noteId,
-        });
-    }
-    async deleteCustomerNote(ctx, id) {
-        try {
-            await this.historyService.deleteCustomerHistoryEntry(ctx, id);
-            return {
-                result: generated_types_1.DeletionResult.DELETED,
-            };
-        }
-        catch (e) {
-            return {
-                result: generated_types_1.DeletionResult.NOT_DELETED,
-                message: e.message,
-            };
-        }
-    }
-    async enforceSingleDefaultAddress(ctx, addressId, input) {
-        const result = await this.connection
-            .getRepository(ctx, address_entity_1.Address)
-            .findOne(addressId, { relations: ['customer', 'customer.addresses'] });
-        if (result) {
-            const customerAddressIds = result.customer.addresses
-                .map(a => a.id)
-                .filter(id => !utils_1.idsAreEqual(id, addressId));
-            if (customerAddressIds.length) {
-                if (input.defaultBillingAddress === true) {
-                    await this.connection.getRepository(ctx, address_entity_1.Address).update(customerAddressIds, {
-                        defaultBillingAddress: false,
-                    });
-                }
-                if (input.defaultShippingAddress === true) {
-                    await this.connection.getRepository(ctx, address_entity_1.Address).update(customerAddressIds, {
-                        defaultShippingAddress: false,
-                    });
-                }
-            }
-        }
-    }
-    async reassignDefaultsForDeletedAddress(ctx, addressToDelete) {
-        if (!addressToDelete.defaultBillingAddress && !addressToDelete.defaultShippingAddress) {
-            return;
-        }
-        const result = await this.connection
-            .getRepository(ctx, address_entity_1.Address)
-            .findOne(addressToDelete.id, { relations: ['customer', 'customer.addresses'] });
-        if (result) {
-            const customerAddresses = result.customer.addresses;
-            if (1 < customerAddresses.length) {
-                const otherAddresses = customerAddresses
-                    .filter(address => !utils_1.idsAreEqual(address.id, addressToDelete.id))
-                    .sort((a, b) => (a.id < b.id ? -1 : 1));
-                if (addressToDelete.defaultShippingAddress) {
-                    otherAddresses[0].defaultShippingAddress = true;
-                }
-                if (addressToDelete.defaultBillingAddress) {
-                    otherAddresses[0].defaultBillingAddress = true;
-                }
-                await this.connection.getRepository(ctx, address_entity_1.Address).save(otherAddresses[0], { reload: false });
-            }
-        }
-    }
-};
-CustomerService = __decorate([
-    common_1.Injectable(),
-    __metadata("design:paramtypes", [transactional_connection_1.TransactionalConnection,
-        config_service_1.ConfigService,
-        user_service_1.UserService,
-        country_service_1.CountryService,
-        list_query_builder_1.ListQueryBuilder,
-        event_bus_1.EventBus,
-        history_service_1.HistoryService,
-        channel_service_1.ChannelService,
-        custom_field_relation_service_1.CustomFieldRelationService])
-], CustomerService);
-exports.CustomerService = CustomerService;
-//# sourceMappingURL=customer.service.js.map