14 | {% for question in question_feedback %} {%if question[1] == question[2]%}
15 |
20 | {%endif%} {%if question[1] != question[2]%}
21 |
26 | {%endif%} {%endfor%}
27 |
28 |
31 | {%endblock%}
32 |
--------------------------------------------------------------------------------
/src/student_network/templates/admin.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %} {% block title %}Staff Account Requests{% endblock %}
2 | {% block content %}
3 | Score: {{score}} / {{question_feedback | length}} ({{percentage}}%)
29 | Back to Quiz Page 30 |
4 |
42 | {%endblock%}
43 |
--------------------------------------------------------------------------------
/.github/workflows/main.yml:
--------------------------------------------------------------------------------
1 | name: CI
2 |
3 | # Controls when the action will run.
4 | on:
5 | # Triggers the workflow on push events but only for the main branch.
6 | push:
7 | # Allows you to run this workflow manually from the Actions tab.
8 | workflow_dispatch:
9 |
10 | jobs:
11 | build:
12 | # The type of runner that the job will run on.
13 | runs-on: ubuntu-latest
14 | # Configures the build to use the latest version of Python 3.
15 | strategy:
16 | matrix:
17 | python-version: [3.x]
18 |
19 | steps:
20 | # Checks-out your repository under $GITHUB_WORKSPACE, so your job can
21 | # access it.
22 | - uses: actions/checkout@v2
23 |
24 | - name: Run Python code formatting with Black
25 | uses: lgeiger/black-action@v1.0.1
26 | with:
27 | args: "."
28 |
29 | - name: Switch to current branch
30 | run: git checkout ${{ env.BRANCH }}
31 |
32 | - name: Set up Python ${{ matrix.python-version }}
33 | uses: actions/setup-python@v1
34 | with:
35 | python-version: ${{ matrix.python-version }}
36 |
37 | - name: Install dependencies
38 | run: |
39 | python -m pip install --upgrade pip
40 | pip install -r requirements.txt
41 | pip install -e .
42 |
43 | - name: Run unit tests with Pytest
44 | run: coverage run --source=src -m pytest -v
45 |
46 | - name: Get code coverage report
47 | run: coverage report -m
48 |
--------------------------------------------------------------------------------
/src/student_network/views/chat.py:
--------------------------------------------------------------------------------
1 | """
2 | Handles the view for the chat system and related functionality.
3 | """
4 | import os
5 |
6 | import student_network.helpers.helper_connections as helper_connections
7 | import student_network.helpers.helper_general as helper_general
8 | import student_network.helpers.helper_profile as helper_profile
9 | from flask import Blueprint, render_template
10 | from flask import session
11 |
12 | chat_blueprint = Blueprint(
13 | "chat", __name__, static_folder="static", template_folder="templates"
14 | )
15 |
16 | BASE_DIR = os.path.dirname(os.path.abspath(__file__))
17 | db_path = os.path.join(BASE_DIR, "db.sqlite3")
18 |
19 |
20 | @chat_blueprint.route("/chat")
21 | def chat():
22 | chat_rooms = helper_general.get_rooms()
23 |
24 | return render_template(
25 | "chat.html",
26 | requestCount=helper_connections.get_connection_request_count(),
27 | username=session["username"],
28 | rooms=chat_rooms,
29 | showChat=False,
30 | notifications=helper_general.get_notifications(),
31 | )
32 |
33 |
34 | @chat_blueprint.route("/chat/
5 | Staff Account Requests ({{requests|length}})
6 |
7 |
8 | {% if requests|length > 0 %} {% for request in requests %}
9 |
41 |
10 |
31 |
37 | {% endfor %} {%else:%}
38 |
32 | {{ request }}
35 |
36 | No Requests
39 | {%endif%} 40 |
14 |
49 |
50 | {%endblock%}
51 |
--------------------------------------------------------------------------------
/docs/designs/database test/templates/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
9 |
14 |
16 |
17 |
18 |
19 |
20 |
56 |
57 |
--------------------------------------------------------------------------------
/src/student_network/templates/flashcards_set.html:
--------------------------------------------------------------------------------
1 |
2 |
6 |
10 | {% extends "base.html" %} {% block title %}Flashcards view set{% endblock %} {%
11 | block content %}
12 |
13 |
14 | {% if errors %}
15 | Write a comment
42 | 43 | 53 | 54 | 55 |
16 |
22 |
23 | {% endif %}
24 |
25 |
26 |
30 |
31 | {% if questions %} {% for question in questions.keys() %}
32 |
27 |
29 | {{set_name}}
28 |
33 |
40 | {% endfor %} {% else %}
41 |
34 |
39 |
35 |
38 | Question: {{question}}
36 | Answer: {{questions[question]}}
37 |
42 |
46 | {%endif%}
47 |
48 |
59 |
60 | {% endblock %}
61 |
--------------------------------------------------------------------------------
/docs/designs/Achievements table reference.csv:
--------------------------------------------------------------------------------
1 | Achievement ID,Achievement Name,Achievement Description,XP value,Associated icon,Rarity/icon colour
2 | 1,Look at you,Visit your profile page for the first time,25,address card,bronze
3 | 2,Looking good,Visit someone else's profile for the first time,25,eye,bronze
4 | 3,Show it off,Open the achievements tab for the first time,25,trophy,bronze
5 | 4,Connected,Add your first connection,50,address book,silver
6 | 5,Popular,Add 10 connections,75,address book,gold
7 | 6,Centre of attention,Add 100 connections,150,address book,platinum
8 | 7,Express yourself,Post to your social feed for the first time,50,file alternate,silver
9 | 8,5 posts,Post to your social feed 5 times,75,file alternate,gold
10 | 9,20 posts,Post to your social feed 20 times,150,file alternate,platinum
11 | 10,Commentary,Make your first comment on a post,50,comment,silver
12 | 11,Describe yourself,Describe yourself by writing a bio,50,tags,silver
13 | 12,Friends,Add your first close connection,50,users,silver
14 | 13,Friend group,Add 10 close connections,75,users,gold
15 | 14,Reaching out,Connect with 1 person outside of your subject,50,handshake,silver
16 | 15,Outside your bubble,Connect with 10 people outside of your subject,75,handshake,gold
17 | 16,Shared intrests,Connect with someone who has a mutual intrest,50,bowling ball,silver
18 | 17,Getting social,Send a connection request,50,user plus,silver
19 | 18,Show yourself,Add a profile picture,50,user circle,silver
20 | 19,Liking that,Like a post for the first time,50,thumbs up,silver
21 | 20,First like,Receive a like on a post,50,heart,silver
22 | 21,Hot topic,Have a post reach 10 comments,100,comments,gold
23 | 22,Everyone loves you,Have a post reach 50 likes,100,heart,gold
24 | 23,Secret meeting,Login during a special event,300,user secret,diamond
25 | 24,Show the love,Like 50 posts,75,thumbs up,gold
26 | 25,Loving everything,Like 500 posts,150,thumbs up,platinum
27 | 26,Shared hobbies,Connect with someone who has a mutual hobby,50,paint brush,silver
28 |
--------------------------------------------------------------------------------
/src/student_network/static/hobbies.js:
--------------------------------------------------------------------------------
1 | hTags = [];
2 | hobbyInput = document.getElementsByName("hobbies_input")[0];
3 | hValues = document.createElement("input");
4 | hValues.setAttribute("type", "hidden");
5 | hValues.setAttribute("name", "hobbies");
6 | hobbyInput.appendChild(hValues);
7 |
8 | hobbyInput.addEventListener("input", function () {
9 | let enteredhTags = hobbyInput.value.split(",");
10 | if (enteredhTags.length > 1) {
11 | enteredhTags.forEach(function (t) {
12 | let filteredTag = filterHTag(t);
13 | if (filteredTag.length > 0) addHTag(filteredTag);
14 | });
15 | hobbyInput.value = "";
16 | }
17 | });
18 |
19 | hobbyInput.addEventListener("keydown", function (e) {
20 | let keyCode = e.which || e.keyCode;
21 | if (keyCode === 8 && hobbyInput.value.length === 0 && hTags.length > 0) {
22 | removeHTag(hTags.length - 1);
23 | }
24 | });
25 |
26 | function addHTag(text) {
27 | let tag = {
28 | text: text,
29 | element: document.createElement("div"),
30 | };
31 |
32 | label = document.createElement("div");
33 | label.classList.add("ui", "label");
34 | label.textContent = tag.text;
35 |
36 | tag.element.classList.add("ui", "labels", "teal");
37 | tag.element.appendChild(label);
38 |
39 | let closeBtn = document.createElement("i");
40 | closeBtn.classList.add("close", "icon");
41 | closeBtn.addEventListener("click", function () {
42 | removeHTag(hTags.indexOf(tag));
43 | });
44 | tag.element.firstElementChild.appendChild(closeBtn);
45 |
46 | hTags.push(tag);
47 |
48 | document.getElementsByName("hobby-div")[0].appendChild(tag.element);
49 |
50 | refreshHTags();
51 | }
52 |
53 | function removeHTag(index) {
54 | let tag = hTags[index];
55 | hTags.splice(index, 1);
56 | tag.element.remove();
57 | refreshhTags();
58 | }
59 |
60 | function refreshHTags() {
61 | let hTagsList = [];
62 | hTags.forEach(function (t) {
63 | hTagsList.push(t.text);
64 | });
65 | hValues.value = hTagsList.join(",");
66 | }
67 |
68 | function filterHTag(tag) {
69 | return tag
70 | .replace(/[^\w -]/g, "")
71 | .trim()
72 | .replace(/\W+/g, "-");
73 | }
74 |
--------------------------------------------------------------------------------
/src/student_network/static/interests.js:
--------------------------------------------------------------------------------
1 | iTags = [];
2 | interestInput = document.getElementsByName("interests_input")[0];
3 | iValues = document.createElement("input");
4 | iValues.setAttribute("type", "hidden");
5 | iValues.setAttribute("name", "interests");
6 | interestInput.appendChild(iValues);
7 |
8 | interestInput.addEventListener("input", function () {
9 | let enterediTags = interestInput.value.split(",");
10 | if (enterediTags.length > 1) {
11 | enterediTags.forEach(function (t) {
12 | let filteredTag = filterITag(t);
13 | if (filteredTag.length > 0) addITag(filteredTag);
14 | });
15 | interestInput.value = "";
16 | }
17 | });
18 |
19 | interestInput.addEventListener("keydown", function (e) {
20 | let keyCode = e.which || e.keyCode;
21 | if (keyCode === 8 && interestInput.value.length === 0 && iTags.length > 0) {
22 | removeITag(iTags.length - 1);
23 | }
24 | });
25 |
26 | function addITag(text) {
27 | let tag = {
28 | text: text,
29 | element: document.createElement("div"),
30 | };
31 |
32 | label = document.createElement("div");
33 | label.classList.add("ui", "label");
34 | label.textContent = tag.text;
35 |
36 | tag.element.classList.add("ui", "labels", "purple");
37 | tag.element.appendChild(label);
38 |
39 | let closeBtn = document.createElement("i");
40 | closeBtn.classList.add("close", "icon");
41 | closeBtn.addEventListener("click", function () {
42 | removeITag(iTags.indexOf(tag));
43 | });
44 | tag.element.firstElementChild.appendChild(closeBtn);
45 |
46 | iTags.push(tag);
47 |
48 | document.getElementsByName("interest-div")[0].appendChild(tag.element);
49 |
50 | refreshITags();
51 | }
52 |
53 | function removeITag(index) {
54 | let tag = iTags[index];
55 | iTags.splice(index, 1);
56 | tag.element.remove();
57 | refreshITags();
58 | }
59 |
60 | function refreshITags() {
61 | let iTagsList = [];
62 | iTags.forEach(function (t) {
63 | iTagsList.push(t.text);
64 | });
65 | iValues.value = iTagsList.join(",");
66 | }
67 |
68 | function filterITag(tag) {
69 | return tag
70 | .replace(/[^\w -]/g, "")
71 | .trim()
72 | .replace(/\W+/g, "-");
73 | }
74 |
--------------------------------------------------------------------------------
/src/student_network/templates/leaderboard.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | {% extends "base.html" %}
5 | {% block title %}Leaderboard{% endblock %}
6 | {% block content %}
7 | {% if errors %}
8 |
14 | {% endif %}
15 |
43 |
44 |
45 |
16 |
27 |
28 |
55 |
56 | {% endblock %}
57 |
--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # Contributing to Student Network
2 |
3 | ## Reporting Issues
4 |
5 | We use
6 | [GitHub Projects as a Kanban board](https://github.com/IsaacCheng9/student-network/projects/1)
7 | and integrate the GitHub Issues feature to track the progress of tasks and
8 | related pull requests - remember to link the issue to the Kanban board.
9 |
10 | Include the following information when reporting an issue (where possible):
11 |
12 | - Breakdown of the problem
13 | - Expected changes
14 | - Reproducible steps (if reporting a bug)
15 |
16 | The `high priority` label should be sparingly to avoid diluting its
17 | significance - overuse of this defeats the purpose of the label.
18 |
19 | ## Project Structure
20 |
21 | This project uses _Flask Blueprints_ to organise the application (more info
22 | [here](https://exploreflask.com/en/latest/blueprints.html)).
23 |
24 | We use a _functional structure_, where pieces of the application are organised
25 | by what they do (further explanation using Facebook as an example
26 | [here](https://exploreflask.com/en/latest/blueprints.html#which-one-is-best)).
27 | Each Python file in the [/views/](src/student_network/views) directory represents a
28 | blueprint, which is registered in the main application in
29 | [app.py](src/student_network/app.py).
30 |
31 | ## Pull Requests
32 |
33 | Include the following information when submitting a pull request:
34 |
35 | - Overview of the changes
36 | - Where needed, add explanations about what the changes will effect and why
37 | they were made.
38 | - Related issues
39 | - Using the `This fixes {link to issue}` syntax will automatically close the
40 | issue once merged.
41 |
42 | ## Unit Tests
43 |
44 | Unit tests should be created and maintained as changes are made to the core
45 | functionality to improve maintainability.
46 |
47 | We use the _Pytest_ framework for this, which has been integrated into GitHub
48 | Actions for automated unit testing (see below).
49 |
50 | ## GitHub Actions
51 |
52 | After pushing to the repository, the workflow in GitHub Actions consists of:
53 |
54 | - Running Python code formatting with _Black_
55 | - This ensures good readability and a consistent style across the codebase to
56 | reduce diffs for code reviews.
57 | - Running all unit tests for Python with _Pytest_
58 | - This helps prevent runtime errors in production.
59 | - Test should be created and kept updated to facilitate this.
60 |
--------------------------------------------------------------------------------
/src/student_network/static/slideshow.js:
--------------------------------------------------------------------------------
1 | class Slideshow {
2 | constructor(targetID, images, captions) {
3 | this.images = images;
4 |
5 | this.targetID = targetID;
6 |
7 | this.index = 0;
8 |
9 | var html = `
17 |
25 |
26 |
18 |
24 | Your Ranking
19 | #{{ myRanking }} / {{ totalUserCount }}
21 |
22 | Top {{percent}}%
23 | Rank |
30 | User |
31 | Level |
32 | Total XP |
33 |
|---|---|---|---|
#{{ i + 1}} |
39 |
40 |
41 |
48 | {{ leaderboard[i][4] }}
45 |
46 | |
49 | {{ leaderboard[i][3][0] }} |
50 | {{ leaderboard[i][1] }} |
51 |
`;
10 |
11 | for (var i = 0; i < images.length; i++) {
12 | html += `
27 |
13 | 
19 |
`;
21 | }
22 |
23 | html += `❮
24 | ❯`;
25 |
26 | html += `${i + 1} / ${
14 | images.length
15 | }
16 | ${captions[i]}
20 | `;
28 |
29 | for (var i = 0; i < images.length; i++) {
30 | html += ``;
31 | }
32 |
33 | $("#" + targetID).append(html + "
");
34 |
35 | var me = this;
36 |
37 | var id = "#" + this.targetID;
38 |
39 | $(id)
40 | .find(".dot")
41 | .on("click", function () {
42 | me.SetIndex($(this));
43 | });
44 |
45 | $(id)
46 | .find(".prev")
47 | .on("click", function () {
48 | me.PrevSlide();
49 | });
50 |
51 | $(id)
52 | .find(".next")
53 | .on("click", function () {
54 | me.NextSlide();
55 | });
56 |
57 | this.UpdateUI();
58 | }
59 |
60 | NextSlide() {
61 | this.index = (this.index + 1) % this.images.length;
62 | this.UpdateUI();
63 | }
64 |
65 | PrevSlide() {
66 | this.index = (this.index - 1) % this.images.length;
67 | this.UpdateUI();
68 | }
69 |
70 | SetIndex(elem) {
71 | var index = elem.index();
72 |
73 | this.index = index;
74 | this.UpdateUI();
75 | }
76 |
77 | UpdateUI() {
78 | var slides = $("#" + this.targetID).find(".slide-img");
79 | var dots = $("#" + this.targetID).find(".dot");
80 |
81 | $(slides).css("display", "none");
82 | $(dots).removeClass("active");
83 |
84 | $(slides).eq(this.index).css("display", "block");
85 | $(dots).eq(this.index).addClass("active");
86 | }
87 | }
88 |
89 | function OpenModal(imgSrc) {
90 | $(".modal img").attr("src", imgSrc);
91 | $(".modal").fadeIn();
92 | }
93 |
94 | function CloseModal() {
95 | $(".modal").fadeOut();
96 | }
97 |
98 | $(".modal").hide();
99 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Byte-compiled / optimized / DLL files
2 | __pycache__/
3 | *.py[cod]
4 | *$py.class
5 |
6 | # C extensions
7 | *.so
8 |
9 | # Distribution / packaging
10 | .Python
11 | build/
12 | develop-eggs/
13 | dist/
14 | downloads/
15 | eggs/
16 | .eggs/
17 | lib/
18 | lib64/
19 | parts/
20 | sdist/
21 | var/
22 | wheels/
23 | pip-wheel-metadata/
24 | share/python-wheels/
25 | *.egg-info/
26 | .installed.cfg
27 | *.egg
28 | MANIFEST
29 |
30 | # PyInstaller
31 | # Usually these files are written by a python script from a template
32 | # before PyInstaller builds the exe, so as to inject date/other infos into it.
33 | *.manifest
34 | *.spec
35 |
36 | # Installer logs
37 | pip-log.txt
38 | pip-delete-this-directory.txt
39 |
40 | # Unit test / coverage reports
41 | htmlcov/
42 | .tox/
43 | .nox/
44 | .coverage
45 | .coverage.*
46 | .cache
47 | nosetests.xml
48 | coverage.xml
49 | *.cover
50 | *.py,cover
51 | .hypothesis/
52 | .pytest_cache/
53 |
54 | # Translations
55 | *.mo
56 | *.pot
57 |
58 | # Django stuff:
59 | *.log
60 | local_settings.py
61 |
62 | # Flask stuff:
63 | instance/
64 | .webassets-cache
65 |
66 | # Scrapy stuff:
67 | .scrapy
68 |
69 | # Sphinx documentation
70 | docs/_build/
71 |
72 | # PyBuilder
73 | target/
74 |
75 | # Jupyter Notebook
76 | .ipynb_checkpoints
77 |
78 | # IPython
79 | profile_default/
80 | ipython_config.py
81 |
82 | # pyenv
83 | .python-version
84 |
85 | # pipenv
86 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
87 | # However, in case of collaboration, if having platform-specific dependencies or dependencies
88 | # having no cross-platform support, pipenv may install dependencies that don't work, or not
89 | # install all needed dependencies.
90 | #Pipfile.lock
91 |
92 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
93 | __pypackages__/
94 |
95 | # Celery stuff
96 | celerybeat-schedule
97 | celerybeat.pid
98 |
99 | # SageMath parsed files
100 | *.sage.py
101 |
102 | # Environments
103 | .env
104 | .venv
105 | env/
106 | venv/
107 | ENV/
108 | env.bak/
109 | venv.bak/
110 |
111 | # Spyder project settings
112 | .spyderproject
113 | .spyproject
114 |
115 | # Rope project settings
116 | .ropeproject
117 |
118 | # mkdocs documentation
119 | /site
120 |
121 | # mypy
122 | .mypy_cache/
123 | .dmypy.json
124 | dmypy.json
125 |
126 | # Pyre type checker
127 | .pyre/
128 |
129 | # VS Code
130 | .vscode/launch.json
131 | .vscode/settings.json
132 |
133 | # IntelliJ
134 | .idea
135 | identifier.sqlite
136 |
137 | # Databases
138 | *.db
--------------------------------------------------------------------------------
/.github/workflows/codeql-analysis.yml:
--------------------------------------------------------------------------------
1 | # For most projects, this workflow file will not need changing; you simply need
2 | # to commit it to your repository.
3 | #
4 | # You may wish to alter this file to override the set of languages analyzed,
5 | # or to provide custom queries or build logic.
6 | #
7 | # ******** NOTE ********
8 | # We have attempted to detect the languages in your repository. Please check
9 | # the `language` matrix defined below to confirm you have the correct set of
10 | # supported CodeQL languages.
11 | #
12 | name: "CodeQL"
13 |
14 | on:
15 | push:
16 | branches: [ main ]
17 | pull_request:
18 | # The branches below must be a subset of the branches above
19 | branches: [ main ]
20 | schedule:
21 | - cron: '43 16 * * 2'
22 |
23 | jobs:
24 | analyze:
25 | name: Analyze
26 | runs-on: ubuntu-latest
27 | permissions:
28 | actions: read
29 | contents: read
30 | security-events: write
31 |
32 | strategy:
33 | fail-fast: false
34 | matrix:
35 | language: [ 'javascript', 'python' ]
36 | # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
37 | # Learn more about CodeQL language support at https://git.io/codeql-language-support
38 |
39 | steps:
40 | - name: Checkout repository
41 | uses: actions/checkout@v2
42 |
43 | # Initializes the CodeQL tools for scanning.
44 | - name: Initialize CodeQL
45 | uses: github/codeql-action/init@v1
46 | with:
47 | languages: ${{ matrix.language }}
48 | # If you wish to specify custom queries, you can do so here or in a config file.
49 | # By default, queries listed here will override any specified in a config file.
50 | # Prefix the list here with "+" to use these queries and those in the config file.
51 | # queries: ./path/to/local/query, your-org/your-repo/queries@main
52 |
53 | # Autobuild attempts to build any compiled languages (C/C++, C#, or Java).
54 | # If this step fails, then you should remove it and run the build manually (see below)
55 | - name: Autobuild
56 | uses: github/codeql-action/autobuild@v1
57 |
58 | # ℹ️ Command-line programs to run using the OS shell.
59 | # 📚 https://git.io/JvXDl
60 |
61 | # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
62 | # and modify them (or add more) to build your code if your project
63 | # uses a compiled language
64 |
65 | #- run: |
66 | # make bootstrap
67 | # make release
68 |
69 | - name: Perform CodeQL Analysis
70 | uses: github/codeql-action/analyze@v1
71 |
--------------------------------------------------------------------------------
/src/student_network/static/styles/mobile.css:
--------------------------------------------------------------------------------
1 | /* Semantic UI has these classes, however they're only applicable to*/
2 | /* grids, containers, rows and columns.*/
3 | /* plus, there isn't any `mobile hidden`, `X hidden` class.*/
4 | /* this snippet is using the same class names and same approach*/
5 | /* plus a bit more but to all elements.*/
6 | /* see https://github.com/Semantic-Org/Semantic-UI/issues/1114*/
7 |
8 | /* Mobile */
9 | @media only screen and (max-width: 767px) {
10 | [class*="mobile hidden"],
11 | [class*="tablet only"]:not(.mobile),
12 | [class*="computer only"]:not(.mobile),
13 | [class*="large screen only"]:not(.mobile),
14 | [class*="widescreen only"]:not(.mobile),
15 | [class*="or lower hidden"] {
16 | display: none !important;
17 | }
18 | }
19 |
20 | /* Tablet / iPad Portrait */
21 | @media only screen and (min-width: 768px) and (max-width: 991px) {
22 | [class*="mobile only"]:not(.tablet),
23 | [class*="tablet hidden"],
24 | [class*="computer only"]:not(.tablet),
25 | [class*="large screen only"]:not(.tablet),
26 | [class*="widescreen only"]:not(.tablet),
27 | [class*="or lower hidden"]:not(.mobile) {
28 | display: none !important;
29 | }
30 | }
31 |
32 | /* Computer / Desktop / iPad Landscape */
33 | @media only screen and (min-width: 992px) and (max-width: 1199px) {
34 | [class*="mobile only"]:not(.computer),
35 | [class*="tablet only"]:not(.computer),
36 | [class*="computer hidden"],
37 | [class*="large screen only"]:not(.computer),
38 | [class*="widescreen only"]:not(.computer),
39 | [class*="or lower hidden"]:not(.tablet):not(.mobile) {
40 | display: none !important;
41 | }
42 | }
43 |
44 | /* Large Monitor */
45 | @media only screen and (min-width: 1200px) and (max-width: 1919px) {
46 | [class*="mobile only"]:not([class*="large screen"]),
47 | [class*="tablet only"]:not([class*="large screen"]),
48 | [class*="computer only"]:not([class*="large screen"]),
49 | [class*="large screen hidden"],
50 | [class*="widescreen only"]:not([class*="large screen"]),
51 | [class*="or lower hidden"]:not(.computer):not(.tablet):not(.mobile) {
52 | display: none !important;
53 | }
54 | }
55 |
56 | /* Widescreen Monitor */
57 | @media only screen and (min-width: 1920px) {
58 | [class*="mobile only"]:not([class*="widescreen"]),
59 | [class*="tablet only"]:not([class*="widescreen"]),
60 | [class*="computer only"]:not([class*="widescreen"]),
61 | [class*="large screen only"]:not([class*="widescreen"]),
62 | [class*="widescreen hidden"],
63 | [class*="widescreen or lower hidden"] {
64 | display: none !important;
65 | }
66 | }
--------------------------------------------------------------------------------
/prototypes/registration.py:
--------------------------------------------------------------------------------
1 | """Handles the registration process for a new user account."""
2 | import re
3 | import sqlite3
4 | from email_validator import validate_email, EmailNotValidError
5 |
6 |
7 | def main():
8 | with sqlite3.connect("../db.sqlite3") as conn:
9 | cur = conn.cursor()
10 | # Gets the user inputs from the registration page.
11 | username = "ic324"
12 | password = "Password01"
13 | password_confirm = "Password01"
14 | email = "ic324@exeter.ac.uk"
15 | valid = validate_registration(cur, username, password, password_confirm, email)
16 | print(valid)
17 | conn.commit()
18 |
19 |
20 | def validate_registration(
21 | cur, username: str, password: str, password_confirm: str, email: str
22 | ) -> bool:
23 | """
24 | Validates the registration details to ensure that the email address is
25 | valid, and that the passwords in the form match.
26 |
27 | Arguments:
28 | cur: Cursor for the SQLite database.
29 | username: The username input by the user in the form.
30 | password: The password input by the user in the form.
31 | password_confirm: The password confirmation input by the user in the
32 | form.
33 | email: The email address input by the user in the form.
34 |
35 | Returns:
36 | valid (bool): States whether the registration details are valid.
37 | """
38 | valid = True
39 |
40 | # Checks that the email address has the correct format, checks whether it
41 | # exists, and isn't a blacklist email.
42 | try:
43 | valid_email = validate_email(email)
44 | # Updates with the normalised form of the email address.
45 | email = valid_email.email
46 | except EmailNotValidError:
47 | print("Email is invalid!")
48 | valid = False
49 |
50 | # Checks that the email address has the University of Exeter domain.
51 | domain = re.search("@.*", email).group()
52 | if domain != "@exeter.ac.uk":
53 | print("Email address does not belong to University of Exeter!")
54 | valid = False
55 |
56 | # Checks that the username hasn't already been registered.
57 | cur.execute("SELECT * FROM Accounts WHERE username=?;", (username,))
58 | if cur.fetchone() is not None:
59 | print("Username has already been registered!")
60 | valid = False
61 |
62 | # Checks that the password has a minimum length of 6 characters, and at
63 | # least one number.
64 | if len(password) <= 5 or any(char.isdigit() for char in password) is False:
65 | print("Password does not meet requirements!")
66 | valid = False
67 |
68 | # Checks that the passwords match.
69 | if password != password_confirm:
70 | print("Passwords do not match!")
71 | valid = False
72 |
73 | return valid
74 |
75 |
76 | if __name__ == "__main__":
77 | main()
78 |
--------------------------------------------------------------------------------
/src/student_network/app.py:
--------------------------------------------------------------------------------
1 | """
2 | A student network application which is presented as a web application using
3 | the Flask module. Students each have their own profile page, and they can post
4 | on their feed.
5 | """
6 | import os
7 | import sqlite3
8 | from datetime import datetime
9 |
10 | import student_network.views.achievements as achievements
11 | import student_network.views.chat as chat
12 | import student_network.views.connections as connections
13 | import student_network.views.flashcards as flashcards
14 | import student_network.views.login as login
15 | import student_network.views.posts as posts
16 | import student_network.views.profile as profile
17 | import student_network.views.quizzes as quizzes
18 | import student_network.views.staff as staff
19 | from flask import Flask, request, session
20 | from flask_socketio import SocketIO
21 |
22 | BASE_DIR = os.path.dirname(os.path.abspath(__file__))
23 | DB_PATH = os.path.join(BASE_DIR, "db.sqlite3")
24 |
25 | app = Flask(__name__)
26 | socketio = SocketIO(app)
27 | app.register_blueprint(achievements.achievements_blueprint, url_prefix="")
28 | app.register_blueprint(chat.chat_blueprint, url_prefix="")
29 | app.register_blueprint(connections.connections_blueprint, url_prefix="")
30 | app.register_blueprint(login.login_blueprint, url_prefix="")
31 | app.register_blueprint(posts.posts_blueprint, url_prefix="")
32 | app.register_blueprint(profile.profile_blueprint, url_prefix="")
33 | app.register_blueprint(quizzes.quizzes_blueprint, url_prefix="")
34 | app.register_blueprint(flashcards.flashcards_blueprint, url_prefix="")
35 | app.register_blueprint(staff.staff_blueprint, url_prefix="")
36 | app.secret_key = (
37 | '\xfd{H\xe5 <\x95\xf9\xe3\x96.5\xd1\x01O .content {
120 | position: absolute;
121 | top: 0;
122 | bottom: 0;
123 | width: 50%;
124 | left: 50%;
125 | transform: translate(-50%);
126 | }
127 |
128 | .modal .content img {
129 | position: relative;
130 | top: 0;
131 | bottom: 0;
132 | }
133 |
134 | .close-icon {
135 | font-size: 2em;
136 | cursor: pointer;
137 | color: #333;
138 | width: 100%;
139 | position: relative;
140 | top: 1em;
141 | right: 0;
142 | }
143 |
--------------------------------------------------------------------------------
/src/student_network/views/staff.py:
--------------------------------------------------------------------------------
1 | """
2 | Handles the view for staff administration tools and related functionality.
3 | """
4 |
5 | import sqlite3
6 |
7 | import student_network.helpers.helper_connections as helper_connections
8 | from flask import Blueprint, redirect, render_template, session
9 |
10 | staff_blueprint = Blueprint(
11 | "staff", __name__, static_folder="static", template_folder="templates"
12 | )
13 |
14 |
15 | @staff_blueprint.route("/admin", methods=["GET", "POST"])
16 | def show_staff_requests() -> object:
17 | """
18 | Displays requests to sign up as a staff member.
19 |
20 | Returns:
21 | The web page for handling administration.
22 | """
23 | if "admin" in session:
24 | if not session["admin"]:
25 | return render_template(
26 | "error.html",
27 | message=["You are not logged in to an admin account"],
28 | requestCount=helper_connections.get_connection_request_count(),
29 | )
30 | with sqlite3.connect("db.sqlite3") as conn:
31 | # Loads the list of connection requests and their avatars.
32 | requests = []
33 | cur = conn.cursor()
34 | # Extracts incoming requests.
35 | cur.execute("SELECT username FROM ACCOUNTS WHERE type='pending_staff';")
36 | conn.commit()
37 | row = cur.fetchall()
38 | if len(row) > 0:
39 | for elem in row:
40 | requests.append(elem[0])
41 |
42 | return render_template(
43 | "admin.html",
44 | requests=requests,
45 | requestCount=helper_connections.get_connection_request_count(),
46 | )
47 | else:
48 | return render_template(
49 | "error.html",
50 | message=["You are not logged in to an admin account"],
51 | requestCount=helper_connections.get_connection_request_count(),
52 | )
53 |
54 |
55 | @staff_blueprint.route("/accept_staff/
13 |
43 |
59 |
93 | {% endblock %}
94 |
--------------------------------------------------------------------------------
/docs/designs/django_test/mysite/poll/views.py:
--------------------------------------------------------------------------------
1 | from django.http import HttpResponseRedirect
2 | from django.shortcuts import get_object_or_404, render
3 | from django.urls import reverse
4 | from django.views import generic
5 |
6 | from django.utils import timezone
7 |
8 | from .models import Choice, Question
9 |
10 | """
11 | def index(request):
12 | return HttpResponse("Hello, world. You're at the poll index.")
13 |
14 | def detail(request, question_id):
15 | return HttpResponse("You're looking at question %s." % question_id)
16 |
17 | def results(request, question_id):
18 | question = get_object_or_404(Question, pk=question_id)
19 | return render(request, 'poll/results.html', {'question': question})
20 | """
21 |
22 |
23 | class IndexView(generic.ListView):
24 | template_name = "poll/index.html"
25 | context_object_name = "latest_question_list"
26 |
27 | def get_queryset(self):
28 | """
29 | Return the last five published questions (not including those set to be
30 | published in the future).
31 | """
32 | return Question.objects.filter(pub_date__lte=timezone.now()).order_by(
33 | "-pub_date"
34 | )[:5]
35 |
36 |
37 | class DetailView(generic.DetailView):
38 | model = Question
39 | template_name = "poll/detail.html"
40 |
41 | def get_queryset(self):
42 | """
43 | Excludes any questions that aren't published yet.
44 | """
45 | return Question.objects.filter(pub_date__lte=timezone.now())
46 |
47 |
48 | class ResultsView(generic.DetailView):
49 | model = Question
50 | template_name = "poll/results.html"
51 |
52 |
53 | def vote(request, question_id):
54 | question = get_object_or_404(Question, pk=question_id)
55 | try:
56 | selected_choice = question.choice_set.get(pk=request.POST["choice"])
57 | except (KeyError, Choice.DoesNotExist):
58 | # Redisplay the question voting form.
59 | return render(
60 | request,
61 | "poll/detail.html",
62 | {
63 | "question": question,
64 | "error_message": "You didn't select a choice.",
65 | },
66 | )
67 | else:
68 | selected_choice.votes += 1
69 | selected_choice.save()
70 | # Always return an HttpResponseRedirect after successfully dealing
71 | # with POST data. This prevents data from being posted twice if a
72 | # user hits the Back button.
73 | return HttpResponseRedirect(reverse("poll:results", args=(question.id,)))
74 |
75 |
76 | def index(request):
77 | latest_question_list = Question.objects.order_by("-pub_date")[:5]
78 | context = {"latest_question_list": latest_question_list}
79 | return render(request, "poll/index.html", context)
80 |
81 |
82 | def detail(request, question_id):
83 | try:
84 | question = Question.objects.get(pk=question_id)
85 | except Question.DoesNotExist:
86 | raise Http404("Question does not exist")
87 | return render(request, "poll/detail.html", {"question": question})
88 |
89 |
90 | """
91 | def detail(request, question_id):
92 | question = get_object_or_404(Question, pk=question_id)
93 | return render(request, 'poll/detail.html', {'question': question})
94 | """
95 |
--------------------------------------------------------------------------------
/src/student_network/templates/flashcards_view.html:
--------------------------------------------------------------------------------
1 |
2 |
6 |
10 | {% extends "base.html" %} {% block title %}Flashcard set list{% endblock %} {%
11 | block content %}
12 |
13 |
14 |
14 |
24 |
15 |
23 | Welcome to Reconnect!
16 |
17 |
22 | 18 | Reconnect is a student network application for the University of 19 | Exeter. 20 |
21 |
25 |
26 | Our aim with Reconnect is to increase student interaction with other
27 | students through fun games, posts, and discussions. This application will
28 | also encourage students to communicate and bond through degree-related
29 | topics, with the help of both student and staff-made quizzes.
30 |
31 |
32 |
33 |
34 | Get Started:
35 | 36 | 37 | 38 | or 39 | 40 | 41 | 42 |43 |
44 |
58 | Search For a User:
45 |
46 |
55 |
56 |
57 |
47 |
52 |
53 |
54 |
15 | {% if errors %} {% if "delete set" in errors %}
16 |
20 | {% else %}
21 |
27 | {% endif %} {% endif %}
28 |
60 |
61 | {% for card_set in sets %}
62 |
29 |
58 |
59 |
63 |
99 | {% endfor %} {% endblock %}
100 |
--------------------------------------------------------------------------------
/docs/designs/django_test/mysite/mysite/settings.py:
--------------------------------------------------------------------------------
1 | """
2 | Django settings for mysite project.
3 |
4 | Generated by 'django-admin startproject' using Django 3.1.6.
5 |
6 | For more information on this file, see
7 | https://docs.djangoproject.com/en/3.1/topics/settings/
8 |
9 | For the full list of settings and their values, see
10 | https://docs.djangoproject.com/en/3.1/ref/settings/
11 | """
12 |
13 | from pathlib import Path
14 |
15 | # Build paths inside the project like this: BASE_DIR / 'subdir'.
16 | BASE_DIR = Path(__file__).resolve().parent.parent
17 |
18 |
19 | # Quick-start development settings - unsuitable for production
20 | # See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
21 |
22 | # SECURITY WARNING: keep the secret key used in production secret!
23 | SECRET_KEY = "w_4$(rsh7hcg_a27w+5ua_k&d8$q&qg5okk++q0hj#qx*b+(e@"
24 |
25 | # SECURITY WARNING: don't run with debug turned on in production!
26 | DEBUG = True
27 |
28 | ALLOWED_HOSTS = []
29 |
30 |
31 | # Application definition
32 |
33 | INSTALLED_APPS = [
34 | "poll.apps.PollConfig",
35 | "django.contrib.admin",
36 | "django.contrib.auth",
37 | "django.contrib.contenttypes",
38 | "django.contrib.sessions",
39 | "django.contrib.messages",
40 | "django.contrib.staticfiles",
41 | ]
42 |
43 | MIDDLEWARE = [
44 | "django.middleware.security.SecurityMiddleware",
45 | "django.contrib.sessions.middleware.SessionMiddleware",
46 | "django.middleware.common.CommonMiddleware",
47 | "django.middleware.csrf.CsrfViewMiddleware",
48 | "django.contrib.auth.middleware.AuthenticationMiddleware",
49 | "django.contrib.messages.middleware.MessageMiddleware",
50 | "django.middleware.clickjacking.XFrameOptionsMiddleware",
51 | ]
52 |
53 | ROOT_URLCONF = "mysite.urls"
54 |
55 | TEMPLATES = [
56 | {
57 | "BACKEND": "django.template.backends.django.DjangoTemplates",
58 | "DIRS": [],
59 | "APP_DIRS": True,
60 | "OPTIONS": {
61 | "context_processors": [
62 | "django.template.context_processors.debug",
63 | "django.template.context_processors.request",
64 | "django.contrib.auth.context_processors.auth",
65 | "django.contrib.messages.context_processors.messages",
66 | ],
67 | },
68 | },
69 | ]
70 |
71 | WSGI_APPLICATION = "mysite.wsgi.application"
72 |
73 |
74 | # Database
75 | # https://docs.djangoproject.com/en/3.1/ref/settings/#databases
76 |
77 | DATABASES = {
78 | "default": {
79 | "ENGINE": "django.db.backends.sqlite3",
80 | "NAME": BASE_DIR / "db.sqlite3",
81 | }
82 | }
83 |
84 |
85 | # Password validation
86 | # https://docs.djangoproject.com/en/3.1/ref/settings/#auth-password-validators
87 |
88 | AUTH_PASSWORD_VALIDATORS = [
89 | {
90 | "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
91 | },
92 | {
93 | "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
94 | },
95 | {
96 | "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
97 | },
98 | {
99 | "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
100 | },
101 | ]
102 |
103 |
104 | # Internationalization
105 | # https://docs.djangoproject.com/en/3.1/topics/i18n/
106 |
107 | LANGUAGE_CODE = "en-us"
108 |
109 | TIME_ZONE = "GMT"
110 |
111 | USE_I18N = True
112 |
113 | USE_L10N = True
114 |
115 | USE_TZ = True
116 |
117 |
118 | # Static files (CSS, JavaScript, Images)
119 | # https://docs.djangoproject.com/en/3.1/howto/static-files/
120 |
121 | STATIC_URL = "/static/"
122 |
--------------------------------------------------------------------------------
/src/student_network/templates/flashcards_play.html:
--------------------------------------------------------------------------------
1 |
2 |
6 |
10 |
11 |
60 |
61 | {% extends "base.html" %} {% block title %} Flashcards {% endblock %} {% block
62 | content %} {% if question_count > 0 %}
63 |
64 |
65 |
66 |
67 |
68 |
64 |
98 |
65 |
66 | {{ card_set[3] }}
67 |
71 | Created by
72 |
73 |
97 |
66 | {{ card_set[3] }}
67 |
68 | {{ card_set[1] }}
69 |
70 |
71 | Created by
72 |
73 | {{ card_set[1] }}
69 |
74 | {{ card_set[2] }}
75 |
84 |
85 | {% if card_set[2] == username %}
86 |
76 | {{ card_set[5] }} {% if card_set[5]==1 %} card {% else %} cards {%
77 | endif %}
78 |
79 |
80 | {{ card_set[4] }} {% if card_set[4]==1 %} play {% else %} plays {%
81 | endif %}
82 |
83 |
87 |
90 |
93 |
94 |
95 | {% endif %}
96 |
69 |
70 |
71 |
82 | {% else %}
83 |
84 |
88 | {% endif %}
89 |
90 |
141 |
142 | {%endblock%}
143 |
--------------------------------------------------------------------------------
/src/student_network/templates/privacy_policy.html:
--------------------------------------------------------------------------------
1 |
2 |
6 |
10 | {% extends "base.html" %} {% block title %}Privacy Policy{% endblock %} {% block
11 | content %}
12 |
85 |
86 |
87 |
13 |
79 |
80 | {%endblock%}
81 |
--------------------------------------------------------------------------------
/src/student_network/templates/flashcards_edit.html:
--------------------------------------------------------------------------------
1 |
2 |
6 |
10 | {% extends "base.html" %} {% block title %}Flashcards edit set{% endblock %} {%
11 | block content %}
12 |
13 |
14 | {% if errors %} {% if "save" in errors %}
15 |
19 | {% else %}
20 |
21 |
27 |
28 | {% endif %} {% endif %}
29 |
30 |
35 |
36 |
49 |
50 | {% if questions %} {% for question in questions.keys() %}
51 |
37 |
48 |
38 |
39 |
46 |
47 |
52 |
90 | {% endfor %} {% else %}
91 |
53 |
88 |
89 |
54 |
87 |
55 |
65 |
56 |
63 |
64 |
66 |
76 |
67 |
74 |
75 |
77 |
85 |
86 |
92 |
96 | {%endif%}
97 |
98 |
99 |
103 |
104 |
105 |
109 |
110 |
111 |
115 |
116 |
125 |
126 |
127 |
131 |
132 |
133 |
134 |
135 |
136 |
137 | {% endblock %}
138 |
--------------------------------------------------------------------------------
/docs/designs/django_test/mysite/poll/tests.py:
--------------------------------------------------------------------------------
1 | import datetime
2 |
3 | from django.test import TestCase
4 | from django.utils import timezone
5 |
6 | from django.urls import reverse
7 |
8 | from .models import Question
9 |
10 |
11 | class QuestionModelTests(TestCase):
12 | def test_was_published_recently_with_future_question(self):
13 | """
14 | was_published_recently() returns False for questions whose pub_date
15 | is in the future.
16 | """
17 | time = timezone.now() + datetime.timedelta(days=30)
18 | future_question = Question(pub_date=time)
19 | self.assertIs(future_question.was_published_recently(), False)
20 |
21 | def test_was_published_recently_with_old_question(self):
22 | """
23 | was_published_recently() returns False for questions whose pub_date
24 | is older than 1 day.
25 | """
26 | time = timezone.now() - datetime.timedelta(days=1, seconds=1)
27 | old_question = Question(pub_date=time)
28 | self.assertIs(old_question.was_published_recently(), False)
29 |
30 | def test_was_published_recently_with_recent_question(self):
31 | """
32 | was_published_recently() returns True for questions whose pub_date
33 | is within the last day.
34 | """
35 | time = timezone.now() - datetime.timedelta(hours=23, minutes=59, seconds=59)
36 | recent_question = Question(pub_date=time)
37 | self.assertIs(recent_question.was_published_recently(), True)
38 |
39 | def create_question(question_text, days):
40 | """
41 | Create a question with the given `question_text` and published the
42 | given number of `days` offset to now (negative for questions published
43 | in the past, positive for questions that have yet to be published).
44 | """
45 | time = timezone.now() + datetime.timedelta(days=days)
46 | return Question.objects.create(question_text=question_text, pub_date=time)
47 |
48 |
49 | class QuestionIndexViewTests(TestCase):
50 | def test_no_questions(self):
51 | """
52 | If no questions exist, an appropriate message is displayed.
53 | """
54 | response = self.client.get(reverse("poll:index"))
55 | self.assertEqual(response.status_code, 200)
56 | self.assertContains(response, "No polls are available.")
57 | self.assertQuerysetEqual(response.context["latest_question_list"], [])
58 |
59 | def test_past_question(self):
60 | """
61 | Questions with a pub_date in the past are displayed on the
62 | index page.
63 | """
64 | create_question(question_text="Past question.", days=-30)
65 | response = self.client.get(reverse("poll:index"))
66 | self.assertQuerysetEqual(
67 | response.context["latest_question_list"], ["
93 |
94 |
95 |
14 |
62 |
63 |
135 |
136 | {%endblock%}
137 |
--------------------------------------------------------------------------------
/src/student_network/views/achievements.py:
--------------------------------------------------------------------------------
1 | """
2 | Handles the view for achievements and related functionality.
3 | """
4 |
5 | import sqlite3
6 |
7 | import student_network.helpers.helper_achievements as helper_achievements
8 | import student_network.helpers.helper_connections as helper_connections
9 | import student_network.helpers.helper_general as helper_general
10 | import student_network.helpers.helper_profile as helper_profile
11 | from flask import Blueprint, render_template, request, session
12 |
13 | achievements_blueprint = Blueprint(
14 | "achievements", __name__, static_folder="static", template_folder="templates"
15 | )
16 |
17 |
18 | @achievements_blueprint.route("/achievements", methods=["GET"])
19 | def achievements() -> object:
20 | """
21 | Display achievements which the user has unlocked/locked.
22 |
23 | Returns:
24 | The web page for viewing achievements.
25 | """
26 | unlocked_achievements, locked_achievements = helper_achievements.get_achievements(
27 | session["username"]
28 | )
29 |
30 | # Displays the percentage of achievements unlocked.
31 | percentage = int(
32 | 100
33 | * len(unlocked_achievements)
34 | / (len(unlocked_achievements) + len(locked_achievements))
35 | )
36 | percentage_color = "green"
37 | if percentage < 75:
38 | percentage_color = "yellow"
39 | if percentage < 50:
40 | percentage_color = "orange"
41 | if percentage < 25:
42 | percentage_color = "red"
43 |
44 | # Award achievement ID 3 - Show it off if necessary
45 | helper_achievements.apply_achievement(session["username"], 3)
46 |
47 | session["prev-page"] = request.url
48 | return render_template(
49 | "achievements.html",
50 | unlocked_achievements=unlocked_achievements,
51 | locked_achievements=locked_achievements,
52 | requestCount=helper_connections.get_connection_request_count(),
53 | allUsernames=helper_general.get_all_usernames(),
54 | percentage=percentage,
55 | percentage_color=percentage_color,
56 | notifications=helper_general.get_notifications(),
57 | )
58 |
59 |
60 | @achievements_blueprint.route("/leaderboard", methods=["GET"])
61 | def leaderboard() -> object:
62 | """
63 | Displays leaderboard of users with the most experience.
64 |
65 | Returns:
66 | The web page for viewing rankings.
67 | """
68 | with sqlite3.connect("db.sqlite3") as conn:
69 | cur = conn.cursor()
70 | cur.execute("SELECT * FROM UserLevel ORDER BY experience DESC")
71 | top_users = cur.fetchall()
72 | if top_users:
73 | total_user_count = len(top_users)
74 |
75 | my_ranking = helper_achievements.binary_search(
76 | top_users,
77 | (session["username"], helper_general.get_exp(session["username"])),
78 | )
79 |
80 | top_users = top_users[0 : min(25, len(top_users))]
81 | top_users = list(
82 | map(
83 | lambda x: (
84 | x[0],
85 | x[1],
86 | helper_profile.get_profile_picture(x[0]),
87 | helper_profile.get_level(x[0]),
88 | helper_profile.get_degree(x[0])[1],
89 | ),
90 | top_users,
91 | )
92 | )
93 | percent = int(100 * (my_ranking / total_user_count))
94 | session["prev-page"] = request.url
95 | if "error" in session:
96 | errors = session["error"]
97 | session.pop("error", None)
98 | return render_template(
99 | "leaderboard.html",
100 | leaderboard=top_users,
101 | requestCount=helper_connections.get_connection_request_count(),
102 | allUsernames=helper_general.get_all_usernames(),
103 | myRanking=my_ranking,
104 | totalUserCount=total_user_count,
105 | percent=percent,
106 | errors=errors,
107 | notifications=helper_general.get_notifications(),
108 | )
109 | else:
110 | return render_template(
111 | "leaderboard.html",
112 | leaderboard=top_users,
113 | requestCount=helper_connections.get_connection_request_count(),
114 | allUsernames=helper_general.get_all_usernames(),
115 | myRanking=my_ranking,
116 | totalUserCount=total_user_count,
117 | percent=percent,
118 | notifications=helper_general.get_notifications(),
119 | )
120 |
--------------------------------------------------------------------------------
/src/student_network/helpers/helper_login.py:
--------------------------------------------------------------------------------
1 | """
2 | Performs checks and actions to help the login system work effectively.
3 | """
4 | import re
5 | from typing import Tuple, List
6 |
7 | from email_validator import validate_email, EmailNotValidError
8 |
9 |
10 | def validate_registration(
11 | cur,
12 | username: str,
13 | full_name: str,
14 | password: str,
15 | password_confirm: str,
16 | email: str,
17 | terms: str,
18 | ) -> Tuple[bool, List[str]]:
19 | """
20 | Validates the registration details to ensure that the email address is
21 | valid, and that the passwords in the form match.
22 |
23 | Args:
24 | cur: Cursor for the SQLite database.
25 | username: The username input by the user in the form.
26 | full_name: The full name input by the user in the form.
27 | password: The password input by the user in the form.
28 | password_confirm: The password confirmation input by the user in the
29 | form.
30 | email: The email address input by the user in the form.
31 | terms: The terms and conditions input checkbox.
32 |
33 | Returns:
34 | Whether the registration was valid, and the error message(s) if not.
35 | """
36 | # Registration remains valid as long as it isn't caught by any checks. If
37 | # not, error messages will be provided to the user.
38 | valid = True
39 | message = []
40 |
41 | # Checks that there are no null inputs.
42 | if (
43 | username == ""
44 | or full_name == ""
45 | or password == ""
46 | or password_confirm == ""
47 | or email == ""
48 | ):
49 | message.append("Not all fields have been filled in!")
50 | valid = False
51 |
52 | # Checks that the username only contains valid characters.
53 | if username.isalnum() is False:
54 | message.append("Username must only contain letters and numbers!")
55 | valid = False
56 | # Checks that the username hasn't already been registered.
57 | cur.execute("SELECT * FROM Accounts WHERE username=?;", (username,))
58 | if cur.fetchone() is not None:
59 | message.append("Username has already been registered!")
60 | valid = False
61 |
62 | # Checks that the full name doesn't exceed 40 characters.
63 | if len(full_name) > 40:
64 | message.append("Full name exceeds 40 characters!")
65 | valid = False
66 | # Checks that the full name only contains valid characters.
67 | if not all(x.isalpha() or x.isspace() for x in full_name):
68 | message.append("Full name must only contain letters and spaces!")
69 | valid = False
70 |
71 | # Checks that the email hasn't already been registered.
72 | cur.execute("SELECT * FROM Accounts WHERE email=?;", (email,))
73 | if cur.fetchone() is not None:
74 | message.append("Email has already been registered!")
75 | valid = False
76 | # Checks that the email address has the correct format, checks whether it
77 | # exists, and isn't a blacklist email.
78 | try:
79 | valid_email = validate_email(email)
80 | # Updates with the normalised form of the email address.
81 | email = valid_email.email
82 | # If the format is valid, checks that the email address has the
83 | # University of Exeter domain.
84 | if re.search("@.*", email) is not None:
85 | domain = re.search("@.*", email).group()
86 | domain_type = domain.split(".")[1]
87 | if domain_type not in ["ac", "edu"]:
88 | valid = False
89 | message.append(
90 | "Email does not belong to a registered educational institute!"
91 | )
92 | except EmailNotValidError:
93 | message.append("Email is invalid!")
94 | valid = False
95 |
96 | # Checks that the password has a minimum length of 8 characters, and at
97 | # least one number.
98 | if len(password) <= 7 or any(char.isdigit() for char in password) is False:
99 | message.append(
100 | "Password does not meet requirements! It must contain "
101 | "at least eight characters, including at least one "
102 | "number."
103 | )
104 | valid = False
105 | # Checks that the passwords match.
106 | if password != password_confirm:
107 | message.append("Passwords do not match!")
108 | valid = False
109 |
110 | # Checks that the terms of service has been ticked.
111 | if terms is None:
112 | message.append("You must accept the terms of service!")
113 | valid = False
114 |
115 | return valid, message
116 |
--------------------------------------------------------------------------------
/src/student_network/templates/terms.html:
--------------------------------------------------------------------------------
1 |
2 |
6 |
10 | {% extends "base.html" %} {% block title %}Terms and Conditions{% endblock %} {%
11 | block content %}
12 |
15 |
61 |
16 |
29 |
17 |
28 |
18 |
25 |
26 |
27 |
30 |
41 |
31 |
40 | Search Hobby
32 |
39 |
42 |
44 | AND
43 |
45 |
56 |
57 |
46 |
55 | Search Interest
47 |
54 |
58 |
59 |
60 |
13 |
94 |
95 | {%endblock%}
96 |
--------------------------------------------------------------------------------
/tests/test_login_system.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | import student_network.helpers.helper_login as helper_login
4 | from pytest_steps import test_steps
5 |
6 |
7 | @test_steps(
8 | "terms_not_accepted",
9 | "not_university_email",
10 | "not_valid_email",
11 | "password_mismatch",
12 | "password_no_number",
13 | "username_too_short",
14 | "full_name_contains_symbol",
15 | "username_contains_symbol",
16 | )
17 | def test_invalid_registration():
18 | """
19 | Tests that invalid registration details are rejected.
20 | """
21 | with sqlite3.connect("db.sqlite3") as conn:
22 | cur = conn.cursor()
23 |
24 | # Invalid registration as terms haven't been accepted.
25 | username = "goodname"
26 | full_name = "Good Name"
27 | password = "goodpw123"
28 | password_confirm = "goodpw123"
29 | email = "goodname@exeter.ac.uk"
30 | terms = None
31 | valid, _ = helper_login.validate_registration(
32 | cur,
33 | username,
34 | full_name,
35 | password,
36 | password_confirm,
37 | email,
38 | terms,
39 | )
40 | assert valid is False
41 | yield
42 |
43 | # Invalid registration as the email address isn't from a university.
44 | email = "goodnamebademail@gmail.com"
45 | terms = ""
46 | valid, _ = helper_login.validate_registration(
47 | cur,
48 | username,
49 | full_name,
50 | password,
51 | password_confirm,
52 | email,
53 | terms,
54 | )
55 | assert valid is False
56 | yield
57 |
58 | # Invalid registration as the email address has an invalid format.
59 | email = "bademail@"
60 | valid, _ = helper_login.validate_registration(
61 | cur,
62 | username,
63 | full_name,
64 | password,
65 | password_confirm,
66 | email,
67 | terms,
68 | )
69 | assert valid is False
70 | yield
71 |
72 | # Invalid registration as the passwords don't match.
73 | password_confirm = "mismatch"
74 | email = "goodname@exeter.ac.uk"
75 | valid, _ = helper_login.validate_registration(
76 | cur,
77 | username,
78 | full_name,
79 | password,
80 | password_confirm,
81 | email,
82 | terms,
83 | )
84 | assert valid is False
85 | yield
86 |
87 | # Invalid registration as the password doesn't contain a number.
88 | password = "badpassword"
89 | password_confirm = "badpassword"
90 | email = "goodname@exeter.ac.uk"
91 | valid, _ = helper_login.validate_registration(
92 | cur,
93 | username,
94 | full_name,
95 | password,
96 | password_confirm,
97 | email,
98 | terms,
99 | )
100 | assert valid is False
101 | yield
102 |
103 | # Invalid registration as the password doesn't contain eight
104 | # characters.
105 | password = "badpw1"
106 | password_confirm = "badpw1"
107 | email = "goodname@exeter.ac.uk"
108 | valid, _ = helper_login.validate_registration(
109 | cur,
110 | username,
111 | full_name,
112 | password,
113 | password_confirm,
114 | email,
115 | terms,
116 | )
117 | assert valid is False
118 | yield
119 |
120 | # Invalid registration as the full name contains a symbol.
121 | full_name = "Bad Name_"
122 | password = "goodpw123"
123 | password_confirm = "goodpw123"
124 | email = "goodname@exeter.ac.uk"
125 | valid, _ = helper_login.validate_registration(
126 | cur,
127 | username,
128 | full_name,
129 | password,
130 | password_confirm,
131 | email,
132 | terms,
133 | )
134 | assert valid is False
135 | yield
136 |
137 | # Invalid registration as the username contains a symbol.
138 | username = "b@dname"
139 | full_name = "Good Name"
140 | password = "goodpw123"
141 | password_confirm = "goodpw123"
142 | email = "goodname@exeter.ac.uk"
143 | valid, _ = helper_login.validate_registration(
144 | cur,
145 | username,
146 | full_name,
147 | password,
148 | password_confirm,
149 | email,
150 | terms,
151 | )
152 | assert valid is False
153 | yield
154 |
155 |
156 | def test_valid_registration():
157 | """
158 | Tests that valid registration details are accepted.
159 | """
160 | with sqlite3.connect("db.sqlite3") as conn:
161 | cur = conn.cursor()
162 | valid, _ = helper_login.validate_registration(
163 | cur,
164 | "goodname",
165 | "Good Name",
166 | "goodpw123",
167 | "goodpw123",
168 | "goodname@exeter.ac.uk",
169 | "",
170 | )
171 | assert valid is True
172 |
173 |
174 | def test_null_registration():
175 | """
176 | Tests that null registration details are rejected.
177 | """
178 | with sqlite3.connect("db.sqlite3") as conn:
179 | cur = conn.cursor()
180 | valid, _ = helper_login.validate_registration(cur, "", "", "", "", "", "")
181 | assert valid is False
182 |
--------------------------------------------------------------------------------
/src/student_network/templates/register.html:
--------------------------------------------------------------------------------
1 |
2 |
6 |
10 | {% extends "base.html" %} {% block title %}Register{% endblock %} {% block
11 | content %}
12 |
13 |
135 |
136 |
137 |
160 |
161 | {% endblock %}
162 |
--------------------------------------------------------------------------------
/src/student_network/templates/quiz.html:
--------------------------------------------------------------------------------
1 |
2 |
6 |
10 | {% extends "base.html" %} {% block title %}Quiz{% endblock %} {% block content
11 | %}
12 |
13 |
19 |
20 |
21 |
22 | {%for index in range(questions|length)%}
23 |
102 |
103 |
104 |
105 |
189 |
190 | {%endblock%}
191 |
--------------------------------------------------------------------------------
/src/student_network/templates/request.html:
--------------------------------------------------------------------------------
1 |
2 |
6 |
10 | {% extends "base.html" %} {% block title %}Request{% endblock %} {% block
11 | content %}
12 |
24 |
31 |
61 | {%endfor%}
62 |
63 |
32 |
35 | {{quiz_name}}
33 |{{quiz_author}}
34 |
36 |
39 |
40 |
41 |
44 |
45 |
46 |
49 |
50 |
51 |
54 |
55 |
56 |
59 |
60 |
64 |
101 |
65 |
73 |
85 |
74 |
75 |
76 |
84 |
86 |
87 |
95 |
96 |
97 |
98 |
99 |
100 |
13 | {%if requests|length == 0 and connections|length == 0 %}
14 |
17 | {% endif %} {%if requests|length > 0%}
18 |
184 | {%endblock%}
185 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Student Network - Reconnect
2 |
3 | [](https://github.com/psf/black)
4 | 
5 |
6 | A student network which promotes interaction within the student community.
7 | This aims to provide social opportunities by encouraging students to engage with
8 | each other in a fun and friendly online environment.
9 |
10 | ## Screenshots
11 |
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | 
20 |
21 | ## Installation
22 |
23 | ### Python Version
24 |
25 | The application has been developed and tested to work on Python 3.8 and onwards.
26 |
27 | ### Running the Application Locally
28 |
29 | To run the application, you should follow the following steps:
30 |
31 | 1. Clone this GitHub repository.
32 | 2. Ensure that you're in the root directory: `student-network`
33 | 3. Install the required Python libraries: `pip install -r requirements.txt`
34 | 4. Install the code as a package on your local machine with the command:
35 | `pip install -e .`
36 | 5. Run the application with the command: `python -m student_network.app`
37 | 6. Navigate to http://127.0.0.1:5000/ in your web browser.
38 |
39 | ## Usage
40 |
41 | Upon opening the application, you will be greeted with a home page. From here,
42 | you can log into your existing account, or you can register a new account. It
43 | should be noted that registration will only work with university email
44 | addresses, and academics will be sent for manual verification after signing up.
45 |
46 | When you log in, you will be redirected to your profile page. This displays
47 | information about you, such as your hobbies, interests, your rarest achievements
48 | unlocked, and links to your social media profiles. Posts made by you are also
49 | displayed on this page.
50 |
51 | By default, some details will be filled in for you, such as your profile
52 | picture, bio, date of birth, and gender. You can edit all these details by
53 | pressing the 'Edit Profile' button.
54 |
55 | To search for other members on the Reconnect network, you can navigate to the
56 | 'Members' page using the navigation bar on the top. From here, you can search by
57 | the username, with the option of searching by a common hobby and/or interest
58 | too. Search results will be displayed live with their username and their degree,
59 | enabling you to visit the profiles of people and make connections.
60 |
61 | Connections may be formed with people, with the option of marking connections as
62 | close friends. Whereas connections must be accepted by people, you are able to
63 | mark people as close friends without making a request. This also means that a
64 | user may be your close friend, but you may not be their close friend; the close
65 | friend system is one-way. If you wish to limit interaction with another user,
66 | then you can block them. All these options may be accessed by navigating to a
67 | user's profile.
68 |
69 | You can view a list of your connections and pending connection requests on the
70 | Connections page. Users who you have marked as a close friend have an icon of a
71 | handshake next to them.
72 |
73 | On your feed, you can view all the posts of people who you have connected with.
74 | This is sorted in chronological order, with the newest posts appearing at the
75 | top. You can also make new posts from this page; these are categorised as a text
76 | post, an image post, or a link post.
77 |
78 | Achievements may be unlocked by performing tasks on the Reconnect network. You
79 | can view these on the Achievements page, which displays your progress with
80 | achievements as a percentage, and the achievements you have completed, starting
81 | from the most recent. This page also shows you which achievements you are yet to
82 | unlock. Hovering over each achievement shows the title of the achievement,
83 | description, and number of XP gained by unlocking it. Each of these achievements
84 | has its own unique icon. Watch out for hidden achievements which are not
85 | displayed until you unlock them; these will reward you with extra XP!
86 |
87 | You will level up your profile based on how much XP you have gained. This
88 | encourages some healthy competition in the Reconnect network. By interacting
89 | more in various parts of the application, you will quickly be able to climb up
90 | the leaderboard!
91 |
92 | We have also provided you with an easy way to test and share your knowledge on
93 | the Quizzes page. From here, you can create a quiz consisting of five
94 | multiple-choice questions for others to complete. You can also view and take
95 | part in quizzes made from other people.
96 |
97 | ## Demo Instructions
98 |
99 | For testing purposes, we have created a lot of accounts and sample data to make
100 | it easier to demo the product. The users `barn354` and `ic324`, both with
101 | password `Password01`, have been set up with a full student profile and multiple
102 | posts.
103 |
104 | The following dummy accounts have been set up:
105 |
106 | - `student1`, `student2`, `student3`, and `student4` for student accounts.
107 | - `staffuser` and `staffusertwo` for staff accounts.
108 | - `adminuser` for an administrator account.
109 |
110 | ## Documentation
111 |
112 | ### Requirements Analysis
113 |
114 | Requirements analysis has been encapsulated through our research documents on
115 | potential solutions, design thinking plan, and MoSCoW matrix. They can be found
116 | in the following path: [docs/requirements-analysis](docs/requirements-analysis)
117 |
118 | ### Poster
119 |
120 | A promotional poster has been designed for this project. It can be found in the
121 | following GitHub repository
122 | path: [docs/designs/poster.pdf](docs/designs/poster.pdf)
123 |
--------------------------------------------------------------------------------
/src/student_network/helpers/helper_profile.py:
--------------------------------------------------------------------------------
1 | """
2 | Performs checks and actions to help the profile system work effectively.
3 | """
4 | import os
5 | import sqlite3
6 | import uuid
7 | from datetime import date, datetime
8 | from typing import List, Tuple
9 |
10 | import student_network.helpers.helper_general as helper_general
11 | from PIL import Image
12 | from werkzeug.utils import secure_filename
13 |
14 | BASE_DIR = os.path.dirname(os.path.abspath(__file__))
15 | DB_PATH = os.path.join(BASE_DIR, "db.sqlite3")
16 |
17 |
18 | def calculate_age(born: datetime) -> int:
19 | """
20 | Calculates the user's current age based on their date of birth.
21 |
22 | Args:
23 | born: The user's date of birth.
24 |
25 | Returns:
26 | The age of the user in years.
27 | """
28 | today = date.today()
29 | return today.year - born.year - ((today.month, today.day) < (born.month, born.day))
30 |
31 |
32 | def get_degree(username: str) -> Tuple[int, str]:
33 | """
34 | Gets the degree of a user.
35 |
36 | Args:
37 | username: The username of the user's profile picture.
38 |
39 | Returns:
40 | The degree of the user.
41 | The degreeID of the user.
42 | """
43 | with sqlite3.connect("db.sqlite3") as conn:
44 | cur = conn.cursor()
45 | cur.execute("SELECT degree FROM UserProfile WHERE username=?;", (username,))
46 | degree_id = cur.fetchone()
47 | if degree_id:
48 | cur.execute("SELECT degree FROM Degree WHERE degreeId=?;", (degree_id[0],))
49 | degree = cur.fetchone()
50 | return degree_id[0], degree[0]
51 |
52 |
53 | def get_level(username: str) -> List[int]:
54 | """
55 | Gets the current user experience points, the experience points
56 | for the next level and the user's current level from the database.
57 |
58 | Args:
59 | username: The username of the user logged in.
60 |
61 | Returns:
62 | The user's level, XP, and XP to reach the next level.
63 | """
64 | level = 1
65 | xp_next_level = 100
66 | xp_increase_per_level = 15
67 |
68 | exp = helper_general.get_exp(username)
69 | while exp >= xp_next_level:
70 | level += 1
71 | exp -= xp_next_level
72 | xp_next_level += xp_increase_per_level
73 |
74 | return [level, exp, xp_next_level]
75 |
76 |
77 | def get_profile_picture(username: str) -> str:
78 | """
79 | Gets the profile picture of a user.
80 |
81 | Args:
82 | username: The username of the user's profile picture.
83 |
84 | Returns:
85 | The profile picture of the user.
86 | """
87 | with sqlite3.connect("db.sqlite3") as conn:
88 | cur = conn.cursor()
89 | cur.execute(
90 | "SELECT profilepicture FROM UserProfile WHERE username=?;", (username,)
91 | )
92 | row = cur.fetchone()
93 | if row:
94 | return row[0]
95 |
96 |
97 | def read_socials(username: str):
98 | """
99 | Args:
100 | username: The username whose socials to check.
101 |
102 | Returns:
103 | The social media accounts of that user.
104 | """
105 | with sqlite3.connect("db.sqlite3") as conn:
106 | cur = conn.cursor()
107 | socials = {}
108 | # Gets the user's socials
109 | cur.execute(
110 | "SELECT social, link from UserSocial WHERE username=?;", (username,)
111 | )
112 | row = cur.fetchall()
113 | if len(row) > 0:
114 | for item in row:
115 | socials[item[0]] = item[1]
116 | return socials
117 |
118 |
119 | def validate_edit_profile(
120 | bio: str, gender: str, dob: str, hobbies: list, interests: list
121 | ) -> Tuple[bool, List[str]]:
122 | """
123 | Validates the details in the profile editing form.
124 |
125 | Args:
126 | bio: The bio input by the user in the form.
127 | gender: The gender input selected by the user in the form.
128 | dob: The date of birth input selected by the user in the form.
129 | hobbies: The list of hobbies from the form.
130 | interests: The list of interests from the form.
131 |
132 | Returns:
133 | Whether profile editing was valid, and the error message(s) if not.
134 | """
135 | # Editing profile remains valid as long as it isn't caught by any checks.
136 | # If not, error messages will be provided to the user.
137 | valid = True
138 | message = []
139 |
140 | # Checks that the bio has a maximum of 160 characters.
141 | if len(bio) > 160:
142 | valid = False
143 | message.append("Bio must not exceed 160 characters!")
144 |
145 | # Checks that the gender is male, female, or other.
146 | if gender not in ["Male", "Female", "Other"]:
147 | valid = False
148 | message.append("Gender must be male, female, or other!")
149 |
150 | # Only performs check if a new date of birth was entered.
151 | if dob != "":
152 | # Converts date string to datetime.
153 | dob = datetime.strptime(dob, "%Y-%m-%d")
154 | # Checks that date of birth is a past date.
155 | if datetime.today() < dob:
156 | valid = False
157 | message.append("Date of birth must be a past date!")
158 |
159 | # Checks that each hobby has a maximum of 24 characters.
160 | for hobby in hobbies:
161 | if len(hobby) > 24:
162 | valid = False
163 | message.append("Hobbies must not exceed 24 characters!")
164 | break
165 | # Checks that each interest has a maximum of 24 characters.
166 | for interest in interests:
167 | if len(interest) > 24:
168 | valid = False
169 | message.append("Interests must not exceed 24 characters!")
170 | break
171 |
172 | return valid, message
173 |
174 |
175 | def validate_profile_pic(file) -> Tuple[bool, List[str], str]:
176 | """
177 | Validates the file to check that it's a valid image.
178 |
179 | Args:
180 | file: The file uploaded by the user.
181 |
182 | Returns:
183 | Whether the file uploaded is a valid image, and any error messages.
184 | """
185 | valid = True
186 | message = []
187 | file_name_hashed = ""
188 |
189 | # Hashes the name of the file and resizes it.
190 | if helper_general.is_allowed_photo_file(file.filename):
191 | secure_filename(file.filename)
192 | file_name_hashed = str(uuid.uuid4())
193 | file_path = os.path.join("./static/images" + "//avatars", file_name_hashed)
194 | img = Image.open(file)
195 | img = img.resize((400, 400))
196 | img = img.convert("RGB")
197 | img.save(file_path + ".jpg")
198 | elif file:
199 | valid = False
200 | message.append("Your file must be an image.")
201 |
202 | return valid, message, file_name_hashed
203 |
--------------------------------------------------------------------------------
/src/student_network/templates/achievements.html:
--------------------------------------------------------------------------------
1 |
2 |
6 |
10 | {% extends "base.html" %} {% block title %}Achievements{% endblock %} {% block
11 | content %}
12 |
13 |
220 |
221 |
19 | Your Connection Requests ({{requests|length}})
20 |
21 |
22 | {% for i in range(requests|length) %}
23 |
54 | {%endif%} {%if connections|length > 0%}
55 |
24 |
45 | 
46 |
52 | {% endfor %}
53 |
47 | {{ requests[i] }}
50 |
51 |
56 | Your Connections ({{connections|length}})
57 |
58 |
59 | {% for connection in connections %}
60 |
86 | {%endif%} {%if pending|length > 0%}
87 |
61 |
72 | 
73 |
84 | {% endfor %}
85 |
74 | {{ connection[0] }}
77 | {% if connection[2]%}
78 |
79 |
80 |
81 | {%endif%}
82 |
83 |
88 | Your Pending Connections ({{pending|length}})
89 |
90 |
91 | {% for connection in pending %}
92 |
118 | {%endif%} {%if blocked|length > 0%}
119 |
93 |
104 |
105 |
116 | {% endfor %}
117 |
106 | {% if connection[2]%}
107 |
108 |
109 |
110 | {%endif%}
111 | {{ connection[0] }}
114 |
115 |
120 | Your Blocked Connections ({{blocked|length}})
121 |
122 |
123 | {% for connection in blocked %}
124 |
150 | {% endif %}
151 |
125 |
136 |
137 |
148 | {% endfor %}
149 |
138 | {% if connection[2]%}
139 |
140 |
141 |
142 | {%endif%}
143 | {{ connection[0] }}
146 |
147 | Recommended Connections
152 |
153 | {% if mutuals|length > 0 %} {% for i in range(mutuals|length) %}
154 |
183 |
155 |
167 | 
168 |
176 | {% endfor %} {% else %}
177 |
181 | {%endif%}
182 |
169 | {{mutuals[i][0]}}
172 |
173 | {{mutuals[i][1] | safe}} 174 |
175 | 173 | {{mutuals[i][1] | safe}} 174 |
222 |
268 |
269 |
270 |
271 |
272 |
273 |
274 |
277 |
278 | {%endblock%}
279 |
--------------------------------------------------------------------------------
/src/student_network/templates/chat.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %} {% block title %}Home Page{% endblock %} {% block
2 | content %}
3 |
4 |
58 |
59 |
223 |
267 |
224 |
233 |
234 | {% for achievement in unlocked_achievements %}
235 |
225 |
228 |
229 | {{percentage}}%
226 | achievements completed
227 |
230 | Completed ({{unlocked_achievements|length}})
231 |
232 |
240 |
243 |
244 | {% endfor %}
245 |
246 |
247 |
251 |
252 | {% for achievement in locked_achievements %}
253 |
248 | Locked ({{locked_achievements|length}})
249 |
250 |
258 |
261 |
264 |
265 | {% endfor %}
266 |
60 |
244 |
--------------------------------------------------------------------------------
/src/student_network/templates/base.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
13 |
17 |
18 |
19 |
20 |
21 |
22 |
26 |
30 |
61 |
163 |
164 |
165 |
166 |
167 |
241 |
242 | {% endblock %}
243 |
62 |
94 | {% if showChat %}
95 |
63 |
66 |
67 |
68 |
69 |
93 |
70 | {% for user in rooms %}
71 |
75 | 
76 | {{user[0]}}
77 |
78 | {{user[2][1]}} 79 | 89 | 90 | {% endfor %} 91 |
92 | 78 | {{user[2][1]}} 79 | 89 | 90 | {% endfor %} 91 |
99 |
162 |
100 |
154 | {% else %}
155 |
101 |
153 |
102 | {% for message in messages %}
103 |
117 |
118 |
152 |
104 | {% if message[1] != prev %} {% if message[1] == username %}
105 |
114 | {% set prev = message[1] %} {% endfor %}
115 |
116 |
156 |
159 |
160 | {% endif %}
161 |
79 |
80 |
209 |
210 |
211 |
--------------------------------------------------------------------------------
/src/student_network/helpers/helper_general.py:
--------------------------------------------------------------------------------
1 | """
2 | Performs checks and actions to help the general system work effectively.
3 | """
4 | import os
5 | import sqlite3
6 | from datetime import datetime
7 | from math import floor
8 | from typing import Tuple
9 |
10 | import student_network.helpers.helper_profile as helper_profile
11 | from flask import session
12 |
13 | BASE_DIR = os.path.dirname(os.path.abspath(__file__))
14 | DB_PATH = os.path.join(BASE_DIR, "db.sqlite3")
15 |
16 |
17 | def is_allowed_photo_file(file_name) -> bool:
18 | """
19 | Checks if the file is an allowed type.
20 |
21 | Args:
22 | file_name: The name of the file uploaded by the user.
23 |
24 | Returns:
25 | Whether the file is allowed or not (True/False).
26 | """
27 | return "." in file_name and file_name.rsplit(".", 1)[1].lower() in {
28 | "png",
29 | "jpg",
30 | "jpeg",
31 | "gif",
32 | }
33 |
34 |
35 | def display_short_notification_age(seconds):
36 | prefixes = ["y", "mo", "d", "h", "m", "s"]
37 | values = [3600 * 24 * 365, 3600 * 31 * 24, 3600 * 24, 3600, 60, 1]
38 |
39 | for i in range(len(prefixes)):
40 | if seconds >= values[i]:
41 | return str(floor(seconds / values[i])) + prefixes[i]
42 |
43 | return "Just Now"
44 |
45 |
46 | def get_all_connections(username: str) -> list:
47 | """
48 | Gets a list of all usernames that are connected to the logged in user.
49 |
50 | Returns:
51 | A list of all usernames that are connected to the logged in user.
52 | """
53 | with sqlite3.connect("db.sqlite3") as conn:
54 | cur = conn.cursor()
55 | cur.execute(
56 | "SELECT user2 FROM Connection "
57 | "WHERE user1=? AND connection_type='connected' UNION ALL "
58 | "SELECT user1 FROM Connection "
59 | "WHERE user2=? AND connection_type='connected'",
60 | (username, username),
61 | )
62 | connections = cur.fetchall()
63 |
64 | return connections
65 |
66 |
67 | def get_all_usernames() -> list:
68 | """
69 | Gets a list of all usernames that are registered.
70 |
71 | Returns:
72 | A list of all usernames that have been registered.
73 | """
74 | with sqlite3.connect("db.sqlite3") as conn:
75 | cur = conn.cursor()
76 | cur.execute("SELECT username FROM Accounts")
77 |
78 | row = cur.fetchall()
79 |
80 | return row
81 |
82 |
83 | def get_notifications():
84 | with sqlite3.connect("db.sqlite3") as conn:
85 | cur = conn.cursor()
86 |
87 | cur.execute(
88 | "SELECT body, date, url FROM notification WHERE username=? ORDER "
89 | "BY date DESC",
90 | (session["username"],),
91 | )
92 |
93 | row = cur.fetchall()
94 |
95 | notification_metadata = list(
96 | map(
97 | lambda x: (
98 | x[0],
99 | display_short_notification_age(
100 | (
101 | datetime.now()
102 | - datetime.strptime(x[1], "%Y-%m-%d " "%H:%M:%S")
103 | ).total_seconds()
104 | ),
105 | x[2],
106 | ),
107 | row,
108 | )
109 | )
110 |
111 | return notification_metadata
112 |
113 |
114 | def check_level_exists(username: str, conn):
115 | """
116 | Checks that a user has a record in the database for their level.
117 |
118 | Args:
119 | username: The username of the user to check.
120 | conn: The connection to the database.
121 | """
122 | cur = conn.cursor()
123 | cur.execute("SELECT * FROM UserLevel WHERE username=?;", (username,))
124 | if cur.fetchone() is None:
125 | cur.execute(
126 | "INSERT INTO UserLevel (username, experience) VALUES (?, ?);", (username, 0)
127 | )
128 | conn.commit()
129 |
130 |
131 | def get_messages(username: str):
132 | """
133 | Get messages between logged in user and each user with chats
134 |
135 | Args:
136 | username: user to get messages of
137 | """
138 | with sqlite3.connect("db.sqlite3") as conn:
139 | cur = conn.cursor()
140 |
141 | cur.execute(
142 | "SELECT message, sender, date FROM PrivateMessages WHERE (sender=? AND receiver=?) ",
143 | (session["username"], username),
144 | )
145 | row = cur.fetchall()
146 |
147 | cur.execute(
148 | "SELECT message, sender, date FROM PrivateMessages WHERE (sender=? AND receiver=?) ",
149 | (username, session["username"]),
150 | )
151 | row += cur.fetchall()
152 |
153 | if row == []:
154 | return [[""], "", ""]
155 |
156 | row.sort(key=lambda x: x[2], reverse=True)
157 |
158 | return [row, "", ""]
159 |
160 |
161 | def recent_message(date: str) -> Tuple[str, int]:
162 | """
163 | Get time since the most recent message
164 |
165 | Args:
166 | date: datetime of message
167 |
168 | Returns:
169 | [type]: [description]
170 | """
171 | seconds = (
172 | datetime.now() - datetime.strptime(date, "%Y-%m-%d " "%H:%M:%S")
173 | ).total_seconds()
174 | elapsed = display_short_notification_age(seconds)
175 |
176 | return (elapsed, seconds)
177 |
178 |
179 | def get_rooms():
180 | """
181 | Get chat rooms for user
182 |
183 | Returns:
184 | chat rooms of user
185 | """
186 | chat_rooms = get_all_connections(session["username"])
187 | chat_rooms = list(
188 | map(lambda x: (x[0], helper_profile.get_profile_picture(x[0])), chat_rooms)
189 | )
190 |
191 | chat_rooms = [list(x) for x in chat_rooms]
192 |
193 | for i, room in enumerate(chat_rooms):
194 | message = get_messages(room[0])
195 | if message[0][0] != "":
196 | message[1], message[2] = recent_message(message[0][0][2])
197 | chat_rooms[i].append(message)
198 |
199 | actives = [x for x in chat_rooms if x[2][2] != ""]
200 | inactives = [x for x in chat_rooms if x[2][2] == ""]
201 | actives.sort(key=lambda x: x[2][2])
202 | chat_rooms = actives + inactives
203 |
204 | return chat_rooms
205 |
206 |
207 | def one_exp(cur, username: str):
208 | """
209 | Awards 1 exp point
210 |
211 | Args:
212 | username: user to award exp to
213 | """
214 | cur.execute(
215 | "UPDATE UserLevel SET experience = experience + 1 WHERE username=?;",
216 | (username,),
217 | )
218 |
219 |
220 | def get_exp(username: str):
221 | """
222 | Get current exp of given user
223 |
224 | Args:
225 | username: user to find exp value of
226 |
227 | Returns:
228 | exp of user
229 | """
230 | with sqlite3.connect("db.sqlite3") as conn:
231 | cur = conn.cursor()
232 | check_level_exists(username, conn)
233 | # Get user experience
234 | cur.execute("SELECT experience FROM UserLevel WHERE username=?;", (username,))
235 | row = cur.fetchone()
236 |
237 | return int(row[0])
238 |
239 |
240 | def new_notification(body, url):
241 | now = datetime.now()
242 |
243 | with sqlite3.connect("db.sqlite3") as conn:
244 | cur = conn.cursor()
245 |
246 | cur.execute(
247 | "INSERT INTO notification (username, body, date, url) VALUES (?, "
248 | "?, ?, ?);",
249 | (session["username"], body, now.strftime("%Y-%m-%d %H:%M:%S"), url),
250 | )
251 |
252 | conn.commit()
253 |
254 |
255 | def new_notification_username(username, body, url):
256 | now = datetime.now()
257 |
258 | with sqlite3.connect("db.sqlite3") as conn:
259 | cur = conn.cursor()
260 |
261 | cur.execute(
262 | "INSERT INTO notification (username, body, date, url) VALUES (?, "
263 | "?, ?, ?);",
264 | (username, body, now.strftime("%Y-%m-%d %H:%M:%S"), url),
265 | )
266 |
267 | conn.commit()
268 |
--------------------------------------------------------------------------------
/src/student_network/templates/quizzes.html:
--------------------------------------------------------------------------------
1 |
2 |
6 |
10 | {% extends "base.html" %} {% block title %}Quiz list{% endblock %} {% block
11 | content %}
12 |
13 |
14 |
21 |
22 |
81 |
88 |
89 |
90 |
91 |
92 | {% if session["username"] %}
93 |
206 |
207 | {% block content %} {% endblock %}
208 | 
87 |
94 |
95 |
96 | {% if requestCount > 0 %}
97 |
113 | {% endif %}
114 |
115 |
116 |
117 |
118 | {{ requestCount }}
98 | {% endif %}
99 |
111 |
112 |
119 |
120 |
121 |
122 |
132 |
133 |
134 |
135 |
136 |
137 |
147 |
148 |
149 |
150 |
151 |
152 |
153 |
154 |
205 |
23 | {% if errors %}
24 |
30 | {% endif %}
31 |
32 |
50 |
51 |
52 |
53 |
74 |
75 |
76 | {% for quiz in quizzes %}
77 |
78 |
111 | {% endfor %}
112 |
113 |
114 |
115 |
232 | {% endblock %}
233 |
--------------------------------------------------------------------------------
79 |
110 |
80 |
81 | {{ quiz[3] }}
82 |
86 | Created by
87 |
88 |
109 |
81 | {{ quiz[3] }}
82 |
83 | {{ quiz[1] }}
84 |
85 |
86 | Created by
87 |
88 | {{ quiz[1] }}
84 |
89 | {{ quiz[2] }}
90 |
98 |
99 | {% if quiz[2] == username %}
100 |
91 | {{ quiz[5] }} {% if quiz[5]==1 %} question {% else %} questions {%
92 | endif %}
93 |
94 |
95 | {{ quiz[4] }} {% if quiz[4]==1 %} play {% else %} plays {% endif %}
96 |
97 |
101 |
102 |
105 |
106 |
107 | {% endif %}
108 |
Comments
22 | {%for comment in comments%} 23 |