← Back to branch summary

~replaceafill/ubuntu/trusty/schooltool/2.8

« back to all changes in this revision

Viewing changes to src/schooltool/basicperson/sampledata.py

  • Committer: Gediminas Paulauskas
  • Date: 2013-10-10 16:53:33 UTC
  • mfrom: (1.1.27)
  • Revision ID: menesis@pov.lt-20131010165333-knsk88i2od7b8o70
Tags: 1:2.6.0-0ubuntu1
* New upstream release.
* debian/redis.conf: save redis databases less often.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/schooltool/basicperson/sampledata.py
18
18
"""
19
19
Basic person sample data generation
20
20
"""
21
 
from schooltool.person.sampledata import SampleStudents
22
 
from schooltool.person.sampledata import SampleTeachers
 
21
import datetime
 
22
import os
 
23
from pytz import utc
 
24
 
 
25
from zope.interface import implements
 
26
from zope.security.proxy import removeSecurityProxy
 
27
 
23
28
from schooltool.basicperson.person import BasicPerson
24
 
 
25
 
 
26
 
class SampleBasicStudents(SampleStudents):
 
29
from schooltool.sampledata import PortableRandom
 
30
from schooltool.sampledata.interfaces import ISampleDataPlugin
 
31
from schooltool.sampledata.name import NameGenerator
 
32
from schooltool.group.interfaces import IGroupContainer
 
33
from schooltool.term.interfaces import ITermContainer
 
34
from schooltool.app.interfaces import ISchoolToolCalendar
 
35
from schooltool.app.cal import CalendarEvent
 
36
from schooltool.common import DateRange
 
37
 
 
38
 
 
39
class ChoiceGenerator(object):
 
40
    def __init__(self, seed, choices):
 
41
        self.random = PortableRandom(seed)
 
42
        self.choices = choices
 
43
 
 
44
    def generate(self):
 
45
        return self.random.choice(self.choices)
 
46
 
 
47
 
 
48
class SampleStudents(object):
 
49
 
 
50
    implements(ISampleDataPlugin)
 
51
 
 
52
    name = 'students'
 
53
    dependencies = ('terms', )
 
54
 
 
55
    # Number of persons to generate
 
56
    power = 1000
27
57
 
28
58
    def personFactory(self, namegen, prefixgen, gendergen, count):
29
59
        first_name, last_name, full_name = namegen.generate()
33
63
        person.gender = gendergen.generate()
34
64
        return person
35
65
 
36
 
 
37
 
class SampleBasicTeachers(SampleTeachers):
 
66
    def generate(self, app, seed=None):
 
67
        namegen = NameGenerator(str(seed) + self.name)
 
68
        prefixgen = ChoiceGenerator(str(seed), ['Mr', 'Mrs', 'Miss', ''])
 
69
        gendergen = ChoiceGenerator(str(seed), ['male', 'female'])
 
70
 
 
71
        students = IGroupContainer(app)['students']
 
72
        for count in range(self.power):
 
73
            person = self.personFactory(namegen, prefixgen, gendergen, count)
 
74
            # Without removeSecurityProxy we can't add members a
 
75
            # group.
 
76
            removeSecurityProxy(students.members).add(person)
 
77
            app['persons'][person.__name__] = person
 
78
 
 
79
 
 
80
class SampleTeachers(object):
 
81
    implements(ISampleDataPlugin)
 
82
 
 
83
    name = 'teachers'
 
84
    dependencies = ('terms', )
 
85
 
 
86
    # Number of teachers to generate
 
87
    power = 48
38
88
 
39
89
    def personFactory(self, namegen, count):
40
90
        first_name, last_name, full_name = namegen.generate()
42
92
        person = BasicPerson(person_id, first_name, last_name)
43
93
        person.setPassword(person_id)
44
94
        return person
 
95
 
 
96
    def generate(self, app, seed=None):
 
97
        namegen = NameGenerator(str(seed) + self.name)
 
98
        teachers = IGroupContainer(app)['teachers']
 
99
        for count in range(self.power):
 
100
            person = self.personFactory(namegen, count)
 
101
            # Without removeSecurityProxy we can't add members a
 
102
            # group.
 
103
            removeSecurityProxy(teachers.members).add(person)
 
104
            app['persons'][person.__name__] = person
 
105
 
 
106
 
 
107
class SamplePersonalEvents(object):
 
108
    """Sample data plugin class that generates personal random events."""
 
109
 
 
110
    implements(ISampleDataPlugin)
 
111
 
 
112
    name = 'personal_events'
 
113
    dependencies = ('students', 'teachers', 'terms')
 
114
 
 
115
    probability = 2     # probability of having an event on any day
 
116
 
 
117
    def _readLines(self, filename):
 
118
        """Read in lines from file
 
119
 
 
120
        Filename is relative to the module.
 
121
        Returned lines are stripped.
 
122
        """
 
123
        fullpath = os.path.join(os.path.dirname(__file__), filename)
 
124
        lines = file(fullpath).readlines()
 
125
        return [line.strip() for line in lines]
 
126
 
 
127
    def generate(self, app, seed=None):
 
128
        self.random = PortableRandom(seed)
 
129
        event_titles = self._readLines('event_titles.txt')
 
130
        person_ids = [person for person in app['persons'].keys()
 
131
                      if person.startswith('student') or
 
132
                         person.startswith('teacher')]
 
133
        dates = []
 
134
        for term in ITermContainer(app).values():
 
135
            dates.append(term.first)
 
136
            dates.append(term.last)
 
137
        first = min(dates)
 
138
        last = max(dates)
 
139
        days = DateRange(first, last)
 
140
        for person_id in person_ids:
 
141
            person = app['persons'][person_id]
 
142
            calendar = ISchoolToolCalendar(person)
 
143
            for day in days:
 
144
                if self.random.randrange(0, 100) < self.probability:
 
145
                    event_title = self.random.choice(event_titles)
 
146
                    time_hour = self.random.randint(6, 23)
 
147
                    time_min = self.random.choice((0, 30))
 
148
                    event_time = datetime.datetime(day.year,
 
149
                                                   day.month,
 
150
                                                   day.day,
 
151
                                                   time_hour,
 
152
                                                   time_min,
 
153
                                                   tzinfo=utc)
 
154
                    event_duration = datetime.timedelta(
 
155
                                       minutes=self.random.randint(1, 12)*30)
 
156
                    event = CalendarEvent(event_time,
 
157
                                          event_duration,
 
158
                                          event_title)
 
159
                    calendar.addEvent(event)
 
160