1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
# -*- coding: utf-8 -*-
# Copyright 2010-2011 Kolab Systems AG (http://www.kolabsys.com)
#
# Jeroen van Meeuwen (Kolab Systems) <vanmeeuwen a kolabsys.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 only
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Library General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
import calendar
import datetime
import os
import random
import time
from pykolab.conf import Conf
from pykolab.constants import *
from pykolab.tests.constants import *
from pykolab.translate import _
class CalendarItem(object):
def __init__(self, item_num=0, total_num=1, start=0, end=0, folder=None, user=None):
"""
A calendar item is created from a template.
The attributes that can be modified are set to defaults first.
"""
if user == None:
user = TEST_USERS[random.randint(0,(len(TEST_USERS)-1))]
# Used for some randomization
self.item_num = item_num
self.total_num = total_num
self.event_boundary_start = int(start)
self.event_boundary_end = int(end)
# Initial event data
self.event_location = "one or the other meeting room"
self.event_recurrence = ""
self.event_summary = "Test Event %d" %(item_num)
from_user = TEST_USERS[random.randint(0,(len(TEST_USERS)-1))]
self.from_name_str = "%s %s" %(from_user['givenname'].capitalize(),from_user['sn'].capitalize())
self.from_email_str = "%(givenname)s@%(domain)s" %(from_user)
self.kolab_event_date_creation = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
self.kolab_event_date_start = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
self.kolab_event_date_end = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
self.rfc_2822_sent_date = time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime())
self.to_name_str = "%s %s" %(user['givenname'].capitalize(),user['sn'].capitalize())
self.to_email_str = "%(givenname)s@%(domain)s" %(user)
self.uid = "%s.%s" %(str(random.randint(1000000000,9999999999)),str(random.randint(0,999)).zfill(3))
if folder:
self.mailbox = folder
else:
self.mailbox = "INBOX/Calendar"
# Status information
self.dates_randomized = False
self.randomize_recurrence()
self.randomize_dates()
def randomize_dates(self):
"""
Randomize all dates in the event but make sure they
do make sense.
Ergo, the start date is before the end date, and such.
Also, take into account the total number of calendar items, so that
we do not clutter.
"""
if self.dates_randomized:
return
# The ratio is 1/2 goes to the past, 1/8 goes to this month, 3/8 goes to the future months.
# Over 10.000 items, that is 5000 in the past -> 250 days a year, 4 appointments a day, 5 year
# 125 this month
# 4875 to future
# We have two integers (epoch values), a start and an end
mystart = random.randint(self.event_boundary_start,self.event_boundary_end)
myend = mystart + (1800 * random.randint(1,4))
self.kolab_event_date_start = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(mystart))
self.kolab_event_date_end = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(myend))
# Calculate the timespan we're serving assuming 4-6 appointments a day;
self.dates_randomized = True
def randomize_recurrence(self):
"""
Randomize the recurrence of this event.
One every so many events has recurrence.
"""
return
if not random.randint(1,15) == 1:
return
# The recurrence day (of the week)
recur_day = random.randint(0,6)
# # Seek a day somewhere in the past with this day_number
# for days_in_week in calendar.itermonthdates():
# # day_of_week is a list of weeks, where 0 is outside the month
# # described in the call to calendar.itermonthdays(), and so
# # we are able now to find the first day for this recurrence.
# for day_date in days_in_week:
# print day_date
self.dates_randomized = True
def __str__(self):
for tpl_file_location in [ '/usr/share/kolab/tests/kcal-event.tpl', './share/tests/kcal-event.tpl' ]:
if os.path.isfile(tpl_file_location):
tpl_file = open(tpl_file_location, 'r')
tpl_orig = tpl_file.read()
tpl_file.close()
break
return tpl_orig % self.__dict__
def create_items(conf, num=None, folder=None):
for item in TEST_ITEMS:
if item['name'] == 'calendar':
info = item
if num:
info['number'] = int(num)
conf.log.debug(_("Creating %d Events") %(info['number']), level=3)
alloc_uids = []
if os.path.isfile('./share/tests/kcal-event.tpl'):
tpl_file = open('./share/tests/kcal-event.tpl', 'r')
tpl_orig = tpl_file.read()
tpl_file.close()
(start_boundary,end_boundary) = set_bounds(num=num)
imap = True
for user in conf.testing_users:
if conf.use_mail:
pass
elif conf.use_lmtp:
pass
elif conf.use_imap:
import imaplib
if imap:
del imap
imap = imaplib.IMAP4(conf.testing_server)
imap.login("%(givenname)s@%(domain)s" %(user), user['password'])
else:
pass
#print "Running for user %(givenname)s@%(domain)s" %(user)
item_num = 0
while item_num < int(info['number']):
conf.log.debug(_("Creating Calendar item number %d") %(item_num+1), level=5)
item = CalendarItem(item_num=(item_num+1), total_num=num, start=start_boundary, end=end_boundary, folder=folder, user=user)
if not item.uid in alloc_uids:
alloc_uids.append(item.uid)
else:
continue
msg = str(item)
if conf.use_mail:
conf.log.debug(_("Sending UID message %s through SMTP targeting user %s@%s") %(item.uid,user['givenname'],user['domain']), level=9)
elif conf.use_lmtp:
conf.log.debug(_("Sending UID message %s through LMTP targeting user %s@%s") %(item.uid,user['givenname'],user['domain']), level=9)
elif conf.use_imap:
conf.log.debug(_("Saving UID message %s to IMAP (user %s, folder %s)") %(item.uid,user['givenname'],item.mailbox), level=9)
imap.append(item.mailbox, '', imaplib.Time2Internaldate(time.time()), msg)
else:
conf.log.debug(_("Somehow ended up NOT sending these messages"), level=9)
item_num +=1
def set_bounds(num=0):
"""
Set the lower and upper boundaries for this event, using the
total number of events and a reasonable but random average number
of appointments.
returns a tuple epoch (start, end)
"""
# Pretend anywhere between 0 and 5 events per workday,
# Multiply by the number of workdays a week,
# Divide that by 7 for a nice, float average.
events_per_week_avg = float(random.randint(10,25))
events_per_day_avg = events_per_week_avg / 7
ratio = [ 6, 4 ]
# Given the total number of events to be created, and the average number
# of events per day, we can now look at what the lower boundary would be,
# compared to today.
days_to_go_back = (((num / events_per_day_avg) / 10 ) * ratio[0])
days_to_go_forward = (((num / events_per_day_avg) / 10 ) * ratio[1])
now = time.time()
start_of_day = now - (now % (24 * 60 * 60))
boundary_start = start_of_day - (days_to_go_back * 24 * 60 * 60)
boundary_end = start_of_day + (days_to_go_forward * 24 * 60 * 60)
return (boundary_start,boundary_end)
|
