@bonifaceebuka/core-backend 1.0.0

package/dist/services/mobile/EventService.js

@@ -0,0 +1,540 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typedi_1 = require("typedi");
+const logger_1 = require("../../common/configs/logger");
+const AppError_1 = require("../../common/errors/AppError");
+const UserRepository_1 = require("../../repositories/UserRepository");
+const messages_1 = require("../../common/constants/messages");
+const EventRepository_1 = require("@/repositories/EventRepository");
+const UploadService_1 = __importDefault(require("./UploadService"));
+const UploadEnum_1 = require("@/common/enums/UploadEnum");
+const EventTypeRepository_1 = require("@/repositories/EventTypeRepository");
+const IndexEnum_1 = require("@/common/enums/IndexEnum");
+const Paginator_1 = require("@/transformers/Paginator");
+const configs_1 = require("@/common/configs");
+const EventCollection_1 = require("@/transformers/collections/EventCollection");
+const EventResource_1 = require("@/transformers/resources/EventResource");
+const EventAttendanceRepository_1 = require("@/repositories/EventAttendanceRepository");
+let EventService = class EventService {
+    eventRepository;
+    uploadService;
+    eventTypeRepository;
+    eventAttendanceRepository;
+    constructor() {
+        this.eventRepository = new EventRepository_1.EventRepository();
+        this.eventTypeRepository = new EventTypeRepository_1.EventTypeRepository();
+        this.uploadService = new UploadService_1.default();
+        this.eventAttendanceRepository = new EventAttendanceRepository_1.EventAttendanceRepository();
+    }
+    async createEvent(eventData, user_id) {
+        let message;
+        const { event_name, number_of_attendees, cover_image, event_type, location, date_and_time, description, event_venue, } = eventData;
+        if (!cover_image) {
+            message = "Cover image is required!";
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 400);
+        }
+        const eventType = await this.eventTypeRepository.getRepo().findOne({
+            select: ['name', 'uuid', 'id'],
+            where: {
+                uuid: event_type
+            }
+        });
+        if (!eventType) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Event type");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const createdEvent = await this.eventRepository.createWithCoordinates({
+            name: event_name,
+            number_of_attendees,
+            type_id: eventType.id,
+            location,
+            event_venue,
+            date: date_and_time,
+            description,
+            user_id
+        }, location.longitude, location.latitude);
+        const eventId = createdEvent.identifiers?.[0]?.id;
+        logger_1.logger.info("Event created without cover image");
+        const uploadedFile = await this.uploadService.uploadImage(cover_image, eventId, UploadEnum_1.UploadDirectories.EVENTS, "EventModel");
+        logger_1.logger.info("Event cover image successfully created");
+        await this.eventRepository.updateOne({
+            uuid: createdEvent.generatedMaps?.[0]?.uuid,
+            user_id,
+        }, {
+            cover_image_id: uploadedFile.id
+        });
+        logger_1.logger.info("Event cover image added successfully");
+        await this.eventAttendanceRepository.create({
+            event_id: createdEvent.identifiers?.[0]?.id,
+            attender_id: user_id
+        });
+        return {
+            successful: true,
+            data: null,
+            message: "Event created successfully"
+        };
+    }
+    async getEventCreationData() {
+        const event_types = await this.eventTypeRepository.getRepo().find({
+            select: ['name', 'uuid']
+        });
+        const attendees = IndexEnum_1.AttendeeRange;
+        return {
+            successful: true,
+            data: {
+                attendees,
+                event_types
+            },
+            message: "Event creation data fetched successfully!"
+        };
+    }
+    async getOneEvent(event_id, user_id) {
+        let message;
+        const { data } = await this.eventRepository.getOneEvent(event_id, user_id);
+        const { raw } = data;
+        if (!raw[0]) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Event");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: EventResource_1.EventResource.toJSON(raw[0], user_id),
+            message: "Event fetched successfully!"
+        };
+    }
+    async getEvents(user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const dataFetchParams = {
+            page_number,
+            limit,
+        };
+        const events = await this.loadPaginatedEvents(dataFetchParams, user_id);
+        if (!events) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Events");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: events,
+            message: "Events fetched successfully!"
+        };
+    }
+    async getRecommendedEvents(user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const offset = (page_number - 1) * limit;
+        const userRepository = new UserRepository_1.UserRepository();
+        const existingUser = await userRepository.findOneAndRelations({
+            where: {
+                id: user_id
+            },
+            relations: ['user_profile']
+        });
+        if (!existingUser) {
+            const message = messages_1.dynamic_messages.NOT_FOUND("User");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message);
+        }
+        const location = existingUser?.user_profile?.location;
+        const recommendationOptions = {
+            page_number,
+            limit,
+            user_id,
+            lat: location?.coordinates?.lat,
+            lng: location?.coordinates?.long,
+            city: location?.city,
+            state: location?.state,
+            country: location?.country,
+            connections: [],
+        };
+        const events = await this.recommendEvents(recommendationOptions);
+        return {
+            successful: true,
+            data: events,
+            message: "Events fetched successfully!"
+        };
+    }
+    async getUpcomingEvents(user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const offset = (page_number - 1) * limit;
+        const userRepository = new UserRepository_1.UserRepository();
+        const existingUser = await userRepository.findOneAndRelations({
+            where: {
+                id: user_id
+            },
+            relations: ['user_profile']
+        });
+        if (!existingUser) {
+            const message = messages_1.dynamic_messages.NOT_FOUND("User");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message);
+        }
+        const location = existingUser?.user_profile?.location;
+        // const upcomingOptions: RecommendationOptions = {
+        //     page_number,
+        //     limit,
+        //     user_id,
+        //     lat: location?.coordinates?.lat,
+        //     lng:location?.coordinates?.long,
+        //     city: location?.city,
+        //     state: location?.state,
+        //     country: location?.country,
+        //     connections: [],
+        // };
+        // const events = await this.upcomingEvents(upcomingOptions)
+        const dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                upcoming_event: true
+            }
+        };
+        const events = await this.loadPaginatedEvents(dataFetchParams);
+        if (!events) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Events");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: events,
+            message: "Events fetched successfully!"
+        };
+    }
+    async loadPaginatedEvents(loadPagesDto, userId) {
+        const { data, total, perPage, page } = await this.eventRepository.loadPaginatedEvents(loadPagesDto, userId);
+        const { raw } = data;
+        return (0, Paginator_1.paginator)({
+            total,
+            perPage,
+            currentPage: page,
+            data: EventCollection_1.EventCollection.toJSON(raw, userId),
+        });
+    }
+    async updateOneEvent(eventData, event_id, user_id) {
+        let message;
+        const { event_name, number_of_attendees, cover_image, event_type, location, date_and_time, description, event_venue, } = eventData;
+        let optionalFieldsToUpdate = {};
+        const event = await this.eventRepository.basicFindOneByConditions({
+            uuid: event_id,
+            user_id
+        });
+        if (!event) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Event");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        const eventType = await this.eventTypeRepository.getRepo().findOne({
+            select: ['name', 'uuid', 'id'],
+            where: {
+                uuid: event_type
+            }
+        });
+        if (!eventType) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Event type");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        if (cover_image) {
+            await this.uploadService.deleteFile(event?.cover_image_id, event?.id, "image");
+            const uploadedFile = await this.uploadService.uploadImage(cover_image, event?.id, UploadEnum_1.UploadDirectories.EVENTS, "EventModel");
+            optionalFieldsToUpdate.cover_image_id = uploadedFile.id;
+        }
+        await this.eventRepository.updateWithCoordinates({
+            uuid: event.uuid,
+            user_id,
+        }, {
+            name: event_name,
+            number_of_attendees,
+            type_id: eventType.id,
+            location,
+            event_venue,
+            date: date_and_time,
+            description,
+            ...optionalFieldsToUpdate,
+        }, location.longitude, location.latitude);
+        return {
+            successful: true,
+            data: EventResource_1.EventResource.toJSON(event),
+            message: "Event updated successfully!"
+        };
+    }
+    async deleteOneEvent(event_id, user_id) {
+        let message;
+        const event = await this.eventRepository.basicFindOneByConditions({
+            uuid: event_id,
+            user_id
+        });
+        if (!event) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Event");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        await this.uploadService.deleteFile(event?.cover_image_id, event?.id, "image");
+        await this.eventRepository.deleteByCondition({
+            uuid: event.uuid,
+            user_id,
+        });
+        return {
+            successful: true,
+            data: EventResource_1.EventResource.toJSON(event),
+            message: "Event deleted successfully!"
+        };
+    }
+    async searchEvents(search_string, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const offset = (page_number - 1) * limit;
+        const dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                search_string
+            }
+        };
+        const events = await this.loadPaginatedEvents(dataFetchParams);
+        if (!events) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Events");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: events,
+            message: "Events fetched successfully!"
+        };
+    }
+    async eventsHostedMe(user_id, pageNumber) {
+        let message;
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const dataFetchParams = {
+            page_number,
+            limit,
+            metadata: {
+                user_id
+            }
+        };
+        const events = await this.loadPaginatedEvents(dataFetchParams, user_id);
+        if (!events) {
+            message = messages_1.dynamic_messages.NOT_FOUND("Events");
+            logger_1.logger.info(message);
+            throw new AppError_1.AppError(message, 404);
+        }
+        return {
+            successful: true,
+            data: events,
+            message: "My hosted events fetched successfully!"
+        };
+    }
+    async recommendEvents(options) {
+        const { user_id, page_number, limit } = options;
+        const { rows, total } = await this.eventRepository.getRecommendedEvents(options);
+        return (0, Paginator_1.paginator)({
+            total,
+            perPage: limit,
+            currentPage: page_number,
+            data: EventCollection_1.EventCollection.toJSON(rows, user_id),
+        });
+    }
+    async upcomingEvents(options) {
+        const { user_id, lat, lng, city, state, country, connections = [], radius = configs_1.CONFIGS.LOCATION_RADIUS, // 50km
+        page_number, limit } = options;
+        const qb = this.eventRepository.getRepo().createQueryBuilder("e")
+            .leftJoinAndSelect("e.user", "u")
+            .leftJoinAndSelect("u.user_profile", "creator_profile")
+            .leftJoinAndSelect("creator_profile.avatar", "creator_avatar")
+            /* ---------------------------------
+               Events happening within 5(km) distance
+            ---------------------------------- */
+            .addSelect(`
+      ST_Distance(
+        e.coordinates::geography,
+        ST_SetSRID(ST_MakePoint(:lng, :lat), 4326)::geography
+      )
+      `, "distance")
+            /* ---------------------------------
+                Events that have the same event type with the ones the user has attended before (continuous)
+            ---------------------------------- */
+            .addSelect(`
+      COALESCE((
+        SELECT COUNT(*)::float
+        FROM event_attendance ea
+        JOIN events ev ON ev.id = ea.event_id
+        WHERE ea.attender_id = :user_id
+        AND ev.type_id = e.type_id
+      ) / 5, 0)
+      `, "type_score")
+            /* ---------------------------------
+               Distance Scoring (0 → 1) of events happening around the location of the user
+            ---------------------------------- */
+            .addSelect(`
+      GREATEST(
+        0,
+        1 - (
+          ST_Distance(
+            e.coordinates::geography,
+            ST_SetSRID(ST_MakePoint(:lng, :lat), 4326)::geography
+          ) / :radius
+        )
+      )
+      `, "distance_score")
+            /* ---------------------------------
+                Location Scoring of events happening around the location(state, city and country) of the user
+            ---------------------------------- */
+            .addSelect(`
+      CASE
+        WHEN e.location->>'city' = :city THEN 1
+        WHEN e.location->>'state' = :state THEN 0.6
+        WHEN e.location->>'country' = :country THEN 0.3
+        ELSE 0
+      END
+      `, "location_score")
+            /* ---------------------------------
+               Scoring of events created by a user's connection
+            ---------------------------------- */
+            .addSelect(`
+      CASE
+        WHEN e.user_id = ANY(:connections)
+        THEN 1 ELSE 0
+      END
+      `, "creator_score")
+            /* ---------------------------------
+               Events the user's connection(s) will be attending
+            ---------------------------------- */
+            .addSelect(`
+      COALESCE((
+        SELECT COUNT(*)::float
+        FROM event_attendance ea
+        WHERE ea.event_id = e.id
+        AND ea.attender_id = ANY(:connections)
+      ) / 10, 0)
+      `, "attendance_score")
+            /* ---------------------------------
+               Time decay score
+            ---------------------------------- */
+            .addSelect(`
+      GREATEST(
+        0,
+        1 - (EXTRACT(EPOCH FROM (e.date - NOW())) / 604800)
+      )
+      `, "time_score")
+            /* ---------------------------------
+               Final score (inline expressions)
+            ---------------------------------- */
+            .addSelect(`
+      (
+        0.30 * COALESCE((
+          SELECT COUNT(*)::float
+          FROM event_attendance ea
+          JOIN events ev ON ev.id = ea.event_id
+          WHERE ea.attender_id = :user_id
+          AND ev.type_id = e.type_id
+        ) / 5, 0)
+        +
+        0.25 * GREATEST(
+          0,
+          1 - (
+            ST_Distance(
+              e.coordinates::geography,
+              ST_SetSRID(ST_MakePoint(:lng, :lat), 4326)::geography
+            ) / :radius
+          )
+        )
+        +
+        0.15 * CASE
+          WHEN e.location->>'city' = :city THEN 1
+          WHEN e.location->>'state' = :state THEN 0.6
+          WHEN e.location->>'country' = :country THEN 0.3
+          ELSE 0
+        END
+        +
+        0.10 * CASE
+          WHEN e.user_id = ANY(:connections) THEN 1 ELSE 0
+        END
+        +
+        0.15 * COALESCE((
+          SELECT COUNT(*)::float
+          FROM event_attendance ea
+          WHERE ea.event_id = e.id
+          AND ea.attender_id = ANY(:connections)
+        ) / 10, 0)
+        +
+        0.05 * GREATEST(
+          0,
+          1 - (EXTRACT(EPOCH FROM (e.date - NOW())) / 604800)
+        )
+      )
+      `, "final_score")
+            /* ---------------------------------
+                Filter events that have not happened
+            ---------------------------------- */
+            .where("e.status = 'SCHEDULED'")
+            .andWhere("e.date > NOW()")
+            .andWhere(`
+      ST_DWithin(
+        e.coordinates::geography,
+        ST_SetSRID(ST_MakePoint(:lng, :lat), 4326)::geography,
+        :radius
+      )
+      `)
+            .andWhere("e.deleted_at IS NULL")
+            /* ---------------------------------
+               Ordering
+            ---------------------------------- */
+            .orderBy("final_score", "DESC")
+            .addOrderBy("distance", "ASC")
+            // .limit(limit)
+            .take(limit)
+            .skip(page_number)
+            /* ---------------------------------
+               Parameters
+            ---------------------------------- */
+            .setParameters({
+            user_id,
+            lat,
+            lng,
+            city,
+            state,
+            country,
+            connections,
+            radius,
+        });
+        const [rows, total] = await qb.getManyAndCount();
+        //   const {entities, raw}  = await qb.getRawAndEntities();
+        //   return entities;
+        return (0, Paginator_1.paginator)({
+            total,
+            perPage: limit,
+            currentPage: page_number,
+            data: EventCollection_1.EventCollection.toJSON(rows, user_id),
+        });
+    }
+};
+EventService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], EventService);
+exports.default = EventService;

package/dist/services/mobile/NotificationService.js

@@ -0,0 +1,89 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typedi_1 = require("typedi");
+const Paginator_1 = require("@/transformers/Paginator");
+const configs_1 = require("@/common/configs");
+const NotificationRepository_1 = require("@/repositories/NotificationRepository");
+const NotificationCollection_1 = require("@/transformers/collections/NotificationCollection");
+let NotificationService = class NotificationService {
+    notificationRepository;
+    constructor() {
+        this.notificationRepository = new NotificationRepository_1.NotificationRepository();
+    }
+    async fetchAllNotifications(user_id, pageNumber) {
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const options = {
+            page_number,
+            limit
+        };
+        const { rows, total } = await this.notificationRepository.fetchAllNotifications(user_id, options);
+        const data = (0, Paginator_1.paginator)({
+            total,
+            perPage: limit,
+            currentPage: page_number,
+            data: NotificationCollection_1.NotificationCollection.toJSON(rows),
+        });
+        return {
+            successful: true,
+            data,
+            message: `Notifications fetched successfully`
+        };
+    }
+    async fetchReadNotifications(user_id, pageNumber) {
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const options = {
+            metadata: user_id,
+            page_number,
+            limit
+        };
+        const { rows, total } = await this.notificationRepository.fetchReadNotifications(options);
+        const data = (0, Paginator_1.paginator)({
+            total,
+            perPage: limit,
+            currentPage: page_number,
+            data: NotificationCollection_1.NotificationCollection.toJSON(rows),
+        });
+        return {
+            successful: true,
+            data,
+            message: `Notifications fetched successfully`
+        };
+    }
+    async fetchUnreadNotifications(user_id, pageNumber) {
+        const page_number = pageNumber || 1;
+        const limit = configs_1.CONFIGS.DATA_FETCH_LIMIT || 10;
+        const options = {
+            metadata: user_id,
+            page_number,
+            limit
+        };
+        const { rows, total } = await this.notificationRepository.fetchUnreadNotifications(options);
+        const data = (0, Paginator_1.paginator)({
+            total,
+            perPage: limit,
+            currentPage: page_number,
+            data: NotificationCollection_1.NotificationCollection.toJSON(rows),
+        });
+        return {
+            successful: true,
+            data,
+            message: `Notifications fetched successfully`
+        };
+    }
+};
+NotificationService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], NotificationService);
+exports.default = NotificationService;