Beispiel #1
0
    def post(self):
        args = self.request.json
        year = int(args.pop('year'))
        if 1999 > year > 2099:
            return dict(status='nok', reason='Zły rok %s' % year)

        leaves = Leave.query.filter(Leave.year==year).all()
        leaves = groupby(leaves, lambda l: l.user_id)
        for user_id, (mandated, remarks) in args.iteritems():
            user_id = int(user_id)
            try:
                mandated = int(mandated)
            except Exception:
                user = User.query.get(user_id)
                return dict(
                    status='nok',
                    reason=self._(u'Wrong hours format: ${hours} for user ${name}', hours=mandated, name=user.name)
                )

            if 0 > mandated  or mandated > 99:
                user = User.query.get(user_id)
                return dict(
                    status='nok',
                    reason=self._(u'Wrong hours number: ${hours} for user ${name}', hours=mandated, name=user.name)
                )

            leave_obj = leaves.get(user_id)
            if not leave_obj:
                leave_obj = Leave(user_id=user_id, year=year)
            else:
                leave_obj = leave_obj[0]
            leave_obj.number = mandated
            leave_obj.remarks = remarks
            self.session.add(leave_obj)
        return dict(status='ok')
Beispiel #2
0
    def get(self):
        year = self.request.GET.get('year', datetime.date.today().year)
        users = User.query.filter(User.is_not_client()).filter(
            User.is_active == True).filter(User.freelancer == False).all()

        used_entries = self.session.query('user_id', 'days').from_statement("""
            SELECT t.user_id, sum(t.time)/8 as days
            FROM time_entry t
            WHERE deleted = false AND
                  t.project_id = 86 AND
                  date_part('year', t.date) = :year
            GROUP BY user_id
        """).params(year=year).all()

        used = defaultdict(lambda: 0)
        for u in used_entries:
            used[u[0]] = u[1]

        applications = m.Absence.get_for_year(year)

        return dict(
            users=users,
            mandated=Leave.get_for_year(year),
            used=used,
            applications=applications,
            year=int(year),
            serialize_url=h.serialize_url,
            str=str,
        )
Beispiel #3
0
    def get(self):
        year = self.request.GET.get('year', datetime.date.today().year)
        users = User.query.filter(User.is_not_client()).filter(User.is_active==True).filter(User.freelancer==False).all()

        used = Leave.get_used_for_year(year)
        applications = m.Absence.get_for_year(year)

        return dict(
            users=users,
            mandated=Leave.get_for_year(year),
            used=used,
            applications=applications,
            year=int(year),
            serialize_url=h.serialize_url,
            str=str,
        )
Beispiel #4
0
    def get(self):
        year = self.request.GET.get('year', datetime.date.today().year)
        users = User.query.filter(User.is_not_client()).filter(User.is_active==True).filter(User.freelancer==False).all()

        used_entries = self.session.query('user_id', 'days').from_statement("""
            SELECT t.user_id, sum(t.time)/8 as days
            FROM time_entry t
            WHERE deleted = false AND
                  t.project_id = 86 AND
                  date_part('year', t.date) = :year
            GROUP BY user_id
        """).params(year=year).all()

        used = defaultdict(lambda: 0)
        for u in used_entries:
            used[u[0]] = u[1]

        applications = m.Absence.get_for_year(year)

        return dict(
            users=users,
            mandated=Leave.get_for_year(year),
            used=used,
            applications=applications,
            year=int(year),
            serialize_url=h.serialize_url,
            str=str,
        )
Beispiel #5
0
    def get(self):
        year = self.request.GET.get('year', datetime.date.today().year)
        users = User.query.filter(User.is_not_client()).filter(
            User.is_active == True).filter(User.freelancer == False).all()

        used = Leave.get_used_for_year(year)
        applications = m.Absence.get_for_year(year)

        return dict(
            users=users,
            mandated=Leave.get_for_year(year),
            used=used,
            applications=applications,
            year=int(year),
            serialize_url=h.serialize_url,
            str=str,
        )
Beispiel #6
0
    def post(self):
        args = self.request.json
        year = int(args.pop('year'))
        if 1999 > year > 2099:
            return dict(status='nok', reason='Zły rok %s' % year)

        leaves = Leave.query.filter(Leave.year == year).all()
        leaves = groupby(leaves, lambda l: l.user_id)
        for user_id, (mandated, remarks) in args.iteritems():
            user_id = int(user_id)
            try:
                mandated = int(mandated)
            except Exception:
                user = User.query.get(user_id)
                return dict(
                    status='nok',
                    reason=self._(
                        u'Wrong hours format: ${hours} for user ${name}',
                        hours=mandated,
                        name=user.name))

            if 0 > mandated or mandated > 99:
                user = User.query.get(user_id)
                return dict(
                    status='nok',
                    reason=self._(
                        u'Wrong hours number: ${hours} for user ${name}',
                        hours=mandated,
                        name=user.name))

            leave_obj = leaves.get(user_id)
            if not leave_obj:
                leave_obj = Leave(user_id=user_id, year=year)
            else:
                leave_obj = leave_obj[0]
            leave_obj.number = mandated
            leave_obj.remarks = remarks
            self.session.add(leave_obj)
        return dict(status='ok')
Beispiel #7
0
    def get(self):
        # Requested (or current) year
        year = self.request.GET.get('year')
        year = int(year) if year else datetime.date.today().year
        # Year start day and end day
        start = datetime.date(year, 1, 1)
        end = datetime.date(year, 12, 31)
        start_day = dict(
            day=start.day,
            dow=start.weekday(),
        )

        day_count, date_range, months = self.necessary_data(start, end)
        holidays = Holiday.query \
                          .filter(Holiday.date >= start) \
                          .all()

        # Users
        users = []
        user_groups = []
        for name, (fullname, shortcut) in self.request.user.get_locations():
            usersq = User.query.filter(User.is_not_client()) \
                               .filter(User.is_active==True) \
                               .filter(User.location==name) \
                               .order_by(User.is_freelancer(), User.name).all()
            users.extend(usersq)
            user_groups.append((fullname, len(usersq)))

        # Leaves
        leave_mandated = Leave.get_for_year(start.year)
        leave_used = Leave.get_used_for_year(start.year)

        # Transform users to dictionary, group by city and order by leave days
        users = [dict(
            id=str(u.id),
            name=u.name,
            leave_mandated=leave_mandated[u.id][0],
            leave_used=leave_used[u.id],
            location=u.location,
        ) for u in users]

        users = sorted(
            users,
            key=lambda u: u['location'],
        )

        user_groups = sorted(
            user_groups,
            key=lambda u: u,
        )

        absences, absences_months = self.get_absences(start, end, users)
        lates = self.get_lates(start, end)
        absences_sum = (
            reduce(lambda s, u: s + u['leave_used'], users, 0),
            reduce(lambda s, u: s + u['leave_mandated'], users, 0),
        )

        data = {
            'users': users,
            'userGroups': user_groups,
            'year': start.year,
            'startDay': start_day,
            'dayCount': day_count,
            'months': months,
            'absences': absences,
            'absencesSum': absences_sum,
            'absencesMonths': absences_months,
            'lates': lates,
            'holidays': [h.date.strftime('%Y-%m-%d') for h in holidays],
        }

        return dict(
            data=json.dumps(data, ensure_ascii=False),
            year=start.year,
            v=self,
        )
Beispiel #8
0
    def get(self):
        # Requested (or current) year
        year = self.request.GET.get('year')
        year = int(year) if year else datetime.date.today().year
        # Year start day and end day
        start = datetime.date(year, 1, 1)
        end = datetime.date(year, 12, 31)
        start_day = dict(
            day=start.day,
            dow=start.weekday(),
        )

        day_count, date_range, months = self.necessary_data(start, end)
        holidays = Holiday.query \
                          .filter(Holiday.date >= start) \
                          .all()

        # Users
        users_p = User.query.filter(User.is_not_client()) \
                            .filter(User.is_active==True) \
                            .filter(User.location=='poznan') \
                            .order_by(User.freelancer, User.name).all()
        users_w = User.query.filter(User.is_not_client()) \
                            .filter(User.is_active==True) \
                            .filter(User.location=='wroclaw') \
                            .order_by(User.freelancer, User.name).all()
        
        user_groups = [
            (u'Poznań', len(users_p)),
            (u'Wrocław', len(users_w)),
        ]
        
        reverse = False
        if self.request.user.location == 'wroclaw':
            user_groups.insert(0, user_groups.pop())
            reverse = True

        users_p.extend(users_w) 

        # Leaves
        leave_mandated = Leave.get_for_year(start.year)
        leave_used = Leave.get_used_for_year(start.year)

        # Transform users to dictionary, group by city and order by leave days
        users = [dict(
                      id=str(u.id),
                      name=u.name,
                      leave_mandated=leave_mandated[u.id][0],
                      leave_used=leave_used[u.id],
                      location=u.location,
                     ) for u in users_p]
        
        
        employees, students = [], []
        for user in users:
            if user['leave_mandated'] > 0:
                employees.append(user)
            else:
                students.append(user)
        
        users = employees + students
        # groupby location
        users = sorted(
            users,
            key=lambda u: u['location'],
            reverse=reverse
        )
        
        absences, absences_months = self.get_absences(start, end, users)
        lates = self.get_lates(start, end)
        absences_sum = (
            reduce(lambda s, u: s + u['leave_used'], users, 0),
            reduce(lambda s, u: s + u['leave_mandated'], users, 0),
        )

        data = {
            'users': users,
            'userGroups': user_groups,
            'year': start.year,
            'startDay': start_day,
            'dayCount': day_count,
            'months': months,
            'absences': absences,
            'absencesSum': absences_sum,
            'absencesMonths': absences_months,
            'lates': lates,
            'holidays': [h.date.strftime('%Y-%m-%d') for h in holidays],
        }

        return dict(
            data=json.dumps(data, ensure_ascii=False),
            year=start.year,
            v=self,
        )
Beispiel #9
0
    def get(self):
        # Requested (or current) year
        year = self.request.GET.get('year')
        year = int(year) if year else datetime.date.today().year
        # Year start day and end day
        start = datetime.date(year, 1, 1)
        end = datetime.date(year, 12, 31)
        start_day = dict(
            day=start.day,
            dow=start.weekday(),
        )

        day_count, date_range, months = self.necessary_data(start, end)
        holidays = Holiday.query \
                          .filter(Holiday.date >= start) \
                          .all()

        # Users
        users_p = User.query.filter(User.is_not_client()) \
                            .filter(User.is_active==True) \
                            .filter(User.location=='poznan') \
                            .order_by(User.freelancer, User.name).all()
        users_w = User.query.filter(User.is_not_client()) \
                            .filter(User.is_active==True) \
                            .filter(User.location=='wroclaw') \
                            .order_by(User.freelancer, User.name).all()

        user_groups = [
            (u'Poznań', len(users_p)),
            (u'Wrocław', len(users_w)),
        ]

        reverse = False
        if self.request.user.location == 'wroclaw':
            user_groups.insert(0, user_groups.pop())
            reverse = True

        users_p.extend(users_w)

        # Leaves
        leave_mandated = Leave.get_for_year(start.year)
        leave_used = Leave.get_used_for_year(start.year)

        # Transform users to dictionary, group by city and order by leave days
        users = [
            dict(
                id=str(u.id),
                name=u.name,
                leave_mandated=leave_mandated[u.id][0],
                leave_used=leave_used[u.id],
                location=u.location,
            ) for u in users_p
        ]

        employees, students = [], []
        for user in users:
            if user['leave_mandated'] > 0:
                employees.append(user)
            else:
                students.append(user)

        users = employees + students
        # groupby location
        users = sorted(users, key=lambda u: u['location'], reverse=reverse)

        absences, absences_months = self.get_absences(start, end, users)
        lates = self.get_lates(start, end)
        absences_sum = (
            reduce(lambda s, u: s + u['leave_used'], users, 0),
            reduce(lambda s, u: s + u['leave_mandated'], users, 0),
        )

        data = {
            'users': users,
            'userGroups': user_groups,
            'year': start.year,
            'startDay': start_day,
            'dayCount': day_count,
            'months': months,
            'absences': absences,
            'absencesSum': absences_sum,
            'absencesMonths': absences_months,
            'lates': lates,
            'holidays': [h.date.strftime('%Y-%m-%d') for h in holidays],
        }

        return dict(
            data=json.dumps(data, ensure_ascii=False),
            year=start.year,
            v=self,
        )
Beispiel #10
0
    def get(self):
        # Requested (or current) year
        year = self.request.GET.get('year')
        year = int(year) if year else datetime.date.today().year
        # Year start day and end day
        start = datetime.date(year, 1, 1)
        end = datetime.date(year, 12, 31)
        start_day = dict(
            day=start.day,
            dow=start.weekday(),
        )

        day_count, date_range, months = self.necessary_data(start, end)
        holidays = Holiday.query \
                          .filter(Holiday.date >= start) \
                          .all()

        # Users
        users = []
        user_groups = []
        for name, (fullname, shortcut) in self.request.user.get_locations():
            usersq = User.query.filter(User.is_not_client()) \
                               .filter(User.is_active==True) \
                               .filter(User.location==name) \
                               .order_by(User.is_freelancer(), User.name).all()
            users.extend(usersq)
            user_groups.append((fullname, len(usersq)))

        # Leaves
        leave_mandated = Leave.get_for_year(start.year)
        leave_used = Leave.get_used_for_year(start.year)

        # Transform users to dictionary, group by city and order by leave days
        users = [
            dict(
                id=str(u.id),
                name=u.name,
                leave_mandated=leave_mandated[u.id][0],
                leave_used=leave_used[u.id],
                location=u.location,
            ) for u in users
        ]

        users = sorted(
            users,
            key=lambda u: u['location'],
        )

        user_groups = sorted(
            user_groups,
            key=lambda u: u,
        )

        absences, absences_months = self.get_absences(start, end, users)
        lates = self.get_lates(start, end)
        absences_sum = (
            reduce(lambda s, u: s + u['leave_used'], users, 0),
            reduce(lambda s, u: s + u['leave_mandated'], users, 0),
        )

        data = {
            'users': users,
            'userGroups': user_groups,
            'year': start.year,
            'startDay': start_day,
            'dayCount': day_count,
            'months': months,
            'absences': absences,
            'absencesSum': absences_sum,
            'absencesMonths': absences_months,
            'lates': lates,
            'holidays': [h.date.strftime('%Y-%m-%d') for h in holidays],
        }

        return dict(
            data=json.dumps(data, ensure_ascii=False),
            year=start.year,
            v=self,
        )