मेरे पास टास्क नामक एक टेबल है। यह कार्य, कार्य स्कोर और उस कर्मचारी को कैप्चर करता है जिसे इसे सौंपा गया है। मैं सप्ताह के लिए अपने कुल कार्य स्कोर का उपयोग करके कर्मचारी के प्रदर्शन की गणना करना चाहता हूं (अवधि गतिशील होनी चाहिए। अधिमानतः इनपुट क्षेत्र) और आवंटित कुल स्कोर। मैं वास्तविक स्कोर को एकत्रित करने के बारे में सोच रहा हूं, फिर खरीद कुल स्कोर को विभाजित करके प्रतिशत प्राप्त करने के लिए 100 से गुणा करें। मेरी बड़ी चुनौती यह है कि यह गणना कहां की जाए। क्या मुझे प्रदर्शन नामक एक मॉडल बनाना चाहिए और एक फ़ंक्शन का उपयोग करना चाहिए? या अगर कोई मुझे दिखा सकता है कि इस बारे में कैसे जाना है?

यहाँ मॉडल है;

class Task(models.Model):
    title = model.CharField(max_length=200)
    scores = models.IntegerField(null=True, blank=True)

    def __str__(self):
        return self.name

यहां वह सूत्र है जिसका मैं उपयोग करना चाहता हूं। प्रदर्शन (%) = वास्तविक स्कोर / कुल स्कोर * 100. कुल स्कोर इनपुट फ़ील्ड होना चाहिए।

अपडेट करें यहाँ प्रासंगिक मॉडल हैं। मैं कर्मचारी के रूप में उपयोगकर्ता मॉडल का उपयोग कर रहा हूं।

**USER OR EMPLOYEE MODEL**
 
class User(AbstractUser):
    ROLE_CHOICES = (
    ("STAFF", "Staff"),
    ("HOD", "Hod"),
    ("CEO", "Ceo"),
    )

    GENDER_CHOICES = (
    ("Male", "Male"),
    ("Female", "Female")
    )

    CONFIRMATION_CHOICES = (
        ("YES", "yes"),
        ("NO", "no")
    )

    UNDERTAKING_CHOICES = (
        ("YES", "yes"),
        ("NOT YET", "Not yet")
    )

    GENDER_CHOICES = (
        ("Male", "Male"),
        ("Female", "Female")
    )

    EMPLOYEE_TYPE_CHOICES = (
        ("Permanent", "Permanent"),
        ("Contract", "Contract")
    )

    first_name = models.CharField(max_length=100, blank=True)
    last_name = models.CharField(max_length=100, blank=True)
    middle_name = models.CharField(max_length=100, null=True, blank=True)
    email = models.EmailField(null=True)
    avatar =  models.ImageField(upload_to='images/avatar', null=True, blank=True)
    department = models.ForeignKey(Department, related_name='userdept', on_delete=models.CASCADE, null=True)
    role = models.ForeignKey(Role, related_name='userrol', on_delete=models.CASCADE, null=True, blank=True)
    user_role = models.CharField(max_length=100, choices=ROLE_CHOICES, null=True)
    avatar = models.ImageField(upload_to="avatars", null=True, blank=True)
    is_hod = models.BooleanField(default=False)
    is_ceo = models.BooleanField(default=False)
    is_admin = models.BooleanField(default=False)
    is_superuser = models.BooleanField(default=False)
    gender = models.CharField(max_length=100, choices=GENDER_CHOICES, null=True, blank=True)
    cell_phone = models.CharField(max_length=20, blank=True, null=True)
    employee_id = models.CharField(max_length=200, null=True, blank=True)
    supervisor = models.CharField(max_length=200, null=True, blank=True)
    work_email = models.EmailField(null=True, blank=True)
    work_phone = models.CharField(max_length=20, blank=True)
    start_date = models.CharField(max_length=20, blank=True)
    salary = models.CharField(max_length=20, blank=True, null=True)
    work_location = models.CharField(max_length=20, null=True, blank=True)
    probation_length = models.CharField(max_length=20, null=True, blank=True)
    pay_slip_type = models.CharField(max_length=20, null=True, blank=True)
    can_terminate = models.CharField(max_length=20, null=True, blank=True)
    dob = models.CharField(max_length=20, null=True, blank=True)
    employee_type = models.CharField(max_length=20, choices=EMPLOYEE_TYPE_CHOICES, null=True, blank=True)
    comfirmed = models.CharField(max_length=3, choices=CONFIRMATION_CHOICES, null=True)
    undertaking = models.CharField(max_length=8, choices=UNDERTAKING_CHOICES, null=True)
    leave_days = models.IntegerField(null=True, blank=True) 
    line_manager = models.CharField(max_length=20, null=True, blank=True)   
    last_promotion_date = models.CharField(max_length=20, null=True, blank=True)
    
    
    def __str__(self):
        return self.first_name+' '+self.last_name


**TASK MODEL**

from django.db import models
from departments.models import Department
from akps.models import Akp
from users.models import User
from goals.models import OrganisationGoal, OrganisationSubGoal, DepartmentGoal
from django.template.loader import render_to_string
from django.core.mail import send_mail
from django.core.mail import EmailMultiAlternatives
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.utils.text import slugify
# from django.template.loader import render_to_string
from django.core.mail import send_mail
from django.core.mail import EmailMultiAlternatives
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.utils.text import slugify
from django.core.exceptions import ValidationError


class Task(models.Model):
    STATUS_CHOICES = (
    ("COMPLETED", "completed"),
    ("FAILED", "failed"),
    )
    department = models.ForeignKey(Department, related_name='soussdepartmentt', on_delete=models.CASCADE, null=True)
    akp = models.ForeignKey(Akp, related_name='sousakpp', on_delete=models.CASCADE, null=True)
    organisationgoal = models.ForeignKey(OrganisationGoal, on_delete=models.CASCADE, null=True)
    organisationsubgoal = models.ForeignKey(OrganisationSubGoal, on_delete=models.CASCADE, null=True, blank=True)
    departmentgoal = models.ForeignKey(DepartmentGoal, on_delete=models.CASCADE, related_name='departgoal', null=True, blank=True)
    name = models.CharField(max_length=300, null=True)
    description = models.TextField(max_length=1000, null=True)
    assignedby = models.ForeignKey(User, on_delete=models.CASCADE, related_name='taskassignb', null=True, blank=True)
    assignedto = models.ForeignKey(User, on_delete=models.CASCADE, related_name='taskassignt', null=True, blank=True)
    user = models.ForeignKey(User, related_name='usertas', on_delete=models.CASCADE, null=True)
    scores = models.IntegerField(null=True, blank=True)
    status = models.CharField(max_length=10, choices=STATUS_CHOICES, null=True, blank=True)
    email = models.EmailField(null=True)
    due_date = models.DateField(null=True)
    created_at = models.DateTimeField(auto_now_add=True, null=True)
    updated_at = models.DateTimeField(auto_now=True, null=True)


    def __str__(self):
        return self.name


    def clean(self):
        other_tasks = Task.objects.exclude(pk=self.pk) \
            .filter(departmentgoal=self.departmentgoal)

        if other_tasks.count() > 0:
            contributed = (
                other_tasks.values("departmentgoal")
                .annotate(total=models.Sum("scores"))
                .values_list("total", flat=True)[0]
            )
        else:
            contributed = 0

        if self.scores and self.scores + contributed > self.departmentgoal.scores:
            raise ValidationError({"scores": "Score is too much"})

यहाँ एक परिदृश्य है;

  • उपयोगकर्ता ए ने साप्ताहिक 10 में से 8 कार्य पूरे कर लिए हैं। उन्होंने कुल 18 अंक बनाए। नोट: साप्ताहिक स्कोर 20 अंक से अधिक नहीं हो सकते।

  • उपरोक्त प्रक्रिया हर हफ्ते दोहराई जाती है। बता दें कि दूसरे हफ्ते उन्होंने 20 अंक बनाए।

  • या तो १ महीने, ४ महीने, ६ महीने या १ साल के बाद, मैं चाहता हूँ उसके प्रदर्शन की गणना करें और उसके डैशबोर्ड पर प्रदर्शित करें। गणित वास्तविक स्कोर/कुल स्कोर * 100 है। मेरा मानना ​​​​है कि यह उपयोगकर्ता और कार्य मॉडल के साथ प्राप्त किया जा सकता है लेकिन मुझे नहीं पता कि इसे कैसे कार्यान्वित किया जाए।

उपयोगकर्ता और डैशबोर्ड देखें

from tasks.models import Task
from users.models import User
from goals.models import DepartmentGoal, OrganisationGoal
from django.utils import timezone
from datetime import timedelta

def dashboard(request):
    
    completed_tasks = Task.objects.filter(status="COMPLETED", assignedto=request.user).count()
    failed_tasks = Task.objects.filter(status="FAILED", assignedto=request.user).count()

    debt_complt_goal = DepartmentGoal.objects.filter(status="COMPLETED", department=request.user.department).count()
    debt_failed_goal = DepartmentGoal.objects.filter(status="FAILED", department=request.user.department).count()

    complt_org_goals = OrganisationGoal.objects.filter(status="COMPLETED").count()
    failed_org_goals = OrganisationGoal.objects.filter(status="FAILED").count()

    return render (request, 'home.html', {
        'completed_tasks':completed_tasks, 
        'failed_tasks':failed_tasks, 
        'debt_complt_goal':debt_complt_goal,
        'debt_failed_goal':debt_failed_goal,
        'complt_org_goals':complt_org_goals,
        'failed_org_goals':failed_org_goals,
    })



from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
from .models import Profile, User
from .forms import ProfileForm, CreateUserForm, UserSetPasswordForm
from django.contrib.auth.forms import AuthenticationForm
from django.contrib.auth import authenticate, login, logout
from django.contrib import messages


def list_users_view(request):
    department = request.user.department
    dept_users = User.objects.filter(department=department)
    users = User.objects.all()
    context = {
        'users':users,
        'dept_users':dept_users
        }
    return render(request, 'users/list-users.html', context)
0
Thaddeaus Iorbee 4 अगस्त 2021, 04:42

2 जवाब

सबसे बढ़िया उत्तर

यहां वे मानदंड हैं जिनकी मैंने व्याख्या की है:

  1. assignedto फ़ील्ड का उपयोग करने वाले उपयोगकर्ता के साथ एक कार्य संबद्ध है।
  2. कार्य की एक नियत तिथि है जिसका उपयोग प्रदर्शन की गणना करते समय समय सीमा मापदंडों के विरुद्ध किया जाएगा।
  3. कार्य या तो पूरा हो गया है या विफल हो गया है।
  4. यदि उपयोगकर्ता कार्य पूरा करता है, तो उपयोगकर्ता कार्य से जुड़े स्कोर को प्राप्त कर लेगा।

समाधान

प्रदर्शन की गणना करने के लिए अपने User मॉडल पर एक कस्टम विधि जोड़ें। विधि एक समय सीमा के बीच प्रदर्शन की गणना करने के लिए start और end दिनांक तर्क मांगेगी।

from django.db.models import Sum, Q


class User(AbstractUser):
    ...

    def performance(self, start, end):
        actual = Sum("scores", filter=Q(status="completed"))

        q = self.taskassignt.filter(
            due_date__gte=start,
            due_date__lt=end  # `end` is excluded from the range
        ).annotate(actual=actual, total=Sum("scores"))

        return (q[0].actual / q[0].total) * 100

ध्यान दें कि समय सीमा कार्यान्वयन end को सीमा से बाहर करता है क्योंकि यह lt (से कम) ऑपरेटर का उपयोग करता है।

विधि का उपयोग है:

from django.utils import timezone
from datetime import timedelta


# user is a `User` instance
user.performance(timezone.now() + timedelta(days=-7), timezone.now())
0
Scratch'N'Purr 3 सितंबर 2021, 02:35

मैं इसे ऊपर आपके मॉडल में पूरी तरह से मैप नहीं कर सकता क्योंकि आप उपयोगकर्ता मैपिंग और टाइमस्टैम्प जैसी कुछ चीजें खो रहे हैं, लेकिन यह कुछ ऐसा होना चाहिए:

from django.db.models import Count, Sum, F
from datetime import datetime, timedelta

end_date = datetime.now()
start_date = end_date - timedelta(days=7)
performance = Sum(F('scores')) / (Count(F('scores')) * 100)
Task.objects.filter(
    employee_id=123, 
    timestamp__gt=start_date, 
    timestamp__lte=end_date
).aggregate(
    performance=performance
)
0
shapiromatron 4 अगस्त 2021, 02:35