@ozdao/martyrs 0.2.477 → 0.2.479

package/src/modules/governance/controllers/routes/votings.routes.js

@@ -1,14 +1,12 @@
-const votingFactory = require("../factories/votings.controller");
-
-module.exports = function(app, db, origins, publicPath) {
+import votingFactory from '../factories/votings.controller.js';
+export default (function (app, db, origins, publicPath) {
   const controller = votingFactory(db);
-
-  app.get("/api/votings", controller.getAllVotings);
-  app.get("/api/votings/:id", controller.getVotingById);
-  app.post("/api/votings", controller.createVoting);
-  app.put("/api/votings/:id", controller.updateVoting);
-  app.delete("/api/votings/:id", controller.deleteVoting);
-  app.post("/api/votings/:id/start", controller.startVoting);
-  app.post("/api/votings/:id/end", controller.endVoting);
-  app.get("/api/votings/:id/results", controller.getVotingResults);
-};
+  app.get('/api/votings', controller.getAllVotings);
+  app.get('/api/votings/:id', controller.getVotingById);
+  app.post('/api/votings', controller.createVoting);
+  app.put('/api/votings/:id', controller.updateVoting);
+  app.delete('/api/votings/:id', controller.deleteVoting);
+  app.post('/api/votings/:id/start', controller.startVoting);
+  app.post('/api/votings/:id/end', controller.endVoting);
+  app.get('/api/votings/:id/results', controller.getVotingResults);
+});

package/src/modules/governance/governance.client.js

@@ -1,10 +1,10 @@
 import * as storeInitiatives from './views/store/initiatives.js';
 import * as storeTasks from './views/store/tasks.js';
-import * as storeVotings from './views/store/votings.js';
 import * as storeVotes from './views/store/votes.js';
+import * as storeVotings from './views/store/votings.js';
 
 // Router
-import { createGovernanceRoutes } from './views/router/goverance.router';
+import { createGovernanceRoutes } from './views/router/goverance.router.js';
 
 // Example initialization function for the Governance module
 function initializeGovernance(app, store, router, options = {}) {
@@ -12,7 +12,7 @@ function initializeGovernance(app, store, router, options = {}) {
   const routesGovernance = createGovernanceRoutes('', options);
 
   router.addRoute(route, routesGovernance);
-  
+
   store.addStore('initiatives', storeInitiatives);
   store.addStore('tasks', storeTasks);
   store.addStore('votings', storeVotings);
@@ -29,7 +29,7 @@ const ModuleGovernance = {
       storeVotes,
     },
     router: {
-      createGovernanceRoutes
+      createGovernanceRoutes,
     },
     // components: {
     //   // Pages
@@ -56,7 +56,7 @@ const ModuleGovernance = {
     //   VotingResult,
     //   VoteDisplay,
     // }
-  }
-}
+  },
+};
 
-export default ModuleGovernance;
+export default ModuleGovernance;

package/src/modules/governance/governance.server.js

@@ -1,26 +1,21 @@
-
-const ModelInitiative = require('./models/initiative.model.js');
-const ModelTask = require('./models/task.model.js');
-const ModelVoting = require('./models/voting.model.js');
-const ModelVote = require('./models/vote.model.js');
-
-const RoutesInitiative = require('./controllers/routes/initiatives.routes.js');
-const RoutesTask = require('./controllers/routes/tasks.routes.js');
-const RoutesVoting = require('./controllers/routes/votings.routes.js');
-const RoutesVote = require('./controllers/routes/votes.routes.js');
-
-const FactoryInitiative = require('./controllers/factories/initiatives.controller.js');
-const FactoryTask = require('./controllers/factories/tasks.controller.js');
-const FactoryVoting = require('./controllers/factories/votings.controller.js');
-const FactoryVote = require('./controllers/factories/votes.controller.js');
-
+import FactoryInitiative from './controllers/factories/initiatives.controller.js';
+import FactoryTask from './controllers/factories/tasks.controller.js';
+import FactoryVote from './controllers/factories/votes.controller.js';
+import FactoryVoting from './controllers/factories/votings.controller.js';
+import RoutesInitiative from './controllers/routes/initiatives.routes.js';
+import RoutesTask from './controllers/routes/tasks.routes.js';
+import RoutesVote from './controllers/routes/votes.routes.js';
+import RoutesVoting from './controllers/routes/votings.routes.js';
+import ModelInitiative from './models/initiative.model.js';
+import ModelTask from './models/task.model.js';
+import ModelVote from './models/vote.model.js';
+import ModelVoting from './models/voting.model.js';
 function initializeGovernance(app, db, origins, publicPath) {
   // Setup models in the database object
   db.initiative = ModelInitiative(db);
   db.task = ModelTask(db);
   db.voting = ModelVoting(db);
   db.vote = ModelVote(db);
-
   // Setup routes if the app object is provided
   if (app) {
     RoutesInitiative(app, db, origins, publicPath);
@@ -29,26 +24,28 @@ function initializeGovernance(app, db, origins, publicPath) {
     RoutesVote(app, db, origins, publicPath);
   }
 }
-
-// Exporting controllers, routes, and models
-module.exports = {
+export const models = {
+  ModelInitiative,
+  ModelTask,
+  ModelVoting,
+  ModelVote,
+};
+export const routes = {
+  RoutesInitiative,
+  RoutesTask,
+  RoutesVoting,
+  RoutesVote,
+};
+export const controllers = {
+  FactoryInitiative,
+  FactoryTask,
+  FactoryVoting,
+  FactoryVote,
+};
+export { initializeGovernance as initialize };
+export default {
   initialize: initializeGovernance,
-  models: {
-    ModelInitiative,
-    ModelTask,
-    ModelVoting,
-    ModelVote
-  },
-  routes: {
-    RoutesInitiative,
-    RoutesTask,
-    RoutesVoting,
-    RoutesVote
-  },
-  controllers: {
-    FactoryInitiative,
-    FactoryTask,
-    FactoryVoting,
-    FactoryVote
-  }
-};
+  models,
+  routes,
+  controllers,
+};

package/src/modules/governance/models/initiative.model.js

@@ -1,25 +1,29 @@
-module.exports = (db) => {
-  const InitiativeSchema = new db.mongoose.Schema({
-    title: { type: String, required: true },
-    description: { type: String, required: true },
-    status: { 
-      type: String, 
-      enum: ['draft', 'active', 'completed', 'cancelled'],
-      default: 'draft'
+export default db => {
+  const InitiativeSchema = new db.mongoose.Schema(
+    {
+      title: { type: String, required: true },
+      description: { type: String, required: true },
+      status: {
+        type: String,
+        enum: ['draft', 'active', 'completed', 'cancelled'],
+        default: 'draft',
+      },
+      createdBy: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+      },
+      tasks: [
+        {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: 'Task',
+        },
+      ],
     },
-    createdBy: { 
-      type: db.mongoose.Schema.Types.ObjectId, 
-      ref: 'User', 
-      required: true 
-    },
-    tasks: [{
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: 'Task'
-    }]
-  }, {
-    timestamps: { currentTime: () => Date.now() }
-  });
-
+    {
+      timestamps: { currentTime: () => Date.now() },
+    }
+  );
   const Initiative = db.mongoose.model('Initiative', InitiativeSchema);
   return Initiative;
-};
+};

package/src/modules/governance/models/milestone.model.js

@@ -1,98 +1,102 @@
-module.exports = (db) => {
-  const MilestoneSchema = new db.mongoose.Schema({
-    name: { 
-      type: String, 
-      required: true 
-    },
-    description: { 
-      type: String 
-    },
-    status: { 
-      type: String,
-      enum: ['not_started', 'in_progress', 'completed', 'blocked', 'cancelled'],
-      default: 'not_started'
-    },
-    startDate: { 
-      type: Date,
-      required: true 
-    },
-    dueDate: { 
-      type: Date,
-      required: true 
-    },
-    completedDate: { 
-      type: Date 
-    },
-    progress: {
-      type: Number,
-      min: 0,
-      max: 100,
-      default: 0
-    },
-    owner: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: 'User',
-      required: true
-    },
-    contributors: [{
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: 'User'
-    }],
-    initiative: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: 'Initiative',
-      required: true
-    },
-    priority: {
-      type: String,
-      enum: ['low', 'medium', 'high', 'urgent'],
-      default: 'medium'
-    },
-    tags: [{
-      type: String
-    }],
-    dependencies: [{
-      milestone: {
+export default db => {
+  const MilestoneSchema = new db.mongoose.Schema(
+    {
+      name: {
+        type: String,
+        required: true,
+      },
+      description: {
+        type: String,
+      },
+      status: {
+        type: String,
+        enum: ['not_started', 'in_progress', 'completed', 'blocked', 'cancelled'],
+        default: 'not_started',
+      },
+      startDate: {
+        type: Date,
+        required: true,
+      },
+      dueDate: {
+        type: Date,
+        required: true,
+      },
+      completedDate: {
+        type: Date,
+      },
+      progress: {
+        type: Number,
+        min: 0,
+        max: 100,
+        default: 0,
+      },
+      owner: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+      },
+      contributors: [
+        {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: 'User',
+        },
+      ],
+      initiative: {
         type: db.mongoose.Schema.Types.ObjectId,
-        ref: 'Milestone'
+        ref: 'Initiative',
+        required: true,
       },
-      type: {
+      priority: {
         type: String,
-        enum: ['blocks', 'blocked_by', 'related_to'],
-        required: true
-      }
-    }],
-    metadata: {
-      estimatedHours: Number,
-      actualHours: Number,
-      budget: Number,
-      actualCost: Number,
-      notes: String
-    }
-  }, {
-    timestamps: { 
-      currentTime: () => Date.now() 
+        enum: ['low', 'medium', 'high', 'urgent'],
+        default: 'medium',
+      },
+      tags: [
+        {
+          type: String,
+        },
+      ],
+      dependencies: [
+        {
+          milestone: {
+            type: db.mongoose.Schema.Types.ObjectId,
+            ref: 'Milestone',
+          },
+          type: {
+            type: String,
+            enum: ['blocks', 'blocked_by', 'related_to'],
+            required: true,
+          },
+        },
+      ],
+      metadata: {
+        estimatedHours: Number,
+        actualHours: Number,
+        budget: Number,
+        actualCost: Number,
+        notes: String,
+      },
     },
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true }
-  });
-
+    {
+      timestamps: {
+        currentTime: () => Date.now(),
+      },
+      toJSON: { virtuals: true },
+      toObject: { virtuals: true },
+    }
+  );
   // Virtuals
-  MilestoneSchema.virtual('isOverdue').get(function() {
+  MilestoneSchema.virtual('isOverdue').get(function () {
     return this.dueDate && this.dueDate < new Date() && this.status !== 'completed';
   });
-
-  MilestoneSchema.virtual('duration').get(function() {
+  MilestoneSchema.virtual('duration').get(function () {
     return this.dueDate ? Math.ceil((this.dueDate - this.startDate) / (1000 * 60 * 60 * 24)) : null;
   });
-
   // Indexes
   MilestoneSchema.index({ initiative: 1, status: 1 });
   MilestoneSchema.index({ owner: 1 });
   MilestoneSchema.index({ dueDate: 1 });
   MilestoneSchema.index({ 'dependencies.milestone': 1 });
-
   const Milestone = db.mongoose.model('Milestone', MilestoneSchema);
-  
   return Milestone;
-};
+};

package/src/modules/governance/models/task.model.js

@@ -1,53 +1,56 @@
-module.exports = (db) => {
-  const TaskSchema = new db.mongoose.Schema({
-    title: { 
-      type: String, 
-      required: true 
-    },
-    description: { 
-      type: String 
-    },
-    status: { 
-      type: String, 
-      enum: ['not_started', 'in_progress', 'completed', 'blocked', 'cancelled'],
-      default: 'not_started'
-    },
-    assignedTo: { 
-      type: db.mongoose.Schema.Types.ObjectId, 
-      ref: 'User' 
-    },
-    dueDate: { 
-      type: Date 
-    },
-    // Reference to milestone
-    milestone: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: 'Milestone'
-    },
-    initiative: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: 'Initiative'
-    },
-    // Added priority
-    priority: {
-      type: String,
-      enum: ['low', 'medium', 'high', 'urgent'],
-      default: 'medium'
-    },
-    // Added tags
-    tags: [{
-      type: String
-    }]
-  }, {
-    timestamps: { currentTime: () => Date.now() }
-  });
-
+export default db => {
+  const TaskSchema = new db.mongoose.Schema(
+    {
+      title: {
+        type: String,
+        required: true,
+      },
+      description: {
+        type: String,
+      },
+      status: {
+        type: String,
+        enum: ['not_started', 'in_progress', 'completed', 'blocked', 'cancelled'],
+        default: 'not_started',
+      },
+      assignedTo: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+      },
+      dueDate: {
+        type: Date,
+      },
+      // Reference to milestone
+      milestone: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: 'Milestone',
+      },
+      initiative: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: 'Initiative',
+      },
+      // Added priority
+      priority: {
+        type: String,
+        enum: ['low', 'medium', 'high', 'urgent'],
+        default: 'medium',
+      },
+      // Added tags
+      tags: [
+        {
+          type: String,
+        },
+      ],
+    },
+    {
+      timestamps: { currentTime: () => Date.now() },
+    }
+  );
   // Add indexes
   TaskSchema.index({ milestone: 1 });
   TaskSchema.index({ assignedTo: 1 });
   TaskSchema.index({ status: 1 });
   TaskSchema.index({ dueDate: 1 });
-
   const Task = db.mongoose.model('Task', TaskSchema);
   return Task;
 };

package/src/modules/governance/models/vote.model.js

@@ -1,20 +1,22 @@
-module.exports = (db) => {
-  const VoteSchema = new db.mongoose.Schema({
-    value: { type: Number, required: true },
-    voter: { 
-      type: db.mongoose.Schema.Types.ObjectId, 
-      ref: 'User',
-      required: true 
+export default db => {
+  const VoteSchema = new db.mongoose.Schema(
+    {
+      value: { type: Number, required: true },
+      voter: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+      },
+      voting: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: 'Voting',
+        required: true,
+      },
     },
-    voting: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: 'Voting',
-      required: true
+    {
+      timestamps: { currentTime: () => Date.now() },
     }
-  }, {
-    timestamps: { currentTime: () => Date.now() }
-  });
-
+  );
   const Vote = db.mongoose.model('Vote', VoteSchema);
   return Vote;
-};
+};

package/src/modules/governance/models/voting.model.js

@@ -1,22 +1,26 @@
-module.exports = (db) => {
-  const VotingSchema = new db.mongoose.Schema({
-    title: { type: String, required: true },
-    description: { type: String },
-    startDate: { type: Date, required: true },
-    endDate: { type: Date, required: true },
-    status: { 
-      type: String, 
-      enum: ['pending', 'active', 'closed'],
-      default: 'pending'
+export default db => {
+  const VotingSchema = new db.mongoose.Schema(
+    {
+      title: { type: String, required: true },
+      description: { type: String },
+      startDate: { type: Date, required: true },
+      endDate: { type: Date, required: true },
+      status: {
+        type: String,
+        enum: ['pending', 'active', 'closed'],
+        default: 'pending',
+      },
+      votes: [
+        {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: 'Vote',
+        },
+      ],
     },
-    votes: [{
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: 'Vote'
-    }]
-  }, {
-    timestamps: { currentTime: () => Date.now() }
-  });
-
+    {
+      timestamps: { currentTime: () => Date.now() },
+    }
+  );
   const Voting = db.mongoose.model('Voting', VotingSchema);
   return Voting;
-};
+};