def add_note(request):
id = request.GET.get('id', None)
if id is not None:
note = get_object_or_404(Notes, id=id)
else:
note = None
if request.method == 'POST':
if request.POST.get('control') == 'delete':
note.delete()
messages.add_message(request, messages.INFO, 'Note Deleted!')
return HttpResponseRedirect(reverse('notes:index'))
form = NoteForm(request.POST, instance=note)
if form.is_valid():
obj = form.save(commit=False)
obj.owner = request.user
obj.save()
messages.add_message(request, messages.INFO, 'Note Added!')
return HttpResponseRedirect(reverse('notes:index'))
else:
form = NoteForm(instance=note)
return render(request, 'addNote.html', {'form': form, 'note': note})
def add_note(request):
if request.method == 'POST':
form = NoteForm(request.POST)
if form.is_valid():
form.save()
return redirect('home')
else:
form = NoteForm()
return render(request, 'notes/add_note.html', {'form': form})
def note_edit(request, note_id):
note = get_object_or_404(Note, pk=note_id)
if request.method == 'POST':
form = NoteForm(request.POST, instance=note)
if form.is_valid():
form.save()
return redirect('note_detail', note_id)
else:
form = NoteForm(instance=note)
return render_to_response('notes/note_edit.html', {'form': form},
context_instance=RequestContext(request))
def get(self, request, *args, **kwargs):
bits = request.htmx.trigger_name.split("-")
item = Item.objects.filter(pk=bits[1]).first()
note = Note.objects.filter(item=item).first() if item else None
template = "notes/note_form.html"
if note:
form = NoteForm(initial={"title": note.title, "content": note.content})
else:
form = NoteForm()
context = {"note": note, "form": form, "item": item}
return render(request, template, context)
def viewNote(request, id):
if 'username' not in request.session:
return redirect("myLogin")
viewed_note = Note.objects.filter(note_id=id).first()
if request.method == "POST":
if 'save' in request.POST:
#update/save the note
new_title = request.POST.get("title")
new_content = request.POST.get("content")
viewed_note.title = new_title
viewed_note.content = new_content
viewed_note.date_added = datetime.datetime.now()
viewed_note.save()
messages.add_message(request, messages.INFO, "Note saved.")
return redirect("myHome")
else:
#delete the note
viewed_note.delete()
messages.add_message(request, messages.INFO, "Note deleted.")
return redirect("myHome")
return render(
request, "viewnote.html", {
'username': request.session['username'],
'note': viewed_note,
'form': NoteForm()
})
def post(self, request, *args, **kwargs):
form = NoteForm(request.POST)
context = self.get_context_data()
if (form.is_valid()):
form.save()
return render(request, self.template_name, context)
def post(self, request, *args, **kwargs):
context = self.get_context_data(**kwargs)
form = NoteForm(request.POST, instance=context.get('note'))
if (form.is_valid()):
form.save()
return render(request, self.template_name, context)
def post(self, request, *args, **kwargs):
template = "notes/close_modal.html"
form = NoteForm(request.POST)
item = Item.objects.get(pk=request.POST["item"])
note = Note.objects.filter(item=item).first() if item else None
if "delete" in request.POST:
note.delete()
note = None
elif form.is_valid():
title = form.cleaned_data["title"]
content = form.cleaned_data["content"]
if not title and not content:
if note:
note.delete()
note = None
else:
if not title:
title = item.ref
if note:
note.title = title
note.content = content
note.user = request.user
note.save()
else:
note = Note.objects.create(
title=title, content=content, item=item, user=request.user
)
context = {"note": note, "item": item}
return render(request, template, context)
def __call__(self, request):
from notes.models import Note
request.admin_notes = Note.objects.filter(resolved=False,
parent_id=None)
request.blank_note_form = NoteForm()
return self.get_response(request)
def addnote(request):
if request.method == 'POST':
form = NoteForm(request.POST)
error = None
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('viewnotes'))
else:
return render(request, 'notes/addnote.html', {
'form': form,
'error': error
})
else:
form = NoteForm()
return render(request, 'notes/addnote.html', {
'form': form,
})
def test_form_save(self):
data = {'title': 'Note Title', 'body': 'Note body', 'tags': ''}
form = NoteForm(data=data)
self.assertTrue(form.is_valid())
user = User.objects.create_user(email='*****@*****.**', password='******')
form.instance.owner = user
note = form.save()
self.assertEqual(note, Note.objects.first())
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 process_add_note_form(request):
form = NoteForm(request.POST or None)
form.fields['venue'].queryset = Venue.objects.filter(
customer=request.user.userprofile.customer)
if form.is_valid():
form.create_daterange_notes(request.user)
return {
'success': True,
}
form_html = render_crispy_form(form)
return {'success': False, 'form_html': form_html}
def test_form_save(self):
user = User.objects.create_user(email='*****@*****.**')
form_data = {'title': 'title', 'content': 'content'}
post_data = {'is_public': 'off', 'tags': 'python, django'}
form = NoteForm(data=form_data)
form.instance.user = user
note = form.save(post_data)
self.assertEqual(note.title, 'title')
self.assertEqual(note.content, 'content')
self.assertEqual(len(note.tags), 2)
self.assertEqual(note.is_public, False)
def edit_n(request, Note_id):
if request.POST:
form = NoteForm(request.POST, instance=Note.objects.get(pk=Note_id))
if form.is_valid():
form.save()
return HttpResponseRedirect('/notes/' + Note_id + '/open_n')
else:
notebook_list = Notebook.objects.order_by('-name')
STATIC_URL = 'https://mynotes.muddyoutnback.com/static/notes/'
n = Note.objects.get(pk=Note_id)
form = NoteForm(request.POST)
args = {
'n': n,
'notebook_list': notebook_list,
'notes_count': Ncount(request.user.id),
'all_notebook_count': aNBcount(request.user.id),
'STATIC_URL': STATIC_URL
}
args.update(csrf(request))
args['form'] = form
return render_to_response('notes/edit_n.html', args)
def add_book(request):
template_name = 'books/create_note.html'
book = get_or_create_book(request)
form = NoteForm(request.POST)
if request.method == 'POST' and form.is_valid():
note = form.save(commit=False)
note.user = request.user
note.save()
book.notes.add(note.pk)
return redirect('books:book')
return render(request, template_name, {
'form': form,
})
def test_form_tags_added_to_field(self):
user = User.objects.create_user(email='*****@*****.**')
note = Note.objects.create(
user=user,
title='test',
content='content',
)
note.tags = 'python'
form = NoteForm(instance=note)
form.instance.user = user
self.assertEqual(form.fields['tags'].initial, 'python')
def new_n(request):
notebook_list = Notebook.objects.order_by('-name')
STATIC_URL = 'https://mynotes.muddyoutnback.com/static/notes/'
if request.POST:
form = NoteForm(request.POST)
if form.is_valid():
newnote = form.save(commit=False)
newnote.owner = request.user.id
newnote.save()
return HttpResponseRedirect('/notes/')
else:
form = NoteForm()
args = {
'notebook_list': notebook_list,
'notes_count': Ncount(request.user.id),
'user_username': request.user.username,
'user_id': request.user.id,
'all_notebook_count': aNBcount(request.user.id),
'STATIC_URL': STATIC_URL
}
args.update(csrf(request))
args['form'] = form
return render_to_response('notes/new_n.html', args)
def get_context_data(self, **kwargs):
context = super(AddNoteSnippetView, self).get_context_data(**kwargs)
input_date = self.request.GET.get('date', "")
if input_date:
date = timezone.localtime(parser.parse(input_date)).date()
else:
date = timezone.now().date()
note_form = NoteForm()
note_form.fields['venue'].queryset = Venue.objects.filter(
customer=self.request.user.userprofile.customer).exclude(main_calendar=False)
note_form.fields['date'].initial = date
note_form.fields['end_date'].initial = date.strftime("%d-%m-%Y")
context['NoteForm'] = note_form
return context
def index(request):
all_notes = Note.all_notes.all()
unresolved_notes = Note.unresolved_notes.all()
urgent_notes = Note.urgent_notes.all()
queued_invoices = Invoice.queued_invoices.all()
running_invoices = Invoice.running_invoices.all()
note_form = NoteForm(request.POST)
is_admin = request.user.groups.filter(name='Admin')
updates = Update.objects.all()
if note_form.is_valid():
note_form.save()
return note_form
form = InvoiceForm(request.POST)
if form.is_valid():
form.save()
return form
#return render(request, 'invoices/add_job.html', {'form': form})
return render_to_response('index.html', {'all_notes': all_notes, 'unresolved_notes': unresolved_notes, 'urgent_notes': urgent_notes, 'queued_invoices': queued_invoices, 'running_invoices': running_invoices, 'note_form': note_form, 'is_admin': is_admin, 'updates': updates, 'form': form}, context_instance=RequestContext(request))
def myHome(request):
if 'username' not in request.session:
return redirect("myLogin")
if request.method == "POST":
#delete the account
user_in_session = request.session['username']
user_to_delete = User.objects.filter(username=user_in_session).first()
user_to_delete.delete()
request.session.flush()
return redirect("myLogin")
return render(
request, "home.html", {
'notes':
Note.objects.filter(
user_created=request.session['username']).all(),
'username':
request.session['username'],
'form':
NoteForm()
})
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 test_empty_title(self):
form = NoteForm(data={'title': '', 'text': 'some text'})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['title'], ['This field is required.'])
def note_add(request):
if request.user.is_authenticated:
form = NoteForm()
return render(request, 'notes/addnote.html', {'form': form})
def save_note(request):
if request.method == 'POST':
form = NoteForm(request.POST)
if form.is_valid():
Note.objects.create_note(form.cleaned_data['title'], form.cleaned_data['text'], request.user)
return redirect('/')
