[feature] saving circle group create

packages/api/src/controllers/v2/savingCircle.ts

@@ -0,0 +1,28 @@
+import { Response } from 'express';
+import { services } from '@impactmarket/core';
+
+import { RequestWithUser } from '../../middlewares/core';
+import { standardResponse } from '../../utils/api';
+
+class SavingCircleController {
+    savingCircleService = new services.SavingCircleService();
+
+    create = async (req: RequestWithUser, res: Response) => {
+        if (req.user === undefined) {
+            standardResponse(res, 401, false, '', {
+                error: {
+                    name: 'USER_NOT_FOUND',
+                    message: 'User not identified!'
+                }
+            });
+            return;
+        }
+        const { name, country, amount, frequency, firstDepositOn, members } = req.body;
+        this.savingCircleService
+            .create(req.user, { name, country, amount, frequency, firstDepositOn, members })
+            .then(r => standardResponse(res, 200, true, r))
+            .catch(e => standardResponse(res, 400, false, '', { error: e }));
+    };
+}
+
+export default SavingCircleController;

packages/api/src/routes/v2/index.ts

@@ -11,6 +11,7 @@ import learnAndEarn from './learnAndEarn';
 import microcredit from './microcredit';
 import protocol from './protocol';
 import referrals from './referrals';
+import savingCircle from './savingCircle';
 import story from './story';
 import user from './user';
 
@@ -29,6 +30,7 @@ export default (): Router => {
     referrals(app);
     cico(app);
     lazyAgenda(app);
+    savingCircle(app);
 
     return app;
 };

packages/api/src/routes/v2/savingCircle.ts

@@ -0,0 +1,54 @@
+import { Router } from 'express';
+
+import { authenticateToken } from '../../middlewares';
+import SavingCircleController from '../../controllers/v2/savingCircle';
+import SavingCircleValidator from '../../validators/savingCircle';
+
+export default (app: Router): void => {
+    const savingCircleController = new SavingCircleController();
+    const savingCircleValidator = new SavingCircleValidator();
+    const route = Router();
+    app.use('/saving-circles', route);
+
+    /**
+     * @swagger
+     *
+     * /saving-circles:
+     *   post:
+     *     tags:
+     *       - "saving-circles"
+     *     summary: Create saving circle
+     *     requestBody:
+     *       content:
+     *         application/json:
+     *           schema:
+     *             type: object
+     *             properties:
+     *               name:
+     *                 type: string
+     *                 description: Group name
+     *               members:
+     *                 description: Member addresses
+     *                 type: array
+     *                 items:
+     *                   type: string
+     *               country:
+     *                 type: string
+     *                 description: Group country (2 digits)
+     *               amount:
+     *                 type: number
+     *                 description: Saving amount
+     *               frequency:
+     *                 type: number
+     *                 description: Saving frequency (seconds)
+     *               firstDepositOn:
+     *                 type: number
+     *                 description: First deposit on (timestamp)
+     *     responses:
+     *       "200":
+     *         description: "Success"
+     *     security:
+     *     - BearerToken: []
+     */
+    route.post('/', authenticateToken, savingCircleValidator.create, savingCircleController.create);
+};

packages/api/src/validators/savingCircle.ts

@@ -0,0 +1,18 @@
+import { Joi, celebrate } from 'celebrate';
+
+import { defaultSchema } from './defaultSchema';
+
+class SavingCirclelidator {
+    create = celebrate({
+        body: defaultSchema.object({
+            name: Joi.string().required(),
+            country: Joi.string().length(2).required(),
+            amount: Joi.number().required(),
+            frequency: Joi.number().required(),
+            firstDepositOn: Joi.number().required(),
+            members: Joi.array().items(Joi.string()).min(2).required()
+        })
+    });
+}
+
+export default SavingCirclelidator;

packages/core/src/database/db.ts

@@ -40,6 +40,8 @@ import { MicroCreditBorrowersModel } from './models/microCredit/borrowers';
 import { MicroCreditDocsModel } from './models/microCredit/docs';
 import { MicroCreditLoanManagerModel } from './models/microCredit/loanManagers';
 import { MicroCreditNoteModel } from './models/microCredit/note';
+import { SavingCircleMemberModel } from './models/savingCircle/savingCircleMember';
+import { SavingCircleModel } from './models/savingCircle/savingCircle';
 import { StoryCommentModel } from './models/story/storyComment';
 import { StoryCommunityModel } from './models/story/storyCommunity';
 import { StoryContentModel } from './models/story/storyContent';
@@ -133,6 +135,9 @@ export type DbModels = {
     microCreditLoanManager: ModelStatic<MicroCreditLoanManagerModel>;
     //
     exchangeRegistry: ModelStatic<ExchangeRegistryModel>;
+    //
+    savingCircle: ModelStatic<SavingCircleModel>;
+    savingCircleMember: ModelStatic<SavingCircleMemberModel>;
 };
 export interface DbLoader {
     sequelize: Sequelize;

packages/core/src/database/migrations/z20231030203320-create-saving-circle.js

@@ -0,0 +1,58 @@
+'use strict';
+module.exports = {
+    up: (queryInterface, Sequelize) => {
+        return queryInterface.createTable('saving_circle', {
+            id: {
+              type: Sequelize.INTEGER,
+              allowNull: false,
+              autoIncrement: true,
+              primaryKey: true
+            },
+            name: {
+              type: Sequelize.STRING(64),
+              allowNull: false,
+            },
+            country: {
+              type: Sequelize.STRING(2),
+              allowNull: false
+            },
+            amount: {
+              type: Sequelize.FLOAT,
+              allowNull: false,
+            },
+            frequency: {
+              type: Sequelize.INTEGER,
+              allowNull: false,
+            },
+            firstDepositOn: {
+              type: Sequelize.DATEONLY,
+              allowNull: false,
+            },
+            requestedBy: {
+              type: Sequelize.INTEGER,
+              unique: true,
+              references: {
+                model: 'app_user',
+                key: 'id',
+              },
+              allowNull: false,
+            },
+            status: {
+              type: Sequelize.INTEGER,
+              allowNull: false,
+              defaultValue: 0,
+            },
+            createdAt: {
+              type: Sequelize.DATE,
+              allowNull: false
+            },
+            updatedAt: {
+              type: Sequelize.DATE,
+              allowNull: false
+            },
+        });
+    },
+    down: (queryInterface, Sequelize) => {
+        return queryInterface.dropTable('saving_circle');
+    },
+};

packages/core/src/database/migrations/z20231030212330-create-saving-circle-member.js

@@ -0,0 +1,51 @@
+'use strict';
+module.exports = {
+    up: (queryInterface, Sequelize) => {
+        return queryInterface.createTable('saving_circle_member', {
+            id: {
+              type: Sequelize.INTEGER,
+              allowNull: false,
+              autoIncrement: true,
+              primaryKey: true
+            },
+            userId: {
+              type: Sequelize.INTEGER,
+              references: {
+                model: 'app_user',
+                key: 'id',
+              },
+              onDelete: 'CASCADE',
+              allowNull: false,
+            },
+            groupId: {
+              type: Sequelize.INTEGER,
+              references: {
+                  model: 'saving_circle',
+                  key: 'id',
+              },
+              onDelete: 'CASCADE',
+              allowNull: false,
+            },
+            accept: {
+              type: Sequelize.BOOLEAN,
+              allowNull: false,
+              defaultValue: false,
+            },
+            decisionOn: {
+              type: Sequelize.DATE,
+              allowNull: true,
+            },
+            createdAt: {
+              type: Sequelize.DATE,
+              allowNull: false
+            },
+            updatedAt: {
+              type: Sequelize.DATE,
+              allowNull: false
+            },
+        });
+    },
+    down: (queryInterface, Sequelize) => {
+        return queryInterface.dropTable('saving_circle_member');
+    },
+};

packages/core/src/database/models/index.ts

@@ -40,6 +40,8 @@ import { initializeMicroCreditBorrowersHuma } from './microCredit/borrowersHuma'
 import { initializeMicroCreditDocs } from './microCredit/docs';
 import { initializeMicroCreditLoanManager } from './microCredit/loanManagers';
 import { initializeMicroCreditNote } from './microCredit/note';
+import { initializeSavingCircle } from './savingCircle/savingCircle';
+import { initializeSavingCircleMember } from './savingCircle/savingCircleMember';
 import { initializeStoryComment } from './story/storyComment';
 import { initializeStoryCommunity } from './story/storyCommunity';
 import { initializeStoryContent } from './story/storyContent';
@@ -149,6 +151,10 @@ export default function initModels(sequelize: Sequelize): void {
     // Exchange
     initializeExchangeRegistry(sequelize);
 
+    // Saving Circle
+    initializeSavingCircle(sequelize);
+    initializeSavingCircleMember(sequelize);
+
     // associations
     userAssociation(sequelize);
     communityAssociation(sequelize);

packages/core/src/database/models/savingCircle/savingCircle.ts

@@ -0,0 +1,80 @@
+import { DataTypes, Model, Sequelize } from 'sequelize';
+import { DbModels } from '../../../database/db';
+
+import { SavingCircle, SavingCircleCreation } from '../../../interfaces/savingCircle/savingCircle';
+
+export class SavingCircleModel extends Model<SavingCircle, SavingCircleCreation> {
+    public id!: number;
+    public name!: string;
+    public country!: string;
+    public amount!: number;
+    public frequency!: number;
+    public firstDepositOn!: Date;
+    public requestedBy!: number;
+    public status!: number;
+
+    // timestamps!
+    public readonly createdAt!: Date;
+    public readonly updatedAt!: Date;
+}
+
+export function initializeSavingCircle(sequelize: Sequelize): typeof SavingCircleModel {
+    const { appUser } = sequelize.models as DbModels;
+    SavingCircleModel.init(
+        {
+            id: {
+                type: DataTypes.INTEGER,
+                autoIncrement: true,
+                primaryKey: true
+            },
+            name: {
+                type: DataTypes.STRING(64),
+                allowNull: false
+            },
+            country: {
+                type: DataTypes.STRING(2),
+                allowNull: false
+            },
+            amount: {
+                type: DataTypes.FLOAT,
+                allowNull: false
+            },
+            frequency: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            firstDepositOn: {
+                type: DataTypes.DATEONLY,
+                allowNull: false
+            },
+            requestedBy: {
+                type: DataTypes.INTEGER,
+                unique: true,
+                references: {
+                    model: appUser,
+                    key: 'id'
+                },
+                allowNull: false
+            },
+            status: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0
+            },
+            createdAt: {
+                type: DataTypes.DATE,
+                allowNull: false
+            },
+            updatedAt: {
+                type: DataTypes.DATE,
+                allowNull: false
+            }
+        },
+        {
+            tableName: 'saving_circle',
+            modelName: 'savingCircle',
+            sequelize
+        }
+    );
+    return SavingCircleModel;
+}