Coverage for basic_pages/views.py: 57%
83 statements
« prev ^ index » next coverage.py v7.6.12, created at 2025-03-16 10:58 +0000
1"""
2Basic Pages Views
4This module contains views for basic pages in the application.
5"""
7from django.shortcuts import render
8from django.conf import settings
9from django.core.mail import send_mail
10from django.shortcuts import reverse
11from django.views.generic import FormView
12from django.views.generic import TemplateView
13from django.http import HttpResponse
14from django.http import JsonResponse
15from django import forms
17from .forms import ContactForm
19from datetime import timedelta
20import datetime
22import json
23import requests
24import os
28class HomeView(TemplateView):
29 """
30 A view that displays the home page.
32 Attributes:
33 template_name (str): The name of the template to render.
34 """
36 template_name = "home_page.html"
38 def get_context_data(self, **kwargs):
39 """
40 Update the context dictionary with additional data for rendering.
42 Args:
43 kwargs: Additional keyword arguments passed to the view.
45 Returns:
46 dict: A dictionary containing the updated context.
47 """
48 context = super().get_context_data(**kwargs)
49 # You can add any additional context data here if needed
50 context['page_title'] = 'Home'
51 return context
53 def get_success_url(self):
54 """
55 Return the URL to redirect to after a successful action.
57 Returns:
58 str: The URL of the success page.
59 """
60 return reverse("success_page")
64class DemoView(TemplateView):
65 """
66 A view that displays the demo page.
68 Attributes:
69 template_name (str): The name of the template to render.
70 """
72 template_name = "demo_page.html"
74 def get_context_data(self, **kwargs):
75 """
76 Update the context dictionary with additional data for rendering.
78 Args:
79 kwargs: Additional keyword arguments passed to the view.
81 Returns:
82 dict: A dictionary containing the updated context.
83 """
84 context = super().get_context_data(**kwargs)
85 # You can add any additional context data here if needed
86 return context
88 def get_success_url(self):
89 """
90 Return the URL to redirect to after a successful action.
92 Returns:
93 str: The URL of the success page.
94 """
95 return reverse("success_page")
98class ApiView(TemplateView):
99 """
100 """
101 def post(self, request):
103 post_msg = request.POST["msg"]
104 style = request.POST["style"]
106 prompt_list = []
107 prompt_list.append("Please use about 8 words in chat format and a")
108 prompt_list.append(style)
109 prompt_list.append("attitude respond to :")
110 prompt_list.append(post_msg)
111 promptText = ' '.join(prompt_list)
113 key = os.environ['AI_API_KEY']
114 url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key=" + key
116 msg = {}
117 msg["contents"] = {}
118 msg["contents"]["parts"] = {}
119 msg["contents"]["parts"]["text"] = promptText
121 response = requests.post(url, json=msg)
122 response_dict = response.json()
123 response_text = response_dict["candidates"][0]["content"]["parts"][0]["text"]
125 return JsonResponse({'msg': response_text})
130class AboutView(TemplateView):
131 """
132 A Django class-based view that renders the 'about_page.html' template.
134 Attributes:
135 template_name (str): The name of the template to render, which is set to "about_page.html".
136 """
138 template_name = "about_page.html"
140 def get_context_data(self, **kwargs):
141 """
142 Override the default context data for this view.
144 This method adds any additional context data needed for rendering the 'about_page.html' template.
145 It extends the base class's context data by calling `super().get_context_data(**kwargs)` and then
146 can append or modify context variables as required.
148 Args:
149 **kwargs: Arbitrary keyword arguments passed to the view.
151 Returns:
152 dict: A dictionary containing the context data for the template.
153 """
154 context = super().get_context_data(**kwargs)
155 # You can add any additional context data here if needed
156 return context
160class ContactForm(forms.Form):
161 """
162 A Django form class for handling contact information.
164 Attributes:
165 email (forms.EmailField): A required field for the user's email address.
166 subject (forms.CharField): A required field for the message subject.
167 message (forms.CharField): A required field for the message body, using a Textarea widget.
168 """
170 email = forms.EmailField(required=True)
171 subject = forms.CharField(required=True)
172 message = forms.CharField(widget=forms.Textarea, required=True)
175class ContactView(FormView):
176 """
177 A Django class-based view that handles contact form submissions.
179 Attributes:
180 form_class (forms.Form): The form class to use for rendering and processing the contact form.
181 template_name (str): The name of the template to render, which is set to "contact_page.html".
182 """
184 form_class = ContactForm
185 template_name = "contact_page.html"
187 def get_success_url(self):
188 """
189 Returns the URL to redirect to after a successful form submission.
191 Returns:
192 str: The URL for the success page.
193 """
194 return reverse("success_page")
196 def form_valid(self, form):
197 """
198 Processes a valid form submission and sends an email notification.
200 Args:
201 form (forms.Form): A valid form instance containing cleaned data.
203 Returns:
204 HttpResponse: A redirect response to the success URL.
206 Raises:
207 forms.ValidationError: If the email field is empty after cleaning.
208 """
209 email = form.cleaned_data.get("email")
210 subject = form.cleaned_data.get("subject")
211 message = form.cleaned_data.get("message")
213 # Validate that the email field is not empty
214 if not email:
215 raise forms.ValidationError("This field is required.")
217 full_message = f"""
218 Received message below from {email}, {subject}
219 ________________________
221 {message}
222 """
224 send_mail(
225 subject="Received contact form submission",
226 message=full_message,
227 from_email=settings.DEFAULT_FROM_EMAIL,
228 recipient_list=[settings.NOTIFY_EMAIL],
229 )
231 return super().form_valid(form)
234class SuccessView(TemplateView):
235 """
236 A Django class-based view that renders the 'success_page.html' template.
238 Attributes:
239 template_name (str): The name of the template to render, which is set to "success_page.html".
240 """
242 template_name = "success_page.html"
244 # TODO - get msg info and put on page for confirmation
247class CookieManager:
248 """
249 A utility class for managing cookies.
251 Methods:
252 set_cookie(response, key, value, days_expire=7): Sets a cookie in the given HTTP response.
253 """
255 @staticmethod
256 def set_cookie(
257 response,
258 key,
259 value,
260 days_expire=7,
261 ):
262 """
263 Sets a cookie in the given HTTP response.
265 Args:
266 response (HttpResponse): The HTTP response object to which the cookie will be added.
267 key (str): The name of the cookie.
268 value (str): The value of the cookie.
269 days_expire (int, optional): The number of days until the cookie expires. Defaults to 7 days.
271 Returns:
272 None
273 """
274 if days_expire is None:
275 max_age = 365 * 24 * 60 * 60 # One year
276 else:
277 max_age = days_expire * 24 * 60 * 60
279 expires = datetime.datetime.strftime(
280 datetime.datetime.utcnow() + timedelta(seconds=max_age),
281 "%a, %d-%b-%Y %H:%M:%S GMT",
282 )
284 response.set_cookie(
285 key,
286 value,
287 max_age=max_age,
288 expires=expires,
289 domain=settings.SESSION_COOKIE_DOMAIN,
290 secure=settings.SESSION_COOKIE_SECURE or None,
291 )
294# Usage example:
295# response = HttpResponse("Setting cookie")
296# CookieManager.set_cookie(response, "my_key", "my_value")