from django.db import models from django.forms import ModelForm from django.urls import reverse from django_summernote.widgets import SummernoteWidget from django.core.files.storage import FileSystemStorage from django.forms.widgets import HiddenInput, Textarea, TextInput, Select fs = FileSystemStorage(location='media/') class Model(models.Model): created = models.DateTimeField(auto_now_add=True) updated = models.DateTimeField(auto_now=True) class Meta: abstract = True class Profile(Model): display_name = models.CharField(max_length=255) caption = models.CharField(max_length=30, default='', blank=True) desc = models.TextField(blank=True) class Meta: ordering = ['display_name'] def __str__(self): return self.display_name class Character(Profile):
from django.db import models from django.core.files import File from django.core.files.storage import FileSystemStorage from datetime import datetime import urllib import os imagefs = FileSystemStorage(location='/b7_1/exports/leica/images') class PI(models.Model): """ Store PI name. Names must be entered manually """ sunetid = models.CharField('PI sunetid', max_length=32, primary_key=True, db_index=True) first = models.CharField('first name', max_length=32) last = models.CharField('surname', max_length=32, null=True, blank=True) fullname = models.CharField('Full name', max_length=65, null=True, blank=True) aliases = models.CharField('aliases', max_length=128, null=True, blank=True) def save(self): self.fullname = self.first + " " + self.last self.aliases = self.first + " " + self.last
def setUp(self): self.umask = 0o027 self.old_umask = os.umask(self.umask) self.storage_dir = tempfile.mkdtemp() self.storage = FileSystemStorage(self.storage_dir)
from django.db import models from django.contrib.auth.models import User from django.db.models.signals import post_save from django.core.validators import RegexValidator from datetime import datetime from django.conf import settings from django.core.files.storage import FileSystemStorage docs_storage = FileSystemStorage(location=settings.DOCS_STORAGE_ROOT) def driving_files(): a = str(datetime.now().strftime("%H:%M:%S")) return 'uploads/driving_licence/' + 'DL' + '-'.join(a.split(':')) def pancard_files(): a = str(datetime.now().strftime("%H:%M:%S")) return 'uploads/pancard/' + 'pancard' + '-'.join(a.split(':')) # Create your models here. class UserProfile(models.Model): user = models.OneToOneField(User, on_delete=models.CASCADE) about = models.CharField(max_length=100, default='') city = models.CharField(max_length=25, default='') phone_regex = RegexValidator(regex=r'^\d{10}$', message= \ "Phone number must be of 10 digits") mobile = models.CharField(validators=[phone_regex], max_length=10, blank=True,
class DummyImageFieldModel(models.Model): fs = FileSystemStorage(location=gettempdir()) image_field = models.ImageField(upload_to="%Y/%m/%d", storage=fs)
def edit_student_save(request): if request.method != "POST": return HttpResponse("<h2>Method Not Allowed</h2>") else: student_id = request.session.get("student_id") if student_id == None: return HttpResponseRedirect(reverse("manage_student")) form = EditStudentForm(request.POST, request.FILES) if form.is_valid(): first_name = form.cleaned_data["first_name"] last_name = form.cleaned_data["last_name"] username = form.cleaned_data["username"] email = form.cleaned_data["email"] address = form.cleaned_data["address"] session_year_id = form.cleaned_data["session_year_id"] course_id = form.cleaned_data["course"] sex = form.cleaned_data["sex"] if request.FILES.get('profile_pic', False): profile_pic = request.FILES['profile_pic'] fs = FileSystemStorage() filename = fs.save(profile_pic.name, profile_pic) profile_pic_url = fs.url(filename) else: profile_pic_url = None try: user = CustomUser.objects.get(id=student_id) user.first_name = first_name user.last_name = last_name user.username = username user.email = email user.save() student = Students.objects.get(admin=student_id) student.address = address session_year = SessionYearModel.object.get(id=session_year_id) student.session_year_id = session_year student.gender = sex course = Courses.objects.get(id=course_id) student.course_id = course if profile_pic_url != None: student.profile_pic = profile_pic_url student.save() del request.session['student_id'] messages.success(request, "Successfully Edited Student") return HttpResponseRedirect( reverse("edit_student", kwargs={"student_id": student_id})) except: messages.error(request, "Failed to Edit Student") return HttpResponseRedirect( reverse("edit_student", kwargs={"student_id": student_id})) else: form = EditStudentForm(request.POST) student = Students.objects.get(admin=student_id) return render(request, "hod_template/edit_student_template.html", { "form": form, "id": student_id, "username": student.admin.username })
# -*- coding: utf-8 -*- import datetime import tempfile import shutil from django.db import models # Can't import as "forms" due to implementation details in the test suite (the # current file is called "forms" and is already imported). from django import forms as django_forms from django.core.files.storage import FileSystemStorage temp_storage_location = tempfile.mkdtemp() temp_storage = FileSystemStorage(location=temp_storage_location) class BoundaryModel(models.Model): positive_integer = models.PositiveIntegerField(null=True, blank=True) class Defaults(models.Model): name = models.CharField(max_length=255, default='class default value') def_date = models.DateField(default=datetime.date(1980, 1, 1)) value = models.IntegerField(default=42) class ChoiceModel(models.Model): """For ModelChoiceField and ModelMultipleChoiceField tests.""" name = models.CharField(max_length=10) class ChoiceOptionModel(models.Model):
for child in form.instance.child_set.all(): if len(child.name.split()) < 2: child.name = child.name + ' ' + last_name child.save() class EmptyModelAdmin(admin.ModelAdmin): def get_queryset(self, request): return super().get_queryset(request).filter(pk__gt=1) class OldSubscriberAdmin(admin.ModelAdmin): actions = None temp_storage = FileSystemStorage(tempfile.mkdtemp()) UPLOAD_TO = os.path.join(temp_storage.location, 'test_upload') class PictureInline(admin.TabularInline): model = Picture extra = 1 class GalleryAdmin(admin.ModelAdmin): inlines = [PictureInline] class PictureAdmin(admin.ModelAdmin): pass
def post(self, request): print("in post man in stddetail") Email = request.session['agn_stdmail'] Sscqual = request.POST.get('Sscqual') print("123456") print(Sscqual) Sscname = request.POST.get('Sscname') Sscdate = request.POST.get('Sscdate') Sscmarks = request.POST.get('Sscmarks') Sscgrading = request.POST.get('Sscgrading') SscDoc = request.FILES['SscDoc'] fs = FileSystemStorage() name = fs.save(SscDoc.name, SscDoc) url = fs.url(name) print(url) Intqual = request.POST.get('Intqual') Intname = request.POST.get('Intname') Intdate = request.POST.get('Intdate') Intmarks = request.POST.get('Intmarks') Intgrading = request.POST.get('Intgrading') IntDoc = request.FILES['IntDoc'] name1 = fs.save(IntDoc.name, IntDoc) url1 = fs.url(name1) Uniqual = request.POST.get('Uniqual') Uniname = request.POST.get('Uniname') Unicname = request.POST.get('Unicname') Unidate = request.POST.get('Unidate') Unimarks = request.POST.get('Unimarks') Unigrading = request.POST.get('Unigrading') UniDoc = request.FILES['UniDoc'] agentid = request.session['agentid'] agentmail = request.session['Email2'] name2 = fs.save(UniDoc.name, UniDoc) url2 = fs.url(name2) stdacd = Stdacd(Email=Email, Sscqual=Sscqual, Sscname=Sscname, Sscdate=Sscdate, Sscmarks=Sscmarks, Sscgrading=Sscgrading, SscDoc=SscDoc, Intqual=Intqual, Intname=Intname, Intdate=Intdate, Intmarks=Intmarks, Intgrading=Intgrading, IntDoc=IntDoc, Uniqual=Uniqual, Uniname=Uniname, Unicname=Unicname, Unidate=Unidate, Unimarks=Unimarks, Unigrading=Unigrading, UniDoc=UniDoc, Agentid=agentid, Agentmail=agentmail) stdacd.register() value = { 'Sscqual': Sscqual, 'Sscname': Sscname, 'Sscdate': Sscdate, 'Sscmarks': Sscmarks, 'Sscgrading': Sscgrading, 'SscDoc': url, 'Intqual': Intqual, 'Intname': Intname, 'Intdate': Intdate, 'Intmarks': Intmarks, 'Intgrading': Intgrading, 'IntDoc': url1, 'Uniqual': Uniqual, 'Uniname': Uniname, 'Unicname': Unicname, 'Unidate': Unidate, 'Unimarks': Unimarks, 'Unigrading': Unigrading, 'UniDoc': url2 } data = {'value': value} return render(request, 'agent_portal/academic.html', data)
def SaveIcon(user, newIcon): # data gathering hret = CU.HttpReturn() try: user_m = AM.User.objects.get(username=user) except AM.User.DoesNotExist: hret.results = "User not found." hret.status = 501 return hret try: profile_m = MT.Profile.objects.get(UserFK=user_m) except AM.User.DoesNotExist: hret.results = "Profile not found." hret.status = 501 return hret # save parameter file from user to the server's file storage # new icon type: django.core.files.uploadedfile.InMemoryUploadedFile # 1. check if it's an image import magic filetype = magic.from_buffer(newIcon.read()) newIcon.seek(0) # reset file cursor if 'image' not in filetype: hret.results = "File is not an image." hret.status = 422 return hret # 2. reduce size of image to at most 500 pixels per side # 3. save file at server from django.core.files.storage import FileSystemStorage from django.core.files.base import ContentFile import socket folder = profile_m.HashID[0] host = socket.gethostname() if host.startswith('test') or host.startswith('prod'): fsLoc = os.path.join(settings.BASE_DIR, 'app_proj/static/user_icons', folder ) else: fsLoc = os.path.join(settings.BASE_DIR, 'members/static/user_icons', folder ) fs = FileSystemStorage(location=fsLoc) # requires the absolute path if profile_m.Icon: existingFullPath = os.path.join(fsLoc, profile_m.Icon) if os.path.isfile(existingFullPath): os.remove(existingFullPath) fileName = profile_m.HashID + '_icon.jpg' fs.save(fileName, ContentFile(newIcon.read())) profile_m.Icon = fileName profile_m.save() # return succesfull results records = { 'message': "User icon saved.", 'iconFileName': fileName, } hret = CU.HttpReturn() hret.results = records hret.status = 201 return hret
was opened. """ def __init__(self, *args, **kwargs): self.was_opened = False super().__init__(*args, **kwargs) def open(self): self.was_opened = True super().open() class TestImageField(ImageField): attr_class = TestImageFieldFile # Set up a temp directory for file storage. temp_storage_dir = tempfile.mkdtemp() temp_storage = FileSystemStorage(temp_storage_dir) temp_upload_to_dir = os.path.join(temp_storage.location, 'tests') class Person(models.Model): """ Model that defines an ImageField with no dimension fields. """ name = models.CharField(max_length=50) mugshot = TestImageField(storage=temp_storage, upload_to='tests') class AbstractPersonWithHeight(models.Model): """ Abstract model that defines an ImageField with only one dimension field to make sure the dimension update is correctly run on concrete subclass instance post-initialization. """
if len(child.name.split()) < 2: child.name = child.name + ' ' + last_name child.save() class EmptyModelAdmin(admin.ModelAdmin): def get_queryset(self, request): return super(EmptyModelAdmin, self).get_queryset(request).filter(pk__gt=1) class OldSubscriberAdmin(admin.ModelAdmin): actions = None temp_storage = FileSystemStorage( tempfile.mkdtemp(dir=os.environ['DJANGO_TEST_TEMP_DIR'])) UPLOAD_TO = os.path.join(temp_storage.location, 'test_upload') class PictureInline(admin.TabularInline): model = Picture extra = 1 class GalleryAdmin(admin.ModelAdmin): inlines = [PictureInline] class PictureAdmin(admin.ModelAdmin): pass
from django.utils.translation import ungettext, ugettext_lazy as _ from forms_builder.forms import EntriesForm from forms_builder.models import Form, Field, FormEntry, FieldEntry from forms_builder.settings import CSV_DELIMITER, UPLOAD_ROOT from forms_builder.settings import USE_SITES, EDITABLE_SLUGS from forms_builder.utils import now, slugify from patient_portal.admin import form_creator_admin_site try: import xlwt XLWT_INSTALLED = True XLWT_DATETIME_STYLE = xlwt.easyxf(num_format_str='MM/DD/YYYY HH:MM:SS') except ImportError: XLWT_INSTALLED = False fs = FileSystemStorage(location=UPLOAD_ROOT) form_admin_filter_horizontal = () form_admin_fieldsets = [ (None, { "fields": ("title", ( "status", "login_required", ), "intro", "button_text", "response") }), ] if EDITABLE_SLUGS: form_admin_fieldsets.append((_("Slug"), { "fields": ("slug", ), "classes": ("collapse", ) }))
if not person.id: l = ldap.initialize('ldap://ldap.uiuc.edu') u = l.search_s('ou=people,dc=uiuc,dc=edu', ldap.SCOPE_SUBTREE, 'uid=%s' % person.netid) try: person.ldap_name = u[0][1]['cn'][0] except IndexError: raise ValueError('Bad Netid', 'Not a valid netid') class PreResumePerson(ResumePerson): number = models.IntegerField() # Wher to store the resumes fs = FileSystemStorage(location=settings.RESUME_STORAGE_LOCATION) def create_resume_file_name(instance, filename): return "%s/%s-%s.pdf" % (settings.RESUME_STORAGE_LOCATION, instance.person.netid, os.urandom(16).encode('hex')) class Resume(models.Model): person = models.ForeignKey(ResumePerson, null=True) approved = models.BooleanField(default=False) resume = ContentTypeRestrictedFileField(upload_to=create_resume_file_name, storage=fs, content_types=['application/pdf'], max_upload_size=1048576)
from django.db import models from django.contrib.auth.models import User from django.core.files.storage import FileSystemStorage fs = FileSystemStorage(location='/media/uploads') # TODO: Need to use Reporter instead of SignUp class Reporter(models.Model): user_name = models.CharField(max_length=120, null=True) password = models.CharField(max_length=120, null=True) created_at = models.DateTimeField(auto_now_add=True, blank=True) email = models.EmailField() is_superuser = models.BooleanField(blank=True, default=False) user = models.OneToOneField(User, blank=True, null=True) def __str__(self): return (self.user_name) class Group(models.Model): name = models.CharField(max_length=120) members = models.ManyToManyField(Reporter, through='Membership') def __str__(self): return self.name class Report(models.Model): # See https://docs.djangoproject.com/en/1.8/ref/models/fields/ for explanations of model fields
def post(self, request): Email = request.session['agn_stdmail'] Testeng = request.POST.getlist('Testeng[]') Yeareng = request.POST.getlist('Yeareng[]') Overallscoreeng = request.POST.getlist('Overallscoreeng[]') agentid = request.session['agentid'] agentmail = request.session['Email2'] Testad = request.POST.getlist('Testad[]') Yearad = request.POST.getlist('Yearad[]') Overallscoread = request.POST.getlist('Overallscoread[]') fs = FileSystemStorage() Uploadeng = request.FILES.getlist('Uploadeng[]') print("webfWJEFBJEfliwejhfiWNFLIH") print(Testeng) print(Yeareng) print(Overallscoreeng) print(Uploadeng) print(Testad) print(Yearad) print(Overallscoread) Uploadad = request.FILES.getlist('Uploadad[]') print(Uploadad) urleng = [] urlad = [] for i in range(0, len(Testeng)): testeng = Testeng[i] yeareng = Yeareng[i] overallscoreeng = Overallscoreeng[i] uploadeng = Uploadeng[i] name = fs.save(uploadeng.name, uploadeng) url = fs.url(name) urleng.append(url) stdpro = Stdpro(Agentmail=agentmail, Agentid=agentid, Email=Email, Testeng=testeng, Yeareng=yeareng, Overallscoreeng=overallscoreeng, Uploadeng=uploadeng, Urleng=url) stdpro.register() for i in range(0, len(Testad)): testad = Testad[i] yearad = Yearad[i] overallscoread = Overallscoread[i] uploadad = Uploadad[i] name = fs.save(uploadad.name, uploadad) url = fs.url(name) urlad.append(url) stdpro1 = Stdpro1(Agentmail=agentmail, Agentid=agentid, Email=Email, Testad=testad, Yearad=yearad, Overallscoread=overallscoread, Uploadad=uploadad, Urlad=url) stdpro1.register() '''name3=fs.save(Uploadeng.name,Uploadeng) url3=fs.url(name3) name5=fs.save(Uploadad.name,Uploadad) url5=fs.url(name5) print(url3)''' '''stdpro=Stdpro(Email=Email,Testeng=Testeng,Yeareng=Yeareng,Overallscoreeng=Overallscoreeng,Uploadeng=Uploadeng, Testad=Testad,Yearad=Yearad,Overallscoread=Overallscoread,Uploadad=Uploadad) stdpro.register()''' value = { 'Testeng': Testeng, 'Yeareng': Yeareng, 'Overallscoreeng': Overallscoreeng, 'Uploadeng': urleng, 'Testad': Testad, 'Yearad': Yearad, 'Overallscoread': Overallscoread, 'Uploadad': urlad } data = {'value': value} return render(request, 'agent_portal/Profressional.html')
def storage(): '''Provide a storage that exposes the test templates''' root = os.path.join(os.path.dirname(__file__), '..', 'app', 'templates') return FileSystemStorage(location=root, base_url='/baseurl/')
def register(request): if 'username' in request.POST and 'password' in request.POST and 'email' in request.POST: u = request.POST['username'] p = request.POST['password'] e = request.POST['email'] g = request.POST['inlineRadioOptions'] uploaded_file = request.FILES['document'] #django file system function, used for the profile picture fs = FileSystemStorage() name = fs.save(uploaded_file.name, uploaded_file) url = fs.url(name) #full url dob = request.POST['bday'] #gets dob string todays_date = datetime.today().date() #gets todays date birth_date = datetime.strptime( dob, '%Y-%m-%d').date() #converts dob string into datetime format print(dob) #prints user dob string print(todays_date) #prints todays date print(birth_date) #prints birth date age = ageCalculation(todays_date, birth_date) #gets age from function print(age) #prints value returned from the function some_var = request.POST.getlist( 'hobby') #some_var holds list of boxes ticked print( some_var ) # print boxes checked (hobbies) to the terminal DEBUGGING PURPOSES GET RID OF AFTER user = Member(username=u, email=e) user.set_password(p) #user.save() prof = Profile( user_name=u, Gender=g, imageurl=url, age=age ) #the profile will have a user_name and a gender until now.. more to be added prof.save() user.profile = prof try: user.save() except IntegrityError: raise Http404('Username ' + u + ' already taken: Usernames must be unique') for i in some_var: print( i ) # print specific hobbies from list to the terminal DEBUGGING PURPOSES GET RID OF AFTER selected_ob = Hobbie_choice.objects.get( choice=i) # on each loop i create Hobbie_choice object user.choice.add( selected_ob) # add it to the hobby choice of the created user # All_choices = user.choice.all() # get all the newly added hobbies return render(request, 'match/after_register.html') else: raise Http404('Please enter all fields')
def insert(request): if request.session['shop']: if request.method == 'POST': submit = request.POST['update'] if submit == "insert": pname = request.POST['pname'] img = request.FILES['img'] fs = FileSystemStorage() name = fs.save(img.name, img) url = fs.url(name) cost = request.POST['cost'] season = request.POST['season'] stock = request.POST['stock'] pmodel = request.POST['pmodel'] if stock == "yes" and (season == "all" or season == month): itemavail = 10 else: itemavail = 0 product.objects.create(pname=pname, img=url, cost=cost, season=season, pmodel=pmodel, stockavailable=stock, itemavail=itemavail) return render(request, 'shop/update.html', {'msg': 'update success'}) elif submit == "stockupdate": pname = request.POST['pname'] stock = request.POST['itemavail'] t = product.objects.filter(pname=pname) if len(t) <= 0: return render(request, 'shop/update.html', {'msg': "no items matched for update"}) for i in t: stockavailable = "no" if i.season == month or i.season == "all": if int(stock) >= 1: stockavailable = "yes" product.objects.filter(pname=pname).update( itemavail=stock, stockavailable=stockavailable) return update(request) elif submit == "costupdate": pname = request.POST['pname'] cost = request.POST['cost'] t = product.objects.filter(pname=pname) if len(t) <= 0: return render(request, 'shop/update.html', {'msg': "no items matched for update"}) product.objects.filter(pname=pname).update(cost=cost) return update(request) elif submit == "finditem": pname = request.POST['pname'] t = product.objects.filter(pname=pname) if len(t) >= 1: return render(request, 'shop/update.html', { 'msg': "item found", 'detail': t }) elif pname == "all": t = product.objects.all() return render(request, 'shop/update.html', { 'msg': "item found", 'detail': t }) else: return render(request, 'shop/update.html', {'msg': "no item found"}) elif submit == "findbyorder": orderno = request.POST['orderno'] t = purchasedetail.objects.filter(orderno=orderno) w = customer.objects.all() for i in w: for j in i.orderno: if int(j) == int(orderno): w = customer.objects.filter(cname=i.cname) break else: continue return render(request, 'shop/update.html', { 'msg': "details found", 'details': t, 'detail1': w }) elif submit == "findbycustomer": t = tempcn.objects.all() for i in t: tempcn.objects.filter(orderno=i.orderno).delete() cname = request.POST['cname'] t = purchasedetail.objects.filter(cname=cname) f = customer.objects.filter(cname=cname) if cname == "all": t = purchasedetail.objects.all() f = customer.objects.all() if len(t) >= 1: return render(request, 'shop/update.html', { 'msg': "details found", 'details': t, 'detail1': f }) else: if len(t) == 0: cname = cname.lower() A = cname[0] + cname[1] v = "^" + str(A) + ".*$" t = purchasedetail.objects.all() for i in t: p = i.cname p = str(p).lower() x = re.search(v, p) if (x): tempcn.objects.create( cname=i.cname, orderno=i.orderno, totalcost=i.totalcost, productdetails=i.productdetails, status=i.status, date=i.date, orderby=i.orderby) else: continue t = tempcn.objects.all() if len(t) >= 1: return render(request, 'shop/update.html', { 'msg': "some details found", 'details': t }) else: return render(request, 'shop/update.html', {'msg': "details not found"}) elif submit == "shop": user = request.POST['cname'] request.session["user"] = "******" request.session["admin"] = user return show(request) elif submit == "deleteitem": pname = request.POST['pname'] product.objects.filter(pname=pname).delete() return render(request, 'shop/update.html', {'msg': "product deleted"}) elif submit == "cancelorder": orderno = request.POST['orderno'] purchasedetail.objects.filter(orderno=orderno).update( status="cancelled") return render(request, 'shop/update.html', {'msg': "order cancelled"}) elif submit == "delivered": orderno = request.POST['orderno'] purchasedetail.objects.filter(orderno=orderno).update( status="delivered") return render(request, 'shop/update.html', {'msg': "order status updated"}) elif submit == "todaysbusiness" or submit == "totalbusiness": if submit == "todaysbusiness": t = purchasedetail.objects.filter(date=DATE) if submit == "totalbusiness": t = purchasedetail.objects.all() today = 0 for i in t: if i.totalcost == None: continue today = today + int(i.totalcost) return render(request, 'shop/update.html', {'today': 'TOTAL:' + str(today) + ' rupees'}) elif submit == "addstaff": sname = request.POST['sname'] phonenumber = request.POST['phone'] salary = request.POST['salary'] password = request.POST['password'] if staff.objects.filter(phonenumber=phonenumber).exists(): return render(request, 'shop/update.html', {'msg': "staff phonenumber exists"}) else: staff.objects.create(sname=sname, phonenumber=phonenumber, salary=salary, password=password, dateofjoining=str(DATE)) allstaff.objects.create(sname=sname, phonenumber=phonenumber, salary=salary, dateofjoining=str(DATE)) return render(request, 'shop/update.html', {'msg': "staff added"}) elif submit == "salaryupdate": phonenumber = request.POST['phone'] salary = request.POST['salary'] if staff.objects.filter(phonenumber=phonenumber).exists(): staff.objects.filter(phonenumber=phonenumber).update( salary=salary) allstaff.objects.filter(phonenumber=phonenumber).update( salary=salary) return render(request, 'shop/update.html', {'msg': "salary updated"}) elif allstaff.objects.filter(phonenumber=phonenumber).exists(): allstaff.objects.filter(phonenumber=phonenumber).update( salary=salary) return render(request, 'shop/update.html', {'msg': "salary updated"}) else: return render(request, 'shop/update.html', {'msg': "staff not exist"}) elif submit == "removestaff": phonenumber = request.POST['phone'] if staff.objects.filter(phonenumber=phonenumber).exists(): staff.objects.filter(phonenumber=phonenumber).delete() allstaff.objects.filter(phonenumber=phonenumber).delete() return render(request, 'shop/update.html', {'msg': "staff removed"}) elif allstaff.objects.filter(phonenumber=phonenumber).exists(): allstaff.objects.filter(phonenumber=phonenumber).delete() return render(request, 'shop/update.html', {'msg': "staff removed"}) else: return render(request, 'shop/update.html', {'msg': "staff not exist"}) elif submit == "addnewstaff": sname = request.POST['sname'] phonenumber = request.POST['phone'] salary = request.POST['salary'] if allstaff.objects.filter(phonenumber=phonenumber).exists(): return render(request, 'shop/update.html', {'msg': "staff phonenumber exists"}) else: allstaff.objects.create(sname=sname, phonenumber=phonenumber, salary=salary, dateofjoining=str(DATE)) return render(request, 'shop/update.html', {'msg': "staff added"}) elif submit == "tobedelivered": t = purchasedetail.objects.filter(status="tobedelivered") if len(t) > 0: return render(request, 'shop/update.html', {'details': t}) else: return render(request, 'shop/update.html', {'msg': "no orders pending"}) elif submit == "findstaffbyname": sname = request.POST['sname'] if sname == "all": t = allstaff.objects.all() return render(request, 'shop/update.html', {'sdetail': t}) elif allstaff.objects.filter(sname=sname).exists(): t = allstaff.objects.filter(sname=sname) return render(request, 'shop/update.html', {'sdetail': t}) else: return render(request, 'shop/update.html', {'msg': "no staff found"}) elif submit == "findstaffbynumber": phonenumber = request.POST['phone'] t = allstaff.objects.filter(phonenumber=phonenumber) if len(t) > 0: return render(request, 'shop/update.html', {'sdetail': t}) else: return render(request, 'shop/update.html', {'msg': "no staff found"}) else: return render(request, 'shop/adminlogin.html')
def storage(self): return FileSystemStorage(location=self.chunks_dir)
#skin-purple-light #skin-yellow #skin-yellow-light GVSIGOL_SKIN = '##GVSIGOL_SKIN##' GVSIGOL_NAME = '##GVSIGOL_NAME##' GVSIGOL_SURNAME = '##GVSIGOL_SURNAME##' GVSIGOL_NAME_SHORT = '##GVSIGOL_NAME_SHORT##' GVSIGOL_SURNAME_SHORT = '##GVSIGOL_SURNAME_SHORT##' CSRF_TRUSTED_ORIGINS = ['##GVSIGOL_HOST##'] FILEMANAGER_DIRECTORY = '##FILEMANAGER_DIR##' FILEMANAGER_MEDIA_ROOT = os.path.join(MEDIA_ROOT, FILEMANAGER_DIRECTORY) FILEMANAGER_MEDIA_URL = os.path.join(MEDIA_URL, FILEMANAGER_DIRECTORY) FILEMANAGER_STORAGE = FileSystemStorage(location=FILEMANAGER_MEDIA_ROOT, base_url=FILEMANAGER_MEDIA_URL, file_permissions_mode=0o666) CONTROL_FIELDS = [{ 'name': 'modified_by', 'type': 'character_varying' },{ 'name': 'last_modification', 'type': 'date' }] EXTERNAL_LAYER_SUPPORTED_TYPES = ['WMS', 'WMTS', 'XYZ', 'Bing', 'OSM'] WMTS_MAX_VERSION = '1.0.0' WMS_MAX_VERSION = '1.3.0' BING_LAYERS = ['Road','Aerial','AerialWithLabels']
def post(self, request, book_id): book_form = BookForm(request.POST, author_choices=self.authors, publisher_choices=self.publishers, genre_choices=self.genres) book = self.book_dao.get_byid(book_id) context = {'book': book} if 'update-book' in request.POST: if book_form.is_valid(): updated_book = Book() updated_book.book_id = book_id updated_book.title = book_form.cleaned_data['title'] updated_book.isbn10 = book_form.cleaned_data['isbn10'] updated_book.isbn13 = book_form.cleaned_data['isbn13'] updated_book.copyRightDate = book_form.cleaned_data[ 'copyright_date'] updated_book.edition = book_form.cleaned_data['edition'] updated_book.numberOfPages = book_form.cleaned_data[ 'num_pages'] updated_book.type = book_form.cleaned_data['book_type'] author = Author() author.author_id = int(book_form.cleaned_data['authors']) updated_book.author = author publisher = Publisher() publisher.publisher_id = int( book_form.cleaned_data['publishers']) updated_book.publisher = publisher genre = Genre() genre.genre_id = int(book_form.cleaned_data['genres']) updated_book.genre = genre self.book_dao.update(updated_book) context['notification'] = "Book updated successfully!" else: context['notification'] = "Not a valid submission." elif 'delete-book' in request.POST: book_id = int(request.POST.get('delete-book')) self.book_dao.delete(book_id) if 'add-image' in request.POST: image_form = BookImageForm(request.POST, request.FILES) if image_form.is_valid(): image_file = request.FILES['image'] fs = FileSystemStorage() filename = fs.save(image_file.name, image_file) uploaded_file_url = fs.url(filename) image = Image() image.image_url = uploaded_file_url image.caption = '' image.book.book_id = book_id self.image_dao.create(image) context['notification'] = filename else: context['notification'] = "Not a valid submission." return render(request, self.template_name, context)
import csvimport.monkeypatch_tzinfo from django.db import models from csvimport.app import settings from copy import deepcopy from django.core.files.storage import FileSystemStorage import re fs = FileSystemStorage(location=settings.MEDIA_ROOT) CHOICES = (('manual', 'manual'), ('cronjob', 'cronjob')) MODELS = [] def get_models(): """ Cannot load at module level for later djangos - since its too early """ global MODELS if MODELS: return MODELS # Create your models here. if not getattr(settings, 'CSVIMPORT_MODELS', []): try: # django1.7 or later ... try: allmodels = models.get_models() except: allmodels = [] except: allmodels = models.loading.get_models() if allmodels: MODELS = ['%s.%s' % (m._meta.app_label,
from groups.models import Group, GroupMember from datetime import datetime from autoslug import AutoSlugField from django.db.models import Max from dashboard.models import NewsItem from django.core.urlresolvers import reverse import os.path from django.conf import settings from django.utils.safestring import mark_safe from courselib.slugs import make_slug STATUS_CHOICES = [('NEW', 'New'), ('INP', 'In-Progress'), ('DON', 'Marked')] from django.core.files.storage import FileSystemStorage SubmissionSystemStorage = FileSystemStorage(location=settings.SUBMISSION_PATH, base_url=None) # per-activity models, defined by instructor: class SubmissionComponent(models.Model): """ A component of the activity that will be submitted by students """ activity = models.ForeignKey(Activity) title = models.CharField( max_length=100, help_text= 'Name for this component (e.g. "Part 1" or "Programming Section")') description = models.CharField( max_length=1000,
from django.contrib.messages import info from django.core.files.storage import FileSystemStorage from django.http import HttpResponse, HttpResponseRedirect from django.shortcuts import render, get_object_or_404 from django.utils.translation import ungettext, ugettext_lazy as _ from mezzanine.conf import settings from mezzanine.core.admin import TabularDynamicInlineAdmin from mezzanine.core.forms import DynamicInlineAdminForm from mezzanine.forms.forms import EntriesForm from mezzanine.forms.models import Form, Field, FormEntry, FieldEntry from mezzanine.pages.admin import PageAdmin from mezzanine.utils.static import static_lazy as static from mezzanine.utils.urls import admin_url, slugify fs = FileSystemStorage(location=settings.FORMS_UPLOAD_ROOT) # Copy the fieldsets for PageAdmin and add the extra fields for FormAdmin. form_fieldsets = deepcopy(PageAdmin.fieldsets) form_fieldsets[0][1]["fields"][3:0] = ["content", "button_text", "response"] form_fieldsets = list(form_fieldsets) form_fieldsets.insert(1, (_("Email"), { "fields": ("send_email", "email_from", "email_copies", "email_subject", "email_message") })) inline_field_excludes = [] if not settings.FORMS_USE_HTML5: inline_field_excludes += ["placeholder_text"]
def stu_profile_edit_save(request): id = request.POST.get("student_id") print(id) enrolment_no = request.POST.get("enrolment_no") stu_first_name = request.POST.get("stu_first_name") stu_last_name = request.POST.get("stu_last_name") sex = request.POST.get("sex") phone_no = request.POST.get("phone_no") ssc_percentage = request.POST.get("ssc_percentage") hsc_percentage = request.POST.get("hsc_percentage") ug_stream = request.POST.get("ug_stream") ug_percentage = request.POST.get("ug_percentage") pg_cgpa = request.POST.get("pg_cgpa") context = { "eno": enrolment_no, "fname": stu_first_name, "lname": stu_last_name, "phone_no": phone_no, "ssc": ssc_percentage, "hsc": hsc_percentage, "ug": ug_percentage, "pg": pg_cgpa, } if enrolment_no == "" or stu_first_name == "" or stu_last_name == "" or phone_no == "" or ssc_percentage == "" or hsc_percentage == "" or ug_stream == "" or ug_percentage == "" or pg_cgpa == "": messages.error(request, "fill all the details") response = stu_profile(request, context) return response user = Students.objects.get(id=id) if request.FILES.get('profile_pic'): profile_pic = request.FILES.get('profile_pic') # dir_storage = '/media/student_media/profile_picture/' + enrolment_no fs = FileSystemStorage() filename = fs.save(profile_pic.name, profile_pic) print(filename) profile_pic_url = fs.url(filename) user.profile_pic = profile_pic_url # usernamecheck = CustomUser.objects.filter(username=enrolment_no).first() # # if usernamecheck != None: # messages.error(request, "With this enrollment Account is already Created") # response = edit_student(request, context) # return response usertable = CustomUser.objects.get(id=user.user_type_id) usertable.first_name = stu_first_name usertable.last_name = stu_last_name usertable.save() user.enrolment_no = enrolment_no user.gender = sex user.phone_no = phone_no user.ssc_percentage = ssc_percentage user.hsc_percentage = hsc_percentage user.ug_percentage = ug_percentage user.pg_cgpa = pg_cgpa user.save() messages.success(request, "Student Account Updated") return HttpResponseRedirect(reverse("stu_profile_edit", kwargs={'id': id}))
def setUp(self): self.storage_dir = tempfile.mkdtemp() self.storage = FileSystemStorage(self.storage_dir) self.thread = threading.Thread(target=self.save_file, args=['conflict'])
def write_upload_to_file(photo_file, upload_path): """ Save bufferred file in memory to disk """ fss = FileSystemStorage() filename = fss.save(upload_path + photo_file.name, photo_file) uploaded_file_url = fss.url(filename) return uploaded_file_url
def setUp(self): self.storage_dir = tempfile.mkdtemp() self.storage = FileSystemStorage(self.storage_dir)
def index(request): # Authentication auth_error = get_auth_error(request) if auth_error is not None: return auth_error # Finally process the request if request.method != 'POST': # GET processing # Render the form return render(request, 'SubmitExperiment/index.html', {'form': ExperimentForm()}) # POST processing # Validate form and submit experiment form = ExperimentForm(request.POST, request.FILES) if not form.is_valid(): messages.error(request, 'Submitted form was not valid.') messages.info(request, 'Please fix the errors and try again.') return render(request, 'SubmitExperiment/index.html', {'form': form}) # I shouldn't be validating fields here, but in form # I can't know whether user is logged in or not if request.user.is_authenticated: email = request.user.email else: email = form.cleaned_data['author_email'] if email is None or len(email) == 0: messages.error(request, 'Submitted form was not valid.') messages.info(request, 'Please fix the errors and try again.') form.add_error('author_email', 'This field is required.') return render(request, 'SubmitExperiment/index.html', {'form': form}) # Form is valid here, continue in_file = request.FILES['in_file'] if form.cleaned_data['default_cfg']: # Picking default configuration if possible config_list = PredefinedConfiguration.objects.all().order_by( 'required_bytes') if len(config_list) == 0: raise AssertionError('there are no predefined configurations') last_leq_id = None for c in config_list: if in_file.size >= c.required_bytes: last_leq_id = c.id else: break if last_leq_id is None: last_leq_id = config_list[0].id messages.warning( request, "Provided file is too small for all configurations.") chosen_cfg = PredefinedConfiguration.objects.get(id=last_leq_id) messages.info( request, "Best possible configuration was chosen and requires {} bytes.". format(chosen_cfg.required_bytes)) cfg_file = chosen_cfg.cfg_file elif form.cleaned_data['choose_cfg'] is not None: # User picked one of predefined configurations cfg = PredefinedConfiguration.objects.get( id=form.cleaned_data['choose_cfg'].id) cfg_file = cfg.cfg_file if in_file.size < cfg.required_bytes: messages.warning( request, "Your file is smaller than" " recommended file size for chosen configuration.") messages.warning( request, "Recommended file size: {} bytes".format(cfg.required_bytes)) messages.warning( request, "Size of provided file: {} bytes".format(in_file.size)) else: # User provided his own configuration cfg_file = request.FILES['own_cfg'] fs = FileSystemStorage() in_file_path = fs.path(fs.save(in_file.name, in_file)) cfg_file_path = fs.path(fs.save(cfg_file.name, cfg_file)) try: _thread.start_new_thread(submit_experiment, (form, email, in_file_path, cfg_file_path)) except BaseException as e: print('Could not start a thread: {}'.format(e)) messages.success( request, 'Experiment {} was created.'.format(form.cleaned_data['exp_name'])) return redirect('SubmitExperiment:index')