Course completed activity logged; Razorpay explicit error; user filtering fix; Docker build fix

Author: Rajat Saxena

apps/web/config/strings.ts

@@ -121,7 +121,7 @@ export const responses = {
     default_payment_plan_required:
         "Mark a payment plan as default before enabling the community",
     community_content_already_reported: "Content already reported",
-    profile_incomplete: "Complete your profile to join this community",
+    profile_incomplete: "Complete your profile to perform this action",
     cannot_reject_member_with_active_subscription:
         "Cannot reject a member with an active subscription",
     cannot_leave_community_last_moderator:

apps/web/graphql/courses/logic.ts

@@ -92,6 +92,18 @@ async function formatCourse(courseId: string, ctx: GQLContext) {
         ctx,
     });
 
+    if (
+        [Constants.CourseType.COURSE, Constants.CourseType.DOWNLOAD].includes(
+            course.type,
+        )
+    ) {
+        const { nextLesson } = await getPrevNextCursor(
+            course.courseId,
+            ctx.subdomain._id,
+        );
+        (course as any).firstLesson = nextLesson;
+    }
+
     const result = {
         ...course,
         groups: course!.groups?.map((group: any) => ({
@@ -129,19 +141,19 @@ export const getCourse = async (
     }
 
     if (course.published) {
-        if (
-            [constants.course, constants.download].includes(
-                course.type as
-                    | typeof constants.course
-                    | typeof constants.download,
-            )
-        ) {
-            const { nextLesson } = await getPrevNextCursor(
-                course.courseId,
-                ctx.subdomain._id,
-            );
-            (course as any).firstLesson = nextLesson;
-        }
+        // if (
+        //     [constants.course, constants.download].includes(
+        //         course.type as
+        //             | typeof constants.course
+        //             | typeof constants.download,
+        //     )
+        // ) {
+        //     const { nextLesson } = await getPrevNextCursor(
+        //         course.courseId,
+        //         ctx.subdomain._id,
+        //     );
+        //     (course as any).firstLesson = nextLesson;
+        // }
         // course.groups = accessibleGroups;
         return await formatCourse(course.courseId, ctx);
     } else {
@@ -471,6 +483,7 @@ export const getProducts = async ({
                       entityId: course.courseId,
                       entityType: Constants.MembershipEntityType.COURSE,
                       domain: ctx.subdomain._id,
+                      status: Constants.MembershipStatus.ACTIVE,
                   })
                 : undefined;
         const sales =

apps/web/graphql/lessons/logic.ts

@@ -17,13 +17,13 @@ import {
 } from "./helpers";
 import constants from "../../config/constants";
 import GQLContext from "../../models/GQLContext";
-import { Course } from "../../models/Course";
 import { deleteMedia } from "../../services/medialit";
 import { recordProgress } from "../users/logic";
-import { Progress, Quiz } from "@courselit/common-models";
+import { Constants, Progress, Quiz } from "@courselit/common-models";
 import LessonEvaluation from "../../models/LessonEvaluation";
 import { checkPermission } from "@courselit/utils";
 import { recordActivity } from "../../lib/record-activity";
+import { InternalCourse } from "@courselit/common-logic";
 
 const { permissions, quiz } = constants;
 
@@ -130,7 +130,7 @@ export const createLesson = async (
     lessonValidator(lessonData);
 
     try {
-        const course: Course | null = await CourseModel.findOne({
+        const course: InternalCourse | null = await CourseModel.findOne({
             courseId: lessonData.courseId,
             domain: ctx.subdomain._id,
         });
@@ -199,7 +199,7 @@ export const deleteLesson = async (id: string, ctx: GQLContext) => {
 
     try {
         // remove from the parent Course's lessons array
-        let course: Course | null = await CourseModel.findOne({
+        let course: InternalCourse | null = await CourseModel.findOne({
             domain: ctx.subdomain._id,
         }).elemMatch("lessons", { $eq: lesson.lessonId });
         if (!course) {
@@ -223,7 +223,10 @@ export const deleteLesson = async (id: string, ctx: GQLContext) => {
     }
 };
 
-export const getAllLessons = async (course: Course, ctx: GQLContext) => {
+export const getAllLessons = async (
+    course: InternalCourse,
+    ctx: GQLContext,
+) => {
     const lessons = await LessonModel.find(
         {
             lessonId: {
@@ -316,16 +319,46 @@ export const markLessonCompleted = async (
     await recordActivity({
         domain: ctx.subdomain._id,
         userId: ctx.user.userId,
-        type: "lesson_completed",
+        type: Constants.ActivityType.LESSON_COMPLETED,
         entityId: lesson.lessonId,
         metadata: {
             courseId: lesson.courseId,
         },
     });
 
+    await recordCourseCompleted(lesson.courseId, ctx);
+
     return true;
 };
 
+const recordCourseCompleted = async (courseId: string, ctx: GQLContext) => {
+    const course = await CourseModel.findOne({ courseId });
+    if (!course) {
+        throw new Error(responses.item_not_found);
+    }
+
+    const isCourseCompleted = course.lessons.every((lessonId) => {
+        const progress = ctx.user.purchases.find(
+            (progress: Progress) => progress.courseId === courseId,
+        );
+        if (!progress) {
+            return false;
+        }
+        return progress.completedLessons.includes(lessonId);
+    });
+
+    if (!isCourseCompleted) {
+        return;
+    }
+
+    await recordActivity({
+        domain: ctx.subdomain._id,
+        userId: ctx.user.userId,
+        type: Constants.ActivityType.COURSE_COMPLETED,
+        entityId: courseId,
+    });
+};
+
 export const evaluateLesson = async (
     lessonId: string,
     answers: { answers: number[][] },

apps/web/models/GQLContext.ts

@@ -1,8 +1,8 @@
+import { InternalUser } from "@courselit/common-logic";
 import { Domain } from "./Domain";
-import { User } from "./User";
 
 export default interface GQLContext {
-    user: User;
+    user: InternalUser;
     subdomain: Domain;
     address: string;
 }

apps/web/pages/course/[slug]/[id]/index.tsx

@@ -10,10 +10,9 @@ import { ArrowRight, CheckCircled, Circle, Lock } from "@courselit/icons";
 import {
     COURSE_PROGRESS_START,
     ENROLL_BUTTON_TEXT,
-    FREE_COST,
     SIDEBAR_TEXT_COURSE_ABOUT,
 } from "../../../../ui-config/strings";
-import { FetchBuilder, checkPermission } from "@courselit/utils";
+import { FetchBuilder, checkPermission, getPlanPrice } from "@courselit/utils";
 import {
     AppState,
     AppDispatch,
@@ -34,7 +33,11 @@ import RouteBasedComponentScaffold, {
     Divider,
 } from "@components/public/scaffold";
 import Article from "@components/public/article";
-import { Link, Button2, PriceTag } from "@courselit/components-library";
+import {
+    Link,
+    Button2,
+    getSymbolFromCurrency,
+} from "@courselit/components-library";
 import { useSession } from "next-auth/react";
 import { useEffect, useState } from "react";
 const { permissions } = UIConstants;
@@ -52,6 +55,8 @@ type CourseWithoutGroups = Pick<
     | "cost"
     | "courseId"
     | "tags"
+    | "paymentPlans"
+    | "defaultPaymentPlan"
 >;
 
 export type CourseFrontend = CourseWithoutGroups & {
@@ -104,6 +109,18 @@ export const graphQuery = `
         },
         tags,
         firstLesson
+        paymentPlans {
+            planId
+            name
+            type
+            oneTimeAmount
+            emiAmount
+            emiTotalInstallments
+            subscriptionMonthlyAmount
+            subscriptionYearlyAmount
+        }
+        leadMagnet
+        defaultPaymentPlan
       }
     }
   `;
@@ -264,6 +281,12 @@ const CourseViewer = (props: CourseProps) => {
         } catch (err: any) {}
     };
 
+    const { amount, period } = getPlanPrice(
+        course?.paymentPlans.find(
+            (x) => x.planId === course?.defaultPaymentPlan,
+        )!,
+    );
+
     return (
         <>
             <Head>
@@ -303,14 +326,18 @@ const CourseViewer = (props: CourseProps) => {
                         <div>
                             <p>{profile.fetched}</p>
                             <div className="flex justify-between items-center">
-                                <PriceTag
-                                    cost={course.cost}
-                                    freeCostCaption={FREE_COST}
-                                    currencyISOCode={
-                                        props.siteInfo.currencyISOCode as string
-                                    }
-                                />
-                                <Link href={`/checkout/${course.courseId}`}>
+                                <div className="font-medium flex items-center">
+                                    {getSymbolFromCurrency(
+                                        props.siteInfo.currencyISOCode,
+                                    )}
+                                    {amount}
+                                    <span className="text-sm text-muted-foreground ml-1">
+                                        {period}
+                                    </span>
+                                </div>
+                                <Link
+                                    href={`/checkout?type=course&id=${course.courseId}`}
+                                >
                                     <Button2>{ENROLL_BUTTON_TEXT}</Button2>
                                 </Link>
                             </div>
@@ -398,6 +425,8 @@ export function formatCourse(
         groups: post.groups as GroupWithLessons[],
         tags: post.tags,
         firstLesson: post.firstLesson,
+        paymentPlans: post.paymentPlans,
+        defaultPaymentPlan: post.defaultPaymentPlan,
     };
 }
 

apps/web/payments-new/razorpay-payment.ts

@@ -125,7 +125,11 @@ export default class RazorpayPayment implements Payment {
                     },
                     (err, plan) => {
                         if (err) {
-                            reject(new Error(err.error.description));
+                            reject(
+                                new Error(
+                                    `Error creating plan on Razorpay: ${err.error.description}`,
+                                ),
+                            );
                         }
                         this.razorpay.subscriptions.create(
                             {
@@ -169,7 +173,11 @@ export default class RazorpayPayment implements Payment {
                     },
                     (err, order) => {
                         if (err) {
-                            reject(new Error(err.error.description));
+                            reject(
+                                new Error(
+                                    `Error creating plan on Razorpay: ${err.error.description}`,
+                                ),
+                            );
                         }
                         resolve(order);
                     },

packages/common-logic/src/utils/convert-filters-to-db-conditions.ts

@@ -42,17 +42,40 @@ export async function convertFiltersToDBConditions({
             }
             dbFilters.push(emailCondition);
         }
-        if (name === "product" || name === "community") {
+        if (name === "product") {
             const productCondition: { userId: unknown } = {
                 userId: undefined,
             };
             const memberships = await membershipModel.find(
                 {
                     domain,
-                    entityType:
-                        name === "product"
-                            ? Constants.MembershipEntityType.COURSE
-                            : Constants.MembershipEntityType.COMMUNITY,
+                    entityType: Constants.MembershipEntityType.COURSE,
+                    entityId: value,
+                },
+                {
+                    userId: 1,
+                },
+            );
+            if (condition === "Has") {
+                productCondition.userId = {
+                    $in: memberships.map((m) => m.userId),
+                };
+            }
+            if (condition === "Does not have") {
+                productCondition.userId = {
+                    $not: { $in: memberships.map((m) => m.userId) },
+                };
+            }
+            dbFilters.push(productCondition);
+        }
+        if (name === "community") {
+            const productCondition: { userId: unknown } = {
+                userId: undefined,
+            };
+            const memberships = await membershipModel.find(
+                {
+                    domain,
+                    entityType: Constants.MembershipEntityType.COMMUNITY,
                     entityId: value,
                 },
                 {

services/app/Dockerfile

@@ -17,6 +17,7 @@ COPY packages/icons /app/packages/icons
 COPY packages/tailwind-config /app/packages/tailwind-config
 COPY packages/tsconfig /app/packages/tsconfig
 COPY packages/common-models /app/packages/common-models
+COPY packages/common-logic /app/packages/common-logic
 COPY packages/common-widgets /app/packages/common-widgets
 COPY packages/components-library /app/packages/components-library
 COPY packages/state-management /app/packages/state-management