@chevre/domain 22.9.0-alpha.2 → 22.9.0-alpha.21

package/example/src/chevre/findAvailableChannelMovieTicket.ts

@@ -0,0 +1,25 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const paymentServiceRepo = await chevre.repository.PaymentService.createInstance(mongoose.connection);
+
+    const result = await paymentServiceRepo.findAvailableChannelMovieTicket({
+        id: '5f9a52994f3709000abe6417',
+        project: {
+            id: project.id
+        }
+    });
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result, { depth: null });
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migrateMembers2identities.ts

@@ -0,0 +1,109 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+// const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+
+const AVAILABLE_ROLES = [
+    chevre.factory.iam.RoleName.Customer,
+    chevre.factory.iam.RoleName.EventsViewer,
+    chevre.factory.iam.RoleName.POS
+];
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const identityRepo = await chevre.repository.Identity.createInstance(mongoose.connection);
+    const memberRepo = await chevre.repository.Member.createInstance(mongoose.connection);
+    const projectRepo = await chevre.repository.Project.createInstance(mongoose.connection);
+
+    const cursor = memberRepo.getCursor(
+        {
+            // _id: { $eq: 'cinerino' }
+            'member.typeOf': { $eq: chevre.factory.creativeWorkType.WebApplication },
+            'project.id': { $ne: '*' }
+        },
+        {
+            _id: 1,
+            project: 1,
+            member: 1,
+            typeOf: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let updateCount = 0;
+    let projectIdsWithoutCustomProviders: string[] = [];
+    let projectIdsWithCustomProviders: string[] = [];
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const iamMember: Pick<chevre.factory.iam.IMember, 'project' | 'member' | 'typeOf'> = doc.toObject();
+        const roleNames = iamMember.member.hasRole.map(({ roleName }) => roleName)
+            .join(',');
+        const expectedRoles = iamMember.member.hasRole.length === 1 &&
+            iamMember.member.hasRole.every(({ roleName }) => AVAILABLE_ROLES.includes(roleName));
+        if (!expectedRoles) {
+            throw new Error('roles not expected');
+        }
+
+        const projectSettings = (await projectRepo.findById({
+            id: iamMember.project.id,
+            inclusion: ['settings']
+        })).settings;
+        const tokenIssuers: string[] = Array.isArray((<any>projectSettings).tokenIssuers) ? (<any>projectSettings).tokenIssuers : [];
+        if (tokenIssuers.length > 0) {
+            projectIdsWithCustomProviders.push(iamMember.project.id);
+        } else {
+            projectIdsWithoutCustomProviders.push(iamMember.project.id);
+        }
+
+        console.log(
+            'alreadyMigrated?',
+            iamMember.member.id, iamMember.member.typeOf, iamMember.project.id, roleNames, tokenIssuers.length, 'tokenIssuers', i);
+        let alreadyMigrated = false;
+        const existingIdentity = (await identityRepo.projectFields(
+            {
+                limit: 1,
+                page: 1,
+                project: { id: { $eq: iamMember.project.id } },
+                about: { id: { $eq: iamMember.member.id } }
+            },
+            ['about']
+        )).shift();
+        alreadyMigrated = existingIdentity?.about.id === iamMember.member.id
+            && existingIdentity.about.typeOf === iamMember.member.typeOf;
+
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.', iamMember.member.id, iamMember.member.typeOf, iamMember.project.id, i);
+        } else {
+            if (tokenIssuers.length === 1) {
+                console.log(
+                    'updating project...',
+                    iamMember.member.id, iamMember.member.typeOf, iamMember.project.id, i);
+                // await identityProviderRepo.save({
+                //     attributes: newProvider
+                // });
+                updateCount += 1;
+                console.log(
+                    'updated.',
+                    iamMember.member.id, iamMember.member.typeOf, iamMember.project.id, i);
+            }
+        }
+    });
+
+    projectIdsWithoutCustomProviders = [...new Set(projectIdsWithoutCustomProviders)];
+    projectIdsWithCustomProviders = [...new Set(projectIdsWithCustomProviders)];
+    console.log(projectIdsWithoutCustomProviders);
+    console.log(projectIdsWithCustomProviders);
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migratePaymentServiceChannelsCreditCard.ts

@@ -0,0 +1,104 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+// const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const paymentServiceRepo = await chevre.repository.PaymentService.createInstance(mongoose.connection);
+
+    const cursor = paymentServiceRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.service.paymentService.PaymentServiceType.CreditCard }
+            // _id: { $eq: 'cinerino' }
+        },
+        {
+            _id: 1,
+            availableChannel: 1,
+            productID: 1,
+            project: 1,
+            typeOf: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let updateCount = 0;
+    let serviceUrls: string[] = [];
+    const unexpectedProjectIds: string[] = [];
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const paymentService: Pick<
+            chevre.factory.service.paymentService.IService,
+            'availableChannel' | 'id' | 'productID' | 'project' | 'typeOf'
+        > = doc.toObject();
+
+        console.log(
+            'alreadyMigrated?', paymentService.project.id, i);
+        if (typeof paymentService.id !== 'string') {
+            throw new Error('id must be string');
+        }
+
+        let alreadyMigrated = false;
+        try {
+            const existingChannel = await paymentServiceRepo.findAvailableChannelCreditCard({
+                project: { id: paymentService.project.id },
+                id: paymentService.id
+            });
+            if (typeof existingChannel.credentials?.siteId === 'string'
+                && typeof existingChannel.credentials?.sitePass === 'string') {
+                alreadyMigrated = true;
+            }
+        } catch (error) {
+            // no op
+        }
+
+        const serviceUrl = paymentService.availableChannel?.serviceUrl;
+        if (typeof serviceUrl === 'string') {
+            serviceUrls.push(serviceUrl);
+        } else {
+            throw new Error('serviceUrl must be string');
+        }
+
+        // docs(same serviceUrl and different siteId,sitePass ) exist?
+        // const credentials =
+        //     <chevre.factory.serviceChannel.ICredentialsCreditCard | undefined>paymentService.availableChannel?.credentials;
+        // if (typeof credentials?.siteId !== 'string') {
+        //     throw new Error('siteId must be string');
+        // }
+        // if (typeof credentials?.sitePass !== 'string') {
+        //     throw new Error('sitePass must be string');
+        // }
+
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.', paymentService.project.id, i);
+        } else {
+            console.log(
+                'updating...',
+                paymentService.project.id, i);
+            // await paymentServiceRepo.saveChannelByServiceUrl(newChannel);
+            updateCount += 1;
+            console.log(
+                'updated.',
+                paymentService.project.id, i);
+        }
+    });
+
+    serviceUrls = [...new Set(serviceUrls)];
+    console.log('unexpectedProjectIds:', unexpectedProjectIds);
+    // console.log(serviceUrls);
+    console.log(serviceUrls);
+    console.log(serviceUrls.length, 'serviceUrls found');
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migratePaymentServiceChannelsMovieTicket.ts

@@ -0,0 +1,112 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+// const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const paymentServiceRepo = await chevre.repository.PaymentService.createInstance(mongoose.connection);
+
+    const cursor = paymentServiceRepo.getCursor(
+        {
+            typeOf: { $eq: chevre.factory.service.paymentService.PaymentServiceType.MovieTicket }
+            // _id: { $eq: 'cinerino' }
+        },
+        {
+            _id: 1,
+            availableChannel: 1,
+            productID: 1,
+            project: 1,
+            typeOf: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let updateCount = 0;
+    let serviceUrls: string[] = [];
+    const unexpectedProjectIds: string[] = [];
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const paymentService: Pick<
+            chevre.factory.service.paymentService.IService,
+            'availableChannel' | 'id' | 'productID' | 'project' | 'typeOf'
+        > = doc.toObject();
+
+        console.log(
+            'alreadyMigrated?', paymentService.project.id, i);
+        if (typeof paymentService.id !== 'string') {
+            throw new Error('id must be string');
+        }
+
+        let alreadyMigrated = false;
+        try {
+            const existingChannel = await paymentServiceRepo.findAvailableChannelMovieTicket({
+                project: { id: paymentService.project.id },
+                id: paymentService.id
+            });
+            if (typeof existingChannel.credentials?.authorizeServerDomain === 'string') {
+                alreadyMigrated = true;
+            }
+        } catch (error) {
+            // no op
+        }
+
+        const serviceUrl = paymentService.availableChannel?.serviceUrl;
+        if (typeof serviceUrl === 'string') {
+            serviceUrls.push(serviceUrl);
+        } else {
+            throw new Error('serviceUrl must be string');
+        }
+
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.', paymentService.project.id, i);
+        } else {
+            const credentials =
+                <chevre.factory.serviceChannel.ICredentialsMovieTicket | undefined>paymentService.availableChannel?.credentials;
+            if (typeof credentials?.authorizeServerDomain !== 'string') {
+                throw new Error('authorizeServerDomain must be string');
+            }
+            if (typeof credentials?.clientId !== 'string') {
+                throw new Error('clientId must be string');
+            }
+            if (typeof credentials?.clientSecret !== 'string') {
+                throw new Error('clientSecret must be string');
+            }
+            const newChannel: chevre.factory.serviceChannel.IServiceChannelMovieTicket = {
+                credentials,
+                project: { id: '*', typeOf: chevre.factory.organizationType.Project },
+                providesService: {
+                    typeOf: chevre.factory.service.paymentService.PaymentServiceType.MovieTicket
+                },
+                serviceUrl,
+                typeOf: 'ServiceChannel'
+            };
+            console.log(
+                'updating...',
+                paymentService.project.id, i, newChannel);
+            await paymentServiceRepo.saveChannelByServiceUrl(newChannel);
+            updateCount += 1;
+            console.log(
+                'updated.',
+                paymentService.project.id, i);
+        }
+    });
+
+    serviceUrls = [...new Set(serviceUrls)];
+    console.log('unexpectedProjectIds:', unexpectedProjectIds);
+    console.log(serviceUrls);
+    console.log(serviceUrls.length, 'serviceUrls found');
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migrateProjectTokenIssuers.ts

@@ -0,0 +1,100 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+// const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const identityProviderRepo = await chevre.repository.IdentityProvider.createInstance(mongoose.connection);
+    const projectRepo = await chevre.repository.Project.createInstance(mongoose.connection);
+
+    const cursor = projectRepo.getCursor(
+        {
+            // _id: { $eq: 'cinerino' }
+        },
+        {
+            _id: 1,
+            settings: 1,
+            typeOf: 1
+        }
+    );
+    console.log('docs found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const project: Pick<chevre.factory.project.IProject, 'id' | 'typeOf' | 'settings'> = doc.toObject();
+
+        console.log(
+            'alreadyMigrated?', project.id, i);
+        const tokenIssuers: string[] | undefined = (<any>project.settings).tokenIssuers;
+        let alreadyMigrated = false;
+        if (Array.isArray(tokenIssuers)) {
+            let existingProvidersCount = 0;
+            for (const tokenIssuer of tokenIssuers) {
+                const existingProviders = await identityProviderRepo.projectFields(
+                    {
+                        limit: 1,
+                        page: 1,
+                        project: { id: { $eq: project.id } },
+                        identifier: { $eq: tokenIssuer }
+                    },
+                    ['identifier']
+                );
+                existingProvidersCount += existingProviders.length;
+            }
+            if (existingProvidersCount === tokenIssuers.length) {
+                alreadyMigrated = true;
+            }
+        } else {
+            alreadyMigrated = true;
+        }
+
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.', project.id, i);
+        } else {
+            if (Array.isArray(tokenIssuers)) {
+                const newProviders = tokenIssuers.map((tokenIssuer) => {
+                    return {
+                        identifier: tokenIssuer,
+                        project: {
+                            id: project.id,
+                            typeOf: <chevre.factory.organizationType.Project>chevre.factory.organizationType.Project
+                        },
+                        typeOf: <chevre.factory.organizationType.Organization>chevre.factory.organizationType.Organization,
+                        verified: true
+                    };
+                });
+                console.log(
+                    'updating project...',
+                    project.id, i, newProviders.length, 'newProviders');
+                for (const newProvider of newProviders) {
+                    console.log(
+                        'updating project...',
+                        project.id, i, newProvider);
+                    // await identityProviderRepo.save({
+                    //     attributes: newProvider
+                    // });
+                }
+                updateCount += 1;
+                console.log(
+                    'updated.',
+                    project.id, i);
+            }
+        }
+    });
+
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/migrateWebSites.ts

@@ -0,0 +1,146 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+// const excludedProject = { id: String(process.env.EXCLUDED_PROJECT_ID) };
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const paymentServiceRepo = await chevre.repository.PaymentService.createInstance(mongoose.connection);
+    const potentialActionRepo = await chevre.repository.PotentialAction.createInstance(mongoose.connection);
+    const identityProviderRepo = await chevre.repository.IdentityProvider.createInstance(mongoose.connection);
+    const webSiteRepo = await chevre.repository.WebSite.createInstance(mongoose.connection);
+
+    let webSiteIdentifiers: string[] = [];
+
+    const cursor = paymentServiceRepo.getCursor(
+        {
+        },
+        {
+            _id: 1,
+            availableChannel: 1,
+            productID: 1,
+            project: 1,
+            typeOf: 1
+        }
+    );
+    console.log('docs found');
+
+    await cursor.eachAsync(async (doc) => {
+        const paymentService: Pick<
+            chevre.factory.service.paymentService.IService,
+            'availableChannel' | 'id' | 'productID' | 'project' | 'typeOf'
+        > = doc.toObject();
+
+        const serviceUrl = paymentService.availableChannel?.serviceUrl;
+        if (typeof serviceUrl === 'string') {
+            webSiteIdentifiers.push((new URL(serviceUrl).hostname));
+        } else {
+            throw new Error('serviceUrl must be string');
+        }
+    });
+
+    const cursor2 = potentialActionRepo.getCursor(
+        {
+        },
+        {
+            target: 1
+        }
+    );
+    console.log('docs found');
+
+    await cursor2.eachAsync(async (doc) => {
+        const potentialAction: Pick<
+            chevre.factory.potentialAction.IPotentialAction,
+            'target'
+        > = doc.toObject();
+
+        const urlTemplate = potentialAction.target.urlTemplate;
+        if (typeof urlTemplate === 'string') {
+            webSiteIdentifiers.push((new URL(urlTemplate).hostname));
+        } else {
+            throw new Error('urlTemplate must be string');
+        }
+    });
+
+    const cursor3 = identityProviderRepo.getCursor(
+        {
+        },
+        {
+            identifier: 1
+        }
+    );
+    console.log('docs found');
+
+    await cursor3.eachAsync(async (doc) => {
+        const identityProvider: Pick<
+            chevre.factory.identityProvider.IIdentityProvider,
+            'identifier'
+        > = doc.toObject();
+
+        if (typeof identityProvider.identifier === 'string') {
+            webSiteIdentifiers.push((new URL(identityProvider.identifier).hostname));
+        } else {
+            throw new Error('identityProvider.identifier must be string');
+        }
+    });
+
+    webSiteIdentifiers = [...new Set(webSiteIdentifiers)];
+    console.log(webSiteIdentifiers);
+    console.log(webSiteIdentifiers.length, 'webSiteIdentifiers found');
+
+    let i = 0;
+    let updateCount = 0;
+
+    for (const webSiteIdentifier of webSiteIdentifiers) {
+        i += 1;
+
+        const existingWebSites = await webSiteRepo.projectFields(
+            {
+                about: { identifier: { $eq: webSiteIdentifier } }
+            },
+            ['about']
+        );
+        const alreadyMigrated = existingWebSites.length === 1;
+        if (alreadyMigrated) {
+            console.log(
+                'already migrated.', webSiteIdentifier, i);
+        } else {
+            const creatingWebSite: Pick<
+                chevre.factory.creativeWork.certification.webSite.ICertification,
+                'about' | 'certificationStatus' | 'project' | 'auditDate'
+            > = {
+                project: { id: '*', typeOf: chevre.factory.organizationType.Project },
+                about: { identifier: webSiteIdentifier, typeOf: chevre.factory.creativeWorkType.WebSite },
+                certificationStatus: chevre.factory.CertificationStatusEnumeration.CertificationInactive
+            };
+            console.log(
+                'updating...', i, creatingWebSite);
+            const { id } = await webSiteRepo.save({
+                attributes: creatingWebSite
+            });
+            await webSiteRepo.save({
+                id,
+                attributes: {
+                    ...creatingWebSite,
+                    auditDate: new Date(),
+                    certificationStatus: chevre.factory.CertificationStatusEnumeration.CertificationActive
+                }
+            });
+            updateCount += 1;
+            console.log(
+                'updated.', i);
+        }
+    }
+
+    console.log(i, 'docs checked');
+    console.log(updateCount, 'docs updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/reIndex.ts

@@ -11,7 +11,8 @@ mongoose.Model.on('index', (...args) => {
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    await chevre.repository.Reservation.createInstance(mongoose.connection);
+    await chevre.repository.Identity.createInstance(mongoose.connection);
+    await chevre.repository.IdentityProvider.createInstance(mongoose.connection);
     console.log('success!');
 }
 

package/example/src/chevre/searchPaymentServices.ts

@@ -0,0 +1,32 @@
+// tslint:disable:no-implicit-dependencies no-console
+import * as  mongoose from 'mongoose';
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const paymentServiceRepo = await chevre.repository.PaymentService.createInstance(mongoose.connection);
+
+    const limit = 10;
+    const page = 1;
+    const docs = await paymentServiceRepo.projectFields(
+        {
+            limit,
+            page,
+            project: { id: { $eq: project.id } },
+            availableChannel: { serviceUrl: { $eq: 'xxx' } }
+        },
+        ['availableChannel', 'productID']
+    );
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(docs, { depth: null });
+    console.log(docs.length, 'docs found');
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/unsetUnnecessaryFields.ts

@@ -9,17 +9,16 @@ import { chevre } from '../../../lib/index';
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const accountRepo = await chevre.repository.Account.createInstance(mongoose.connection);
+    const identityProviderRepo = await chevre.repository.IdentityProvider.createInstance(mongoose.connection);
 
     let updateResult: any;
-    updateResult = await accountRepo.unsetUnnecessaryFields({
+
+    updateResult = await identityProviderRepo.unsetUnnecessaryFields({
         filter: {
             _id: { $exists: true }
         },
         $unset: {
-            createdAt: 1,
-            updatedAt: 1,
-            __v: 1
+            verified: 1
         }
     });
     console.log(updateResult);