roles

config/database.js

@@ -16,8 +16,8 @@ module.exports = ({ env }) => ({
     connection: {
       host: env("DATABASE_HOST", "localhost"),
       port: env.int("DATABASE_PORT", 3306),
-      database: env("DATABASE_NAME", "games"),
-      user: env("DATABASE_USERNAME", "games"),
+      database: env("DATABASE_NAME", "zango"),
+      user: env("DATABASE_USERNAME", "zango"),
       password: env("DATABASE_PASSWORD", "12345"),
       // schema: env("DATABASE_SCHEMA", "public"), // Not required
       // ssl: {

package-lock.json

 {
-  "name": "offers-backend",
+  "name": "zango-backend",
   "version": "0.1.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
-      "name": "offers-backend",
+      "name": "zango-backend",
       "version": "0.1.0",
       "license": "MIT",
       "dependencies": {

package.json

 {
-  "name": "offers-backend",
+  "name": "zango-backend",
   "private": true,
   "version": "0.1.0",
   "description": "A Strapi application",

src/admin/app.js

@@ -18,10 +18,10 @@ const config = {
   notifications: { releases: false },
   translations: {
     en: {
-      "app.components.LeftMenu.navbrand.title": "Offers",
-      "app.components.LeftMenu.navbrand.title": "Offers",   
+      "app.components.LeftMenu.navbrand.title": "Zango",
+      "app.components.LeftMenu.navbrand.title": "Zango",   
       "app.components.LeftMenu.navbrand.subtitle": "",
-      "Auth.form.welcome.title": "Welcome to Offers",
+      "Auth.form.welcome.title": "Welcome to Zango",
       "Auth.form.welcome.subtitle": "Log in to your App"
     }
   },

src/api/categorie/content-types/categorie/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "categories",
+  "info": {
+    "singularName": "categorie",
+    "pluralName": "categories",
+    "displayName": "Categories",
+    "description": ""
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "name": {
+      "type": "string"
+    },
+    "subCategories": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "api::sub-categorie.sub-categorie",
+      "mappedBy": "category"
+    }
+  }
+}

src/api/categorie/controllers/categorie.js

+'use strict';
+
+/**
+ * categorie controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::categorie.categorie');

src/api/game/routes/game.js → src/api/categorie/routes/categorie.js

 'use strict';
 
 /**
- * game router
+ * categorie router
  */
 
 const { createCoreRouter } = require('@strapi/strapi').factories;
 
-module.exports = createCoreRouter('api::game.game');
+module.exports = createCoreRouter('api::categorie.categorie');

src/api/categorie/services/categorie.js

+'use strict';
+
+/**
+ * categorie service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('api::categorie.categorie');

src/api/course-detail/content-types/course-detail/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "course_details",
+  "info": {
+    "singularName": "course-detail",
+    "pluralName": "course-details",
+    "displayName": "Course-details"
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "endUser": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "api::end-user.end-user",
+      "inversedBy": "courseDetail"
+    },
+    "experience": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "api::experience.experience",
+      "mappedBy": "courseDetail"
+    }
+  }
+}

src/api/course-detail/controllers/course-detail.js

+'use strict';
+
+/**
+ * course-detail controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::course-detail.course-detail');

src/api/course-detail/routes/course-detail.js

+'use strict';
+
+/**
+ * course-detail router
+ */
+
+const { createCoreRouter } = require('@strapi/strapi').factories;
+
+module.exports = createCoreRouter('api::course-detail.course-detail');

src/api/course-detail/services/course-detail.js

+'use strict';
+
+/**
+ * course-detail service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('api::course-detail.course-detail');

src/api/game/content-types/game/schema.json → src/api/end-user/content-types/end-user/schema.json

 {
   "kind": "collectionType",
-  "collectionName": "games",
+  "collectionName": "end_users",
   "info": {
-    "singularName": "game",
-    "pluralName": "games",
-    "displayName": "Games"
+    "singularName": "end-user",
+    "pluralName": "end-users",
+    "displayName": "End-user",
+    "description": ""
   },
   "options": {
     "draftAndPublish": true
   },
   "pluginOptions": {},
   "attributes": {
-    "firstReleaseDate": {
+    "name": {
       "type": "string"
     },
-    "name": {
+    "number": {
       "type": "string"
     },
-    "rating": {
+    "age": {
       "type": "string"
     },
-    "summary": {
-      "type": "text"
+    "courseDetail": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "api::course-detail.course-detail",
+      "inversedBy": "endUser"
     }
   }
 }

src/api/end-user/controllers/end-user.js

+'use strict';
+
+/**
+ * end-user controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::end-user.end-user');

src/api/end-user/routes/end-user.js

+'use strict';
+
+/**
+ * end-user router
+ */
+
+const { createCoreRouter } = require('@strapi/strapi').factories;
+
+module.exports = createCoreRouter('api::end-user.end-user');

src/api/end-user/services/end-user.js

+'use strict';
+
+/**
+ * end-user service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('api::end-user.end-user');

src/api/experience/content-types/experience/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "experiences",
+  "info": {
+    "singularName": "experience",
+    "pluralName": "experiences",
+    "displayName": "Experiences",
+    "description": ""
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "name": {
+      "type": "string"
+    },
+    "description": {
+      "type": "text"
+    },
+    "pricePerPerson": {
+      "type": "string"
+    },
+    "address": {
+      "type": "text"
+    },
+    "masterCity": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "api::master-city.master-city"
+    },
+    "masterMonths": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "api::master-month.master-month"
+    },
+    "duration": {
+      "type": "string"
+    },
+    "minimumDuration": {
+      "type": "string"
+    },
+    "maximumDuration": {
+      "type": "string"
+    },
+    "ageLowerLimit": {
+      "type": "string"
+    },
+    "ageNotes": {
+      "type": "string"
+    },
+    "phoneNumber": {
+      "type": "string"
+    },
+    "minGroupSize": {
+      "type": "string"
+    },
+    "maxGroupSize": {
+      "type": "string"
+    },
+    "indoor": {
+      "type": "boolean"
+    },
+    "subCategory": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "api::sub-categorie.sub-categorie",
+      "inversedBy": "experience"
+    },
+    "link": {
+      "type": "string"
+    },
+    "cancellationPolicy": {
+      "type": "text"
+    },
+    "vendor": {
+      "type": "relation",
+      "relation": "manyToOne",
+      "target": "api::vendor.vendor",
+      "inversedBy": "experiences"
+    },
+    "courseDetail": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "api::course-detail.course-detail",
+      "inversedBy": "experience"
+    },
+    "timeSlots": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "api::time-slot.time-slot",
+      "mappedBy": "experience"
+    }
+  }
+}

src/api/experience/controllers/experience.js

+'use strict';
+
+/**
+ * experience controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::experience.experience');

src/api/experience/routes/experience.js

+'use strict';
+
+/**
+ * experience router
+ */
+
+const { createCoreRouter } = require('@strapi/strapi').factories;
+
+module.exports = createCoreRouter('api::experience.experience');

src/api/experience/services/experience.js

+'use strict';
+
+/**
+ * experience service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('api::experience.experience');

src/api/game/controllers/game.js

-"use strict";
-
-/**
- * game controller
- */
-
-const { createCoreController } = require("@strapi/strapi").factories;
-
-module.exports = createCoreController("api::game.game", () => ({
-  async importSeedData(ctx) {
-    await strapi.service("api::game.game").importSeedDataFromApi();
-    ctx.send({ ok: true });
-  },
-}));

src/api/game/routes/custom-routes.js

-const routes = {
-    routes: [
-      {
-        method: "POST",
-        path: "/games/import-seed-data",
-        handler: "api::game.game.importSeedData",
-        config: {
-          // some configuration...
-        }
-      },
-      
-    ]
-  };
-  
-  module.exports = routes;
-  
\ No newline at end of file

src/api/game/services/game.js

-"use strict";
-
-const axios = require("axios");
-const { factories } = require("@strapi/strapi");
-
-/**
- * game service
- */
-
-const { createCoreService } = require("@strapi/strapi").factories;
-
-module.exports = factories.createCoreService(
-  "api::game.game",
-  ({ strapi: Strapi }) => ({
-    async importSeedDataFromApi() {
-      const seedData = await axios.get(
-        "https://public.connectnow.org.uk/applicant-test/"
-      );
-      //   console.log("seedData", seedData.data[0]);
-      let seedDataFinal = seedData.data;
-      const date = new Date()
-      const deletedCnt = await strapi.db.query("api::game.game").deleteMany({ where: {} });
-
-      for (let i = 0; i < seedDataFinal.length; i++) {
-        const item = seedDataFinal[i];
-        // console.log("seedData", item);
-
-        //   console.log(`Attempting to create country: `, country);
-        await strapi.entityService.create("api::game.game", {
-          data: {
-            firstReleaseDate: `${item.first_release_date}`,
-            name: item.name,
-            rating: `${item.rating}`,
-            summary: item.summary,
-            publishedAt: date
-          },
-        });
-      }
-    },
-  })
-);

src/api/gift-card/content-types/gift-card/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "gift_cards",
+  "info": {
+    "singularName": "gift-card",
+    "pluralName": "gift-cards",
+    "displayName": "Gift-cards"
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "name": {
+      "type": "string"
+    }
+  }
+}

src/api/gift-card/controllers/gift-card.js

+'use strict';
+
+/**
+ * gift-card controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::gift-card.gift-card');

src/api/gift-card/routes/gift-card.js

+'use strict';
+
+/**
+ * gift-card router
+ */
+
+const { createCoreRouter } = require('@strapi/strapi').factories;
+
+module.exports = createCoreRouter('api::gift-card.gift-card');

src/api/gift-card/services/gift-card.js

+'use strict';
+
+/**
+ * gift-card service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('api::gift-card.gift-card');

src/api/master-city/content-types/master-city/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "master_cities",
+  "info": {
+    "singularName": "master-city",
+    "pluralName": "master-cities",
+    "displayName": "Master-city"
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "name": {
+      "type": "string"
+    }
+  }
+}

src/api/master-city/controllers/master-city.js

+'use strict';
+
+/**
+ * master-city controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::master-city.master-city');

src/api/master-city/routes/master-city.js

+'use strict';
+
+/**
+ * master-city router
+ */
+
+const { createCoreRouter } = require('@strapi/strapi').factories;
+
+module.exports = createCoreRouter('api::master-city.master-city');

src/api/master-city/services/master-city.js

+'use strict';
+
+/**
+ * master-city service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('api::master-city.master-city');

src/api/master-day/content-types/master-day/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "master_days",
+  "info": {
+    "singularName": "master-day",
+    "pluralName": "master-days",
+    "displayName": "Master-days"
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "name": {
+      "type": "string"
+    }
+  }
+}

src/api/master-day/controllers/master-day.js

+'use strict';
+
+/**
+ * master-day controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::master-day.master-day');

src/api/master-day/routes/master-day.js

+'use strict';
+
+/**
+ * master-day router
+ */
+
+const { createCoreRouter } = require('@strapi/strapi').factories;
+
+module.exports = createCoreRouter('api::master-day.master-day');

src/api/master-day/services/master-day.js

+'use strict';
+
+/**
+ * master-day service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('api::master-day.master-day');

src/api/master-month/content-types/master-month/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "master_months",
+  "info": {
+    "singularName": "master-month",
+    "pluralName": "master-months",
+    "displayName": "Master-months"
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "name": {
+      "type": "string"
+    }
+  }
+}

src/api/master-month/controllers/master-month.js

+'use strict';
+
+/**
+ * master-month controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::master-month.master-month');

src/api/master-month/routes/master-month.js

+'use strict';
+
+/**
+ * master-month router
+ */
+
+const { createCoreRouter } = require('@strapi/strapi').factories;
+
+module.exports = createCoreRouter('api::master-month.master-month');

src/api/master-month/services/master-month.js

+'use strict';
+
+/**
+ * master-month service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('api::master-month.master-month');

src/api/sub-categorie/content-types/sub-categorie/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "sub_categories",
+  "info": {
+    "singularName": "sub-categorie",
+    "pluralName": "sub-categories",
+    "displayName": "Sub-categories",
+    "description": ""
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "name": {
+      "type": "string"
+    },
+    "category": {
+      "type": "relation",
+      "relation": "manyToOne",
+      "target": "api::categorie.categorie",
+      "inversedBy": "subCategories"
+    },
+    "experience": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "api::experience.experience",
+      "inversedBy": "subCategory"
+    }
+  }
+}

src/api/sub-categorie/controllers/sub-categorie.js

+'use strict';
+
+/**
+ * sub-categorie controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::sub-categorie.sub-categorie');

src/api/sub-categorie/routes/sub-categorie.js

+'use strict';
+
+/**
+ * sub-categorie router
+ */
+
+const { createCoreRouter } = require('@strapi/strapi').factories;
+
+module.exports = createCoreRouter('api::sub-categorie.sub-categorie');

src/api/sub-categorie/services/sub-categorie.js

+'use strict';
+
+/**
+ * sub-categorie service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('api::sub-categorie.sub-categorie');

src/api/time-slot/content-types/time-slot/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "time_slots",
+  "info": {
+    "singularName": "time-slot",
+    "pluralName": "time-slots",
+    "displayName": "Time-slots",
+    "description": ""
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "start": {
+      "type": "time"
+    },
+    "end": {
+      "type": "time"
+    },
+    "masterDay": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "api::master-day.master-day"
+    },
+    "experience": {
+      "type": "relation",
+      "relation": "manyToOne",
+      "target": "api::experience.experience",
+      "inversedBy": "timeSlots"
+    }
+  }
+}

src/api/time-slot/controllers/time-slot.js

+'use strict';
+
+/**
+ * time-slot controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::time-slot.time-slot');

src/api/time-slot/routes/time-slot.js

+'use strict';
+
+/**
+ * time-slot router
+ */
+
+const { createCoreRouter } = require('@strapi/strapi').factories;
+
+module.exports = createCoreRouter('api::time-slot.time-slot');

src/api/time-slot/services/time-slot.js

+'use strict';
+
+/**
+ * time-slot service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('api::time-slot.time-slot');

src/api/vendor/content-types/vendor/schema.json

+{
+  "kind": "collectionType",
+  "collectionName": "vendors",
+  "info": {
+    "singularName": "vendor",
+    "pluralName": "vendors",
+    "displayName": "Vendor",
+    "description": ""
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {},
+  "attributes": {
+    "name": {
+      "type": "string"
+    },
+    "experiences": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "api::experience.experience",
+      "mappedBy": "vendor"
+    }
+  }
+}

src/api/vendor/controllers/vendor.js

+'use strict';
+
+/**
+ * vendor controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('api::vendor.vendor');

src/api/vendor/routes/vendor.js

+'use strict';
+
+/**
+ * vendor router
+ */
+
+const { createCoreRouter } = require('@strapi/strapi').factories;
+
+module.exports = createCoreRouter('api::vendor.vendor');

src/api/vendor/services/vendor.js

+'use strict';
+
+/**
+ * vendor service
+ */
+
+const { createCoreService } = require('@strapi/strapi').factories;
+
+module.exports = createCoreService('api::vendor.vendor');

src/extensions/users-permissions/strapi-server.js

@@ -319,7 +319,7 @@ const userPermissionExtension = (plugin) => {
       ctx.request.body.httpsThirdPartyOTPApiRequestBody =
         spertoCPOtpData.config.data;
       ctx.request.body.httpThirdPartyOTPApiResposneBody = JSON.stringify(
-        spertoCPOtpData.data
+        spertoCPOtpData.datauser
       );
       ctx.request.body.httpThirdPartyOTPApiError = false;
       // console.log(">>>>>",ctx.request.body.httpThirdPartyOTPApiError);