refactor: switched to less for css

- Added build setup to include styles.less in building community.css
- The old styles are still in style.css. Those styles will be slowly moved to style.less.
- Move all the new styles to style.less

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/workflows/ci.yml

@@ -36,27 +36,12 @@ jobs:
     - name: setup node
       uses: actions/setup-node@v2
       with:
-        node-version: '14'
+        node-version: '12'
         check-latest: true
-    - name: setup cache for bench
-      uses: actions/cache@v2
-      with:
-        path: ~/bench-cache
-        key: ${{ runner.os }}
     - name: install bench
-      run: |
+      run: pip3 install frappe-bench
-        pip3 install frappe-bench
-        which bench
     - name: bench init
-      run: |
+      run: bench init ~/frappe-bench --skip-redis-config-generation
-        if [ -d ~/bench-cache/bench.tgz ]
-        then
-           (cd && tar xzf ~/bench-cache/bench.tgz)
-        else
-          bench init ~/frappe-bench --skip-redis-config-generation
-          mkdir -p ~/bench-cache
-          (cd && tar czf ~/bench-cache/bench.tgz frappe-bench)
-        fi
     - name: add community app to bench
       working-directory: /home/runner/frappe-bench
       run: bench get-app community $GITHUB_WORKSPACE
@@ -65,13 +50,10 @@ jobs:
       run: bench new-site --mariadb-root-password root --admin-password admin frappe.local
     - name: install community app
       working-directory: /home/runner/frappe-bench
-      run: bench --verbose --site frappe.local install-app community
+      run: bench --site frappe.local install-app community
     - name: allow tests
       working-directory: /home/runner/frappe-bench
       run: bench --site frappe.local set-config allow_tests true
-    - name: bench build
-      working-directory: /home/runner/frappe-bench
-      run: bench --site frappe.local build
     - name: run tests
       working-directory: /home/runner/frappe-bench
       run: bench --site frappe.local run-tests --app community

.gitignore

@@ -3,5 +3,4 @@
 *.egg-info
 *.swp
 tags
-community/docs/current
+community/docs/current
-community/public/dist

community/community/doctype/community_course_member/community_course_member.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2021, Frappe and contributors
+// For license information, please see license.txt
+
+frappe.ui.form.on('Community Course Member', {
+	// refresh: function(frm) {
+
+	// }
+});

community/community/doctype/community_course_member/community_course_member.json

@@ -0,0 +1,96 @@
+{
+ "actions": [],
+ "autoname": "field:user_name",
+ "creation": "2021-03-02 11:24:49.612530",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "enabled",
+  "full_name",
+  "user_name",
+  "email",
+  "short_intro",
+  "bio",
+  "photo",
+  "route"
+ ],
+ "fields": [
+  {
+   "default": "1",
+   "fieldname": "enabled",
+   "fieldtype": "Check",
+   "label": "Enabled"
+  },
+  {
+   "fieldname": "full_name",
+   "fieldtype": "Data",
+   "in_list_view": 1,
+   "label": "Full Name",
+   "reqd": 1
+  },
+  {
+   "fieldname": "user_name",
+   "fieldtype": "Data",
+   "in_list_view": 1,
+   "label": "User Name",
+   "reqd": 1,
+   "unique": 1
+  },
+  {
+   "fieldname": "email",
+   "fieldtype": "Data",
+   "label": "Email",
+   "options": "Email",
+   "reqd": 1
+  },
+  {
+   "fieldname": "short_intro",
+   "fieldtype": "Data",
+   "label": "Short Intro"
+  },
+  {
+   "fieldname": "bio",
+   "fieldtype": "Markdown Editor",
+   "label": "Bio"
+  },
+  {
+   "fieldname": "photo",
+   "fieldtype": "Attach Image",
+   "label": "Photo"
+  },
+  {
+   "fieldname": "route",
+   "fieldtype": "Data",
+   "label": "Route"
+  }
+ ],
+ "has_web_view": 1,
+ "index_web_pages_for_search": 1,
+ "is_published_field": "enabled",
+ "links": [],
+ "modified": "2021-04-06 11:50:41.551665",
+ "modified_by": "Administrator",
+ "module": "Community",
+ "name": "Community Course Member",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "System Manager",
+   "share": 1,
+   "write": 1
+  }
+ ],
+ "quick_entry": 1,
+ "route": "community-course-member",
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "track_changes": 1
+}

community/community/doctype/community_course_member/community_course_member.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2021, Frappe and contributors
+# For license information, please see license.txt
+
+from __future__ import unicode_literals
+import frappe
+import re
+from frappe.website.website_generator import WebsiteGenerator
+from frappe import _
+
+class CommunityCourseMember(WebsiteGenerator):
+
+	def get_context(self, context):
+		context.abbr = ("").join([ s[0] for s in self.full_name.split() ])
+		return context
+
+	def validate(self):
+		self.validate_user_name()
+		if not self.route:
+			self.route = self.user_name	
+	
+	def validate_user_name(self):
+		if len(self.user_name) < 4:
+			frappe.throw(_("Username must be atleast 4 characters long."))
+		if not re.match("^[A-Za-z0-9_]*$", self.user_name):
+			frappe.throw(_("Username can only contain alphabets, numbers, and underscore."))
+		self.user_name = self.user_name.lower()
+
+	def after_insert(self):
+		if frappe.db.exists("User", self.email):
+			user = frappe.get_doc("User", self.email)
+		else:
+			user, update_password_link = self.create_user()
+			self.send_email(update_password_link)
+
+	def send_email(self, update_password_link):
+
+		args = {
+			'update_password_link': update_password_link,
+			'full_name': self.full_name,
+		}
+
+		frappe.sendmail(
+			recipients=self.email,
+			sender="Administrator",
+			subject=_("Set your Password"), 
+			template="community_course_membership",
+			reference_doctype=self.doctype, 
+			reference_name=self.name,
+			send_priority=0, 
+			queue_separately=True, 
+			args=args)
+
+	def create_user(self):
+		user = 	frappe.get_doc({
+					"doctype": "User",
+					"email": self.email,
+					"first_name": self.full_name.split(" ")[0],
+					"full_name": self.full_name,
+					"username": self.user_name,
+					"send_welcome_email": 0,
+					"user_type": 'Website User',
+					"redirect_url": self.name
+				})
+		user.save(ignore_permissions=True)
+		update_password_link = user.reset_password()
+		return user, update_password_link

community/community/doctype/community_course_member/templates/community_course_member.html

@@ -0,0 +1,25 @@
+{% extends "templates/web.html" %}
+{% block page_content %}
+<div class="py-20 row">
+    {% if photo %}
+    <div class="col-sm-2 border border-dark">
+        <img src="{{ photo }}" alt="{{ full_name }}">
+    </div>
+    {% else %}
+    <div class="col-sm-2">
+        <div class="standard-image" style="font-size: 30px;">{{ abbr }}</div>
+    </div>
+    {% endif %}
+    <div class="col">
+        <h1>{{ full_name }}</h1>
+        {% if short_intro %}
+        <p class="lead"> {{ short_intro }} </p>
+        {% endif %}
+        {% if bio %}
+        <p class="markdown-style"> {{ frappe.utils.md_to_html(bio) }} </p>
+        {% endif %}
+    </div>
+</div>
+{% endblock %}
+
+<!-- this is a sample default web page template -->

community/community/doctype/community_course_member/templates/community_course_member_row.html

@@ -0,0 +1,4 @@
+<div>
+	<a href="{{ doc.route }}">{{ doc.full_name }}</a>
+</div>
+<!-- this is a sample default list template -->

community/community/doctype/community_course_member/test_community_course_member.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2021, Frappe and Contributors
+# See license.txt
+from __future__ import unicode_literals
+
+# import frappe
+import unittest
+
+class TestCommunityCourseMember(unittest.TestCase):
+	pass

community/community/doctype/community_event_volunteer/community_event_volunteer.json

@@ -13,13 +13,13 @@
    "fieldtype": "Link",
    "in_list_view": 1,
    "label": "Member",
-   "options": "User"
+   "options": "Community Member"
   }
  ],
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2021-05-21 12:15:51.286478",
+ "modified": "2021-02-15 12:03:31.153575",
  "modified_by": "Administrator",
  "module": "Community",
  "name": "Community Event Volunteer",

community/community/doctype/community_member/community_member.js

@@ -1,7 +1,7 @@
-// Copyright (c) 2021, FOSS United and contributors
+// Copyright (c) 2021, Frappe and contributors
 // For license information, please see license.txt
 
-frappe.ui.form.on('Chapter', {
+frappe.ui.form.on('Community Member', {
 	// refresh: function(frm) {
 
 	// }

community/community/doctype/community_member/community_member.json

@@ -0,0 +1,155 @@
+{
+ "actions": [],
+ "allow_guest_to_view": 1,
+ "allow_rename": 1,
+ "creation": "2021-02-12 15:47:23.591567",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "full_name",
+  "email",
+  "enabled",
+  "column_break_4",
+  "username",
+  "email_preference",
+  "section_break_7",
+  "bio",
+  "section_break_9",
+  "role",
+  "photo",
+  "column_break_12",
+  "short_intro",
+  "route",
+  "abbr"
+ ],
+ "fields": [
+  {
+   "default": "1",
+   "fieldname": "enabled",
+   "fieldtype": "Check",
+   "label": "Enabled"
+  },
+  {
+   "fieldname": "full_name",
+   "fieldtype": "Data",
+   "in_list_view": 1,
+   "in_standard_filter": 1,
+   "label": "Full Name",
+   "reqd": 1
+  },
+  {
+   "allow_in_quick_entry": 1,
+   "fieldname": "role",
+   "fieldtype": "Select",
+   "label": "Role",
+   "options": "\nBoard\nDirector\nVolunteer\nSpeaker"
+  },
+  {
+   "allow_in_quick_entry": 1,
+   "fieldname": "photo",
+   "fieldtype": "Attach Image",
+   "label": "Photo"
+  },
+  {
+   "fieldname": "short_intro",
+   "fieldtype": "Data",
+   "label": "Short Intro"
+  },
+  {
+   "allow_in_quick_entry": 1,
+   "fieldname": "bio",
+   "fieldtype": "Markdown Editor",
+   "label": "Bio"
+  },
+  {
+   "fieldname": "route",
+   "fieldtype": "Data",
+   "label": "Route"
+  },
+  {
+   "fieldname": "email",
+   "fieldtype": "Data",
+   "in_standard_filter": 1,
+   "label": "Email",
+   "options": "Email",
+   "reqd": 1,
+   "unique": 1
+  },
+  {
+   "allow_in_quick_entry": 1,
+   "fieldname": "username",
+   "fieldtype": "Data",
+   "in_list_view": 1,
+   "label": "User Name",
+   "unique": 1
+  },
+  {
+   "fieldname": "email_preference",
+   "fieldtype": "Select",
+   "label": "Email preference",
+   "options": "Email on every Message\nOne Digest Mail per day\nNever"
+  },
+  {
+   "fieldname": "column_break_4",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "section_break_7",
+   "fieldtype": "Section Break"
+  },
+  {
+   "fieldname": "section_break_9",
+   "fieldtype": "Section Break"
+  },
+  {
+   "fieldname": "column_break_12",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "abbr",
+   "fieldtype": "Data",
+   "label": "Abbr",
+   "read_only": 1
+  }
+ ],
+ "index_web_pages_for_search": 1,
+ "links": [],
+ "modified": "2021-04-28 11:22:35.402217",
+ "modified_by": "Administrator",
+ "module": "Community",
+ "name": "Community Member",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "System Manager",
+   "share": 1,
+   "write": 1
+  },
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "Website Manager",
+   "share": 1,
+   "write": 1
+  }
+ ],
+ "quick_entry": 1,
+ "search_fields": "full_name",
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "title_field": "full_name",
+ "track_changes": 1
+}

community/community/doctype/community_member/community_member.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2021, Frappe and contributors
+# For license information, please see license.txt
+
+from __future__ import unicode_literals
+import frappe
+import re
+from frappe import _
+from frappe.model.document import Document
+import random
+
+class CommunityMember(Document):
+
+	def validate(self):
+		self.validate_username()
+		self.abbr = ("").join([ s[0] for s in self.full_name.split() ])
+		if self.route != self.username:
+			self.route = self.username	
+	
+	def validate_username(self):
+		if not self.username:
+			self.username = create_username_from_email(self.email)
+
+		if self.username:
+			if len(self.username) < 4:
+				frappe.throw(_("Username must be atleast 4 characters long."))
+			if not re.match("^[A-Za-z0-9_]*$", self.username):
+				frappe.throw(_("Username can only contain alphabets, numbers and underscore."))
+			self.username = self.username.lower()
+
+	def __repr__(self):
+		return f"<CommunityMember: {self.email}>"
+
+def create_member_from_user(doc, method):
+	username = doc.username
+
+	if ( doc.username and  username_exists(doc.username)) or not doc.username:
+		username = create_username_from_email(doc.email)
+
+	elif len(doc.username) < 4:
+		username = adjust_username(doc.username)
+
+	if username_exists(username):
+		username = username + str(random.randint(0,9))
+
+	member = frappe.get_doc({
+		"doctype": "Community Member",
+		"full_name": doc.full_name,
+		"username": username,
+		"email": doc.email,
+		"route": doc.username,
+		"owner": doc.email
+	})
+	member.save(ignore_permissions=True)
+
+def username_exists(username):
+	return frappe.db.exists("Community Member", dict(username=username))
+
+def create_username_from_email(email):
+	string = email.split("@")[0]
+	return ''.join(e for e in string if e.isalnum())
+
+def adjust_username(username):
+	return username.ljust(4, str(random.randint(0,9)))

community/community/doctype/community_member/templates/community_member.html

@@ -0,0 +1,25 @@
+{% extends "templates/web.html" %}
+{% block page_content %}
+<div class="py-20 row">
+    {% if photo %}
+    <div class="col-sm-2 border border-dark">
+        <img src="{{ photo }}" alt="{{ full_name }}">
+    </div>
+    {% else %}
+    <div class="col-sm-2">
+        <div class="standard-image" style="font-size: 30px;">{{ abbr }}</div>
+    </div>
+    {% endif %}
+    <div class="col">
+        <h1>{{ full_name }}</h1>
+        {% if short_intro %}
+        <p class="lead"> {{ short_intro }} </p>
+        {% endif %}
+        {% if bio %}
+        <p class="markdown-style"> {{ frappe.utils.md_to_html(bio) }} </p>
+        {% endif %}
+    </div>
+</div>
+{% endblock %}
+
+<!-- this is a sample default web page template -->

community/community/doctype/community_member/templates/community_member_row.html

@@ -0,0 +1,4 @@
+<div>
+	<a href="{{ doc.route }}">{{ doc.title or doc.name }}</a>
+</div>
+<!-- this is a sample default list template -->

community/community/doctype/community_member/test_community_member.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2021, Frappe and Contributors
+# See license.txt
+from __future__ import unicode_literals
+from community.lms.doctype.lms_course.test_lms_course import new_user
+import frappe
+import unittest
+
+class TestCommunityMember(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(self):
+        users = ["test_user@example.com","test_user1@example.com"]
+
+        for user in users:
+            if not frappe.db.exists("User", user):
+                new_user("Test User", user)
+
+    def test_member_created_from_user(self):
+        user = frappe.db.get_value("User","test_user@example.com", ["full_name", "email", "username"], as_dict=True)
+        self.assertTrue(frappe.db.exists("Community Member", {"username":user.username}))
+
+        member = frappe.db.get_value("Community Member",
+                        filters={"email": user.email},
+                        fieldname=["full_name", "email", "owner", "username", "route"],
+                        as_dict=True
+                    )
+
+        self.assertEqual(user.full_name, member.full_name)
+        self.assertEqual(member.owner, user.email)
+        self.assertEqual(user.username, member.username)
+        self.assertEqual(member.username, member.route)
+        
+    def test_members_with_same_name(self):
+        user1 = frappe.db.get_value("User","test_user@example.com", ["email"], as_dict=True)
+        user2 = frappe.get_doc("User","test_user1@example.com", ["email"], as_dict=True)
+
+        self.assertTrue(frappe.db.exists("Community Member", {"email": user1.email} ))
+        self.assertTrue(frappe.db.exists("Community Member", {"email": user2.email }))
+
+        member1 = frappe.db.get_value("Community Member",
+                        filters={"email": user1.email},
+                        fieldname=["full_name", "email", "owner", "username", "route"],
+                        as_dict=True
+                    )
+        member2 = frappe.db.get_value("Community Member",
+                        filters={"email": user2.email},
+                        fieldname=["full_name", "email", "owner", "username", "route"],
+                        as_dict=True
+                    )
+
+        self.assertEqual(member1.full_name, member2.full_name)
+        self.assertEqual(member1.email, user1.email)
+        self.assertEqual(member2.email, user2.email)
+        self.assertNotEqual(member1.username, member2.username)
+
+    def test_username_validations(self):
+        user = new_user("Tst", "tst@example.com")
+        self.assertTrue(frappe.db.exists("Community Member", {"email":user.email} ))
+
+        member = frappe.db.get_value("Community Member",
+                        filters={"email": user.email},
+                        fieldname=["username"],
+                        as_dict=True
+                    )
+
+        self.assertEqual(len(member.username), 4)
+        frappe.delete_doc("User", user.email)
+
+    def test_user_without_username(self):
+        user = new_user("Test User", "test_user2@example.com")
+        self.assertTrue(frappe.db.exists("Community Member", {"email":user.email} ))
+
+        member = frappe.db.get_value("Community Member",
+                        filters={"email": user.email},
+                        fieldname=["username"],
+                        as_dict=True
+                    )
+
+        self.assertTrue(member.username)
+        frappe.delete_doc("User", user.email)
+
+    @classmethod
+    def tearDownClass(self):
+        users = ["test_user@example.com","test_user1@example.com"]
+
+        for user in users:
+            if frappe.db.exists("User", user):
+                frappe.delete_doc("User", user)
+
+            if frappe.db.exists("Community Member", {"email": user}):
+                frappe.delete_doc("Community Member", {"email": user})

community/community/utils.py

@@ -1 +1,16 @@
 import frappe
+
+def create_members_from_users():
+	users = frappe.get_all("User", {"enabled": 1}, ["email"])
+	for user in users:
+		if not frappe.db.get_value("Community Member", {"email": user.email}, "name"):
+			doc = frappe.get_doc("User", {"email": user.email})
+			username = doc.username if doc.username and len(doc.username) > 3 else ("").join([ s for s in doc.full_name.split() ])
+			if not frappe.db.exists("Community Member", username):
+				member = frappe.new_doc("Community Member")
+				member.full_name = doc.full_name
+				member.username = username
+				member.email = doc.email
+				member.route = username
+				member.owner = doc.email
+				member.insert(ignore_permissions=True)

community/community/web_form/update_profile/update_profile.js

@@ -0,0 +1,5 @@
+frappe.ready(function() {
+	frappe.web_form.after_save = () => {
+		window.location.href = frappe.web_form.get_value("username")
+	}
+})

community/community/web_form/update_profile/update_profile.json

@@ -0,0 +1,100 @@
+{
+ "accept_payment": 0,
+ "allow_comments": 0,
+ "allow_delete": 0,
+ "allow_edit": 1,
+ "allow_incomplete": 0,
+ "allow_multiple": 0,
+ "allow_print": 0,
+ "amount": 0.0,
+ "amount_based_on_field": 0,
+ "apply_document_permissions": 0,
+ "breadcrumbs": "",
+ "button_label": "Save",
+ "creation": "2021-03-09 17:34:03.394301",
+ "doc_type": "Community Member",
+ "docstatus": 0,
+ "doctype": "Web Form",
+ "idx": 0,
+ "is_standard": 1,
+ "login_required": 1,
+ "max_attachment_size": 0,
+ "modified": "2021-03-22 12:04:22.571655",
+ "modified_by": "Administrator",
+ "module": "Community",
+ "name": "update-profile",
+ "owner": "Administrator",
+ "payment_button_label": "Buy Now",
+ "published": 1,
+ "route": "edit-profile",
+ "route_to_success_link": 0,
+ "show_attachments": 0,
+ "show_in_grid": 0,
+ "show_sidebar": 0,
+ "sidebar_items": [],
+ "success_message": "Profile updated successfully.",
+ "success_url": "/",
+ "title": "Update Profile",
+ "web_form_fields": [
+  {
+   "allow_read_on_all_link_options": 0,
+   "fieldname": "full_name",
+   "fieldtype": "Data",
+   "hidden": 0,
+   "label": "Full Name",
+   "max_length": 0,
+   "max_value": 0,
+   "read_only": 0,
+   "reqd": 1,
+   "show_in_filter": 0
+  },
+  {
+   "allow_read_on_all_link_options": 0,
+   "fieldname": "username",
+   "fieldtype": "Data",
+   "hidden": 0,
+   "label": "User Name",
+   "max_length": 0,
+   "max_value": 0,
+   "read_only": 0,
+   "reqd": 1,
+   "show_in_filter": 0
+  },
+  {
+   "allow_read_on_all_link_options": 0,
+   "fieldname": "short_intro",
+   "fieldtype": "Data",
+   "hidden": 0,
+   "label": "Short Intro",
+   "max_length": 0,
+   "max_value": 0,
+   "read_only": 0,
+   "reqd": 0,
+   "show_in_filter": 0
+  },
+  {
+   "allow_read_on_all_link_options": 0,
+   "fieldname": "bio",
+   "fieldtype": "Data",
+   "hidden": 0,
+   "label": "Bio",
+   "max_length": 0,
+   "max_value": 0,
+   "read_only": 0,
+   "reqd": 0,
+   "show_in_filter": 0
+  },
+  {
+   "allow_read_on_all_link_options": 0,
+   "fieldname": "photo",
+   "fieldtype": "Attach Image",
+   "hidden": 0,
+   "label": "Photo",
+   "max_length": 0,
+   "max_value": 0,
+   "read_only": 0,
+   "reqd": 0,
+   "show_in_filter": 0
+  }
+ ]
+}

community/community/web_form/update_profile/update_profile.py

@@ -0,0 +1,7 @@
+from __future__ import unicode_literals
+
+import frappe
+
+def get_context(context):
+	# do your magic here
+	pass

community/community/widgets/Avatar.html

@@ -1,14 +0,0 @@
-{% set color = member.get_palette() %}
-<a href="/{{member.username}}">
-  <span class="avatar {{ avatar_class }}" title="{{ member.full_name }}">
-    {% if member.user_image %}
-    <img class="avatar-frame standard-image" style="object-fit: cover;" src="{{ member.user_image }}" title="{{ member.full_name }}">
-    </img>
-    {% else %}
-    <span class="avatar-frame standard-image" title="{{ member.full_name }}"
-      style="background-color: var({{color[0]}}); color: var({{color[1]}});">
-      {{ frappe.utils.get_abbr(member.full_name) }}
-    </span>
-    {% endif %}
-  </span>
-</a>

community/hackathon/doctype/community_hackathon/community_hackathon.json

@@ -23,7 +23,7 @@
    "fieldname": "organizer",
    "fieldtype": "Link",
    "label": "Organizer",
-   "options": "User"
+   "options": "Community Member"
   },
   {
    "fieldname": "year",
@@ -34,7 +34,7 @@
  ],
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2021-05-21 12:22:26.619776",
+ "modified": "2021-04-14 11:43:23.515972",
  "modified_by": "Administrator",
  "module": "Hackathon",
  "name": "Community Hackathon",

community/hackathon/doctype/community_project_member/community_project_member.py

@@ -3,14 +3,13 @@
 # For license information, please see license.txt
 
 from __future__ import unicode_literals
-import frappe
+# import frappe
 from frappe.model.document import Document
-from frappe import _
 
 class CommunityProjectMember(Document):
     def validate(self):
         self.validate_if_already_member()
-
+    
     def validate_if_already_member(self):
         if frappe.get_all("Community Project Member", {"owner": self.owner}):
             frappe.throw(_("You have already applied for the membership of this project."))

community/hooks.py

@@ -10,16 +10,15 @@ app_icon = "octicon octicon-file-directory"
 app_color = "grey"
 app_email = "jannat@erpnext.com"
 app_license = "AGPL"
-
 # Includes in <head>
 # ------------------
 
 # include js, css files in header of desk.html
-# app_include_css = "/assets/community/css/community.css"
+app_include_css = "/assets/community/css/community.css"
-# app_include_js = "/assets/community/js/community.js"
+app_include_js = "/assets/community/js/community.js"
 
 # include js, css files in header of web template
-web_include_css = "community.bundle.css"
+web_include_css = "/assets/css/community.css"
 # web_include_css = "/assets/community/css/community.css"
 # web_include_js = "/assets/community/js/community.js"
 
@@ -84,17 +83,22 @@ web_include_css = "community.bundle.css"
 # ---------------
 # Override standard doctype classes
 
-override_doctype_class = {
+# override_doctype_class = {
-	"User": "community.overrides.user.CustomUser"
+# 	"ToDo": "custom_app.overrides.CustomToDo"
-}
+# }
 
 # Document Events
 # ---------------
 # Hook on document methods and events
 
 doc_events = {
-
+	"User": {
-}
+		"after_insert": "community.community.doctype.community_member.community_member.create_member_from_user"
+	},
+    "LMS Message": {
+        "after_insert": "community.lms.doctype.lms_message.lms_message.publish_message"
+    }
+ }
 
 # Scheduled Tasks
 # ---------------
@@ -132,19 +136,16 @@ primary_rules = [
     {"from_route": "/sketches/<sketch>", "to_route": "sketches/sketch"},
     {"from_route": "/courses/<course>", "to_route": "courses/course"},
     {"from_route": "/courses/<course>/<topic>", "to_route": "courses/topic"},
+    {"from_route": "/hackathons", "to_route": "hackathons"},
     {"from_route": "/hackathons/<hackathon>", "to_route": "hackathons/hackathon"},
     {"from_route": "/hackathons/<hackathon>/<project>", "to_route": "hackathons/project"},
     {"from_route": "/dashboard", "to_route": ""},
     {"from_route": "/add-a-new-batch", "to_route": "add-a-new-batch"},
-    {"from_route": "/courses/<course>/home", "to_route": "batch/home"},
+    {"from_route": "/courses/<course>/<batch>/learn", "to_route": "courses/learn"},
-    {"from_route": "/courses/<course>/learn", "to_route": "batch/learn"},
+    {"from_route": "/courses/<course>/<batch>/schedule", "to_route": "courses/schedule"},
-    {"from_route": "/courses/<course>/learn/<int:chapter>.<int:lesson>", "to_route": "batch/learn"},
+    {"from_route": "/courses/<course>/<batch>/members", "to_route": "courses/members"},
-    {"from_route": "/courses/<course>/schedule", "to_route": "batch/schedule"},
+    {"from_route": "/courses/<course>/<batch>/discuss", "to_route": "courses/discuss"},
-    {"from_route": "/courses/<course>/members", "to_route": "batch/members"},
+    {"from_route": "/courses/<course>/<batch>/about", "to_route": "courses/about"}
-    {"from_route": "/courses/<course>/discuss", "to_route": "batch/discuss"},
-    {"from_route": "/courses/<course>/about", "to_route": "batch/about"},
-    {"from_route": "/courses/<course>/progress", "to_route": "batch/progress"},
-    {"from_route": "/courses/<course>/join", "to_route": "batch/join"}
 ]
 
 # Any frappe default URL is blocked by profile-rules, add it here to unblock it
@@ -161,11 +162,8 @@ whitelist = [
     "/socket.io",
     "/hackathons",
     "/dashboard",
-    "/join-request",
+    "/join-request"
-    "/add-a-new-batch",
+    "/add-a-new-batch"
-    "/new-sign-up",
-    "/message",
-    "/about"
 ]
 whitelist_rules = [{"from_route": p, "to_route": p[1:]} for p in whitelist]
 
@@ -177,19 +175,3 @@ profile_rules = [
 website_route_rules = primary_rules + whitelist_rules + profile_rules
 
 update_website_context = 'community.widgets.update_website_context'
-
-## Specify the additional tabs to be included in the user profile page.
-## Each entry must be a subclass of community.community.plugins.ProfileTab
-# profile_tabs = []
-
-## Specify the extension to be used to control what scripts and stylesheets
-## to be included in lesson pages. The specified value must be be a
-## subclass of community.community.plugins.PageExtension
-# community_lesson_page_extension = None
-
-## Markdown Macros for Lessons
-community_markdown_macro_renderers = {
-	"Exercise": "community.plugins.exercise_renderer",
-	"Quiz": "community.plugins.quiz_renderer",
-	"YouTubeVideo": "community.plugins.youtube_video_renderer",
-}

community/lms/api.py

@@ -16,32 +16,8 @@ def autosave_section(section, code):
     return {"name": doc.name}
 
 @frappe.whitelist()
-def submit_solution(exercise, code):
+def get_section(name):
-    """Submits a solution.
+    """Saves the code edited in one of the sections.
-
-    @exerecise: name of the exercise to submit
-    @code: solution to the exercise
     """
-    ex = frappe.get_doc("Exercise", exercise)
+    doc = frappe.get_doc("LMS Section", name)
-    if not ex:
+    return doc and doc.as_dict()
-        return
-    doc = ex.submit(code)
-    return {"name": doc.name, "creation": doc.creation}
-
-@frappe.whitelist()
-def save_current_lesson(course_name, lesson_name):
-    """Saves the current lesson for a student/mentor.
-    """
-    name = frappe.get_value(
-        doctype="LMS Batch Membership",
-        filters={
-            "course": course_name,
-            "member": frappe.session.user
-        },
-        fieldname="name")
-    if not name:
-        return
-    doc = frappe.get_doc("LMS Batch Membership", name)
-    doc.current_lesson = lesson_name
-    doc.save(ignore_permissions=True)
-    return {"current_lesson": doc.current_lesson}

community/lms/doctype/chapter/chapter.py

@@ -1,15 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) 2021, FOSS United and contributors
-# For license information, please see license.txt
-
-from __future__ import unicode_literals
-import frappe
-from frappe.model.document import Document
-
-class Chapter(Document):
-    def get_lessons(self):
-        rows = frappe.db.get_all("Lesson",
-            filters={"chapter": self.name},
-            fields='name',
-            order_by="index_")
-        return [frappe.get_doc('Lesson', row['name']) for row in rows]

community/lms/doctype/code_revision/code_revision.js

@@ -1,7 +1,7 @@
 // Copyright (c) 2021, FOSS United and contributors
 // For license information, please see license.txt
 
-frappe.ui.form.on('Exercise', {
+frappe.ui.form.on('Code Revision', {
 	// refresh: function(frm) {
 
 	// }

community/lms/doctype/code_revision/code_revision.json

@@ -1,39 +1,41 @@
 {
  "actions": [],
- "creation": "2021-06-07 14:19:54.958989",
+ "creation": "2021-04-07 00:26:28.806520",
  "doctype": "DocType",
  "editable_grid": 1,
  "engine": "InnoDB",
  "field_order": [
-  "quiz",
+  "section",
-  "result",
+  "code",
-  "score"
+  "author"
  ],
  "fields": [
   {
-   "fieldname": "quiz",
+   "fieldname": "section",
    "fieldtype": "Link",
-   "label": "Quiz",
+   "in_list_view": 1,
-   "options": "LMS Quiz"
+   "label": "Section",
+   "options": "LMS Section"
   },
   {
-   "fieldname": "result",
+   "fieldname": "code",
-   "fieldtype": "Table",
+   "fieldtype": "Code",
-   "label": "Result",
+   "label": "Code"
-   "options": "LMS Quiz Result"
   },
   {
-   "fieldname": "score",
+   "fieldname": "author",
-   "fieldtype": "Data",
+   "fieldtype": "Link",
-   "label": "Score"
+   "in_list_view": 1,
+   "label": "Author",
+   "options": "User"
   }
  ],
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2021-06-07 14:19:54.958989",
+ "modified": "2021-04-14 11:26:19.628317",
  "modified_by": "Administrator",
  "module": "LMS",
- "name": "LMS Quiz Submission",
+ "name": "Code Revision",
  "owner": "Administrator",
  "permissions": [
   {
@@ -51,5 +53,6 @@
  ],
  "sort_field": "modified",
  "sort_order": "DESC",
+ "title_field": "section",
  "track_changes": 1
 }

community/lms/doctype/code_revision/code_revision.py

@@ -1,8 +1,10 @@
+# -*- coding: utf-8 -*-
 # Copyright (c) 2021, FOSS United and contributors
 # For license information, please see license.txt
 
+from __future__ import unicode_literals
 # import frappe
 from frappe.model.document import Document
 
-class LMSQuizResult(Document):
+class CodeRevision(Document):
 	pass

community/lms/doctype/code_revision/test_code_revision.py

@@ -6,5 +6,5 @@ from __future__ import unicode_literals
 # import frappe
 import unittest
 
-class TestLesson(unittest.TestCase):
+class TestCodeRevision(unittest.TestCase):
 	pass

community/lms/doctype/exercise/exercise.json

@@ -1,123 +0,0 @@
-{
- "actions": [],
- "allow_rename": 1,
- "creation": "2021-05-19 17:43:39.923430",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "title",
-  "description",
-  "code",
-  "answer",
-  "column_break_4",
-  "course",
-  "hints",
-  "tests",
-  "image",
-  "lesson",
-  "index_",
-  "index_label"
- ],
- "fields": [
-  {
-   "fieldname": "title",
-   "fieldtype": "Data",
-   "in_list_view": 1,
-   "label": "Title"
-  },
-  {
-   "fieldname": "course",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Course",
-   "options": "LMS Course"
-  },
-  {
-   "columns": 4,
-   "fieldname": "description",
-   "fieldtype": "Small Text",
-   "in_list_view": 1,
-   "label": "Description"
-  },
-  {
-   "columns": 4,
-   "fieldname": "answer",
-   "fieldtype": "Code",
-   "label": "Answer"
-  },
-  {
-   "fieldname": "tests",
-   "fieldtype": "Code",
-   "label": "Tests"
-  },
-  {
-   "fieldname": "column_break_4",
-   "fieldtype": "Column Break"
-  },
-  {
-   "columns": 4,
-   "fieldname": "hints",
-   "fieldtype": "Small Text",
-   "label": "Hints"
-  },
-  {
-   "columns": 4,
-   "fieldname": "code",
-   "fieldtype": "Code",
-   "label": "Code"
-  },
-  {
-   "fieldname": "image",
-   "fieldtype": "Code",
-   "label": "Image",
-   "read_only": 1
-  },
-  {
-   "fieldname": "lesson",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Lesson",
-   "options": "Lesson"
-  },
-  {
-   "fieldname": "index_",
-   "fieldtype": "Int",
-   "label": "Index",
-   "read_only": 1
-  },
-  {
-   "fieldname": "index_label",
-   "fieldtype": "Data",
-   "in_list_view": 1,
-   "label": "Index Label",
-   "read_only": 1
-  }
- ],
- "index_web_pages_for_search": 1,
- "links": [],
- "modified": "2021-06-01 05:22:15.656013",
- "modified_by": "Administrator",
- "module": "LMS",
- "name": "Exercise",
- "owner": "Administrator",
- "permissions": [
-  {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "System Manager",
-   "share": 1,
-   "write": 1
-  }
- ],
- "search_fields": "title",
- "sort_field": "index_label",
- "sort_order": "ASC",
- "title_field": "title",
- "track_changes": 1
-}

community/lms/doctype/exercise/exercise.py

@@ -1,53 +0,0 @@
-# Copyright (c) 2021, FOSS United and contributors
-# For license information, please see license.txt
-
-import frappe
-from frappe.model.document import Document
-# from ..lms_sketch.livecode import livecode_to_svg
-
-class Exercise(Document):
-    def get_user_submission(self):
-        """Returns the latest submission for this user.
-        """
-        user = frappe.session.user
-        if not user or user == "Guest":
-            return
-
-        result = frappe.get_all('Exercise Submission',
-            fields="*",
-            filters={
-                "owner": user,
-                "exercise": self.name
-            },
-            order_by="creation desc",
-            page_length=1)
-
-        if result:
-            return result[0]
-
-    def submit(self, code):
-        """Submits the given code as solution to exercise.
-        """
-        user = frappe.session.user
-        if not user or user == "Guest":
-            return
-
-        old_submission = self.get_user_submission()
-        if old_submission and old_submission.solution == code:
-            return old_submission
-
-        course = frappe.get_doc("LMS Course", self.course)
-        batch = course.get_student_batch(user)
-
-        doc = frappe.get_doc(
-            doctype="Exercise Submission",
-            exercise=self.name,
-            exercise_title=self.title,
-            course=self.course,
-            lesson=self.lesson,
-            batch=batch and batch.name,
-            solution=code)
-        doc.insert(ignore_permissions=True)
-
-        return doc
-

community/lms/doctype/exercise/test_exercise.py

@@ -1,49 +0,0 @@
-# Copyright (c) 2021, FOSS United and Contributors
-# See license.txt
-
-import frappe
-import unittest
-
-class TestExercise(unittest.TestCase):
-    def setUp(self):
-        frappe.db.sql('delete from `tabExercise Submission`')
-        frappe.db.sql('delete from `tabExercise`')
-        frappe.db.sql('delete from `tabLMS Course`')
-
-    def new_exercise(self):
-        course = frappe.get_doc({
-            "doctype": "LMS Course",
-            "name": "test-course",
-            "title": "Test Course",
-            "short_introduction": "Test Course",
-            "description": "Test Course"
-        })
-        course.insert()
-        e = frappe.get_doc({
-            "doctype": "Exercise",
-            "name": "test-problem",
-            "course": course.name,
-            "title": "Test Problem",
-            "description": "draw a circle",
-            "code": "# draw a single cicle",
-            "answer": (
-                "# draw a single circle\n" +
-                "circle(100, 100, 50)")
-        })
-        e.insert()
-        return e
-
-    def test_exercise(self):
-        e = self.new_exercise()
-        assert e.get_user_submission() is None
-
-    def test_exercise_submission(self):
-        e = self.new_exercise()
-        submission = e.submit("circle(100, 100, 50)")
-        assert submission is not None
-        assert submission.exercise == e.name
-        assert submission.course == e.course
-
-        user_submission = e.get_user_submission()
-        assert user_submission is not None
-        assert user_submission.name == submission.name

community/lms/doctype/exercise_submission/exercise_submission.js

@@ -1,8 +0,0 @@
-// Copyright (c) 2021, FOSS United and contributors
-// For license information, please see license.txt
-
-frappe.ui.form.on('Exercise Submission', {
-	// refresh: function(frm) {
-
-	// }
-});

community/lms/doctype/exercise_submission/exercise_submission.json

@@ -1,90 +0,0 @@
-{
- "actions": [],
- "creation": "2021-05-19 11:41:18.108316",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "exercise",
-  "solution",
-  "exercise_title",
-  "course",
-  "batch",
-  "lesson",
-  "image"
- ],
- "fields": [
-  {
-   "fieldname": "exercise",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Exercise",
-   "options": "Exercise"
-  },
-  {
-   "fieldname": "solution",
-   "fieldtype": "Code",
-   "in_list_view": 1,
-   "label": "Solution"
-  },
-  {
-   "fetch_from": "exercise.title",
-   "fieldname": "exercise_title",
-   "fieldtype": "Data",
-   "in_list_view": 1,
-   "label": "Exercise Title",
-   "read_only": 1
-  },
-  {
-   "fetch_from": "exercise.course",
-   "fieldname": "course",
-   "fieldtype": "Link",
-   "label": "Course",
-   "options": "LMS Course",
-   "read_only": 1
-  },
-  {
-   "fieldname": "batch",
-   "fieldtype": "Link",
-   "label": "Batch",
-   "options": "LMS Batch"
-  },
-  {
-   "fetch_from": "exercise.lesson",
-   "fieldname": "lesson",
-   "fieldtype": "Link",
-   "label": "Lesson",
-   "options": "Lesson"
-  },
-  {
-   "fieldname": "image",
-   "fieldtype": "Code",
-   "label": "Image",
-   "read_only": 1
-  }
- ],
- "index_web_pages_for_search": 1,
- "links": [],
- "modified": "2021-05-21 11:28:45.833018",
- "modified_by": "Administrator",
- "module": "LMS",
- "name": "Exercise Submission",
- "owner": "Administrator",
- "permissions": [
-  {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "System Manager",
-   "share": 1,
-   "write": 1
-  }
- ],
- "sort_field": "modified",
- "sort_order": "DESC",
- "track_changes": 1
-}

community/lms/doctype/exercise_submission/exercise_submission.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2021, FOSS United and contributors
-# For license information, please see license.txt
-
-import frappe
-from frappe.model.document import Document
-from ..lesson.lesson import update_progress
-
-class ExerciseSubmission(Document):
-
-    def after_insert(self):
-        course_details = frappe.get_doc("LMS Course", self.course)
-        if not (course_details.is_mentor(frappe.session.user) or frappe.flags.in_test):
-            update_progress(self.lesson)

community/lms/doctype/exercise_submission/test_exercise_submission.py

@@ -1,8 +0,0 @@
-# Copyright (c) 2021, FOSS United and Contributors
-# See license.txt
-
-# import frappe
-import unittest
-
-class TestExerciseSubmission(unittest.TestCase):
-	pass

community/lms/doctype/invite_request/invite_request.js

@@ -1,8 +0,0 @@
-// Copyright (c) 2021, FOSS United and contributors
-// For license information, please see license.txt
-
-frappe.ui.form.on('Invite Request', {
-  // refresh: function(frm) {
-
-  // }
-});

community/lms/doctype/invite_request/invite_request.json

@@ -1,88 +0,0 @@
-{
- "actions": [],
- "creation": "2021-04-29 16:29:56.857914",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "invite_email",
-  "signup_email",
-  "column_break_4",
-  "status",
-  "full_name",
-  "username",
-  "invite_code"
- ],
- "fields": [
-  {
-   "allow_in_quick_entry": 1,
-   "fieldname": "invite_email",
-   "fieldtype": "Data",
-   "in_list_view": 1,
-   "label": "Invite Email",
-   "options": "Email",
-   "unique": 1
-  },
-  {
-   "fieldname": "full_name",
-   "fieldtype": "Data",
-   "label": "Full Name"
-  },
-  {
-   "fieldname": "column_break_4",
-   "fieldtype": "Column Break"
-  },
-  {
-   "fieldname": "signup_email",
-   "fieldtype": "Data",
-   "label": "Signup Email",
-   "options": "Email"
-  },
-  {
-   "fieldname": "username",
-   "fieldtype": "Data",
-   "label": "Username"
-  },
-  {
-   "fieldname": "invite_code",
-   "fieldtype": "Data",
-   "label": "Invite Code"
-  },
-  {
-   "default": "Pending",
-   "fieldname": "status",
-   "fieldtype": "Select",
-   "in_list_view": 1,
-   "in_standard_filter": 1,
-   "label": "Status",
-   "options": "Pending\nApproved\nRejected\nRegistered"
-  }
- ],
- "index_web_pages_for_search": 1,
- "links": [],
- "modified": "2021-05-03 09:22:20.954921",
- "modified_by": "Administrator",
- "module": "LMS",
- "name": "Invite Request",
- "owner": "Administrator",
- "permissions": [
-  {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "System Manager",
-   "share": 1,
-   "write": 1
-  }
- ],
- "quick_entry": 1,
- "search_fields": "invite_email, signup_email",
- "sort_field": "modified",
- "sort_order": "DESC",
- "title_field": "invite_email",
- "track_changes": 1
-}

community/lms/doctype/invite_request/invite_request.py

@@ -1,87 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) 2021, FOSS United and contributors
-# For license information, please see license.txt
-
-from __future__ import unicode_literals
-import frappe
-from frappe import _
-from frappe.model.document import Document
-import json
-from frappe.utils.password import get_decrypted_password
-
-class InviteRequest(Document):
-    def on_update(self):
-        if self.has_value_changed("status") and self.status == "Approved":
-            self.send_email()
-
-    def create_user(self, password):
-        full_name_split = self.full_name.split(" ")
-        user = 	frappe.get_doc({
-                    "doctype": "User",
-                    "email": self.signup_email,
-                    "first_name": full_name_split[0],
-                    "last_name": full_name_split[1] if len(full_name_split) > 1 else "",
-                    "username": self.username,
-                    "send_welcome_email": 0,
-                    "user_type": "Website User",
-                    "new_password": password
-                })
-        user.save(ignore_permissions=True)
-        return user
-
-    def send_email(self):
-        subject = _("Your request has been approved.")
-        args = {
-            "full_name": self.full_name,
-            "signup_form_link": "/new-sign-up?invite_code={0}".format(self.name),
-            "site_url": frappe.utils.get_url()
-        }
-        frappe.sendmail(
-            recipients=self.invite_email,
-            sender=frappe.db.get_single_value("LMS Settings", "email_sender"),
-            subject=subject,
-            header=[subject, "green"],
-            template = "lms_invite_request_approved",
-            args=args)
-
-@frappe.whitelist(allow_guest=True)
-def create_invite_request(invite_email):
-
-    if not frappe.utils.validate_email_address(invite_email):
-        return "invalid email"
-
-    if frappe.db.exists("User", invite_email):
-        return "user"
-
-    if frappe.db.exists("Invite Request", {"invite_email": invite_email}):
-        return "invite"
-
-    frappe.get_doc({
-            "doctype": "Invite Request",
-            "invite_email": invite_email,
-            "status": "Approved"
-        }).save(ignore_permissions=True)
-    return "OK"
-
-
-@frappe.whitelist(allow_guest=True)
-def update_invite(data):
-    data = frappe._dict(json.loads(data)) if type(data) == str else frappe._dict(data)
-
-    try:
-        doc = frappe.get_doc("Invite Request", data.invite_code)
-    except frappe.DoesNotExistError:
-        frappe.throw(_("Invalid Invite Code."))
-
-    doc.signup_email = data.signup_email
-    doc.username = data.username
-    doc.full_name = data.full_name
-    doc.invite_code = data.invite_code
-    doc.save(ignore_permissions=True)
-
-    user = doc.create_user(data.password)
-    if user:
-        doc.status = "Registered"
-        doc.save(ignore_permissions=True)
-
-    return "OK"

community/lms/doctype/invite_request/test_invite_request.py

@@ -1,62 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) 2021, FOSS United and Contributors
-# See license.txt
-from __future__ import unicode_literals
-from community.lms.doctype.invite_request.invite_request import create_invite_request, update_invite
-import frappe
-import unittest
-
-class TestInviteRequest(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(self):
-        create_invite_request("test_invite@example.com")
-
-    def test_create_invite_request(self):
-        if frappe.db.exists("Invite Request", {"invite_email": "test_invite@example.com"}):
-            invite = frappe.db.get_value("Invite Request",
-                        filters={"invite_email": "test_invite@example.com"},
-                        fieldname=["invite_email", "status", "signup_email"],
-                        as_dict=True)
-            self.assertEqual(invite.status, "Approved")
-            self.assertEqual(invite.signup_email, None)
-
-    def test_create_invite_request_update(self):
-        if frappe.db.exists("Invite Request", {"invite_email": "test_invite@example.com"}):
-
-            data = {
-                "signup_email": "test_invite@example.com",
-                "username": "test_invite",
-                "full_name": "Test Invite",
-                "password": "Test@invite",
-                "invite_code": frappe.db.get_value("Invite Request", {"invite_email": "test_invite@example.com"}, "name")
-            }
-
-            update_invite(data)
-            invite = frappe.db.get_value("Invite Request",
-                        filters={"invite_email": "test_invite@example.com"},
-                        fieldname=["invite_email", "status", "signup_email", "full_name", "username", "invite_code", "name"],
-                        as_dict=True)
-            self.assertEqual(invite.signup_email, "test_invite@example.com")
-            self.assertEqual(invite.full_name, "Test Invite")
-            self.assertEqual(invite.username, "test_invite")
-            self.assertEqual(invite.invite_code, invite.name)
-            self.assertEqual(invite.status, "Registered")
-
-            user = frappe.db.get_value("User", "test_invite@example.com",
-                        fieldname=["first_name", "username", "send_welcome_email", "user_type"],
-                        as_dict=True)
-            self.assertTrue(user)
-            self.assertEqual(user.first_name, invite.full_name.split(" ")[0])
-            self.assertEqual(user.username, invite.username)
-            self.assertEqual(user.send_welcome_email, 0)
-            self.assertEqual(user.user_type, "Website User")
-
-    @classmethod
-    def tearDownClass(self):
-        if frappe.db.exists("User", "test_invite@example.com"):
-            frappe.delete_doc("User", "test_invite@example.com")
-
-        invite_request = frappe.db.exists("Invite Request", {"invite_email": "test_invite@example.com"})
-        if invite_request:
-            frappe.delete_doc("Invite Request", invite_request)

community/lms/doctype/lesson/lesson.json

@@ -1,89 +0,0 @@
-{
- "actions": [],
- "autoname": "format:{####} {title}",
- "creation": "2021-05-03 06:21:12.995987",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "chapter",
-  "include_in_preview",
-  "column_break_4",
-  "title",
-  "index_",
-  "index_label",
-  "section_break_6",
-  "body"
- ],
- "fields": [
-  {
-   "fieldname": "chapter",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Chapter",
-   "options": "Chapter"
-  },
-  {
-   "fieldname": "title",
-   "fieldtype": "Data",
-   "in_list_view": 1,
-   "label": "Title"
-  },
-  {
-   "default": "1",
-   "fieldname": "index_",
-   "fieldtype": "Int",
-   "in_list_view": 1,
-   "label": "Index"
-  },
-  {
-   "fieldname": "body",
-   "fieldtype": "Markdown Editor",
-   "label": "Body"
-  },
-  {
-   "fieldname": "index_label",
-   "fieldtype": "Data",
-   "label": "Index Label",
-   "read_only": 1
-  },
-  {
-   "default": "0",
-   "fieldname": "include_in_preview",
-   "fieldtype": "Check",
-   "label": "Include In Preview"
-  },
-  {
-   "fieldname": "section_break_6",
-   "fieldtype": "Section Break"
-  },
-  {
-   "fieldname": "column_break_4",
-   "fieldtype": "Column Break"
-  }
- ],
- "index_web_pages_for_search": 1,
- "links": [],
- "modified": "2021-06-23 17:59:52.946515",
- "modified_by": "Administrator",
- "module": "LMS",
- "name": "Lesson",
- "owner": "Administrator",
- "permissions": [
-  {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "System Manager",
-   "share": 1,
-   "write": 1
-  }
- ],
- "sort_field": "modified",
- "sort_order": "DESC",
- "track_changes": 1
-}

community/lms/doctype/lesson/lesson.py

@@ -1,129 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) 2021, FOSS United and contributors
-# For license information, please see license.txt
-
-from __future__ import unicode_literals
-import frappe
-from frappe.model.document import Document
-from ...md import markdown_to_html, find_macros
-
-class Lesson(Document):
-    def before_save(self):
-        dynamic_documents = ["Exercise", "Quiz"]
-        for section in dynamic_documents:
-            self.update_lesson_name_in_document(section)
-
-    def update_lesson_name_in_document(self, section):
-        doctype_map= {
-            "Exercise": "Exercise",
-            "Quiz": "LMS Quiz"
-        }
-        macros = find_macros(self.body)
-        documents = [value for name, value in macros if name == section]
-        index = 1
-        for name in documents:
-            e = frappe.get_doc(doctype_map[section], name)
-            e.lesson = self.name
-            e.index_ = index
-            e.save()
-            index += 1
-        self.update_orphan_documents(doctype_map[section], documents)
-
-    def update_orphan_documents(self, doctype, documents):
-        """Updates the documents that were previously part of this lesson,
-        but not any more.
-        """
-        linked_documents = {row['name'] for row in frappe.get_all(doctype, {"lesson": self.name})}
-        active_documents = set(documents)
-        orphan_documents = linked_documents - active_documents
-        for name in orphan_documents:
-            ex = frappe.get_doc(doctype, name)
-            ex.lesson = None
-            ex.index_ = 0
-            ex.index_label = ""
-            ex.save()
-
-    def render_html(self):
-        return markdown_to_html(self.body)
-
-    def get_exercises(self):
-        if not self.body:
-            return []
-
-        macros = find_macros(self.body)
-        exercises = [value for name, value in macros if name == "Exercise"]
-        return [frappe.get_doc("Exercise", name) for name in exercises]
-
-    def get_progress(self):
-        return frappe.db.get_value("LMS Course Progress", {"lesson": self.name, "owner": frappe.session.user}, "status")
-
-    def get_slugified_class(self):
-        if self.get_progress():
-            return ("").join([ s for s in self.get_progress().lower().split() ])
-        return
-
-@frappe.whitelist()
-def save_progress(lesson, course):
-    if not frappe.db.exists("LMS Batch Membership",
-            {
-                "member": frappe.session.user,
-                "course": course
-            }):
-        return
-    if frappe.db.exists("LMS Course Progress",
-            {
-                "lesson": lesson,
-                "owner": frappe.session.user
-            }):
-        return
-
-    lesson_details = frappe.get_doc("Lesson", lesson)
-    dynamic_content = find_macros(lesson_details.body)
-
-    status = "Complete"
-    if dynamic_content:
-        status = "Partially Complete"
-
-    frappe.get_doc({
-        "doctype": "LMS Course Progress",
-        "lesson": lesson_details.name,
-        "status": status
-    }).save(ignore_permissions=True)
-
-def update_progress(lesson):
-    user = frappe.session.user
-    if not all_dynamic_content_submitted(lesson, user):
-        return
-    if frappe.db.exists("LMS Course Progress", {"lesson": lesson, "owner": user}):
-        course_progress = frappe.get_doc("LMS Course Progress", {"lesson": lesson, "owner": user})
-        course_progress.status = "Complete"
-        course_progress.save(ignore_permissions=True)
-
-def all_dynamic_content_submitted(lesson, user):
-    all_exercises_submitted = check_all_exercise_submission(lesson, user)
-    all_quiz_submitted = check_all_quiz_submitted(lesson, user)
-    return all_exercises_submitted and all_quiz_submitted
-
-def check_all_exercise_submission(lesson, user):
-    exercise_names = frappe.get_list("Exercise", {"lesson": lesson}, pluck="name", ignore_permissions=True)
-    if not len(exercise_names):
-        return True
-    query = {
-        "exercise": ["in", exercise_names],
-        "owner": user
-    }
-    if frappe.db.count("Exercise Submission", query) == len(exercise_names):
-        return True
-    return False
-
-def check_all_quiz_submitted(lesson, user):
-    quizzes = frappe.get_list("LMS Quiz", {"lesson": lesson}, pluck="name", ignore_permissions=True)
-    if not len(quizzes):
-        return True
-    query = {
-        "quiz": ["in", quizzes],
-        "owner": user
-    }
-    if frappe.db.count("LMS Quiz Submission", query) == len(quizzes):
-        return True
-    return False

community/lms/doctype/lms_batch/lms_batch.json

@@ -1,15 +1,17 @@
 {
  "actions": [],
+ "autoname": "field:title",
  "creation": "2021-03-18 19:37:34.614796",
  "doctype": "DocType",
  "editable_grid": 1,
  "engine": "InnoDB",
  "field_order": [
   "course",
+  "title",
   "start_date",
   "start_time",
   "column_break_3",
-  "title",
+  "code",
   "sessions_on",
   "end_time",
   "section_break_5",
@@ -25,15 +27,21 @@
   {
    "fieldname": "course",
    "fieldtype": "Link",
-   "in_list_view": 1,
-   "in_standard_filter": 1,
    "label": "Course",
    "options": "LMS Course"
   },
+  {
+   "fieldname": "code",
+   "fieldtype": "Data",
+   "label": "Code",
+   "read_only": 1,
+   "unique": 1
+  },
   {
    "fieldname": "title",
    "fieldtype": "Data",
-   "label": "Title"
+   "label": "Title",
+   "unique": 1
   },
   {
    "fieldname": "description",
@@ -41,12 +49,10 @@
    "label": "Description"
   },
   {
-   "default": "Public",
    "fieldname": "visibility",
    "fieldtype": "Select",
-   "in_list_view": 1,
    "label": "Visibility",
-   "options": "Public\nUnlisted\nPrivate"
+   "options": "\nPublic\nUnlisted\nPrivate"
   },
   {
    "fieldname": "membership",
@@ -55,19 +61,16 @@
    "options": "\nOpen\nRestricted\nInvite Only\nClosed"
   },
   {
-   "default": "Active",
    "fieldname": "status",
    "fieldtype": "Select",
-   "in_list_view": 1,
    "label": "Status",
-   "options": "Active\nInactive"
+   "options": "\nActive\nInactive"
   },
   {
-   "default": "Ready",
    "fieldname": "stage",
    "fieldtype": "Select",
    "label": "Stage",
-   "options": "Ready\nIn Progress\nCompleted\nCancelled"
+   "options": "\nReady\nIn Progress\nCompleted\nCancelled"
   },
   {
    "fieldname": "column_break_3",
@@ -75,8 +78,7 @@
   },
   {
    "fieldname": "section_break_5",
-   "fieldtype": "Section Break",
+   "fieldtype": "Section Break"
-   "label": "Batch Description"
   },
   {
    "fieldname": "column_break_9",
@@ -84,19 +86,16 @@
   },
   {
    "fieldname": "section_break_7",
-   "fieldtype": "Section Break",
+   "fieldtype": "Section Break"
-   "label": "Batch Settings"
   },
   {
    "fieldname": "start_date",
    "fieldtype": "Date",
-   "in_list_view": 1,
    "label": "Start Date"
   },
   {
    "fieldname": "start_time",
    "fieldtype": "Time",
-   "in_list_view": 1,
    "label": "Start Time"
   },
   {
@@ -107,7 +106,6 @@
   {
    "fieldname": "end_time",
    "fieldtype": "Time",
-   "in_list_view": 1,
    "label": "End Time"
   }
  ],
@@ -119,7 +117,7 @@
    "link_fieldname": "batch"
   }
  ],
- "modified": "2021-06-16 10:51:05.403726",
+ "modified": "2021-04-21 12:45:21.144972",
  "modified_by": "Administrator",
  "module": "LMS",
  "name": "LMS Batch",

community/lms/doctype/lms_batch/lms_batch.py

@@ -5,69 +5,35 @@
 from __future__ import unicode_literals
 import frappe
 from frappe.model.document import Document
-from frappe import _
+from community.www.courses.utils import get_member_with_email
-from community.lms.doctype.lms_batch_membership.lms_batch_membership import create_membership
-from community.query import find, find_all
 
 class LMSBatch(Document):
-    def validate(self):
+	def validate(self):
-        self.validate_if_mentor()
+		if not self.code:
+			self.generate_code()
 
-    def validate_if_mentor(self):
+	def generate_code(self):
-        course = frappe.get_doc("LMS Course", self.course)
+		short_code = frappe.db.get_value("LMS Course", self.course, "short_code")
-        if not course.is_mentor(frappe.session.user):
+		course_batches = frappe.get_all("LMS Batch",{"course":self.course})
-           frappe.throw(_("You are not a mentor of the course {0}").format(course.title))
+		self.code = short_code + str(len(course_batches) + 1)
 
-    def after_insert(self):
+@frappe.whitelist()
-        create_membership(batch=self.name, course=self.course, member_type="Mentor")
+def get_messages(batch):
-
+    messages =  frappe.get_all("LMS Message", {"batch": batch}, ["*"], order_by="creation")
-    def is_member(self, email, member_type=None):
+    for message in messages:
-        """Checks if a person is part of a batch.
+        message.message = frappe.utils.md_to_html(message.message)
-
+        member_email = frappe.db.get_value("Community Member", message.author, ["email"])
-        If member_type is specified, checks if the person is a Student/Mentor.
+        if member_email == frappe.session.user:
-        """
+            message.author_name = "You"
-
+            message.is_author = True
-        filters = {
+    return messages
-            "batch": self.name,
-            "member": email
-        }
-        if member_type:
-            filters['member_type'] = member_type
-        return frappe.db.exists("LMS Batch Membership", filters)
-
-    def get_messages(self):
-        messages =  frappe.get_all("LMS Message", {"batch": self.name}, ["*"], order_by="creation")
-        for message in messages:
-            message.message = frappe.utils.md_to_html(message.message)
-            if message.author == frappe.session.user:
-                message.author_name = "You"
-                message.is_author = True
-        return messages
-
-    def get_membership(self, email):
-        """Returns the membership document of given user.
-        """
-        name = frappe.get_value(
-            doctype="LMS Batch Membership",
-            filters={
-                "batch": self.name,
-                "member": email
-            },
-            fieldname="name")
-        return frappe.get_doc("LMS Batch Membership", name)
-
-    def get_current_lesson(self, user):
-        """Returns the name of the current lesson for the given user.
-        """
-        membership = self.get_membership(user)
-        return membership and membership.current_lesson
 
 @frappe.whitelist()
 def save_message(message, batch):
     doc = frappe.get_doc({
         "doctype": "LMS Message",
         "batch": batch,
-        "author": frappe.session.user,
+        "author": get_member_with_email(),
         "message": message
     })
-    doc.save(ignore_permissions=True)
+    doc.save(ignore_permissions=True)

community/lms/doctype/lms_batch_membership/lms_batch_membership.js

@@ -2,13 +2,7 @@
 // For license information, please see license.txt
 
 frappe.ui.form.on('LMS Batch Membership', {
-	onload: function(frm) {
+	// refresh: function(frm) {
-		frm.set_query('member', function(doc) {
+
-			return {
+	// }
-				filters: {
-					"ignore_user_type": 1,
-				}
-			};
-		});
-	},
 });

community/lms/doctype/lms_batch_membership/lms_batch_membership.json

@@ -6,14 +6,11 @@
  "engine": "InnoDB",
  "field_order": [
   "batch",
+  "role",
+  "column_break_3",
   "member",
   "member_name",
-  "member_username",
+  "member_type"
-  "column_break_3",
-  "course",
-  "member_type",
-  "role",
-  "current_lesson"
  ],
  "fields": [
   {
@@ -30,10 +27,9 @@
    "in_list_view": 1,
    "in_standard_filter": 1,
    "label": "Member",
-   "options": "User"
+   "options": "Community Member"
   },
   {
-   "default": "Student",
    "fieldname": "member_type",
    "fieldtype": "Select",
    "in_list_view": 1,
@@ -41,7 +37,6 @@
    "options": "\nStudent\nMentor\nStaff"
   },
   {
-   "default": "Member",
    "fieldname": "role",
    "fieldtype": "Select",
    "in_standard_filter": 1,
@@ -59,32 +54,11 @@
   {
    "fieldname": "column_break_3",
    "fieldtype": "Column Break"
-  },
-  {
-   "fetch_from": "batch.course",
-   "fieldname": "course",
-   "fieldtype": "Data",
-   "in_list_view": 1,
-   "label": "Course",
-   "read_only": 1
-  },
-  {
-   "fieldname": "current_lesson",
-   "fieldtype": "Link",
-   "label": "Current Lesson",
-   "options": "Lesson"
-  },
-  {
-   "fetch_from": "member.username",
-   "fieldname": "member_username",
-   "fieldtype": "Data",
-   "label": "Memeber Username",
-   "read_only": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2021-06-21 12:10:28.808803",
+ "modified": "2021-04-26 12:52:59.826509",
  "modified_by": "Administrator",
  "module": "LMS",
  "name": "LMS Batch Membership",

community/lms/doctype/lms_batch_membership/lms_batch_membership.py

@@ -8,71 +8,35 @@ from frappe.model.document import Document
 from frappe import _
 
 class LMSBatchMembership(Document):
+	
+	def validate(self):
+		self.validate_membership_in_same_batch()
+		self.validate_membership_in_different_batch_same_course()
+	
+	def validate_membership_in_same_batch(self):
+		previous_membership = frappe.db.get_value("LMS Batch Membership", {"member": self.member, "batch": self.batch}, ["member_type","member"], as_dict=1)
+		if previous_membership:
+			member_name = frappe.db.get_value("Community Member", self.member, "full_name")
+			frappe.throw(_("{0} is already a {1} of {2}").format(member_name, previous_membership.member_type, self.batch))
 
-    def validate(self):
+	def validate_membership_in_different_batch_same_course(self):
-        self.validate_membership_in_same_batch()
+		course = frappe.db.get_value("LMS Batch", self.batch, "course")
-        self.validate_membership_in_different_batch_same_course()
+		previous_membership = frappe.get_all("LMS Batch Membership", {"member": self.member}, ["batch", "member_type"])
-
+		for membership in previous_membership:
-    def validate_membership_in_same_batch(self):
+			batch_course = frappe.db.get_value("LMS Batch", membership.batch, "course")
-        filters={
+			if batch_course == course and (membership.member_type == "Student" or self.member_type == "Student"):
-            "member": self.member,
+				member_name = frappe.db.get_value("Community Member", self.member, "full_name")
-            "course": self.course,
+				frappe.throw(_("{0} is already a {1} of {2} course through {3} batch").format(member_name, membership.member_type, course, membership.batch))
-            "name": ["!=", self.name]
-        }
-        if self.batch:
-            filters["batch"] = self.batch
-        previous_membership = frappe.db.get_value("LMS Batch Membership",
-            filters,
-            fieldname=["member_type","member"],
-            as_dict=1)
-
-        if previous_membership:
-            member_name = frappe.db.get_value("User", self.member, "full_name")
-            course_title = frappe.db.get_value("LMS Course", self.course, "title")
-            frappe.throw(_("{0} is already a {1} of the course {2}").format(member_name, previous_membership.member_type, course_title))
-
-    def validate_membership_in_different_batch_same_course(self):
-        """Ensures that a studnet is only part of one batch.
-        """
-        # nothing to worry if the member is not a student
-        if self.member_type != "Student":
-            return
-
-        course = frappe.db.get_value("LMS Batch", self.batch, "course")
-        memberships = frappe.get_all(
-            "LMS Batch Membership",
-            filters={
-                "member": self.member,
-                "name": ["!=", self.name],
-                "member_type": "Student",
-                "course": self.course
-            },
-            fields=["batch", "member_type", "name"]
-        )
-
-        if memberships:
-            membership = memberships[0]
-            member_name = frappe.db.get_value("User", self.member, "full_name")
-            frappe.throw(_("{0} is already a Student of {1} course through {2} batch").format(member_name, course, membership.batch))
 
 @frappe.whitelist()
-def create_membership(course, batch=None, member=None, member_type="Student", role="Member"):
+def create_membership(batch, member=None, member_type="Student", role="Member"):
-    frappe.get_doc({
+	if not member:
-        "doctype": "LMS Batch Membership",
+		member = frappe.db.get_value("Community Member", {"email": frappe.session.user}, "name")
-        "batch": batch,
+	frappe.get_doc({
-        "course": course,
+		"doctype": "LMS Batch Membership",
-        "role": role,
+		"batch": batch,
-        "member_type": member_type,
+		"role": role,
-        "member": member or frappe.session.user
+		"member_type": member_type,
-    }).save(ignore_permissions=True)
+		"member": member
-    return "OK"
+	}).save(ignore_permissions=True)
-
+	return "OK"
-@frappe.whitelist()
-def update_current_membership(batch, course, member):
-    all_memberships = frappe.get_all("LMS Batch Membership", {"member": member, "course": course})
-    for membership in all_memberships:
-        frappe.db.set_value("LMS Batch Membership", membership.name, "is_current", 0)
-
-    current_membership = frappe.get_all("LMS Batch Membership", {"batch": batch, "member": member})
-    if len(current_membership):
-        frappe.db.set_value("LMS Batch Membership", current_membership[0].name, "is_current", 1)

community/lms/doctype/lms_batch_membership/test_lms_batch_membership.py

@@ -3,78 +3,8 @@
 # See license.txt
 from __future__ import unicode_literals
 
-import frappe
+# import frappe
 import unittest
 
 class TestLMSBatchMembership(unittest.TestCase):
-    def setUp(self):
+	pass
-        frappe.db.sql("DELETE FROM `tabLMS Batch Membership`")
-        frappe.db.sql("DELETE FROM `tabLMS Batch`")
-        frappe.db.sql('delete from `tabLMS Course Mentor Mapping`')
-        frappe.db.sql("DELETE FROM `tabLMS Course`")
-        frappe.db.sql("DELETE FROM `tabUser` where email like '%@test.com'")
-
-    def new_course_batch(self):
-        course = frappe.get_doc({
-            "doctype": "LMS Course",
-            "name": "test-course",
-            "title": "Test Course",
-            "short_code": "XX",
-            "short_introduction": "Test Course",
-            "description": "Test Course"
-        })
-        course.insert()
-
-        self.new_user("mentor@test.com", "Test Mentor")
-        # without this, the creating batch will fail
-        course.add_mentor("mentor@test.com")
-
-        frappe.session.user = "mentor@test.com"
-
-        batch = frappe.get_doc({
-            "doctype": "LMS Batch",
-            "name": "test-batch",
-            "title": "Test Batch",
-            "course": course.name
-        })
-        batch.insert(ignore_permissions=True)
-
-        frappe.session.user = "Administrator"
-        return course, batch
-
-    def new_user(self, email="test@test.com", full_name="Test User"):
-        user = frappe.get_doc({
-            "doctype": "User",
-            "name": email,
-            "email": email,
-            "first_name": full_name,
-        })
-        user.insert()
-        return user
-
-    def add_membership(self, batch_name, member_name, member_type="Student"):
-        doc = frappe.get_doc({
-            "doctype": "LMS Batch Membership",
-            "batch": batch_name,
-            "member": member_name,
-            "member_type": member_type
-        })
-        doc.insert()
-        return doc
-
-    def test_membership(self):
-        course, batch = self.new_course_batch()
-        member = self.new_user("test01@test.com")
-        membership = self.add_membership(batch.name, member.name)
-
-        assert membership.course == course.name
-        assert membership.member_name == member.full_name
-
-    def test_membership_change_role(self):
-        course, batch = self.new_course_batch()
-        member = self.new_user("test01@test.com")
-        membership = self.add_membership(batch.name, member.name)
-
-        # it should be possible to change role
-        membership.role = "Admin"
-        membership.save()

community/lms/doctype/lms_course/lms_course.json

@@ -1,28 +1,16 @@
 {
- "actions": [
+ "actions": [],
-  {
-   "action": "community.lms.doctype.lms_course.lms_course.reindex_lessons",
-   "action_type": "Server Action",
-   "group": "Reindex",
-   "label": "Reindex Lessons"
-  },
-  {
-   "action": "community.lms.doctype.lms_course.lms_course.reindex_exercises",
-   "action_type": "Server Action",
-   "group": "Reindex",
-   "label": "Reindex Exercises"
-  }
- ],
  "allow_guest_to_view": 1,
  "allow_rename": 1,
+ "autoname": "field:title",
  "creation": "2021-03-01 16:49:33.622422",
  "doctype": "DocType",
  "editable_grid": 1,
  "engine": "InnoDB",
  "field_order": [
   "title",
+  "slug",
   "is_published",
-  "disable_self_learning",
   "column_break_3",
   "short_code",
   "video_link",
@@ -42,8 +30,7 @@
   {
    "fieldname": "description",
    "fieldtype": "Markdown Editor",
-   "label": "Description",
+   "label": "Description"
-   "reqd": 1
   },
   {
    "default": "0",
@@ -56,6 +43,14 @@
    "fieldtype": "Data",
    "label": "Short Code"
   },
+  {
+   "description": "The slug of the course. Autogenerated from the title if not specified.",
+   "fieldname": "slug",
+   "fieldtype": "Data",
+   "in_list_view": 1,
+   "label": "Slug",
+   "unique": 1
+  },
   {
    "fieldname": "column_break_3",
    "fieldtype": "Column Break"
@@ -72,22 +67,15 @@
   {
    "fieldname": "short_introduction",
    "fieldtype": "Small Text",
-   "label": "Short Introduction",
+   "label": "Short Introduction"
-   "reqd": 1
-  },
-  {
-   "default": "0",
-   "fieldname": "disable_self_learning",
-   "fieldtype": "Check",
-   "label": "Disable Self Learning"
   }
  ],
  "index_web_pages_for_search": 1,
  "is_published_field": "is_published",
  "links": [
   {
-   "group": "Chapters",
+   "group": "Topics",
-   "link_doctype": "Chapter",
+   "link_doctype": "LMS Topic",
    "link_fieldname": "course"
   },
   {
@@ -99,14 +87,9 @@
    "group": "Mentors",
    "link_doctype": "LMS Course Mentor Mapping",
    "link_fieldname": "course"
-  },
-  {
-   "group": "Mentors",
-   "link_doctype": "LMS Mentor Request",
-   "link_fieldname": "course"
   }
  ],
- "modified": "2021-06-21 11:34:04.552376",
+ "modified": "2021-04-21 14:45:41.658056",
  "modified_by": "Administrator",
  "module": "LMS",
  "name": "LMS Course",
@@ -125,7 +108,7 @@
    "write": 1
   }
  ],
- "search_fields": "title",
+ "search_fields": "slug",
  "sort_field": "creation",
  "sort_order": "DESC",
  "title_field": "title",

community/lms/doctype/lms_course/lms_course.py

@@ -5,37 +5,33 @@
 from __future__ import unicode_literals
 import frappe
 from frappe.model.document import Document
-import json
 from ...utils import slugify
-from community.query import find, find_all
-from frappe.utils import flt
 
 class LMSCourse(Document):
-    @staticmethod
+    def before_save(self):
-    def find(name):
+        if not self.slug:
-        """Returns the course with specified name.
+            self.slug = self.generate_slug(title=self.title)
-        """
-        return find("LMS Course", is_published=True, name=name)
-
-    def autoname(self):
-        if not self.name:
-            self.name = self.generate_slug(title=self.title)
-
-    @staticmethod
-    def find_all():
-        """Returns all published courses.
-        """
-        return find_all("LMS Course", is_published=True)
 
     def generate_slug(self, title):
         result = frappe.get_all(
             'LMS Course',
-            fields=['name'])
+            fields=['slug'])
-        slugs = set([row['name'] for row in result])
+        slugs = set([row['slug'] for row in result])
         return slugify(title, used_slugs=slugs)
 
     def __repr__(self):
-        return f"<Course#{self.name}>"
+        return f"<Course#{self.name} {self.slug}>"
+
+    def get_topic(self, slug):
+        """Returns the topic with given slug in this course as a Document.
+        """
+        result = frappe.get_all(
+            "LMS Topic",
+            filters={"course": self.name, "slug": slug})
+
+        if result:
+            row = result[0]
+            return frappe.get_doc('LMS Topic', row['name'])
 
     def has_mentor(self, email):
         """Checks if this course has a mentor with given email.
@@ -43,9 +39,21 @@ class LMSCourse(Document):
         if not email or email == "Guest":
             return False
 
-        mapping = frappe.get_all("LMS Course Mentor Mapping", {"course": self.name, "mentor": email})
+        member = self.get_community_member(email)
+        if not member:
+            return False
+
+        mapping = frappe.get_all("LMS Course Mentor Mapping", {"course": self.name, "mentor": member})
         return mapping != []
 
+    def get_community_member(self, email):
+        """Returns the name of Community Member document for a give user.
+        """
+        try:
+            return frappe.db.get_value("Community Member", {"email": email}, ["name"])
+        except frappe.DoesNotExistError:
+            return None
+
     def add_mentor(self, email):
         """Adds a new mentor to the course.
         """
@@ -58,10 +66,14 @@ class LMSCourse(Document):
         if self.has_mentor(email):
             return
 
+        member = self.get_community_member(email)
+        if not member:
+            return False
+
         doc = frappe.get_doc({
             "doctype": "LMS Course Mentor Mapping",
             "course": self.name,
-            "mentor": email
+            "mentor": member
         })
         doc.insert()
 
@@ -71,232 +83,20 @@ class LMSCourse(Document):
         course_mentors = []
         mentors = frappe.get_all("LMS Course Mentor Mapping", {"course": self.name}, ["mentor"])
         for mentor in mentors:
-            member = frappe.get_doc("User", mentor.mentor)
+            member = frappe.get_doc("Community Member", mentor.mentor)
             # TODO: change this to count query
             member.batch_count = len(frappe.get_all("LMS Batch Membership", {"member": member.name, "member_type": "Mentor"}))
             course_mentors.append(member)
         return course_mentors
 
-    def is_mentor(self, email):
-        """Checks if given user is a mentor for this course.
-        """
-        if not email:
-            return False
-        return frappe.db.count("LMS Course Mentor Mapping",
-            {
-                "course": self.name,
-                "mentor": email
-            })
-
-    def get_student_batch(self, email):
-        """Returns the batch the given student is part of.
-
-        Returns None if the student is not part of any batch.
-        """
-        if not email:
-            return
-
-        batch_name = frappe.get_value(
-            doctype="LMS Batch Membership",
-            filters={
-                "course": self.name,
-                "member_type": "Student",
-                "member": email
-            },
-            fieldname="batch")
-        return batch_name and frappe.get_doc("LMS Batch", batch_name)
-
     def get_instructor(self):
         return frappe.get_doc("User", self.owner)
 
-    def get_chapters(self):
+    @staticmethod
-        """Returns all chapters of this course.
+    def find_all():
+        """Returns all published courses.
         """
-        # TODO: chapters should have a way to specify the order
+        rows = frappe.db.get_all("LMS Course",
-        return find_all("Chapter", course=self.name, order_by="index_")
+            filters={"is_published": True},
-
+            fields='*')
-    def get_batch(self, batch_name):
+        return [frappe.get_doc(dict(row, doctype='LMS Course')) for row in rows]
-        return find("LMS Batch", name=batch_name, course=self.name)
-
-    def get_batches(self, mentor=None):
-        batches = find_all("LMS Batch", course=self.name)
-        if mentor:
-            # TODO: optimize this
-            memberships = frappe.db.get_all(
-                "LMS Batch Membership",
-                {"member": mentor},
-                ["batch"])
-            batch_names = {m.batch for m in memberships}
-            return [b for b in batches if b.name in batch_names]
-
-    def get_upcoming_batches(self):
-        now = frappe.utils.nowdate()
-        batches =  find_all("LMS Batch",
-            course=self.name,
-            start_date=[">", now],
-            status="Active",
-            visibility="Public")
-        return batches
-
-    def get_chapter(self, index):
-        return find("Chapter", course=self.name, index_=index)
-
-    def get_lesson(self, chapter_index, lesson_index):
-        chapter_name = frappe.get_value(
-            "Chapter",
-            {"course": self.name, "index_": chapter_index},
-            "name")
-        lesson_name = chapter_name and frappe.get_value(
-            "Lesson",
-            {"chapter": chapter_name, "index_": lesson_index},
-            "name")
-        return lesson_name and frappe.get_doc("Lesson", lesson_name)
-
-    def get_lesson_index(self, lesson_name):
-        """Returns the {chapter_index}.{lesson_index} for the lesson.
-        """
-        lesson = frappe.get_doc("Lesson", lesson_name)
-        chapter = frappe.get_doc("Chapter", lesson.chapter)
-        return f"{chapter.index_}.{lesson.index_}"
-
-    def reindex_lessons(self):
-        for i, c in enumerate(self.get_chapters(), start=1):
-            c.index_ = i
-            c.save()
-            self._reindex_lessons_in_chapter(c)
-
-    def _reindex_lessons_in_chapter(self, c):
-        for i, lesson in enumerate(c.get_lessons(), start=1):
-            lesson.index = i
-            lesson.index_label = f"{c.index_}.{i}"
-            lesson.save()
-
-    def reindex_exercises(self):
-        for i, c in enumerate(self.get_chapters(), start=1):
-            if c.index_ != i:
-                c.index_ = i
-                c.save()
-            self._reindex_exercises_in_chapter(c)
-
-    def _reindex_exercises_in_chapter(self, c):
-        i = 1
-        for lesson in c.get_lessons():
-            for exercise in lesson.get_exercises():
-                exercise.index_ = i
-                exercise.index_label = f"{c.index_}.{i}"
-                exercise.save()
-                i += 1
-
-    def get_learn_url(self, lesson_number):
-        if not lesson_number:
-            return
-        return f"/courses/{self.name}/learn/{lesson_number}"
-
-    def get_membership(self, member, batch=None):
-        filters = {
-            "member": member,
-            "course": self.name
-        }
-        if batch:
-            filters["batch"] = batch
-        membership = frappe.db.get_value("LMS Batch Membership", filters, ["name","batch", "current_lesson"], as_dict=True)
-        if membership and membership.batch:
-            membership.batch_title = frappe.db.get_value("LMS Batch", membership.batch, "title")
-        return membership
-
-    def get_all_memberships(self, member):
-        all_memberships = frappe.get_all("LMS Batch Membership", {"member": member, "course": self.name}, ["batch"])
-        for membership in all_memberships:
-            membership.batch_title = frappe.db.get_value("LMS Batch", membership.batch, "title")
-        return all_memberships
-
-    def get_mentors(self, batch=None):
-        filters = {
-            "course": self.name,
-            "member_type": "Mentor"
-        }
-        if batch:
-            filters["batch"] = batch
-
-        memberships = frappe.get_all(
-                    "LMS Batch Membership",
-                    filters,
-                    ["member"])
-        member_names = [m['member'] for m in memberships]
-        return find_all("User", name=["IN", member_names])
-
-    def get_students(self, batch=None):
-        """Returns (email, full_name, username) of all the students of this batch as a list of dict.
-        """
-        filters = {
-            "course": self.name,
-            "member_type": "Student"
-        }
-        if batch:
-            filters["batch"] = batch
-        memberships = frappe.get_all(
-                    "LMS Batch Membership",
-                    filters,
-                    ["member"])
-        member_names = [m['member'] for m in memberships]
-        return find_all("User", name=["IN", member_names])
-
-    def get_outline(self):
-        return CourseOutline(self)
-
-class CourseOutline:
-    def __init__(self, course):
-        self.course = course
-        self.chapters = self.get_chapters()
-        self.lessons = self.get_lessons()
-
-    def get_next(self, current):
-        current = flt(current)
-        numbers = sorted(lesson['number'] for lesson in self.lessons)
-        try:
-            index = numbers.index(current)
-            return numbers[index+1]
-        except IndexError:
-            return None
-
-    def get_prev(self, current):
-        current = flt(current)
-        numbers = sorted(lesson['number'] for lesson in self.lessons)
-        try:
-            index = numbers.index(current)
-            if index == 0:
-                return None
-            return numbers[index-1]
-        except IndexError:
-            return None
-
-    def get_chapters(self):
-        return frappe.db.get_all("Chapter",
-            filters={"course": self.course.name},
-            fields=["name", "title", "index_"],
-            order_by="index_")
-
-    def get_lessons(self):
-        chapters = [c['name'] for c in self.chapters]
-        lessons = frappe.db.get_all("Lesson",
-            filters={"chapter": ["IN", chapters]},
-            fields=["name", "title", "chapter", "index_"])
-
-        chapter_numbers = {c['name']: c['index_'] for c in self.chapters}
-        for lesson in lessons:
-            lesson['number'] = flt("{}.{}".format(chapter_numbers[lesson['chapter']], lesson['index_']))
-        return lessons
-
-@frappe.whitelist()
-def reindex_lessons(doc):
-    course_data = json.loads(doc)
-    course = frappe.get_doc("LMS Course", course_data['name'])
-    course.reindex_lessons()
-    frappe.msgprint("All lessons in this course have been re-indexed.")
-
-@frappe.whitelist()
-def reindex_exercises(doc):
-    course_data = json.loads(doc)
-    course = frappe.get_doc("LMS Course", course_data['name'])
-    course.reindex_exercises()
-    frappe.msgprint("All exercises in this course have been re-indexed.")

community/lms/doctype/lms_course/test_lms_course.py

@@ -11,13 +11,12 @@ class TestLMSCourse(unittest.TestCase):
     def setUp(self):
         frappe.db.sql('delete from `tabLMS Course Mentor Mapping`')
         frappe.db.sql('delete from `tabLMS Course`')
+        frappe.db.sql('delete from `tabCommunity Member`')
 
     def new_course(self, title):
         doc = frappe.get_doc({
             "doctype": "LMS Course",
-            "title": title,
+            "title": title
-            "short_introduction": title,
-            "description": title
         })
         doc.insert()
         return doc
@@ -25,7 +24,8 @@ class TestLMSCourse(unittest.TestCase):
     def test_new_course(self):
         course = self.new_course("Test Course")
         assert course.title == "Test Course"
-        assert course.name == "test-course"
+        assert course.slug == "test-course"
+        assert course.get_mentors() == []
 
     def test_find_all(self):
         courses = LMSCourse.find_all()
@@ -41,7 +41,7 @@ class TestLMSCourse(unittest.TestCase):
 
         # now we should find one course
         courses = LMSCourse.find_all()
-        assert [c.name for c in courses] == [course.name]
+        assert [c.slug for c in courses] == [course.slug]
 
     # disabled this test as it is failing
     def _test_add_mentors(self):

community/lms/doctype/lms_course_mentor_mapping/lms_course_mentor_mapping.json

@@ -23,7 +23,7 @@
    "fieldtype": "Link",
    "in_standard_filter": 1,
    "label": "Mentor",
-   "options": "User"
+   "options": "Community Member"
   },
   {
    "fetch_from": "mentor.full_name",
@@ -36,7 +36,7 @@
  ],
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2021-05-21 11:48:43.340315",
+ "modified": "2021-04-20 12:46:48.460934",
  "modified_by": "Administrator",
  "module": "LMS",
  "name": "LMS Course Mentor Mapping",

community/lms/doctype/lms_course_progress/lms_course_progress.js

@@ -1,8 +0,0 @@
-// Copyright (c) 2021, FOSS United and contributors
-// For license information, please see license.txt
-
-frappe.ui.form.on('LMS Course Progress', {
-	// refresh: function(frm) {
-
-	// }
-});

community/lms/doctype/lms_course_progress/lms_course_progress.json

@@ -1,78 +0,0 @@
-{
- "actions": [],
- "creation": "2021-05-31 17:20:13.388453",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "status",
-  "column_break_3",
-  "lesson",
-  "chapter",
-  "course"
- ],
- "fields": [
-  {
-   "fetch_from": "chapter.course",
-   "fieldname": "course",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "in_standard_filter": 1,
-   "label": "Course",
-   "options": "LMS Course",
-   "read_only": 1
-  },
-  {
-   "fetch_from": "lesson.chapter",
-   "fieldname": "chapter",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Chapter",
-   "options": "Chapter",
-   "read_only": 1
-  },
-  {
-   "fieldname": "lesson",
-   "fieldtype": "Link",
-   "in_list_view": 1,
-   "label": "Lesson",
-   "options": "Lesson"
-  },
-  {
-   "fieldname": "status",
-   "fieldtype": "Select",
-   "in_list_view": 1,
-   "in_standard_filter": 1,
-   "label": "Status",
-   "options": "Complete\nPartially Complete\nIncomplete"
-  },
-  {
-   "fieldname": "column_break_3",
-   "fieldtype": "Column Break"
-  }
- ],
- "index_web_pages_for_search": 1,
- "links": [],
- "modified": "2021-06-02 13:05:31.114939",
- "modified_by": "Administrator",
- "module": "LMS",
- "name": "LMS Course Progress",
- "owner": "Administrator",
- "permissions": [
-  {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "System Manager",
-   "share": 1,
-   "write": 1
-  }
- ],
- "sort_field": "modified",
- "sort_order": "DESC",
- "track_changes": 1
-}

community/lms/doctype/lms_course_progress/lms_course_progress.py

@@ -1,8 +0,0 @@
-# Copyright (c) 2021, FOSS United and contributors
-# For license information, please see license.txt
-
-# import frappe
-from frappe.model.document import Document
-
-class LMSCourseProgress(Document):
-	pass

community/lms/doctype/lms_course_progress/test_lms_course_progress.py

@@ -1,8 +0,0 @@
-# Copyright (c) 2021, FOSS United and Contributors
-# See license.txt
-
-# import frappe
-import unittest
-
-class TestLMSCourseProgress(unittest.TestCase):
-	pass

community/lms/doctype/lms_mentor_request/lms_mentor_request.json

@@ -19,7 +19,7 @@
    "fieldtype": "Link",
    "in_standard_filter": 1,
    "label": "Member",
-   "options": "User"
+   "options": "Community Member"
   },
   {
    "fieldname": "course",
@@ -52,7 +52,7 @@
    "fieldname": "reviewed_by",
    "fieldtype": "Link",
    "label": "Reviewed By",
-   "options": "User"
+   "options": "Community Member"
   },
   {
    "fieldname": "comments",
@@ -62,7 +62,7 @@
  ],
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2021-05-21 11:49:12.543502",
+ "modified": "2021-04-19 09:27:03.814016",
  "modified_by": "Administrator",
  "module": "LMS",
  "name": "LMS Mentor Request",

community/lms/doctype/lms_mentor_request/lms_mentor_request.py

@@ -8,115 +8,84 @@ from frappe.model.document import Document
 from frappe import _
 
 class LMSMentorRequest(Document):
-    def on_update(self):
+	def on_update(self):
-        if self.has_value_changed('status'):
+		if self.has_value_changed('status'):
+			template = frappe.db.get_single_value('LMS Settings', 'mentor_request_status_update')
+			if not template:
+				return
 
-            if self.status == "Approved":
+			email_template = frappe.get_doc('Email Template', template)	
-                self.create_course_mentor_mapping()
+			message = frappe.render_template(email_template.response, {'member_name': self.member_name, 'status': self.status})
-
+			subject = _('The status of your application has changed.')
-            if self.status != "Pending":
+			member_email = frappe.db.get_value("Community Member", self.member, "email")
-                self.send_status_change_email()
+			
-
+			if self.status == 'Approved' or self.status == 'Rejected':
-    def create_course_mentor_mapping(self):
+				reviewed_by = frappe.db.get_value('Community Member', self.reviewed_by, 'email')
-        mapping = frappe.get_doc({
+				send_email(member_email, [get_course_author(self.course), reviewed_by], subject, message)
-            "doctype": "LMS Course Mentor Mapping",
+			
-            "mentor": self.member,
+			elif self.status == 'Withdrawn':
-            "course": self.course
+				send_email([member_email, get_course_author(self.course)], None, subject, message)
-        })
-        mapping.save()
-
-    def send_creation_email(self):
-        email_template = self.get_email_template('mentor_request_creation')
-        if not email_template:
-            return
-
-        course_details = frappe.db.get_value("LMS Course", self.course, ["owner", "slug", "title"], as_dict=True)
-        message = frappe.render_template(email_template.response,
-                {
-                    'member_name': frappe.db.get_value("User", frappe.session.user, "full_name"),
-                    'course_url': '/courses/' + course_details.slug,
-                    'course': course_details.title
-                })
-
-        email_args = {
-            "recipients": [frappe.session.user, course_details.owner],
-            "subject": email_template.subject,
-            "header": email_template.subject,
-            "message": message
-        }
-        frappe.enqueue(method=frappe.sendmail, queue="short", timeout=300, is_async=True, **email_args)
-
-    def send_status_change_email(self):
-        email_template = self.get_email_template('mentor_request_status_update')
-        if not email_template:
-            return
-
-        course_details = frappe.db.get_value("LMS Course", self.course, ["owner", "title"], as_dict=True)
-        message = frappe.render_template(email_template.response,
-                {
-                    'member_name': self.member_name,
-                    'status': self.status,
-                    'course': course_details.title
-                })
-
-        if self.status == 'Approved' or self.status == 'Rejected':
-            email_args = {
-                "recipients": self.member,
-                "cc": [course_details.owner, self.reviewed_by],
-                "subject": email_template.subject,
-                "header": email_template.subject,
-                "message": message
-            }
-            frappe.enqueue(method=frappe.sendmail, queue="short", timeout=300, is_async=True, **email_args)
-
-        elif self.status == 'Withdrawn':
-            email_args = {
-                "recipients": [self.member, course_details.owner],
-                "subject": email_template.subject,
-                "header": email_template.subject,
-                "message": message
-            }
-            frappe.enqueue(method=frappe.sendmail, queue="short", timeout=300, is_async=True, **email_args)
-
-    def get_email_template(self, template_name):
-        template = frappe.db.get_single_value('LMS Settings', template_name)
-        if template:
-            return frappe.get_doc('Email Template', template)
 
 @frappe.whitelist()
 def has_requested(course):
-    return frappe.db.count('LMS Mentor Request',
+	return len(frappe.get_all('LMS Mentor Request',
-                filters = {
+					filters = {
-                    'member': frappe.session.user,
+						'member': get_member().name,
-                    'course': course,
+						'course': course,
-                    'status': ['in', ('Pending', 'Approved')]
+						'status': ['in', ('Pending', 'Approved')]
-                }
+					}
+				)
 			)
 
 @frappe.whitelist()
 def create_request(course):
-    if not has_requested(course):
+	if not has_requested(course):
-        request = frappe.get_doc({
+		member = get_member()
-                    'doctype': 'LMS Mentor Request',
+		frappe.get_doc({
-                    'member': frappe.session.user,
+			'doctype': 'LMS Mentor Request',
-                    'course': course,
+			'member': member.name,
-                    'status': 'Pending'
+			'course': course,
-                })
+			'status': 'Pending'
-        request.save(ignore_permissions=True)
+		}).save(ignore_permissions=True)
-        request.send_creation_email()
+		send_creation_email(course, member)
-        return 'OK'
+		return 'OK'
-
+	else:
-    else:
+		return 'Already Applied'
-        return 'Already Applied'
 
 @frappe.whitelist()
 def cancel_request(course):
-    request = frappe.get_doc('LMS Mentor Request',{
+	request = frappe.get_doc('LMS Mentor Request', {'member': get_member().name, 'course': course, 'status': ['in', ('Pending', 'Approved')]})
-                    'member': frappe.session.user,
+	request.status = 'Withdrawn'
-                    'course': course,
+	request.save(ignore_permissions=True)
-                    'status': ['in', ('Pending', 'Approved')]
+	return 'OK'
-                }
+
-            )
+def get_member():
-    request.status = 'Withdrawn'
+	try:
-    request.save(ignore_permissions=True)
+		return frappe.get_doc('Community Member', {'email': frappe.session.user})
-    return 'OK'
+	except frappe.DoesNotExistError:
+		return
+
+def get_course_author(course):
+	return frappe.db.get_value('LMS Course', course, 'owner')
+
+def send_creation_email(course, member):
+	template = frappe.db.get_single_value('LMS Settings', 'mentor_request_creation')
+	if not template:
+		return
+
+	email_template = frappe.get_doc('Email Template', template)
+	member_name = member.full_name
+	message = frappe.render_template(email_template.response, {'member_name': member_name})
+	subject = _('Request for Mentorship')
+	send_email([frappe.session.user, get_course_author(course)], None, subject, message)
+
+def send_email(recipients, cc, subject, message):
+	frappe.sendmail(
+		recipients = recipients,
+		cc = cc,
+		sender = frappe.db.get_single_value('LMS Settings', 'email_sender'),
+		subject = subject, 
+		send_priority = 0, 
+		queue_separately = True,
+		message = message
+	)

community/lms/doctype/lms_message/lms_message.json

@@ -26,7 +26,7 @@
    "fieldtype": "Link",
    "in_list_view": 1,
    "label": "Author",
-   "options": "User"
+   "options": "Community Member"
   },
   {
    "fieldname": "message",
@@ -58,7 +58,7 @@
  ],
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2021-05-21 11:49:34.911479",
+ "modified": "2021-04-28 10:17:57.618127",
  "modified_by": "Administrator",
  "module": "LMS",
  "name": "LMS Message",
@@ -82,4 +82,4 @@
  "sort_order": "DESC",
  "title_field": "author",
  "track_changes": 1
-}
+}

community/lms/doctype/lms_message/lms_message.py

@@ -7,104 +7,98 @@ import frappe
 from frappe.model.document import Document
 from frappe import _
 from frappe.utils import add_days, nowdate
+from community.www.courses.utils import get_batch_members
 
 class LMSMessage(Document):
-    def after_insert(self):
+	""" def after_insert(self):
-        self.publish_message()
+		self.send_email() """
-        #Todo: Adding email preference field for users
-        #self.send_email()
-
-    def publish_message(self):
-        template = self.get_message_template()
-        message = frappe._dict({
-            "author_name": self.author_name,
-            "message_time": frappe.utils.format_datetime(self.creation, "dd-mm-yyyy HH:mm"),
-            "message": frappe.utils.md_to_html(self.message)
-        })
-
-        js = """
-                $(".msger-input").val("");
-                var template = `{0}`;
-                var message = {1};
-                var session_user = ("{2}" == frappe.session.user) ? true : false;
-                message.author_name = session_user ? "You" : message.author_name
-                message.is_author = session_user;
-                template = frappe.render_template(template, {{
-                    "message": message
-                }})
-                $(".messages").append(template);
-                var message_element = document.getElementsByClassName("messages")[0]
-		        message_element.scrollTo(0, message_element.scrollHeight);
-            """.format(template, message, self.owner)
-
-        frappe.publish_realtime(event="eval_js", message=js, after_commit=True)
-
-    def get_message_template(self):
-        return """
-                <li class="{% if message.is_author %} ours {% endif %}">
-                    <div class="d-flex justify-content-between">
-                    <div class="font-weight-bold">
-                            {{ message.author_name }}
-                    </div>
-                    <small class="">
-                        {{ message.message_time }}
-                    </small>
-                    </div>
-                    <div class="message-para">
-                        {{ message.message }}
-                    </div>
-                </li>
-            """
-
-    def send_email(self):
-        membership = frappe.get_all("LMS Batch Membership", {"batch": self.batch}, ["member"])
-        for entry in membership:
-            member = frappe.get_doc("User", entry.member)
-            if member.name != self.author:
-                #Todo: wrap sendmail in frappe.enqueue, else messages takes long to display.
-                frappe.sendmail(
-                    recipients = member.email,
-                    subject = _("New Message on ") + self.batch,
-                    header = _("New Message on ") + self.batch,
-                    template = "lms_message",
-                    args = {
-                        "author": self.author,
-                        "message": frappe.utils.md_to_html(self.message),
-                        "creation": frappe.utils.format_datetime(self.creation, "medium"),
-                        "course": frappe.db.get_value("LMS Batch", self.batch, ["course"])
-                    }
-                )
 
+	def send_email(self):
+		membership = frappe.get_all("LMS Batch Membership", {"batch": self.batch}, ["member"])
+		for entry in membership:
+			member = frappe.get_doc("Community Member", entry.member)
+			if member.name != self.author and member.email_preference == "Email on every Message":
+				frappe.sendmail(
+					recipients = member.email,
+					subject = _("New Message on ") + self.batch,
+					header = _("New Message on ") + self.batch,
+					template = "lms_message",
+					args = {
+						"author": self.author,
+						"message": frappe.utils.md_to_html(self.message),
+						"creation": frappe.utils.format_datetime(self.creation, "medium"),
+						"course": frappe.db.get_value("LMS Batch", self.batch, ["course"])
+					}
+				)
 def send_daily_digest():
-    #Todo: Optimize this
+	emails = frappe._dict()
-    emails = frappe._dict()
+	messages = frappe.get_all("LMS Message", {"creation": [">=", add_days(nowdate(), -1)]}, ["message", "batch", "author", "creation"])
-    messages = frappe.get_all("LMS Message", {"creation": [">=", add_days(nowdate(), -1)]}, ["message", "batch", "author", "creation"])
+	for message in messages:
-    for message in messages:
+		membership = frappe.get_all("LMS Batch Membership", {"batch": message.batch}, ["member"])
-        membership = frappe.get_all("LMS Batch Membership", {"batch": message.batch}, ["member"])
+		for entry in membership:
-        for entry in membership:
+			member = frappe.db.get_value("Community Member", entry.member, ["name", "email_preference", "email"], as_dict=1)
-            member = frappe.db.get_value("User", entry.member, ["name", "email"], as_dict=1)
+			if member.name != message.author and member.email_preference == "One Digest Mail per day":
-            if member.name != message.author:
+				if member.name in emails.keys():
-                if member.name in emails.keys():
+					emails[member.name]["messages"].append(message)
-                    emails[member.name]["messages"].append(message)
+				else:
-                else:
+					emails[member.name] = frappe._dict({
-                    emails[member.name] = frappe._dict({
+						"email": member.email,
-                        "email": member.email,
+						"messages": [message]
-                        "messages": [message]
+					})
-                    })
+	for email in emails:
-    for email in emails:
+		group_by_batch = frappe._dict()
-        group_by_batch = frappe._dict()
+		for message in emails[email]["messages"]:
-        for message in emails[email]["messages"]:
+			if message.batch in group_by_batch.keys():
-            if message.batch in group_by_batch.keys():
+				group_by_batch[message.batch].append(message)
-                group_by_batch[message.batch].append(message)
+			else:
-            else:
+				group_by_batch[message.batch] = [message]
-                group_by_batch[message.batch] = [message]
+		frappe.sendmail(
-        frappe.sendmail(
+			recipients = frappe.db.get_value("Community Member", email, "email"),
-            recipients = frappe.db.get_value("User", email, "email"),
+			subject = _("Message Digest"),
-            subject = _("Message Digest"),
+			header = _("Message Digest"),
-            header = _("Message Digest"),
+			template = "lms_daily_digest",
-            template = "lms_daily_digest",
+			args = {
-            args = {
+				"batches": group_by_batch
-                "batches": group_by_batch
+			},
-            },
+			delayed = False
-            delayed = False
+		)
-        )
+
+def publish_message(doc, method):
+	email = frappe.db.get_value("Community Member", doc.author, "email")
+	template = get_message_template()
+	message = frappe._dict()
+	message.author_name = doc.author_name
+	message.message_time = frappe.utils.pretty_date(doc.creation)
+	message.message = frappe.utils.md_to_html(doc.message)
+
+	js = """
+			$(".msger-input").val("");
+			var template = `{0}`;
+			var message = {1};
+			var session_user = ("{2}" == frappe.session.user) ? true : false;
+			message.author_name = session_user ? "You" : message.author_name
+			message.is_author = session_user;
+			template = frappe.render_template(template, {{
+				"message": message
+			}})
+			$(".message-section").append(template);
+		""".format(template, message, email)
+
+	frappe.publish_realtime(event="eval_js", message=js, after_commit=True)
+
+def get_message_template():
+	return """  
+			<div class="discussion {% if message.is_author %} is-author {% endif %}">
+				<div class="d-flex justify-content-between">
+				<div class="font-weight-bold">
+						{{ message.author_name }}
+				</div>
+				<div class="text-muted">
+					{{ message.message_time }}
+				</div>
+				</div>
+				<div class="mt-5">
+					{{ message.message }}
+				</div>
+			</div>
+		"""

community/lms/doctype/lms_option/lms_option.json

@@ -1,36 +0,0 @@
-{
- "actions": [],
- "creation": "2021-06-07 10:46:10.402684",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "option",
-  "is_correct"
- ],
- "fields": [
-  {
-   "fieldname": "option",
-   "fieldtype": "Data",
-   "label": "Option"
-  },
-  {
-   "default": "0",
-   "fieldname": "is_correct",
-   "fieldtype": "Check",
-   "label": "Is Correct"
-  }
- ],
- "index_web_pages_for_search": 1,
- "istable": 1,
- "links": [],
- "modified": "2021-06-07 10:48:45.290227",
- "modified_by": "Administrator",
- "module": "LMS",
- "name": "LMS Option",
- "owner": "Administrator",
- "permissions": [],
- "sort_field": "modified",
- "sort_order": "DESC",
- "track_changes": 1
-}

community/lms/doctype/lms_option/lms_option.py

@@ -1,8 +0,0 @@
-# Copyright (c) 2021, FOSS United and contributors
-# For license information, please see license.txt
-
-# import frappe
-from frappe.model.document import Document
-
-class LMSOption(Document):
-	pass

community/lms/doctype/lms_quiz/lms_quiz.js

@@ -1,8 +0,0 @@
-// Copyright (c) 2021, FOSS United and contributors
-// For license information, please see license.txt
-
-frappe.ui.form.on('LMS Quiz', {
-	// refresh: function(frm) {
-
-	// }
-});

community/lms/doctype/lms_quiz/lms_quiz.json

@@ -1,57 +0,0 @@
-{
- "actions": [],
- "autoname": "field:title",
- "creation": "2021-06-07 10:50:17.893625",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "title",
-  "questions",
-  "lesson"
- ],
- "fields": [
-  {
-   "fieldname": "title",
-   "fieldtype": "Data",
-   "label": "Title",
-   "unique": 1
-  },
-  {
-   "fieldname": "questions",
-   "fieldtype": "Table",
-   "label": "Questions",
-   "options": "LMS Quiz Question"
-  },
-  {
-   "fieldname": "lesson",
-   "fieldtype": "Link",
-   "label": "Lesson",
-   "options": "Lesson"
-  }
- ],
- "index_web_pages_for_search": 1,
- "links": [],
- "modified": "2021-06-23 17:58:57.642873",
- "modified_by": "Administrator",
- "module": "LMS",
- "name": "LMS Quiz",
- "owner": "Administrator",
- "permissions": [
-  {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "export": 1,
-   "print": 1,
-   "read": 1,
-   "report": 1,
-   "role": "System Manager",
-   "share": 1,
-   "write": 1
-  }
- ],
- "sort_field": "modified",
- "sort_order": "DESC",
- "track_changes": 1
-}

community/lms/doctype/lms_quiz/lms_quiz.py

@@ -1,79 +0,0 @@
-# Copyright (c) 2021, FOSS United and contributors
-# For license information, please see license.txt
-
-from community.lms.doctype.lesson.lesson import update_progress
-import frappe
-from frappe.model.document import Document
-import json
-from frappe import _
-from ..lesson.lesson import update_progress
-
-class LMSQuiz(Document):
-    def validate(self):
-        self.validate_correct_answers()
-
-    def validate_correct_answers(self):
-        for question in self.questions:
-            correct_options = self.get_correct_options(question)
-
-            if len(correct_options) > 1:
-                question.multiple = 1
-
-            if not len(correct_options):
-                frappe.throw(_("At least one answer must be correct for this question: {0}").format(frappe.bold(question.question)))
-
-    def get_correct_options(self, question):
-        correct_option_fields = ["is_correct_1", "is_correct_2", "is_correct_3", "is_correct_4"]
-        return list(filter(lambda x: question.get(x) == 1, correct_option_fields))
-
-    def get_last_submission_details(self):
-        """Returns the latest submission for this user.
-        """
-        user = frappe.session.user
-        if not user or user == "Guest":
-            return
-
-        result = frappe.get_all('LMS Quiz Submission',
-            fields="*",
-            filters={
-                "owner": user,
-                "quiz": self.name
-            },
-            order_by="creation desc",
-            page_length=1)
-
-        if result:
-            return result[0]
-
-@frappe.whitelist()
-def submit(quiz, result):
-    score = 0
-    answer_map = {
-        "is_correct_1": "option_1",
-        "is_correct_2": "option_2",
-        "is_correct_3": "option_3",
-        "is_correct_4": "option_4"
-    }
-    result = json.loads(result)
-    quiz_details = frappe.get_doc("LMS Quiz", quiz)
-
-    for response in result:
-        match = list(filter(lambda x: x.question == response.get("question"), quiz_details.questions))[0]
-        correct_options = quiz_details.get_correct_options(match)
-        correct_answers = [ match.get(answer_map[option]) for option in correct_options ]
-
-        if response.get("answer") == correct_answers:
-            response["result"] = "Right"
-            score += 1
-        else:
-            response["result"] = "Wrong"
-        response["answer"] = ("").join([ ans if idx == len(response.get("answer")) -1 else ans + ", "  for idx, ans in enumerate(response.get("answer")) ])
-
-    frappe.get_doc({
-        "doctype": "LMS Quiz Submission",
-        "quiz": quiz,
-        "result": result,
-        "score": score
-    }).save(ignore_permissions=True)
-    update_progress(quiz_details.lesson)
-    return score

community/lms/doctype/lms_quiz/test_lms_quiz.py

@@ -1,8 +0,0 @@
-# Copyright (c) 2021, FOSS United and Contributors
-# See license.txt
-
-# import frappe
-import unittest
-
-class TestLMSQuiz(unittest.TestCase):
-	pass

community/lms/doctype/lms_quiz_question/lms_quiz_question.json

@@ -1,118 +0,0 @@
-{
- "actions": [],
- "creation": "2021-06-07 10:48:57.994714",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "question",
-  "options_section",
-  "option_1",
-  "is_correct_1",
-  "section_break_5",
-  "option_2",
-  "is_correct_2",
-  "column_break_4",
-  "option_3",
-  "is_correct_3",
-  "section_break_11",
-  "option_4",
-  "is_correct_4",
-  "multiple"
- ],
- "fields": [
-  {
-   "fieldname": "question",
-   "fieldtype": "Text",
-   "in_list_view": 1,
-   "label": "Question",
-   "reqd": 1
-  },
-  {
-   "fieldname": "option_1",
-   "fieldtype": "Data",
-   "label": "Option 1",
-   "reqd": 1
-  },
-  {
-   "fieldname": "option_2",
-   "fieldtype": "Data",
-   "label": "Option 2",
-   "reqd": 1
-  },
-  {
-   "fieldname": "option_3",
-   "fieldtype": "Data",
-   "label": "Option 3"
-  },
-  {
-   "fieldname": "option_4",
-   "fieldtype": "Data",
-   "label": "Option 4"
-  },
-  {
-   "default": "0",
-   "depends_on": "option_1",
-   "fieldname": "is_correct_1",
-   "fieldtype": "Check",
-   "label": "Is Correct"
-  },
-  {
-   "default": "0",
-   "depends_on": "option_2",
-   "fieldname": "is_correct_2",
-   "fieldtype": "Check",
-   "label": "Is Correct"
-  },
-  {
-   "default": "0",
-   "depends_on": "option_3",
-   "fieldname": "is_correct_3",
-   "fieldtype": "Check",
-   "label": "Is Correct"
-  },
-  {
-   "default": "0",
-   "depends_on": "option_4",
-   "fieldname": "is_correct_4",
-   "fieldtype": "Check",
-   "label": "Is Correct"
-  },
-  {
-   "default": "0",
-   "fieldname": "multiple",
-   "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Multiple Correct Answers",
-   "read_only": 1
-  },
-  {
-   "fieldname": "options_section",
-   "fieldtype": "Section Break"
-  },
-  {
-   "fieldname": "column_break_4",
-   "fieldtype": "Section Break"
-  },
-  {
-   "fieldname": "section_break_5",
-   "fieldtype": "Section Break"
-  },
-  {
-   "fieldname": "section_break_11",
-   "fieldtype": "Section Break"
-  }
- ],
- "index_web_pages_for_search": 1,
- "istable": 1,
- "links": [],
- "modified": "2021-06-22 16:54:13.133859",
- "modified_by": "Administrator",
- "module": "LMS",
- "name": "LMS Quiz Question",
- "owner": "Administrator",
- "permissions": [],
- "sort_field": "modified",
- "sort_order": "DESC",
- "track_changes": 1
-}

community/lms/doctype/lms_quiz_question/lms_quiz_question.py

@@ -1,8 +0,0 @@
-# Copyright (c) 2021, FOSS United and contributors
-# For license information, please see license.txt
-
-# import frappe
-from frappe.model.document import Document
-
-class LMSQuizQuestion(Document):
-	pass

community/lms/doctype/lms_quiz_result/lms_quiz_result.json

@@ -1,45 +0,0 @@
-{
- "actions": [],
- "creation": "2021-06-07 14:19:23.683323",
- "doctype": "DocType",
- "editable_grid": 1,
- "engine": "InnoDB",
- "field_order": [
-  "question",
-  "answer",
-  "result"
- ],
- "fields": [
-  {
-   "fieldname": "question",
-   "fieldtype": "Data",
-   "in_list_view": 1,
-   "label": "Question"
-  },
-  {
-   "fieldname": "result",
-   "fieldtype": "Select",
-   "in_list_view": 1,
-   "label": "Result",
-   "options": "Right\nWrong"
-  },
-  {
-   "fieldname": "answer",
-   "fieldtype": "Data",
-   "in_list_view": 1,
-   "label": "Users Response"
-  }
- ],
- "index_web_pages_for_search": 1,
- "istable": 1,
- "links": [],
- "modified": "2021-06-22 18:32:28.813159",
- "modified_by": "Administrator",
- "module": "LMS",
- "name": "LMS Quiz Result",
- "owner": "Administrator",
- "permissions": [],
- "sort_field": "modified",
- "sort_order": "DESC",
- "track_changes": 1
-}

community/lms/doctype/lms_quiz_submission/lms_quiz_submission.js

@@ -1,8 +0,0 @@
-// Copyright (c) 2021, FOSS United and contributors
-// For license information, please see license.txt
-
-frappe.ui.form.on('LMS Quiz Submission', {
-	// refresh: function(frm) {
-
-	// }
-});

community/lms/doctype/lms_quiz_submission/lms_quiz_submission.py

@@ -1,8 +0,0 @@
-# Copyright (c) 2021, FOSS United and contributors
-# For license information, please see license.txt
-
-# import frappe
-from frappe.model.document import Document
-
-class LMSQuizSubmission(Document):
-	pass

community/lms/doctype/lms_quiz_submission/test_lms_quiz_submission.py

@@ -1,8 +0,0 @@
-# Copyright (c) 2021, FOSS United and Contributors
-# See license.txt
-
-# import frappe
-import unittest
-
-class TestLMSQuizSubmission(unittest.TestCase):
-	pass

community/lms/doctype/lms_section/lms_section.json

@@ -0,0 +1,60 @@
+{
+ "actions": [],
+ "creation": "2021-03-05 15:10:53.906006",
+ "doctype": "DocType",
+ "engine": "InnoDB",
+ "field_order": [
+  "label",
+  "type",
+  "contents",
+  "code",
+  "attrs",
+  "index"
+ ],
+ "fields": [
+  {
+   "fieldname": "label",
+   "fieldtype": "Data",
+   "in_list_view": 1,
+   "label": "Label"
+  },
+  {
+   "fieldname": "type",
+   "fieldtype": "Data",
+   "in_list_view": 1,
+   "label": "Type"
+  },
+  {
+   "fieldname": "contents",
+   "fieldtype": "Markdown Editor",
+   "label": "Contents"
+  },
+  {
+   "fieldname": "code",
+   "fieldtype": "Code",
+   "label": "Code"
+  },
+  {
+   "fieldname": "attrs",
+   "fieldtype": "Long Text",
+   "label": "attrs"
+  },
+  {
+   "fieldname": "index",
+   "fieldtype": "Int",
+   "label": "Index"
+  }
+ ],
+ "index_web_pages_for_search": 1,
+ "istable": 1,
+ "links": [],
+ "modified": "2021-03-12 17:56:23.118854",
+ "modified_by": "Administrator",
+ "module": "LMS",
+ "name": "LMS Section",
+ "owner": "Administrator",
+ "permissions": [],
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "track_changes": 1
+}

community/lms/doctype/lms_section/lms_section.py

@@ -10,14 +10,6 @@ class LMSSection(Document):
     def __repr__(self):
         return f"<LMSSection {self.label!r}>"
 
-    def get_exercise(self):
-        if self.type == "exercise":
-            return frappe.get_doc("Exercise", self.id)
-
-    def get_quiz(self):
-        if self.type == "quiz":
-            return frappe.get_doc("LMS Quiz", self.id)
-
     def get_latest_code_for_user(self):
         """Returns the latest code for the logged in user.
         """

community/lms/doctype/lms_settings/lms_settings.json

@@ -6,11 +6,10 @@
  "engine": "InnoDB",
  "field_order": [
   "livecode_url",
-  "column_break_2",
-  "email_sender",
   "mentor_request_section",
   "mentor_request_creation",
-  "mentor_request_status_update"
+  "mentor_request_status_update",
+  "email_sender"
  ],
  "fields": [
   {
@@ -41,16 +40,12 @@
    "fieldname": "mentor_request_section",
    "fieldtype": "Section Break",
    "label": "Mentor Request"
-  },
-  {
-   "fieldname": "column_break_2",
-   "fieldtype": "Column Break"
   }
  ],
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2021-04-29 17:14:43.589700",
+ "modified": "2021-04-21 13:28:35.783395",
  "modified_by": "Administrator",
  "module": "LMS",
  "name": "LMS Settings",

community/lms/doctype/lms_sketch/livecode.py

@@ -3,102 +3,26 @@
 import websocket
 import json
 from .svg import SVG
-import frappe
-from urllib.parse import urlparse
 
-# Files to pass to livecode server
+def livecode_to_svg(livecode_ws_url, code, *, timeout=1):
-# The same code is part of livecode-canvas.js
-# TODO: generate livecode-canvas.js from this file
-START = '''
-import sketch
-code = open("main.py").read()
-env = dict(sketch.__dict__)
-exec(code, env)
-'''
-
-SKETCH = '''
-import json
-
-def sendmsg(msgtype, function, args):
-  """Sends a message to the frontend.
-
-  The frontend will receive the specified message whenever
-  this function is called. The frontend can decide to some
-  action on each of these messages.
-  """
-  msg = dict(msgtype=msgtype, function=function, args=args)
-  print("--MSG--", json.dumps(msg))
-
-def _draw(func, **kwargs):
-  sendmsg(msgtype="draw", function=func, args=kwargs)
-
-def circle(x, y, d):
-    """Draws a circle of diameter d with center (x, y).
-    """
-    _draw("circle", x=x, y=y, d=d)
-
-def line(x1, y1, x2, y2):
-    """Draws a line from point (x1, y1) to point (x2, y2).
-    """
-    _draw("line", x1=x1, y1=y1, x2=x2, y2=y2)
-
-def rect(x, y, w, h):
-    """Draws a rectangle on the canvas.
-
-    Parameters
-    ----------
-    x: x coordinate of the top-left corner of the rectangle
-    y: y coordinate of the top-left corner of the rectangle
-    w: width of the rectangle
-    h: height of the rectangle
-    """
-    _draw("rect", x=x, y=y, w=w, h=h)
-
-def clear():
-    _draw("clear")
-
-# clear the canvas on start
-clear()
-'''
-
-def get_livecode_url():
-    doc = frappe.get_cached_doc("LMS Settings")
-    return doc.livecode_url
-
-def get_livecode_ws_url():
-    url = urlparse(get_livecode_url())
-    protocol = "wss" if url.scheme == "https" else "ws"
-    return protocol + "://" + url.netloc + "/livecode"
-
-def livecode_to_svg(livecode_ws_url, code, *, timeout=3):
     """Renders the code as svg.
     """
-    if livecode_ws_url is None:
+    print("livecode_to_svg")
-        livecode_ws_url = get_livecode_ws_url()
+    ws = websocket.WebSocket()
+    ws.settimeout(timeout)
+    ws.connect(livecode_ws_url)
 
-    try:
+    msg = {
-        ws = websocket.WebSocket()
+        "msgtype": "exec",
-        ws.settimeout(timeout)
+        "runtime": "python-canvas",
-        ws.connect(livecode_ws_url)
+        "code": code
+    }
+    ws.send(json.dumps(msg))
 
-        msg = {
+    messages = _read_messages(ws)
-            "msgtype": "exec",
+    commands = [m['cmd'] for m in messages if m['msgtype'] == 'draw']
-            "runtime": "python",
+    img = draw_image(commands)
-            "code": code,
+    return img.tostring()
-            "files": [
-                {"filename": "start.py", "contents": START},
-                {"filename": "sketch.py", "contents": SKETCH},
-            ],
-            "command": ["python", "start.py"]
-        }
-        ws.send(json.dumps(msg))
-
-        messages = _read_messages(ws)
-        commands = [m for m in messages if m['msgtype'] == 'draw']
-        img = draw_image(commands)
-        return img.tostring()
-    except websocket.WebSocketException as e:
-        frappe.log_error(frappe.get_traceback(), 'livecode_to_svg failed')
 
 def _read_messages(ws):
     messages = []
@@ -108,19 +32,17 @@ def _read_messages(ws):
             if not msg:
                 break
             messages.append(json.loads(msg))
-    except websocket.WebSocketTimeoutException as e:
+    except websocket.WebSocketTimeoutException:
-        print("Error:", e)
         pass
     return messages
 
 def draw_image(commands):
     img = SVG(width=300, height=300, viewBox="0 0 300 300", fill='none', stroke='black')
     for c in commands:
-        args = c['args']
         if c['function'] == 'circle':
-            img.circle(cx=args['x'], cy=args['y'], r=args['d']/2)
+            img.circle(cx=c['x'], cy=c['y'], r=c['d']/2)
         elif c['function'] == 'line':
-            img.line(x1=args['x1'], y1=args['y1'], x2=args['x2'], y2=args['y2'])
+            img.line(x1=c['x1'], y1=c['y1'], x2=c['x2'], y2=c['y2'])
         elif c['function'] == 'rect':
-            img.rect(x=args['x'], y=args['y'], width=args['w'], height=args['h'])
+            img.rect(x=c['x'], y=c['y'], width=c['w'], height=c['h'])
     return img

community/lms/doctype/lms_sketch/lms_sketch.py

@@ -9,11 +9,6 @@ import frappe
 from frappe.model.document import Document
 from . import livecode
 
-DEFAULT_IMAGE = """
-<svg viewBox="0 0 300 300" width="300" xmlns="http://www.w3.org/2000/svg">
-</svg>
-"""
-
 class LMSSketch(Document):
     @property
     def sketch_id(self):
@@ -53,20 +48,15 @@ class LMSSketch(Document):
         else:
             ws_url = self.get_livecode_ws_url()
             value = livecode.livecode_to_svg(ws_url, self.code)
-            if value:
+            cache.set(key, value)
-                cache.set(key, value)
+        return value
-        return value or DEFAULT_IMAGE
 
     @staticmethod
-    def get_recent_sketches(limit=100, owner=None):
+    def get_recent_sketches(limit=100):
         """Returns the recent sketches.
         """
-        filters = {}
-        if owner:
-            filters = {"owner": owner}
         sketches = frappe.get_all(
             "LMS Sketch",
-            filters=filters,
             fields='*',
             order_by='modified desc',
             page_length=limit
@@ -83,7 +73,7 @@ def save_sketch(name, title, code):
         doc.title = title
         doc.code = code
         doc.runtime = 'python-canvas'
-        doc.insert(ignore_permissions=True)
+        doc.insert()
         status = "created"
     else:
         doc = frappe.get_doc("LMS Sketch", name)

community/lms/doctype/lms_topic/lms_topic.js

@@ -1,7 +1,7 @@
 // Copyright (c) 2021, FOSS United and contributors
 // For license information, please see license.txt
 
-frappe.ui.form.on('Lesson', {
+frappe.ui.form.on('LMS Topic', {
 	// refresh: function(frm) {
 
 	// }

community/lms/doctype/lms_topic/lms_topic.json

@@ -1,61 +1,69 @@
 {
  "actions": [],
- "autoname": "format:{####} {title}",
+ "allow_guest_to_view": 1,
- "creation": "2021-05-03 05:49:08.383057",
+ "creation": "2021-03-02 07:20:41.686573",
  "doctype": "DocType",
  "editable_grid": 1,
  "engine": "InnoDB",
  "field_order": [
   "course",
   "title",
+  "slug",
+  "preview",
   "description",
-  "locked",
+  "order",
-  "index_"
+  "sections"
  ],
  "fields": [
   {
    "fieldname": "title",
    "fieldtype": "Data",
    "in_list_view": 1,
-   "label": "Title"
+   "label": "Title",
+   "reqd": 1
   },
   {
    "fieldname": "description",
    "fieldtype": "Markdown Editor",
    "label": "Description"
   },
-  {
-   "default": "0",
-   "fieldname": "locked",
-   "fieldtype": "Check",
-   "label": "Locked"
-  },
   {
    "fieldname": "course",
    "fieldtype": "Link",
    "in_list_view": 1,
    "label": "Course",
-   "options": "LMS Course"
+   "options": "LMS Course",
+   "reqd": 1
   },
   {
-   "default": "1",
+   "fieldname": "order",
-   "fieldname": "index_",
    "fieldtype": "Int",
-   "label": "Index"
+   "label": "Order"
+  },
+  {
+   "fieldname": "preview",
+   "fieldtype": "Markdown Editor",
+   "label": "Preview"
+  },
+  {
+   "fieldname": "sections",
+   "fieldtype": "Table",
+   "label": "Sections",
+   "options": "LMS Section"
+  },
+  {
+   "description": "The slug of the topic. Autogenerated from the title if not specified.",
+   "fieldname": "slug",
+   "fieldtype": "Data",
+   "label": "Slug"
   }
  ],
  "index_web_pages_for_search": 1,
- "links": [
+ "links": [],
-  {
+ "modified": "2021-04-06 14:12:48.514062",
-   "group": "Lessons",
-   "link_doctype": "Lesson",
-   "link_fieldname": "chapter"
-  }
- ],
- "modified": "2021-05-13 21:05:20.531890",
  "modified_by": "Administrator",
  "module": "LMS",
- "name": "Chapter",
+ "name": "LMS Topic",
  "owner": "Administrator",
  "permissions": [
   {
@@ -72,8 +80,10 @@
   }
  ],
  "search_fields": "title",
- "sort_field": "modified",
+ "sort_field": "creation",
- "sort_order": "DESC",
+ "sort_order": "ASC",
  "title_field": "title",
- "track_changes": 1
+ "track_changes": 1,
+ "track_seen": 1,
+ "track_views": 1
 }

community/lms/doctype/lms_topic/lms_topic.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2021, FOSS United and contributors
+# For license information, please see license.txt
+
+from __future__ import unicode_literals
+import frappe
+from frappe.model.document import Document
+from .section_parser import SectionParser
+from ...utils import slugify
+
+class LMSTopic(Document):
+    def before_save(self):
+        course = self.get_course()
+        if not self.slug:
+            self.slug = self.generate_slug(title=self.title)
+
+        sections = SectionParser().parse(self.description or "")
+        self.sections = [self.make_lms_section(i, s) for i, s in enumerate(sections)]
+
+    def get_course(self):
+        return frappe.get_doc("LMS Course", self.course)
+
+    def generate_slug(self, title):
+        result = frappe.get_all(
+            'LMS Topic',
+            filters={'course': self.course},
+            fields=['slug'])
+        slugs = set([row['slug'] for row in result])
+        return slugify(title, used_slugs=slugs)
+
+    def get_sections(self):
+        return sorted(self.sections, key=lambda s: s.index)
+
+    def make_lms_section(self, index, section):
+            s = frappe.new_doc('LMS Section', parent_doc=self, parentfield='sections')
+            s.type = section.type
+            s.label = section.label
+            s.contents = section.contents
+            s.index = index
+            return s
+
+
+

community/lms/doctype/lms_topic/section_parser.py

@@ -0,0 +1,79 @@
+"""Utility to split the text in the topic into multiple sections.
+"""
+from __future__ import annotations
+from dataclasses import dataclass
+import re
+from typing import List, Tuple, Dict, Iterator
+
+RE_SECTION = re.compile(r"^\{\{\s(\w+)\s*(?:\((.*)\))?\s*\}\}\s*")
+class SectionParser:
+    def parse(self, text: str) -> Iterator[Section]:
+        """Parses given text into sections and return an iterator over sections.
+        """
+        lines = text.splitlines()
+        marked_lines = self.parse_lines(lines)
+        return self.group_sections(marked_lines)
+
+    def parse_lines(self, lines: List[str]) -> List[Tuple[str, str, str]]:
+        for line in lines:
+            m = RE_SECTION.match(line)
+            if m:
+                yield m.group(1), self.parse_attrs(m.group(2)), None
+            else:
+                yield None, None, line
+
+    def parse_attrs(self, attrs_str: str) -> Dict[str, str]:
+        # XXX-Anand: Hack
+        code = "dict({})".format(attrs_str or "")
+        return eval(code)
+
+    def group_sections(self, marked_lines) -> Iterator[Section]:
+        index = 0
+
+        def make_section(type='text', id=None, label=None, **attrs):
+            nonlocal index
+            index += 1
+
+            id = id or f"section-{index}"
+            label = label or id
+            return Section(
+                type=type,
+                id=id,
+                label=label,
+                attrs=attrs)
+
+        section = make_section("text")
+
+        for mark, attrs, line in marked_lines:
+            if not mark:
+                section.append(line)
+                continue
+
+            yield section
+
+            if mark == 'end':
+                section = make_section(type='text')
+            else:
+                section = make_section(**attrs)
+
+        yield section
+
+@dataclass
+class Section:
+    """One section of the Topic.
+    """
+    type: str
+    id: str
+    label: str
+    contents: str = ""
+    attrs: dict = None
+
+    def append(self, line):
+        if not line.endswith("\n"):
+            line = line + "\n"
+        self.contents += line
+
+    def __repr__(self):
+        attrs = dict(type=self.type, id=self.id, label=self.label, **self.attrs)
+        attrs_str = ", ".join(f'{k}="{v}"' for k, v in attrs.items())
+        return f'<Section({attrs_str})>'

community/lms/doctype/lms_topic/test_lms_topic.py

@@ -6,5 +6,5 @@ from __future__ import unicode_literals
 # import frappe
 import unittest
 
-class TestChapter(unittest.TestCase):
+class TestLMSTopic(unittest.TestCase):
 	pass

community/lms/md.py

@@ -1,109 +0,0 @@
-"""
-The md module extends markdown to add macros.
-
-Macros can be added to the markdown text in the following format.
-
-    {{ MacroName("macro-argument") }}
-
-These macros will be rendered using a pluggable mechanism.
-
-Apps can provide a hook community_markdown_macro_renderers, a
-dictionary mapping the macro name to the function that to render
-that macro. The function will get the argument passed to the macro
-as argument.
-"""
-
-import frappe
-import re
-from bs4 import BeautifulSoup
-import markdown
-from markdown import Extension
-from markdown.inlinepatterns import InlineProcessor
-import xml.etree.ElementTree as etree
-
-def markdown_to_html(text):
-    """Renders markdown text into html.
-    """
-    return markdown.markdown(text, extensions=['fenced_code', MacroExtension()])
-
-def find_macros(text):
-    """Returns all macros in the given text.
-
-        >>> find_macros(text)
-        [
-            ('YouTubeVideo': 'abcd1234')
-            ('Exercise', 'two-circles'),
-            ('Exercise', 'four-circles')
-        ]
-    """
-    if not text:
-        return []
-    macros = re.findall(MACRO_RE, text)
-    # remove the quotes around the argument
-    return [(name, _remove_quotes(arg)) for name, arg in macros]
-
-def _remove_quotes(value):
-    """Removes quotes around a value.
-
-    Also strips the whitespace.
-
-        >>> _remove_quotes('"hello"')
-        'hello'
-        >>> _remove_quotes("'hello'")
-        'hello'
-        >>> _remove_quotes("hello")
-        'hello'
-    """
-    return value.strip(" '\"")
-
-
-def get_macro_registry():
-    d = frappe.get_hooks("community_markdown_macro_renderers") or {}
-    return {name: frappe.get_attr(klass[0]) for name, klass in d.items()}
-
-def render_macro(macro_name, macro_argument):
-    # stripping the quotes on either side of the argument
-    macro_argument = _remove_quotes(macro_argument)
-
-    registry = get_macro_registry()
-    if macro_name in registry:
-        return registry[macro_name](macro_argument)
-    else:
-        return f"<p>Unknown macro: {macro_name}</p>"
-
-MACRO_RE = r'{{ *(\w+)\(([^{}]*)\) *}}'
-
-class MacroExtension(Extension):
-    """MacroExtension is a markdown extension to support macro syntax.
-    """
-    def extendMarkdown(self, md):
-        self.md = md
-        pattern = MacroInlineProcessor(MACRO_RE)
-        pattern.md = md
-        md.inlinePatterns.register(pattern, 'macro', 75)
-
-class MacroInlineProcessor(InlineProcessor):
-    """MacroInlineProcessor is class that is handles the logic
-    of how to render each macro occurence in the markdown text.
-    """
-    def handleMatch(self, m, data):
-        """Handles each macro match and return rendered contents
-        for that macro as an etree node.
-        """
-        macro = m.group(1)
-        arg = m.group(2)
-        html = render_macro(macro, arg)
-        html = sanitize_html(str(html))
-        e = etree.fromstring(html)
-        return e, m.start(0), m.end(0)
-
-def sanitize_html(html):
-    """Sanotize the html using BeautifulSoup.
-
-    The markdown processor request the correct markup and crashes on
-    any broken tags. This makes sures that all those things are fixed
-    before passing to the etree parser.
-    """
-    soup = BeautifulSoup(html, features="lxml")
-    nodes = soup.body.children
-    return "<div>" + "\n".join(str(node) for node in nodes) + "</div>"

community/lms/models.py

@@ -2,4 +2,4 @@
 """
 from .doctype.lms_course.lms_course import LMSCourse as Course
 from .doctype.lms_sketch.lms_sketch import LMSSketch as Sketch
-from .doctype.lms_batch_membership.lms_batch_membership import LMSBatchMembership as Membership
+

community/lms/web_form/add_a_new_batch/add_a_new_batch.js

@@ -1,39 +1,35 @@
 frappe.ready(function () {
-  frappe.web_form.after_save = () => {
+	frappe.web_form.after_save = () => {
-    let data = frappe.web_form.get_values();
+		let data = frappe.web_form.get_values();
-    let slug = new URLSearchParams(window.location.search).get("slug")
+		frappe.call({
-    frappe.msgprint({
+			"method": "community.lms.doctype.lms_batch_membership.lms_batch_membership.create_membership",
-      message: __("Batch {0} has been successfully created!", [data.title]),
+			"args": {
-      clear: true
+				"batch": data.title,
-    });
+				"member_type": "Mentor"
-    setTimeout(function () {
+			},
-      window.location.href = `courses/${slug}`;
+			"callback": (data) => {
-    }, 2000);
+				if (data.message == "OK") {
-  }
+					window.location.href = "/courses"
+				}
+			}
+		})
+	}
 
-  frappe.web_form.validate = () => {
+	frappe.web_form.validate = () => {
-    let sysdefaults = frappe.boot.sysdefaults;
+		let data = frappe.web_form.get_values();
-    let time_format = sysdefaults && sysdefaults.time_format ? sysdefaults.time_format : 'HH:mm:ss';
+		if (!frappe.datetime.validate(data.start_time) || !frappe.datetime.validate(data.end_time)) {
-    let data = frappe.web_form.get_values();
+			frappe.msgprint(__('Invalid Start or End Time.'));
-
+			return false;
-    data.start_time = moment(data.start_time, time_format).format(time_format)
+		}
-    data.end_time = moment(data.end_time, time_format).format(time_format)
+		if (data.start_time > data.end_time) {
-
+			frappe.msgprint(__('Start Time should be less than End Time.'));
-    if (data.start_date < frappe.datetime.nowdate()) {
+			return false;
-      frappe.msgprint(__('Start date cannot be a past date.'))
+		}
-      return false;
+		console.log(data.start_date, date.nowdate())
-    }
+		if (data.start_date < date.nowdate()) {
-
+			frappe.msgprint(__('Start date cannot be a past date.'))
-    if (!frappe.datetime.validate(data.start_time) || !frappe.datetime.validate(data.end_time)) {
+			return false;
-      frappe.msgprint(__('Invalid Start or End Time.'));
+		}
-      return false;
+		return true;
-    }
+	};	
-
+})
-    if (data.start_time > data.end_time) {
-      frappe.msgprint(__('Start Time should be less than End Time.'));
-      return false;
-    }
-
-    return true;
-  };
-})

community/lms/web_form/add_a_new_batch/add_a_new_batch.json

@@ -11,7 +11,6 @@
  "apply_document_permissions": 0,
  "button_label": "Save",
  "creation": "2021-04-20 11:37:49.135114",
- "custom_css": ".datepicker.active {\n    background-color: white;\n}\n\n[data-doctype=\"Web Form\"] {\n    max-width: 720px;\n    margin: 6rem auto;\n}",
  "doc_type": "LMS Batch",
  "docstatus": 0,
  "doctype": "Web Form",
@@ -19,7 +18,7 @@
  "is_standard": 1,
  "login_required": 1,
  "max_attachment_size": 0,
- "modified": "2021-06-15 18:49:50.530001",
+ "modified": "2021-04-26 11:08:00.026388",
  "modified_by": "Administrator",
  "module": "LMS",
  "name": "add-a-new-batch",
@@ -38,8 +37,8 @@
   {
    "allow_read_on_all_link_options": 0,
    "fieldname": "course",
-   "fieldtype": "Data",
+   "fieldtype": "Link",
-   "hidden": 1,
+   "hidden": 0,
    "label": "Course",
    "max_length": 0,
    "max_value": 0,
@@ -91,7 +90,7 @@
    "fieldname": "start_time",
    "fieldtype": "Data",
    "hidden": 0,
-   "label": "Start Time",
+   "label": "Start Time (HH:MM:SS)",
    "max_length": 0,
    "max_value": 0,
    "read_only": 0,
@@ -103,7 +102,7 @@
    "fieldname": "end_time",
    "fieldtype": "Data",
    "hidden": 0,
-   "label": "End Time",
+   "label": "End Time (HH:MM:SS)",
    "max_length": 0,
    "max_value": 0,
    "read_only": 0,

community/lms/web_form/add_a_new_batch/add_a_new_batch.py

@@ -3,5 +3,5 @@ from __future__ import unicode_literals
 import frappe
 
 def get_context(context):
-    # do your magic here
+	# do your magic here
-    pass
+	pass

community/lms/web_form/add_messages/add_messages.js

@@ -0,0 +1,12 @@
+frappe.ready(function() {
+	// bind events here
+	frappe.web_form.after_load = () => {
+		frappe.web_form.set_value(["batch"], [frappe.utils.get_url_arg('batch')]);
+		frappe.web_form.set_value(["author"], [frappe.utils.get_url_arg('author')]);
+	}
+	frappe.web_form.success_url = `courses/course?course=${frappe.utils.get_url_arg('course')}`;
+
+	$('.breadcrumb-container')
+		.html(`<a href="${frappe.web_form.success_url}">Back to my course</a>`)
+		.addClass('py-4');
+})

community/lms/web_form/add_messages/add_messages.json

@@ -0,0 +1,77 @@
+{
+ "accept_payment": 0,
+ "allow_comments": 0,
+ "allow_delete": 0,
+ "allow_edit": 0,
+ "allow_incomplete": 0,
+ "allow_multiple": 0,
+ "allow_print": 0,
+ "amount": 0.0,
+ "amount_based_on_field": 0,
+ "apply_document_permissions": 0,
+ "button_label": "Send",
+ "client_script": "",
+ "creation": "2021-03-23 13:10:16.814983",
+ "doc_type": "LMS Message",
+ "docstatus": 0,
+ "doctype": "Web Form",
+ "idx": 0,
+ "is_standard": 1,
+ "login_required": 1,
+ "max_attachment_size": 0,
+ "modified": "2021-03-23 19:25:54.984968",
+ "modified_by": "Administrator",
+ "module": "LMS",
+ "name": "add-messages",
+ "owner": "Administrator",
+ "payment_button_label": "Buy Now",
+ "published": 0,
+ "route": "add-messages",
+ "route_to_success_link": 0,
+ "show_attachments": 0,
+ "show_in_grid": 0,
+ "show_sidebar": 0,
+ "sidebar_items": [],
+ "success_url": "",
+ "title": "Add Messages",
+ "web_form_fields": [
+  {
+   "allow_read_on_all_link_options": 0,
+   "fieldname": "batch",
+   "fieldtype": "Link",
+   "hidden": 0,
+   "label": "Batch",
+   "max_length": 0,
+   "max_value": 0,
+   "options": "LMS Batch",
+   "read_only": 1,
+   "reqd": 0,
+   "show_in_filter": 0
+  },
+  {
+   "allow_read_on_all_link_options": 0,
+   "fieldname": "message",
+   "fieldtype": "Data",
+   "hidden": 0,
+   "label": "Message",
+   "max_length": 0,
+   "max_value": 0,
+   "read_only": 0,
+   "reqd": 0,
+   "show_in_filter": 0
+  },
+  {
+   "allow_read_on_all_link_options": 0,
+   "fieldname": "author",
+   "fieldtype": "Link",
+   "hidden": 1,
+   "label": "Author",
+   "max_length": 0,
+   "max_value": 0,
+   "options": "Community Member",
+   "read_only": 1,
+   "reqd": 0,
+   "show_in_filter": 0
+  }
+ ]
+}