Fonction de création de données de décalage de table Django terminée

En conséquence, j'ai remarqué après avoir créé la fonction, mais je me suis demandé s'il serait impossible pour le décideur de quart de faire des ajustements après que tous les changements aient été saisis par la personne elle-même. En outre, il est nécessaire de vérifier auprès de l'utilisateur et de modifier la fonction.

Cela fait longtemps, mais ce sont des vues.

schedule/views.py


from django.shortcuts import render, redirect, HttpResponseRedirect
from shisetsu.models import *
from accounts.models import *
from .models import *
import calendar
import datetime
from datetime import timedelta
from datetime import datetime as dt
from django.db.models import Sum
from django.contrib.auth.models import User
from django.views.generic import FormView, UpdateView, ListView, CreateView, DetailView, DeleteView
from django.urls import reverse_lazy
from .forms import *
from dateutil.relativedelta import relativedelta
from django.contrib.auth.models import User
# Create your views here.

def homeschedule(request):
    from datetime import datetime
    now = datetime.now()
    return HttpResponseRedirect('/schedule/monthschedule/%s/%s/' % (now.year,now.month,))  #Rediriger automatiquement vers l'écran d'équipe de ce mois

def monthschedulefunc(request,year_num,month_num):
    user_list = User.objects.all()
    profile_list = Profile.objects.select_related().values().order_by('hyoujijyun')
    year, month = int(year_num), int(month_num)
    shisetsu_object = Shisetsu.objects.all()
    shift_object = Shift.objects.all()
    object_list = Schedule.objects.filter(year = year, month = month).order_by('user', 'date')
    month_total = Schedule.objects.select_related('User').filter(year = year, month = month).values("user").order_by("user").annotate(month_total_worktime = Sum("day_total_worktime"))
    #Obtenez le nombre de jours dans la plage de travail
    enddate = datetime.date(year,month,20)
    startdate = enddate + relativedelta(months=-1)
    kaisu = enddate - startdate
    kaisu = int(kaisu.days) 
    kikan = str(startdate) +"~"+ str(enddate)
    
    #Faites une liste de dates et de jours
    hiduke = str(startdate)
    date_format = "%Y-%m-%d"
    hiduke = dt.strptime(hiduke, date_format)
    weekdays = ["Mois","Feu","eau","bois","Argent","sol","journée"]
    calender_object = []
    youbi_object = []
    for i in range(kaisu):
        hiduke = hiduke + timedelta(days=1)    
        calender_object.append(hiduke)
        youbi = weekdays[hiduke.weekday()] 
        youbi_object.append(youbi)
    
    kaisu = str(kaisu)

    context = {
        'year': year,
        'month': month,
        'kikan': kikan,
        'object_list': object_list,
        'user_list': user_list,
        'shift_object': shift_object,
        'calender_object': calender_object,
        'youbi_object': youbi_object,
        'kaisu': kaisu,
        'shisetsu_object': shisetsu_object,
        'month_total' : month_total,
        'profile_list' : profile_list,
    }
    return render(request,'schedule/month.html', context)

def scheduleUpdatefunc(request,pk):
    Schedule_list = Schedule.objects.get(pk = int(pk))
    User_list = User.objects.get(username = Schedule_list.user)
    shift_object = Shift.objects.all()
    
    if request.method == 'POST':
        form = ScheduleUpdateForm(data=request.POST)
        year = Schedule_list.year
        month = Schedule_list.month
        #Mettre à jour le traitement du bouton
        if form.is_valid():
            Schedule_list.shift_name_1 = form.cleaned_data['shift_name_1']
            Schedule_list.shisetsu_name_1 = form.cleaned_data['shisetsu_name_1']
            Schedule_list.shift_name_2 = form.cleaned_data['shift_name_2']
            Schedule_list.shisetsu_name_2 = form.cleaned_data['shisetsu_name_2']
            Schedule_list.shift_name_3 = form.cleaned_data['shift_name_3']
            Schedule_list.shisetsu_name_3 = form.cleaned_data['shisetsu_name_3']
            Schedule_list.shift_name_4 = form.cleaned_data['shift_name_4']
            Schedule_list.shisetsu_name_4 = form.cleaned_data['shisetsu_name_4']
            #Bouton de mise à jour
            if "updatebutton" in request.POST:
                Schedule_list.day_total_worktime = form.cleaned_data['day_total_worktime']
            #Calculer à partir du bouton de décalage et de mise à jour
            elif "sumupdatebutton" in request.POST:
                #Calculer le nombre total d'heures de travail quotidiennes à partir des quarts de travail
                sum_work_time = 0
                for shift in shift_object:
                    if str(form.cleaned_data['shift_name_1']) == str(shift.name):
                        sum_work_time = shift.wrok_time + sum_work_time
                    if str(form.cleaned_data['shift_name_2']) == str(shift.name):
                        sum_work_time = shift.wrok_time + sum_work_time
                    if str(form.cleaned_data['shift_name_3']) == str(shift.name):
                        sum_work_time = shift.wrok_time + sum_work_time
                    if str(form.cleaned_data['shift_name_4']) == str(shift.name):
                        sum_work_time = shift.wrok_time + sum_work_time
                
                Schedule_list.day_total_worktime = sum_work_time
        Schedule_list.save()
        return HttpResponseRedirect('/schedule/monthschedule/%s/%s/' % (year,month,))       
    else:
        item = {
            "shift_name_1":Schedule_list.shift_name_1,
            "shisetsu_name_1": Schedule_list.shisetsu_name_1,
            "shift_name_2": Schedule_list.shift_name_2,
            "shisetsu_name_2": Schedule_list.shisetsu_name_2,
            "shift_name_3": Schedule_list.shift_name_3,
            "shisetsu_name_3": Schedule_list.shisetsu_name_3,
            "shift_name_4": Schedule_list.shift_name_4,
            "shisetsu_name_4": Schedule_list.shisetsu_name_4,
            "day_total_worktime": Schedule_list.day_total_worktime,
            }
        form = ScheduleUpdateForm(initial=item)
        context = {
            'form' : form,
            'Schedule_list': Schedule_list,
            'User_list': User_list,
            'shift_object': shift_object,
        }
        return render(request,'schedule/update.html', context )

def schedulecreatefunc(request,year_num,month_num):
    year, month = int(year_num), int(month_num)
    #Supprimer tous les horaires de l'année et du mois cibles
    Schedule.objects.filter(year = year, month = month).delete()
    #Obtenez le nombre de jours dans la plage de travail
    enddate = datetime.date(year,month,20)
    startdate = enddate + relativedelta(months=-1)
    #Extraire l'espoir de la période cible du décalage souhaité
    kiboushift_list = KibouShift.objects.filter(date__range=[startdate, enddate])
    kiboushift_list = list(kiboushift_list)
    shift_list = Shift.objects.all()
    
    #Refléter le décalage souhaité
    for kibou in kiboushift_list:
        sum_work_time = 0
        for shift in shift_list:
                if str(kibou.shift_name_1) == str(shift.name):
                    sum_work_time = shift.wrok_time + sum_work_time
                if str(kibou.shift_name_2) == str(shift.name):
                    sum_work_time = shift.wrok_time + sum_work_time
                if str(kibou.shift_name_3) == str(shift.name):
                    sum_work_time = shift.wrok_time + sum_work_time
                if str(kibou.shift_name_4) == str(shift.name):
                    sum_work_time = shift.wrok_time + sum_work_time
        new_object = Schedule(
            user = kibou.user,
            date = kibou.date, 
            year = year,
            month = month,
            shift_name_1 = kibou.shift_name_1, 
            shisetsu_name_1 = kibou.shisetsu_name_1,
            shift_name_2 = kibou.shift_name_2, 
            shisetsu_name_2 = kibou.shisetsu_name_2,
            shift_name_3 = kibou.shift_name_3, 
            shisetsu_name_3 = kibou.shisetsu_name_3,
            shift_name_4 = kibou.shift_name_4, 
            shisetsu_name_4 = kibou.shisetsu_name_4,
            day_total_worktime = sum_work_time,
            )
        new_object.save()
    
    #Créer une équipe autre que celle souhaitée
    user_list = User.objects.all()
    #Obtenez le nombre de jours dans la plage de travail
    enddate = datetime.date(year,month,20)
    startdate = enddate + relativedelta(months=-1)
    kaisu = enddate - startdate
    kaisu = int(kaisu.days) 
    #le mois dernier
    if month != 1 :
        zengetsu = month - 1
    else:
        zengetsu = 12
        year = year - 1
    #Processus pour chaque utilisateur
    for user in user_list:
        kongetsu_list = Schedule.objects.filter(year = year, month = month, user = user.id).order_by('date')
        zengetsu_list = Schedule.objects.filter(year = year, month = zengetsu, user = user.id).order_by('date')
        sakusei_date = startdate
        shift_list = Shift.objects.all()
        for new_shift in range(kaisu):
            sakusei_date = sakusei_date + timedelta(days=1)
            if kongetsu_list.filter(user = user.id, date = sakusei_date).exists():
                print("ok")                       
            else:
                hukushadate = sakusei_date + relativedelta(months=-1)
                hukusha_list = zengetsu_list.filter(date = hukushadate, user = user.id)
                if zengetsu_list.filter(date = hukushadate, user = user.id).exists():
                    for hukusha in hukusha_list:
                    #Calculer le nombre total d'heures de travail quotidiennes à partir des quarts de travail
                        sum_work_time = 0
                        for shift in shift_list:
                            if str(hukusha.shift_name_1) == str(shift.name):
                                sum_work_time = shift.wrok_time + sum_work_time
                            if str(hukusha.shift_name_2) == str(shift.name):
                                sum_work_time = shift.wrok_time + sum_work_time
                            if str(hukusha.shift_name_3) == str(shift.name):
                                sum_work_time = shift.wrok_time + sum_work_time
                            if str(hukusha.shift_name_4) == str(shift.name):
                                sum_work_time = shift.wrok_time + sum_work_time

                        new_object=Schedule(
                            user = hukusha.user,
                            date = sakusei_date,
                            year = year,
                            month = month,
                            shift_name_1 = hukusha.shift_name_1, 
                            shisetsu_name_1 = hukusha.shisetsu_name_1,
                            shift_name_2 = hukusha.shift_name_2, 
                            shisetsu_name_2 = hukusha.shisetsu_name_2,
                            shift_name_3 = hukusha.shift_name_3, 
                            shisetsu_name_3 = hukusha.shisetsu_name_3,
                            shift_name_4 = hukusha.shift_name_4, 
                            shisetsu_name_4 = hukusha.shisetsu_name_4,
                            day_total_worktime = sum_work_time,
                            )
                        new_object.save()
                else:
                    useradd = User.objects.get(id=user.id)
                    shiftadd = Shift.objects.get(id=2)
                    new_object=Schedule(
                    user = useradd,
                    date = sakusei_date,
                    year = year,
                    month = month,
                    shift_name_1 = shiftadd, 
                    shisetsu_name_1 = None,
                    shift_name_2 = None, 
                    shisetsu_name_2 = None,
                    shift_name_3 = None, 
                    shisetsu_name_3 = None,
                    shift_name_4 = None, 
                    shisetsu_name_4 = None,
                    day_total_worktime = 0,
                    )
                    new_object.save()
    return HttpResponseRedirect('/schedule/monthschedule/%s/%s/' % (year,month,))
            
def kiboulistfunc(request):
    KibouShift_list = KibouShift.objects.all().order_by('-date')
    User_list = User.objects.all()
    shift_object = Shift.objects.all()
    context = {
        'KibouShift_list': KibouShift_list,
        'User_list': User_list,
        'shift_object': shift_object,
        }

    return render(request,'schedule/kiboushift/list.html', context )
        
class KibouCreate(CreateView):
    template_name = 'schedule/kiboushift/create.html'
    model = KibouShift
    fields = ('user', 'date', 'shift_name_1', 'shisetsu_name_1', 'shift_name_2', 'shisetsu_name_2', 'shift_name_3', 'shisetsu_name_3', 'shift_name_4', 'shisetsu_name_4')
    success_url = reverse_lazy('schedule:KibouList')

class KibouUpdate(UpdateView):
    template_name = 'schedule/kiboushift/update.html'
    model = KibouShift
    fields = ('user', 'date', 'shift_name_1', 'shisetsu_name_1', 'shift_name_2', 'shisetsu_name_2', 'shift_name_3', 'shisetsu_name_3', 'shift_name_4', 'shisetsu_name_4')
    success_url = reverse_lazy('schedule:KibouList')

class KibouDelete(DeleteView):
    template_name = 'schedule/kiboushift/delete.html'
    model = KibouShift
    fields = ('user', 'date', 'shift_name_1', 'shisetsu_name_1', 'shift_name_2', 'shisetsu_name_2', 'shift_name_3', 'shisetsu_name_3', 'shift_name_4', 'shisetsu_name_4')
    success_url = reverse_lazy('schedule:KibouList')

Ceci termine la fonction de création. Après avoir créé les données d'équipe souhaitées, les autres jours seront créés le même jour du mois précédent.

Je voulais appeler le même processus (calculer les heures de travail à partir du nom de l'équipe) avec une fonction et renvoyer la valeur, mais je ne sais pas encore, je les ai donc écrites séparément. A partir de maintenant, j'aimerais m'en souvenir et garder le code plus court.

image.png

S'il n'y a pas de mois précédent, j'essaye de le créer pendant les vacances.

Ensuite, nous devrons peut-être entrer dans le monde encore inconnu des css et js ... (rires) En fait, près de 20 personnes sont inscrites, donc lorsque vous affichez le tout, c'est difficile à voir à moins de fixer l'en-tête du tableau ... Comme ça

image.png

Ce sera un décalage d'un jour ...

Je veux le changer pour qu'il soit facile à voir sur mon smartphone. Je ne sais pas s'il peut être utilisé pour les smartphones, mais j'aimerais implémenter un affichage fixe.

Recommended Posts

Fonction de création de données de décalage de table Django terminée
création de table django
Table de décalage Django Python
Fonction de création de décalage Django
Tutoriel Django (Créer une application de blog) ⑤ --Fonction de création d'article
Modifier le HTML et le CSS de la table de décalage Django
Ajout d'une fonction pour enregistrer les décalages souhaités dans la table des décalages Django
Fonction de création de quart de travail Django Ajout de la fonction d'enregistrement de travail de base pendant des jours
Affichez la table des équipes Django! Prend en charge la fermeture de 20 jours
Je veux faire défiler la table de décalage Django, mais ...
[Django] Perform Truncate Table (supprimer toutes les données de la table)
[Django] Ajout d'une nouvelle fonction de création de questions à l'application de sondages