Revert "Make apps into external dependencies"

This reverts commit 668a108.

This revert is due to the wrong architecture created by this bad commit which
made spurious results

Co-Authored-By: Vibhoothi <[email protected]>
Co-Authored-By: Aniketh Gireesh <[email protected]>
Co-Authored-By: B Krishnan Iyer <[email protected]>
Co-Authored-By: Siddarth <[email protected]>
Co-Authored-By: Venu Vardhan <[email protected]>
Signed-off-by: Vibhoothi <[email protected]>
Signed-off-by: Aniketh Gireesh <[email protected]>
Signed-off-by: B Krishnan Iyer <[email protected]>
Signed-off-by: Siddarth <[email protected]>
Signed-off-by: Venu Vardhan <[email protected]>

Author: 5 people

crons/__init__.py renamed to attendance/__init__.py

@@ -0,0 +1,39 @@
+from django.contrib import admin
+from easy_select2 import select2_modelform
+from datetime import datetime
+from django.utils import timezone
+from .models import *
+from .generatorScript import generatorScript
+
+@admin.register(Module)
+class AttendanceModuleAdmin(admin.ModelAdmin):
+    fields = (
+        'name',
+        ('seed', 'SSID', 'isPaused'),
+        ('seedRefreshInterval', 'lastRefreshTime')
+    )
+    list_display = ('name', 'SSID', 'lastRefreshTime', 'isPaused', 'seedRefreshInterval')
+    readonly_fields = ['SSID', 'lastRefreshTime']
+    select2 = select2_modelform(Module, attrs={'width': '250px'})
+    form = select2
+
+    def save_model(self, request, obj, form, change):
+        if 'seed' in form.changed_data and obj.isPaused is False:
+            newSeed = generatorScript(obj.seed)
+            obj.SSID = 'amFOSS_' + str(newSeed)
+            obj.seed = newSeed
+            obj.lastRefreshTime = timezone.now().replace(second=0, microsecond=0)
+        super(AttendanceModuleAdmin, self).save_model(request, obj, form, change)
+
+@admin.register(Log)
+class AttendanceLogAdmin(admin.ModelAdmin):
+    fields = (
+        ('member', 'date', 'duration'),
+        ('modules', 'lastSeen'),
+        'sessions'
+    )
+    list_display = ('member', 'date', 'lastSeen', 'duration')
+    select2 = select2_modelform(Log, attrs={'width': '250px'})
+    form = select2
+
+

attendance/admin.py

@@ -0,0 +1,80 @@
+import graphene
+from graphql_jwt.decorators import login_required
+from datetime import date, datetime, timedelta
+from django.utils import timezone
+import json
+
+from ..models import Log
+from members.models import Group
+from django.contrib.auth.models import User
+from framework.api.user import UserBasicObj
+
+to_tz = timezone.get_default_timezone()
+
+
+class memberPresentObj(graphene.ObjectType):
+    member = graphene.Field(UserBasicObj)
+    firstSeen = graphene.String()
+    lastSeen = graphene.String()
+    duration = graphene.String()
+
+    def resolve_member(self, info):
+        return User.objects.values().get(id=self['member_id'])
+
+    def resolve_firstSeen(self, info):
+        sessions = json.loads(self['sessions'])
+        return sessions[0]['start']
+
+    def resolve_lastSeen(self, info):
+        return self['lastSeen'].astimezone(to_tz)
+
+
+class membersAbsentObj(graphene.ObjectType):
+    member = graphene.Field(UserBasicObj)
+    lastSeen = graphene.String()
+
+    def resolve_member(self, info):
+        return User.objects.values().get(username=self)
+
+    def resolve_lastSeen(self, intro):
+        obj = Log.objects.filter(member__username=self).order_by('-date').first()
+        if obj is not None:
+            return obj.lastSeen
+        else:
+            return None
+
+
+class dailyAttObj(graphene.ObjectType):
+    date = graphene.types.datetime.Date()
+    membersPresent = graphene.List(memberPresentObj)
+    membersAbsent = graphene.List(membersAbsentObj)
+
+    def resolve_date(self, info):
+        return self
+
+    def resolve_membersPresent(self, info):
+        return Log.objects.values().filter(date=self)
+
+    def resolve_membersAbsent(self, info):
+        groups = Group.objects.filter(attendanceEnabled=True).values('members__username')
+        logs = Log.objects.values('member__username').filter(date=self)
+        LogUsernames = []
+        for i in logs:
+            LogUsernames.append(i['member__username'])
+        usernames = []
+        for member in groups:
+            username = member['members__username']
+            if username not in LogUsernames:
+                usernames.append(username)
+        return usernames
+
+
+class Query(object):
+    dailyAttendance = graphene.Field(
+        dailyAttObj,
+        date=graphene.types.datetime.Date(required=True)
+    )
+
+    @login_required
+    def resolve_dailyAttendance(self, info, **kwargs):
+        return kwargs.get('date')

attendance/api/dailyAttendance.py

@@ -0,0 +1,221 @@
+import graphene
+from graphql_jwt.decorators import login_required
+from datetime import date, datetime, timedelta
+from django.db.models import Avg, Count, Sum
+
+import dateutil.parser
+from framework.api.user import UserBasicObj
+from django.contrib.auth.models import User
+
+import json
+
+from ..models import Log
+from members.models import Group
+
+from .dailyAttendance import Query as dailyAttendanceQuery
+
+
+class timePeriodObj(graphene.ObjectType):
+    start = graphene.String()
+    end = graphene.String()
+    duration = graphene.String()
+
+    def resolve_duration(self, info):
+        diff = dateutil.parser.parse(self['end']) - dateutil.parser.parse(self['start'])
+        return diff
+
+
+class attendanceDateObj(timePeriodObj, graphene.ObjectType):
+    sessions = graphene.List(timePeriodObj)
+    date = graphene.String()
+
+    def resolve_duration(self, info):
+        return self['duration']
+
+    def resolve_start(self, info):
+        jsonData = json.loads(self['sessions'])
+        if jsonData:
+            return jsonData[0]['start']
+        else:
+            return None
+
+    def resolve_end(self, info):
+        jsonData = json.loads(self['sessions'])
+        if jsonData:
+            return jsonData[-1]['end']
+        else:
+            return None
+
+    def resolve_sessions(self, info):
+        jsonData = json.loads(self['sessions'])
+        if jsonData:
+            return jsonData
+        else:
+            return None
+
+
+class userAttendanceObj(graphene.ObjectType):
+    daysPresent = graphene.Int()
+    avgDuration = graphene.String()
+    dailyLog = graphene.List(attendanceDateObj)
+
+    def resolve_daysPresent(self, info):
+        return len(self['logs'])
+
+    def resolve_avgDuration(self, info):
+        return self['avgDuration']['duration__avg']
+
+    def resolve_dailyLog(self, info):
+        return self['logs']
+
+
+class userAttStatObj(graphene.ObjectType):
+    user = graphene.Field(UserBasicObj)
+    presentCount = graphene.String()
+    avgDuration = graphene.String()
+    totalDuration = graphene.String()
+
+    def resolve_user(self, info):
+        return User.objects.values().get(id=self['member'])
+
+
+class userDailyAttendanceObj(attendanceDateObj):
+    user = graphene.Field(UserBasicObj)
+
+    def resolve_user(self, info):
+        return User.objects.values().get(id=self['member_id'])
+
+
+class dailyAttendanceObj(graphene.ObjectType):
+    date = graphene.types.datetime.Date()
+    membersPresent = graphene.Int()
+    avgDuration = graphene.String()
+    members = graphene.List(userDailyAttendanceObj)
+
+    def def_date(self, info):
+        return self['date']
+
+    def resolve_membersPresent(self, info):
+        return len(self['log'])
+
+    def resolve_avgDuration(self, info):
+        return self['log'].aggregate(Avg('duration'))['duration__avg']
+
+    def resolve_members(self, info):
+        return self['log'].values()
+
+
+class clubAttendanceObj(graphene.ObjectType):
+    avgDuration = graphene.String()
+    workingDaysCount = graphene.String()
+    dailyLog = graphene.List(dailyAttendanceObj)
+    memberStats = graphene.List(userAttStatObj, order=graphene.String())
+
+    def resolve_avgDuration(self, info):
+        return self['avgDuration']['duration__avg']
+
+    def resolve_workingDaysCount(self, info):
+        return len(self['logs'].values_list('date').distinct())
+
+    def resolve_dailyLog(self, info):
+        sdate = self['start']
+        delta = self['end'] - sdate
+        days = []
+        for i in range(delta.days + 1):
+            days.append(sdate + timedelta(days=i))
+        logs = []
+        for day in days:
+            logs.append({"date": day, "log": self['logs'].filter(date=day)})
+        return logs
+
+    def resolve_memberStats(self, info, **kwargs):
+        order = kwargs.get('order')
+        if order is None:
+            order = '-presentCount'
+        return self['logs'].values('member').annotate(
+            presentCount=Count('member'),
+            avgDuration=Avg('duration'),
+            totalDuration=Sum('duration')).order_by(order, '-presentCount', '-totalDuration')
+
+
+class attendanceUserObj(UserBasicObj):
+    firstSeenToday = graphene.String()
+    lastSeen = graphene.String()
+    duration = graphene.String()
+
+    def resolve_firstSeenToday(self, info):
+        today = date.today()
+        obj = Log.objects.filter(date=today, member__username=self['username'])[0]
+        if obj:
+            sessions = json.loads(obj.sessions)
+            return sessions[0]['start']
+        else:
+            return None
+
+    def resolve_lastSeen(self, info):
+        obj = Log.objects.filter(member__username=self['username']).order_by('-date').first()
+        if obj:
+            return obj.lastSeen
+        else:
+            return None
+
+    def resolve_duration(self, info):
+        obj = Log.objects.filter(member__username=self['username']).order_by('-date').first()
+        if obj:
+            return obj.duration
+        else:
+            return None
+
+
+class attendanceStatObj(graphene.ObjectType):
+    count = graphene.Int()
+    members = graphene.List(attendanceUserObj)
+
+    def resolve_members(self, info):
+        return User.objects.values().filter(username__in=self['members'])
+
+
+class liveAttendanceObj(graphene.ObjectType):
+    membersPresent = graphene.Field(attendanceStatObj)
+
+    def resolve_membersPresent(self, info):
+        count = len(self)
+        return {'count': count, 'members': self}
+
+
+class Query(dailyAttendanceQuery, object):
+    liveAttendance = graphene.Field(liveAttendanceObj)
+    clubAttendance = graphene.Field(clubAttendanceObj,
+                                    startDate=graphene.types.datetime.Date(required=True),
+                                    endDate=graphene.types.datetime.Date()
+                                    )
+
+    @login_required
+    def resolve_liveAttendance(self, info):
+        time = datetime.now() - timedelta(minutes=5)
+        logs = Log.objects.filter(lastSeen__gte=time).values('member__username')
+        u = []
+        for i in logs:
+            u.append(i['member__username'])
+        return u
+
+    @login_required
+    def resolve_clubAttendance(self, info, **kwargs):
+        start = kwargs.get('startDate')
+        end = kwargs.get('endDate')
+        logs = Log.objects.all()
+        if start is not None:
+            logs = logs.filter(date__gte=start)
+        else:
+            raise Exception('Start date required')
+        if end is not None:
+            logs = logs.filter(date__lte=end)
+        else:
+            end = date.today()
+        data = {
+            'logs': logs,
+            'avgDuration': logs.aggregate(Avg('duration')),
+            'start': start,
+            'end': end
+        }
+        return data

attendance/api/log.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class AttendanceConfig(AppConfig):
+    name = 'attendance'

attendance/apps.py

@@ -0,0 +1,19 @@
+from .models import *
+from datetime import date, datetime, timedelta
+from django.utils import timezone
+
+from .generatorScript import generatorScript
+
+to_tz = timezone.get_default_timezone()
+now = datetime.now().astimezone(to_tz)
+
+def refreshSSID(module):
+    lastTime = module.lastRefreshTime.astimezone(to_tz)
+    if module.isPaused is False and now - lastTime >= module.seedRefreshInterval:
+        seed = module.seed
+        newSeed = generatorScript(seed)
+        module.SSID = 'amFOSS_' + str(newSeed)
+        module.seed = newSeed
+        module.lastRefreshTime = now.replace(second=0, microsecond=0)
+        module.save()
+

attendance/generateSSID.py

@@ -0,0 +1,10 @@
+a = 656550107
+c = 8849371
+m = 9850349
+
+def generatorScript(seed):
+    seed = (seed % m) * (a % m)
+    seed = seed % m
+    seed = seed + c
+    seed = seed % m
+    return seed