def edit(request, note_id=None):
note = Note(user_id=1)
if note_id:
note = Note.objects.get(pk=note_id)
if request.method == 'POST':
form = NoteForm(request.POST, request.FILES)
if not form.is_valid():
return render(request, 'edit.html', {'form': form, 'note': note})
note.title = form.cleaned_data.get('title')
note.save()
if request.FILES.get('attachment'):
a = Attachment(note=note)
a.content = request.FILES['attachment']
a.save()
version = Version(note=note, user_id=1)
version.content = form.cleaned_data.get('content')
version.shared = form.cleaned_data.get('shared')
version.save()
return redirect(note)
form = NoteForm(initial={
'content': note.content,
'shared': note.shared,
'title': note.title
})
return render(request, 'edit.html', {'form': form, 'note': note})
def test_note_updates_tags(self):
"""
Tests Tags are automatically updated based on Note content.
"""
note = Note(title='My first note',
content='Noteworthy content for #pyladies')
note.save()
for i in range(3):
if i == 0:
note.content = '... but it can be improved. #workshop #python'
elif i == 1:
note.content = '... but it can be improved some more. #workshop #python'
else:
pass # test saving twice
note.save()
self.assertTrue(Tag.objects.get(keyword='workshop'))
self.assertTrue(Tag.objects.get(keyword='python'))
self.assertEqual(Tag.objects.filter(keyword='pyladies').count(), 0)
self.assertEqual(Tag.objects.count(), 2)
self.assertEqual(note.tags.count(), 2)
self.assertEqual(Note.objects.get().tags.count(), 2)
def setUp(self):
welcomeNote = Note()
welcomeNote.name = "Welcome to Note Space!"
welcomeNote.desc = "Introduction and Quick guide"
welcomeNote.owner = "Note Space Team"
welcomeNote.save()
econNote = Note()
econNote.name = "Basic Economics"
econNote.subject = "Economics"
econNote.desc = "This note is about demands, suplies and how market works."
econNote.owner = "Susan"
econNote.save()
img1 = Image()
img1.index = 1
img1.note = econNote
img1.image = SimpleUploadedFile(
name='IMG_0809.JPG',
content=open(
"C:/Users/B/Desktop/NoteSpace/static/TestNotes/Econ/IMG_0809.JPG",
'rb').read(),
content_type='image/jpeg')
img1.save()
img2 = Image()
img2.index = 2
img2.note = econNote
img2.image = SimpleUploadedFile(
name='IMG_0810.JPG',
content=open(
"C:/Users/B/Desktop/NoteSpace/static/TestNotes/Econ/IMG_0810.JPG",
'rb').read(),
content_type='image/jpeg')
img2.save()
img3 = Image()
img3.index = 3
img3.note = econNote
img3.image = SimpleUploadedFile(
name='IMG_0811.JPG',
content=open(
"C:/Users/B/Desktop/NoteSpace/static/TestNotes/Econ/IMG_0811.JPG",
'rb').read(),
content_type='image/jpeg')
img3.save()
img4 = Image()
img4.index = 4
img4.note = econNote
img4.image = SimpleUploadedFile(
name='IMG_0812.JPG',
content=open(
"C:/Users/B/Desktop/NoteSpace/static/TestNotes/Econ/IMG_0812.JPG",
'rb').read(),
content_type='image/jpeg')
img4.save()
User.objects.create_user("smith", "*****@*****.**", "1234")
self.browser = webdriver.Firefox()
def test_a_user_opens_an_existing_note_for_printing_or_sharing(self):
""" An existing note can be open in a tab for printing or sharing via url.
Viewing does not require login and the url contains a slug instead of the note id.
"""
note = Note(
title="Pisos termicos",
summary=
"Los pisos termicos permiten distintos tipos de cultivo segun la temperatura"
)
note.save()
Paragraph(
description="Distintos tipos de cultivos",
content=
"se clasifican segun la altura sobre el nivel del mar editados",
note=note).save()
visit(self, reverse("show", kwargs={'slug': note.slug}))
body = self.selenium.find_element_by_tag_name('body')
self.assertTrue(has_content(body, "Pisos termicos"))
self.assertTrue(has_content(body, "Distintos tipos de cultivos"))
self.assertTrue(
has_content(
body,
"se clasifican segun la altura sobre el nivel del mar editados"
))
self.assertTrue(
has_content(
body,
"Los pisos termicos permiten distintos tipos de cultivo segun la temperatura"
))
def notes(request):
if request.method == 'GET':
notes = Note.objects.all()
for i in range(len(notes)):
if notes[i].title is None or len(notes[i].title) == 0:
notes[i].title = notes[i].content[:MAX_SYMBOLS]
title = request.query_params.get('string', None)
if title is not None:
notes_title = [
notes.filter(title__icontains=title),
notes.filter(content__icontains=title)
]
res = []
for i in notes_title:
for j in i:
if j not in res:
res.append(j)
notes = res
note_serializer = NoteSerializer(notes, many=True)
return JsonResponse(note_serializer.data, safe=False)
elif request.method == 'POST':
content = request.data.get('content')
note = Note()
note.content = content
note.title = request.data.get('title')
note.save()
note_serializer = NoteSerializer(note)
return JsonResponse(note_serializer,
safe=False,
status=status.HTTP_201_CREATED)
def save_note(message, note, element, story):
if DiscordUser.objects.filter(user_id=message.author.id).exists():
user = DiscordUser.objects.get(user_id=message.author.id)
if Story.objects.filter(owner=user, name=story).exists():
story = Story.objects.get(owner=user, name=story)
if StoryElement.objects.filter(story=story,
name=element).exists():
try:
element = StoryElement.objects.get(story=story,
name=element)
note = Note(element=element, note=note)
note.save()
except MultipleObjectsReturned:
elements = StoryElement.objects.filter(
story=story, name=element)
type_list = [
element.get_type_display()
for element in elements
]
raise MultipleObjectsReturned(type_list)
else:
raise ElementNotFoundError
else:
raise StoryNotFoundError
else:
raise UserNotCreatedError
return element.name
def test_database_can_save_and_get_one_Note_multiple_images(self):
n = Note()
n.name = "test note"
n.desc = "this is note for ..."
n.save()
n_id = n.id
img1 = Image()
img1.index = 1
img1.note = n
img1.image = SimpleUploadedFile(
name='1.jpg',
content=open(
"C:/Users/B/OneDrive/Documents/61FC8C1A-D1FE-4D09-ABE4-BE1689D03C8E.jpg",
'rb').read(),
content_type='image/jpeg')
img1.save()
img2 = Image()
img2.index = 2
img2.note = n
img2.image = SimpleUploadedFile(
name='1.jpg',
content=open(
"C:/Users/B/OneDrive/Documents/61FC8C1A-D1FE-4D09-ABE4-BE1689D03C8E.jpg",
'rb').read(),
content_type='image/jpeg')
img2.save()
n = Note.objects.get(pk=n_id)
images = Image.objects.filter(note=n)
self.assertEqual(images.count(), 2)
def test_note_updates_tags(self):
"""
Tests Tags are automatically updated based on Note content.
"""
note = Note(title='My first note',
content='Noteworthy content for #pyladies')
note.save()
for i in range(3):
if i == 0:
note.content = '... but it can be improved. #workshop #python'
elif i == 1:
note.content = '... but it can be improved some more. #workshop #python'
else:
pass # test saving twice
note.save()
self.assertTrue(Tag.objects.get(keyword='workshop'))
self.assertTrue(Tag.objects.get(keyword='python'))
self.assertEqual(Tag.objects.filter(keyword='pyladies').count(), 0)
self.assertEqual(Tag.objects.count(), 2)
self.assertEqual(note.tags.count(), 2)
self.assertEqual(Note.objects.get().tags.count(), 2)
def post(self, request, *args, **kwargs):
content = request.data.get('content')
note = Note()
note.content = content
note.title = request.data.get('title')
note.save()
return Response(note)
def test_database_note_id_increte_automatically_without_declaration(self):
note1 = Note()
note1.save()
note2 = Note()
note2.save()
self.assertEqual(note2.id - note1.id, 1)
def test_database_canbe_query(self):
note1 = Note()
note1.id = 5
note1.name = "for testing"
note1.save()
n = Note.objects.filter(id=5)[0]
self.assertEqual(n.name, "for testing")
def add_new_note(request):
if request.method == 'POST':
noteform = NoteForm(request.POST)
if noteform.is_valid():
title = request.POST['title']
description = request.POST['description']
note = Note(user=request.user, title=title, description=description)
note.save()
return redirect('notes:index')
def run():
n = Note(title='example', content='This is a test.')
n.save()
# def run():
# print("Test")
def create_note(self, user):
new_note = Note(date=self.cleaned_data['date'],
venue=self.cleaned_data['venue'],
note=self.cleaned_data['note'],
note_type=self.cleaned_data['note_type'],
creator=user,
customer=user.userprofile.customer)
new_note.save()
return new_note
def _post_index(request):
content = request.POST.get("content", False)
if not content or len(content) == 0:
message = {'class': 'error', 'content': 'Please supply a note'}
return _get_index(request, message)
else:
note = Note(content=content, created_by=request.user)
note.save()
return HttpResponseRedirect('/')
def create_note(self, user):
new_note = Note(
date=self.cleaned_data['date'],
venue=self.cleaned_data['venue'],
note=self.cleaned_data['note'],
note_type=self.cleaned_data['note_type'],
creator=user,
customer=user.userprofile.customer
)
new_note.save()
return new_note
def createNewNote(request):
#
if request.method == "POST":
noteId = getNoteId()
location = makeNoteLocation(request.POST['noteBody'], noteId)
tags = splitNoteTags(request.POST["noteTags"])
mynote = Note(note_id = noteId, noteName = request.POST["noteName"], noteLocation = location, noteTags = tags, noteColor = request.POST["noteTags"], noteCreated = datetime.now(), noteEdited = datetime.now())
mynote.save()
return HttpResponse("You saved a note!")
else:
return HttpResponse("Nope!")
def save_data(request):
if 'name' in request.GET and request.GET[
'name'] and 'content' in request.GET and request.GET['content']:
name = request.GET['name']
content = request.GET['content']
note = Note(name=name, content=content)
note.save()
return HttpResponse('Successful')
else:
return HttpResponse('Failed')
def notes(request, id):
if request.method == 'POST':
data = request.data
user = User.objects.get(pk=id)
note = Note(user=user, title=data["title"], note=data["note"])
note.save()
return JsonResponse({"message": "Data saved"}, status=200)
else:
note = Note.objects.filter(user=id)
serialize = NoteDisplaySerializer(note, many=True)
return Response(serialize.data)
def new_note(request):
if request.method == 'POST':
if request.POST.get('title') and request.POST.get('body'):
note = Note()
note.user = request.user
note.title = request.POST.get('title')
note.body = request.POST.get('body')
note.save()
return HttpResponseRedirect(reverse(note_list))
else:
return render(request, 'notes.html')
else:
return render(request, 'notes.html')
def post(self, request, format = None):
data = request.data
note = Note()
if data['title'] and data['content']:
note.title = data['title']
note.content = data['content']
note.pub_date = timezone.now() + timezone.timedelta(hours=3)
note.login = request.user
note.save()
serializer = NoteSerializer(note, many = False, context = { 'request': request})
return Response(serializer.data)
def create(request):
list_of_notes = Note.objects.all().order_by('-last_update_date')
template = 'notes/create.html'
if len(list_of_notes) == 0:
note = Note(title='', content='')
note.save()
elif not list_of_notes[0].title == '':
note = Note(title='', content='')
note.save()
form = NotesForm()
list_of_notes = Note.objects.all().order_by('-last_update_date')
noteid = list_of_notes[0].id
context = {'list_of_notes': list_of_notes, 'form': form, 'noteid': noteid}
return render(request, template, context)
def test_loose_tags_removed_when_note_deleted(self):
"""
Tests 'loose' tags (i.e. Tags associated with no notes) are removed
when Note is deleted.
"""
note = Note(title='My first note',
content='Noteworthy content for #pyladies')
note.save()
note = Note(title='My second note',
content='Noteworthy content for #workshop')
note.save()
Note.objects.all().delete()
self.assertEqual(Tag.objects.count(), 0)
def add(request):
try:
content = request.POST['content']
except (KeyError):
return render(request, 'notes/new.html', {
'error_message': _("Can't add new note."),
})
else:
content = content if content else _('Nothing')
note = Note(content=content,
user=request.user,
edit_date=timezone.now())
note.save()
return HttpResponseRedirect(reverse('notes:index'))
def put(self, request, format = None):
data = request.data
print('==== PUT ======')
print(data)
note = Note()
serializer = NoteSerializer(note, many = False, context = { 'request': request})
try:
note = Note.objects.get(pk = data['id'])
note.views = data['views']
note.save()
serializer = NoteSerializer(note, many = False, context = { 'request': request})
return Response(serializer.data)
except ObjectDoesNotExist:
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
def test_loose_tags_removed_when_note_deleted(self):
"""
Tests 'loose' tags (i.e. Tags associated with no notes) are removed
when Note is deleted.
"""
note = Note(title='My first note',
content='Noteworthy content for #pyladies')
note.save()
note = Note(title='My second note',
content='Noteworthy content for #workshop')
note.save()
Note.objects.all().delete()
self.assertEqual(Tag.objects.count(), 0)
def create(request):
list_of_notes = Note.objects.all().order_by('-last_update_date')
template = 'notes/create.html'
if len(list_of_notes) == 0:
note = Note(title='', content='')
note.save()
elif not list_of_notes[0].title == '':
note = Note(title='', content='')
note.save()
form = NotesForm()
list_of_notes = Note.objects.all().order_by('-last_update_date')
noteid = list_of_notes[0].id
context = {'list_of_notes': list_of_notes, 'form':form, 'noteid': noteid}
return render(request, template, context)
def test_can_get_review_mean_score(self):
n = Note()
n.save()
review1 = Review()
review1.note = n
review1.score = 5
review1.save()
review2 = Review()
review2.note = n
review2.score = 4
review2.save()
self.assertEqual(round(n.mean_score, ndigits=2), 4.5)
def create_daterange_notes(self, user):
end_date = self.cleaned_data['end_date']
date = self.cleaned_data['date']
if date == end_date:
return self.create_note(user)
else:
for x in rrule(DAILY, dtstart=date, until=end_date):
new_note = Note(date=x,
venue=self.cleaned_data['venue'],
note=self.cleaned_data['note'],
note_type=self.cleaned_data['note_type'],
creator=user,
customer=user.userprofile.customer)
new_note.save()
return True
def test_can_store_and_get_review(self):
n = Note()
n.save()
review1 = Review()
review1.note = n
review1.author = "Author 1"
review1.score = 5
review1.text = "very good"
review1.save()
self.assertEqual(n.reviews.all().count(), 1)
self.assertIn(review1, n.reviews.all())
self.assertEqual(n.reviews.all()[0], review1)
self.assertEqual(n.reviews.all()[0].text, "very good")
def test_saving_and_retrieving_notes(self):
first_note = Note()
first_note.contents = 'This could be my first note.'
first_note.save()
second_note = Note()
second_note.contents = 'This could be the note written after the first note.'
second_note.save()
saved_notes = Note.objects.all()
self.assertEqual(saved_notes.count(), 2)
first_saved_note = saved_notes[0]
second_saved_note = saved_notes[1]
self.assertEqual(first_saved_note.contents, 'This could be my first note.')
self.assertEqual(second_saved_note.contents, 'This could be the note written after the first note.')
def create(request, course_key):
'''
Receives an annotation object to create and returns a 303 with the read location.
'''
note = Note(course_id=course_key, user=request.user)
try:
note.clean(request.body)
except ValidationError as e:
log.debug(e)
return ApiResponse(http_response=HttpResponse('', status=400), data=None)
note.save()
response = HttpResponse('', status=303)
response['Location'] = note.get_absolute_url()
return ApiResponse(http_response=response, data=None)
def create(request, course_key):
'''
Receives an annotation object to create and returns a 303 with the read location.
'''
note = Note(course_id=course_key, user=request.user)
try:
note.clean(request.body)
except ValidationError as e:
log.debug(e)
return ApiResponse(http_response=HttpResponse('', status=400), data=None)
note.save()
response = HttpResponse('', status=303)
response['Location'] = note.get_absolute_url()
return ApiResponse(http_response=response, data=None)
def create_daterange_notes(self, user):
end_date = self.cleaned_data['end_date']
date = self.cleaned_data['date']
if date == end_date:
return self.create_note(user)
else:
for x in rrule(DAILY, dtstart=date, until=end_date):
new_note = Note(
date=x,
venue=self.cleaned_data['venue'],
note=self.cleaned_data['note'],
note_type=self.cleaned_data['note_type'],
creator=user,
customer=user.userprofile.customer
)
new_note.save()
return True
def import_notes():
notes = load_json("notes.json")
notebooks = Notebook.objects.all()
notebooksl = len(notebooks) - 1
tags = Tag.objects.all()
tagsl = len(tags) - 1
for note in notes:
new_note = Note()
new_note.title = note['title']
new_note.text = note['text']
new_note.user = USER
new_note.notebook = notebooks[randint(0, notebooksl)]
amt_of_tags = randint(0, tagsl)
new_note.save()
for i in range(0, amt_of_tags):
new_note.tags.add(tags[randint(0, tagsl)])
new_note.save()
print("Imported Notes.")
def test_database_can_search_by_similar(self):
from django.db.models import Q
note1_namesearch = Note()
note1_namesearch.name = "django"
note1_namesearch.save()
note2_descsearch = Note()
note2_descsearch.name = "writing unit test"
note2_descsearch.desc = "for django"
note2_descsearch.save()
Tag_django = Tag()
Tag_django.title = "django"
Tag_django.save()
note3_tagsearch = Note()
note3_tagsearch.name = "Html Template Tags"
note3_tagsearch.save()
note3_tagsearch.tags.add(Tag_django)
note3_tagsearch.save()
note4_ownersearch = Note()
note4_ownersearch.name = "FAQ"
note4_ownersearch.owner = "Django official"
note4_ownersearch.save()
search_result = list(
Note.objects.filter(
Q(name__icontains="django") | Q(desc__icontains="django")
| Q(tags__title__icontains="django")
| Q(owner__icontains="django")))
print(search_result)
self.assertGreaterEqual(len(search_result), 4)
self.assertIn(note1_namesearch, search_result)
self.assertIn(note2_descsearch, search_result)
self.assertIn(note3_tagsearch, search_result)
self.assertIn(note4_ownersearch, search_result)
search_result = Note.objects.filter(
name__trigram_similar="django").filter(
desc__trigram_similar="django")
def add_note(request):
if not request.user.is_authenticated():
return HttpResponseForbidden(
'<a href="{0}" target="_blank">Login</a> required'.format(reverse("social:begin", args=("google",)))
)
if request.method == "POST":
form = Note.AddForm(request.POST)
if form.is_valid():
n = Note()
n.author = form.cleaned_data["author"]
n.title = form.cleaned_data["title"]
n.last_edit = datetime.datetime.now()
n.save()
# TODO(kazeevn) redo it in a better style
return HttpResponse(u"<li><a href=/notes/{0}>{1}</a></li>".format(n.id, n.title))
else:
return HttpResponseForbidden(form.errors.__unicode__())
else:
return HttpResponseForbidden("POST, please!")
def save_note_by_type(message, note, element, type, story):
if DiscordUser.objects.filter(user_id=message.author.id).exists():
user = DiscordUser.objects.get(user_id=message.author.id)
if Story.objects.filter(owner=user, name=story).exists():
story = Story.objects.get(owner=user, name=story)
if StoryElement.objects.filter(story=story,
name=element,
type=type).exists():
element = StoryElement.objects.get(story=story,
name=element,
type=type)
note = Note(element=element, note=note)
note.save()
else:
raise ElementNotFoundError
else:
raise StoryNotFoundError
else:
raise UserNotCreatedError
return element.name
def test_post_one_note(self):
# Arrange
user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
note = Note(phrase="Hola",
context="Hola amiga!",
definition="Hi",
language="ES",
owner=user)
# Act
self.note_request_helper(mock_user=user)
# Assert
try:
with transaction.atomic():
note.save()
self.assertEqual(1, len(Note.objects.all()))
self.assertEqual(note, Note.objects.all()[0])
finally:
pass
def test_remove_missing_user():
with self.assertRaises(ObjectDoesNotExist):
User.objects.get(pk=1).delete()
def test_remove_user():
# Arrange
user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
result_qs = self.request_helper(mock_user=user)
self.assertEqual(1, len(result_qs))
# Act
User.objects.get(pk=1).delete()
# Assert
self.assertEqual(0, len(result_qs))
def edit(request, id=None):
if request.method == 'GET':
n = {}
if id:
n = Note.objects.get(pk=id)
return render(request, 'notes/edit.html', {
"note" : n
})
elif request.method == 'POST':
print('POST')
print(request.POST)
pk = request.POST['pk']
text = request.POST['text']
if pk:
n = Note.objects.get(pk=pk)
#TODO: error handling
else:
n = Note(text=text)
n.text = text
n.save()
return HttpResponseRedirect('/')
def test_api_can_add_review(self):
sample_note = Note()
sample_note.name = 'testing note'
sample_note.save()
note_id = sample_note.id
response = self.client.post("/api/addreview/",
data={
'note_id': str(note_id),
'author': 'bobby',
'text': 'very good',
'score': '5'
},
follow=True)
self.assertEqual(response.json()["status"], "success")
review = Review.objects.filter(author='bobby')[0]
self.assertEqual(review.note, sample_note)
self.assertEqual(review.author, 'bobby')
self.assertEqual(review.text, 'very good')
self.assertEqual(review.score, 5)
def edit_note(request, note_id=None):
context = {}
note = None
if note_id is not None:
note = get_object_or_404(Note, id=note_id)
context["title"] = "{} · Editing".format(note.title)
if note.owner != request.user:
return get_profile(request)
else:
context["title"] = "New note"
context["active"] = "edit"
context["note"] = note or {}
if request.method == "POST":
try:
title = request.POST["title"]
description = request.POST["description"]
if note_id == 4:
raise KeyError()
elif note is None:
note = Note(title=title,
description=description,
owner=request.user)
note.save()
return get_profile(request)
else:
note.title = title
note.description = description
note.save()
return redirect("/note/{}/".format(note_id))
except KeyError:
context["error"] = "Fill in all the fields"
return render(request, "edit_note.html", context)
def setUp(self):
user = self.create_new_user(self.username, EMAIL, self.password)
sub_user = self.create_new_user('sub_user', EMAIL, self.password)
client = APIClient()
client.login(username=user.username, password=self.password)
sub_client = APIClient()
sub_client.login(username=sub_user.username, password=self.password)
notes_name = ['note1', 'note2', 'note3']
notes = []
for note_name in notes_name:
note = Note(user=user, title=note_name)
note.save()
notes.append(note)
self.user = user
self.sub_user = sub_user
self.rest_client = client
self.sub_client = sub_client
self.notes = notes
def test_note_creates_tags(self):
"""
Tests Tags are automatically created based on Note content.
"""
# check that tags are associated with saved object in database
note = Note(title='My first note',
content='Noteworthy content for #pyladies')
note.save()
self.assertEqual(Tag.objects.count(), 1)
self.assertTrue(Tag.objects.get(keyword='pyladies'))
self.assertEqual(Note.objects.get(pk=note.pk).tags.count(), 1)
self.assertEqual(Tag.objects.get(keyword='pyladies').notes.count(), 1)
# check tags are not duplicated and are grouped
note = Note(title='My second note',
content='Noteworthy content for #pyladies with the same hashtag.')
note.save()
self.assertEqual(Tag.objects.count(), 1)
self.assertTrue(Tag.objects.get(keyword='pyladies'))
self.assertEqual(Note.objects.get(pk=note.pk).tags.count(), 1)
self.assertEqual(Tag.objects.get(keyword='pyladies').notes.count(), 2)
def index(request):
"""Lists all of the Notes in the Database"""
list_of_notes = Note.objects.all().order_by('-last_update_date')
print list_of_notes
if len(list_of_notes) == 0:
template = 'notes/create.html'
note = Note(title='', content='')
note.save()
form = NotesForm()
list_of_notes = Note.objects.all().order_by('-last_update_date')
noteid = list_of_notes[0].id
context = {'list_of_notes': list_of_notes, 'form':form, 'noteid': noteid}
return render(request, template, context)
else:
target = list_of_notes[0]
noteid = list_of_notes[0].id
template = 'notes/base.html'
if target.title == '':
target.title = 'Write title here'
if target.content == '':
target.content = 'Write content here'
form = NotesForm(initial={'title': target.title, 'content': target.content})
context = {'list_of_notes': list_of_notes, 'target': target, 'form':form, 'noteid': noteid}
return render(request, template, context)
def newNote(request):
if 'username' not in request.session:
return redirect("myLogin")
if request.method == "POST":
#obtain title and content
title = request.POST.get("title")
content = request.POST.get("content")
user_made = request.session['username']
random_id = ''.join(
random.choices(string.ascii_uppercase + string.ascii_lowercase +
string.digits,
k=6))
note = Note(title=title,
content=content,
note_id=random_id,
user_created=user_made)
note.save()
messages.add_message(request, messages.INFO, "New note added.")
return redirect("myHome")
return render(request, "newnote.html", {
'username': request.session['username'],
'form': NoteForm()
})
def init():
print 'Existing database will be wiped, continue? (y/n)'
choice = raw_input().strip()
if choice == 'y':
print 'Working...'
# Wipe db
clean()
# Common variable
pw = 'sesame'
# FYI
ACCOUNT_TYPES = {
1: 'teacher',
2: 'student',
3: 'parent',
}
# Create teachers
t = Teacher(first_name='Sesame', last_name='Teacher', email='*****@*****.**', user_type=1)
t.save()
t.set_password(pw)
t.save()
# Create classes
for i in range(3):
index = str(i+1)
name = 'Class #' + index
code = 'KLS' + index
start = end = datetime.now().date()
colour = "#" + index*6
k = Klass(teacher=t, name=name, code=code, start=start, end=end, colour=colour)
k.save()
# Create students
students = [
{
'first_name': 'Alton',
'last_name': 'Lau',
'email': '*****@*****.**'
}, {
'first_name': 'Marc',
'last_name': 'Lo',
'email': '*****@*****.**'
}, {
'first_name': 'Madigan',
'last_name': 'Kim',
'email': '*****@*****.**'
}
]
classes = Klass.objects.all()
for i in range(3):
s = students[i]
s = Student(first_name=s['first_name'], last_name=s['last_name'], email=s['email'], user_type=2)
s.save()
s.set_password(pw)
s.save()
s.klasses = classes[:i+1]
k = Klass.objects.all()[0]
s = Student.objects.all()
# Create notes
for i in range(3):
index = str(i+1)
detail = 'This is note #' + index
n = Note(klass=k, detail=detail)
n.save()
n.students = s[:i+1]
print 'All done, goodbye!'
else:
print 'Fine, I see how it is.'
