shutro-erp 0.3.4 → 0.3.5

package/dist/contacts/module.js

@@ -4,9 +4,44 @@
  */
 import { baseShutro } from '../server/index.js';
 import { orm } from '../server/orm.js';
-import { check, defineModel, defineModule, f } from './.kosh/bindings.js';
+import { storageShutro } from '../storage/index.js';
+import { check, defineModel, defineModule, extendModel, f } from './.kosh/bindings.js';
 const EMAIL = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
 const ALL = ['read', 'write', 'create', 'unlink', 'export', 'import'];
+/** A tag on contacts (RFC 0022 step 2): shared by every company, kept by Contacts managers. */
+export const ResPartnerTag = defineModel('res.partner.tag', {
+    label: 'Contact tag',
+    recName: 'name',
+    order: ['name asc'],
+    access: {
+        'contacts.user': ['read'],
+        'contacts.manager': ['read', 'write', 'create', 'unlink'],
+    },
+    fields: {
+        name: f.char({ required: true }),
+    },
+    sqlConstraints: {
+        oneName: { unique: ['name'], message: 'A tag with this name exists.' },
+    },
+});
+/** The company's contact settings (RFC 0020): what a contact needs before it is saved. */
+export const CompanyContacts = extendModel('res.company', {
+    fields: {
+        contactTaxIdRequired: f.boolean({ default: false, label: 'Customers need a tax ID' }),
+        contactUniqueEmail: f.boolean({ default: false, label: 'One contact per email address' }),
+    },
+});
+/** The current company's contact settings. */
+async function contactSettings(env) {
+    const [company] = (await env
+        .model('res.company')
+        .browse([env.companyId])
+        .load(['contactTaxIdRequired', 'contactUniqueEmail'])).read(['contactTaxIdRequired', 'contactUniqueEmail']);
+    return {
+        taxIdRequired: company?.['contactTaxIdRequired'] === true,
+        uniqueEmail: company?.['contactUniqueEmail'] === true,
+    };
+}
 export const ResPartner = defineModel('res.partner', {
     label: 'Contact',
     archivable: true,
@@ -19,6 +54,12 @@ export const ResPartner = defineModel('res.partner', {
     tracking: ['name', 'email', 'phone', 'taxId'],
     fields: {
         name: f.char({ required: true }),
+        /** A photo or logo: an attachment of the contact (RFC 0022 §3.3), with its 256 px thumbnail. */
+        image: f.many2one('storage.attachment', { ondelete: 'set null', label: 'Photo' }),
+        tags: f.many2many('res.partner.tag', { label: 'Tags' }),
+        /** Where the contact is on a map (decimal degrees); filled by hand for now. */
+        latitude: f.decimal({ scale: 6, help: 'Decimal degrees, e.g. 23.8103 for Dhaka' }),
+        longitude: f.decimal({ scale: 6, help: 'Decimal degrees, e.g. 90.4125 for Dhaka' }),
         isCompany: f.boolean({ default: false, label: 'Is a company' }),
         /** The company a person works for. */
         parent: f.many2one('res.partner', { ondelete: 'set null', label: 'Company' }),
@@ -47,19 +88,55 @@ export const ResPartner = defineModel('res.partner', {
             ...check('res.partner', ['email'], (partners) => partners.filter((p) => p.email !== null && !EMAIL.test(p.email))),
             message: 'An email address must look like name@example.com.',
         },
+        // The company's settings (App settings › Contacts): a customer's tax ID, one contact per email.
+        taxIdOfCustomers: {
+            ...check('res.partner', ['isCustomer', 'taxId'], async (partners) => {
+                const { taxIdRequired } = await contactSettings(partners.env);
+                if (!taxIdRequired)
+                    return [];
+                return partners.filter((p) => p.isCustomer && (p.taxId === null || p.taxId.trim() === ''));
+            }),
+            message: 'Customers need a tax ID in this company (App settings › Contacts).',
+        },
+        oneContactPerEmail: {
+            ...check('res.partner', ['email'], async (partners) => {
+                const env = partners.env;
+                const { uniqueEmail } = await contactSettings(env);
+                if (!uniqueEmail)
+                    return [];
+                const refused = [];
+                for (const p of partners) {
+                    if (p.email === null || p.email === '')
+                        continue;
+                    const others = await env
+                        .model('res.partner')
+                        .search({ where: { email: p.email, id: { ne: p.id } } });
+                    if (others.length > 0)
+                        refused.push(p);
+                }
+                return refused;
+            }),
+            message: 'Another contact has this email address (App settings › Contacts: one contact per email).',
+        },
     },
 });
 export const contactsShutro = defineModule({
     name: 'contacts',
-    version: '0.2.0',
-    depends: [baseShutro],
+    version: '0.3.0',
+    depends: [baseShutro, storageShutro],
     groups: [
-        orm.defineGroup({ code: 'contacts.user', label: 'Contacts user', implies: ['base.user'] }),
+        orm.defineGroup({
+            code: 'contacts.user',
+            label: 'Contacts user',
+            // Photos are attachments (RFC 0022 §3.3).
+            implies: ['base.user', 'storage.user'],
+        }),
         orm.defineGroup({
             code: 'contacts.manager',
             label: 'Contacts manager',
             implies: ['contacts.user'],
         }),
     ],
-    models: [ResPartner],
+    models: [ResPartnerTag, ResPartner],
+    extensions: [CompanyContacts],
 });

package/dist/crm/.kosh/bindings.d.ts

@@ -0,0 +1,22 @@
+export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
+import { type DefinitionHelpers } from '../../server/orm.js';
+import type { DefaultLoaded, Env as CoreEnv, RecordSet as CoreRecordSet, Shutro as CoreShutro } from '../../server/orm.js';
+import type { SchemaView } from './schema.js';
+export type { SchemaView };
+/** Every model visible in this view. */
+export type ModelName = keyof SchemaView & string;
+/** `Env` typed to this view. */
+export type Env = CoreEnv<SchemaView>;
+/** `Shutro` typed to this view. */
+export type Shutro = CoreShutro<SchemaView>;
+/** A recordset of `M`, with the default loaded shape unless `L` is given. */
+export type Records<M extends ModelName, L = DefaultLoaded<SchemaView, M>> = CoreRecordSet<SchemaView, M, L>;
+export declare const compute: DefinitionHelpers<SchemaView>['compute'];
+export declare const check: DefinitionHelpers<SchemaView>['check'];
+export declare const onchange: DefinitionHelpers<SchemaView>['onchange'];
+export declare const records: DefinitionHelpers<SchemaView>['records'];
+export declare const method: DefinitionHelpers<SchemaView>['method'];
+/** Module data (RFC 0017): records, overrides of dependencies' records, and references, typed like creates. */
+export declare const record: DefinitionHelpers<SchemaView>['record'];
+export declare const override: DefinitionHelpers<SchemaView>['override'];
+export declare const ref: DefinitionHelpers<SchemaView>['ref'];

package/dist/crm/.kosh/bindings.js

@@ -0,0 +1,15 @@
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: c91d26ecf73fb9c1
+// Bindings of module `crm`: import the definition API from here to get types scoped to what it can see.
+export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
+import { definitions } from '../../server/orm.js';
+/** Definition callbacks typed against this module's view: no casts in computes, checks, onchange, methods. */
+const helpers = definitions();
+export const compute = helpers.compute;
+export const check = helpers.check;
+export const onchange = helpers.onchange;
+export const records = helpers.records;
+export const method = helpers.method;
+/** Module data (RFC 0017): records, overrides of dependencies' records, and references, typed like creates. */
+export const record = helpers.record;
+export const override = helpers.override;
+export const ref = helpers.ref;