@wepublish/api/src/lib/graphql/subscription/subscription.private-mutation.js

API core for we.publish.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.updateAdminSubscription = exports.handleRemoteManagedSubscription = exports.createSubscription = exports.cancelSubscriptionById = exports.deleteSubscriptionById = void 0;
const tslib_1 = require("tslib");
const permissions_1 = require("../permissions");
const api_1 = require("../../../../permissions-api/src");
const api_2 = require("../../../../user-api/src");
const error_1 = require("../../error");
const deleteSubscriptionById = (id, authenticate, subscription) => {
    const { roles } = authenticate();
    (0, permissions_1.authorise)(api_1.CanDeleteSubscription, roles);
    return subscription.delete({
        where: {
            id
        },
        include: {
            deactivation: true,
            periods: true,
            properties: true
        }
    });
};
exports.deleteSubscriptionById = deleteSubscriptionById;
const cancelSubscriptionById = (id, reason, authenticate, subscriptionDB, memberContext) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
    const { roles } = authenticate();
    (0, permissions_1.authorise)(api_1.CanCancelSubscription, roles);
    const subscription = yield subscriptionDB.findUnique({
        where: { id },
        include: {
            deactivation: true,
            periods: true,
            properties: true
        }
    });
    if (!subscription)
        throw new error_1.NotFound('subscription', id);
    if (subscription.deactivation)
        throw new error_1.UserSubscriptionAlreadyDeactivated(subscription.deactivation.date);
    return yield memberContext.deactivateSubscription({
        subscription,
        deactivationReason: reason
    });
});
exports.cancelSubscriptionById = cancelSubscriptionById;
const createSubscription = (_a, authenticate, memberContext, subscriptionClient) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
    var { properties } = _a, input = tslib_1.__rest(_a, ["properties"]);
    const { roles } = authenticate();
    (0, permissions_1.authorise)(api_1.CanCreateSubscription, roles);
    const { subscription } = yield memberContext.createSubscription(subscriptionClient, input['userID'], input['paymentMethodID'], input['paymentPeriodicity'], input['monthlyAmount'], input['memberPlanID'], properties, input['autoRenew'], input['startsAt']);
    return subscription;
});
exports.createSubscription = createSubscription;
const handleRemoteManagedSubscription = ({ paymentProvider, input, originalSubscription }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
    // not updatable subscription properties for externally managed subscriptions
    if ((input.paymentMethodID && input.paymentMethodID !== originalSubscription.paymentMethodID) ||
        (input.memberPlanID && input.memberPlanID !== originalSubscription.memberPlanID) ||
        (input.paidUntil && input.paidUntil !== originalSubscription.paidUntil) ||
        (input.paymentPeriodicity &&
            input.paymentPeriodicity !== originalSubscription.paymentPeriodicity) ||
        (input === null || input === void 0 ? void 0 : input.autoRenew) === false) {
        throw new Error(`It is not possible to update the subscription with payment provider "${paymentProvider.name}".`);
    }
    // update amount is possible
    if (input.monthlyAmount !== originalSubscription.monthlyAmount) {
        yield paymentProvider.updateRemoteSubscriptionAmount({
            subscription: originalSubscription,
            newAmount: parseInt(`${input.monthlyAmount}`, 10)
        });
    }
});
exports.handleRemoteManagedSubscription = handleRemoteManagedSubscription;
const updateAdminSubscription = (id, _b, authenticate, memberContext, subscriptionClient, userClient, paymentProviders) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
    var { properties } = _b, input = tslib_1.__rest(_b, ["properties"]);
    const { roles } = authenticate();
    (0, permissions_1.authorise)(api_1.CanCreateSubscription, roles);
    const originalSubscription = yield subscriptionClient.findUnique({
        where: {
            id
        },
        include: {
            properties: true,
            deactivation: true
        }
    });
    if (originalSubscription.deactivation) {
        throw new Error('You are not allowed to change a deactivated subscription!');
    }
    // handle remote managed subscriptions (Payrexx Subscription)
    const { paymentProviderID } = yield memberContext.getPaymentMethodByIDOrSlug(memberContext.loaders, undefined, originalSubscription.paymentMethodID);
    const paymentProvider = paymentProviders.find(paymentProvider => paymentProvider.id === paymentProviderID);
    if (paymentProvider.remoteManagedSubscription) {
        yield (0, exports.handleRemoteManagedSubscription)({
            paymentProvider,
            input: input,
            originalSubscription
        });
    }
    const user = yield userClient.findUnique({
        where: {
            id: input.userID
        },
        select: api_2.unselectPassword
    });
    if (!user)
        throw new Error('Can not update subscription without user');
    const updatedSubscription = yield subscriptionClient.update({
        where: { id },
        data: Object.assign(Object.assign({}, input), { properties: {
                deleteMany: {
                    subscriptionId: id
                },
                createMany: {
                    data: properties
                }
            } }),
        include: {
            deactivation: true,
            periods: true,
            properties: true
        }
    });
    if (!updatedSubscription)
        throw new error_1.NotFound('subscription', id);
    return yield memberContext.handleSubscriptionChange({
        subscription: updatedSubscription
    });
});
exports.updateAdminSubscription = updateAdminSubscription;
//# sourceMappingURL=subscription.private-mutation.js.map