def get_ica_file(vcal):
#Download the ICA file
req = urllib.request.Request(BASE_URL + "?Vcal=7." + vcal + "&Lo=bwh07&Jd=6558")
f = urllib.request.urlopen(req)
#Read the calendar into a cal variable
return Calendar.from_ical(f.read())
def add_ical(generator, metadata):
# check if a calendar is here
if 'calendar' in metadata.keys():
summ = []
path = metadata['calendar']
if not os.path.isabs(path):
path = os.path.abspath(metadata['calendar'])
cal = Calendar.from_ical(open(path,'rb').read())
for element in cal.walk():
eventdict = {}
if element.name == "VEVENT":
if element.get('summary') != None:
eventdict['summary'] = element.get('summary')
if element.get('description') != None:
eventdict['description'] = element.get('description')
if element.get('url') != None:
eventdict['url'] = element.get('url')
if element.get('dtstart') != None:
eventdict['dtstart'] = element.get('dtstart').dt
if element.get('dtend') != None:
eventdict['dtend'] = element.get('dtend').dt
summ.append(eventdict)
# the id of the calendar is the slugified name of the page
calId = utils.slugify(metadata['title'])
generator.context['events'][calId] = summ
def open_cal():
if os.path.isfile(filename):
if file_extension == 'ics':
print "Extracting events from file:", filename, "\n"
f = open(sys.argv[1], 'rb')
gcal = Calendar.from_ical(f.read())
# TODO: Let this parse multiple events in one ics file
for component in gcal.walk():
event.summary = component.get('SUMMARY')
event.uid = component.get('UID')
event.description = component.get('DESCRIPTION')
event.location = component.get('LOCATION')
event.start = component.get('dtstart').dt
event.end = component.get('dtend').dt
event.url = component.get('URL')
f.close()
else:
print "You entered ", filename, ". "
print file_extension.upper(), " is not a valid file format. Looking for an ICS file."
exit(0)
else:
print "I can't find the file ", filename, "."
print "Please enter an ics file located in the same folder as this script."
exit(0)
def voidwarranties(create_event):
"""
<p>
Het is een locatie waar gelijkgestemden kunnen samenwerken aan projecten.
Soms zijn dit electronica, informatica of gewoon kunstzinnige experimenten. Al
dit experimenteren, of liever gezegd, hacken heeft maar één doel: de
hackerspace upgraden tot een plaats die inspireert om nog leukere dingen te
maken.
</p>
<p>
Een locatie is 1 kant van het verhaal, aan de andere kant zijn er de
leden en bezoekers, de échte bron van ideeën en kennis.
</p>
"""
data = Calendar.from_ical(requests.get("http://voidwarranties.be/index.php/Special:Ask/-5B-5BCategory:Events-5D-5D/-3FHas-20start-20date=start/-3FHas-20end-20date=end/-3FHas-20coordinates=location/format=icalendar/title=VoidWarranties/description=Events-20at-20http:-2F-2Fvoidwarranties.be/limit=500").content)
for event in data.walk()[1:]:
title = str(event["SUMMARY"])
url = event["URL"]
start = event["DTSTART"].dt if event.get("DTSTART") else event["DTSTAMP"].dt
end = event["DTEND"].dt if event.get("DTSTART") else None
db_event = create_event(
title=title,
url=url,
start=start,
end=end
)
db_event.tags.add("hackeragenda")
def get_events_from_calendar(ics):
"""
Return a list with all events.
"""
calendar = Calendar.from_ical(ics)
events = [event for event in calendar.walk() if isinstance(event, Event)]
return events
def test_can_download_valid_ical(self):
"""
正しい形式のiCalファイルをダウンロードできる
"""
from icalendar import Calendar
from icalendar import vDatetime, vText
e = EventFactory()
user = PersonaFactory()
e.attend(user)
e.save()
r = self.client.get('/events/{}/calendar/'.format(e.pk))
for content in r.streaming_content:
cal = Calendar.from_ical(content)
self.assertEqual(cal['version'], '2.0')
self.assertEqual(cal['PRODID'], 'Kawaz')
for component in cal.walk():
if component.name == 'VEVENT':
self.assertEqual(component['summary'], e.title)
self.assertEqual(component['description'], e.body)
self.assertEqual(component['location'], e.place)
self.assertEqual(component['dtstamp'].to_ical(), vDatetime(e.created_at).to_ical())
self.assertEqual(component['dtstart'].to_ical(), vDatetime(e.period_start).to_ical())
self.assertEqual(component['dtend'].to_ical(), vDatetime(e.period_end).to_ical())
self.assertEqual(component['class'].to_ical(), vText('PUBLIC').to_ical())
self.assertEqual(component['organizer'].params['cn'], e.organizer.nickname)
self.assertEqual(component['organizer'].params['role'], e.organizer.role)
# ATENDEEがセットされている
for attendee, cal_attendee in zip(e.attendees.all(), component['attendee']):
self.assertEqual(cal_attendee.params['cn'], attendee.nickname)
self.assertEqual(cal_attendee.params['role'], attendee.role)
def icalendar_data(name, data):
cal = Calendar.from_ical(data)
@register_event
def icalendar_fn(day):
for e in cal.walk():
if isinstance(e, Event):
title = e['SUMMARY']
url = e.get('URL', None)
start = e['DTSTART'].dt
if isinstance(start, datetime):
startdate = start.date()
starttime = start
else:
startdate = start
starttime = None
if startdate == day:
event = "{}: {}".format(name, title)
if starttime:
if starttime.minute == 0:
event += " {:%H}h".format(starttime)
else:
event += " {:%H:%M}".format(starttime)
if url:
event += " ({})".format(url)
yield event
def parse_birthdays(data):
birthdays = []
vcards = Calendar.from_ical(data, multiple=True)
for vcard in vcards:
birthday = vcard.get("bday")
name = vcard.get("fn")
if not birthday:
continue
match = re.search(r"^(\d{4})\-(\d{2})\-(\d{2})$", birthday)
if not match:
print("{} has an invalid birthday: {}".format(name, birthday), file=sys.stderr)
continue
year, month, day = match.groups()
year, month, day = int(year), int(month), int(day)
birthday = Birthday(name, year, month, day)
birthdays.append(birthday)
return birthdays
def get_future_todos(ics):
with open(ics, 'r') as f:
nodes = []
gcal = Calendar.from_ical(f.read())
for component in gcal.walk():
if component.name == "VEVENT":
try:
dtstart_dt = component.get('dtstart').dt
dtend_dt = component.get('dtend').dt
except AttributeError:
continue
if not is_in_future(dtstart_dt):
continue
if is_full_day(dtstart_dt, dtend_dt):
date_part = dtstart_dt.strftime('%Y-%m-%d %a')
else:
# UTC hack
hour = int(dtstart_dt.strftime('%H'))
date_part = dtstart_dt.strftime('%Y-%m-%d %a {}:%M'.format(hour +1))
summary = component.get('summary')
node = NODE_TEMPLATE.format(summary, date_part)
nodes.append(node)
return nodes
def parse(self, ical):
parsed_calendar = ICalendar.from_ical(ical)
self.calendar_timezone = pytz.timezone(parsed_calendar["X-WR-TIMEZONE"])
for subcomponent in parsed_calendar.subcomponents:
if subcomponent.name == "VEVENT":
self.import_event(self.calendar, subcomponent)
def index(request):
try:
response = urllib2.urlopen(ical_url)
data = response.read()
except:
return HttpResponse("Unable to access calendar.", status=500)
cal = Calendar.from_ical(data)
now = timezone.now()
today = date.today()
events = []
for event in cal.walk('vevent'):
start = event.decoded('dtstart')
e = { 'title': event.decoded('summary'),
'start': start}
# If start date is just a date (without time)
if type(start) is type(today):
if start > today:
events.append(e)
else:
# Check if types (timezone or not) match
try:
start > now
except TypeError:
# Add timezone
start = pytz.timezone("Europe/Helsinki").localize(start, is_dst=None)
if start > now:
events.append(e)
return render_to_response('kalender/index.html', {"events":events}, context_instance=RequestContext(request))
def sync_with_ical(self, ical_feed, feed_url):
"""
Parse an icalendar feed and sync the events in the database with it.
:param ical_feed: ical formatted string.
:return: None
"""
today = utcnow().date()
cal = Calendar.from_ical(ical_feed)
for event in cal.walk('vevent'):
uid = event.decoded('uid')
sequence = event.decoded('sequence')
try:
event_obj = self.get(id=uid)
if event_obj and event_obj.sequence == sequence:
continue
except Event.DoesNotExist:
event_obj = Event()
event_obj.update_from_ical(event)
end_date = event_obj.end_time
if isinstance(end_date, datetime):
# use date since some feeds only produce date objects
end_date = end_date.date()
if today > end_date:
continue
if not event_obj.url and 'google.com' in feed_url:
event_obj.url = calendar_url_for_event(event_obj,
calendar_id_from_google_url(feed_url))
event_obj.save()
def create_events_from_ics(self):
filename = '/home/bschreiber/Downloads/adecalendar.ics'
cal = Calendar.from_ical(open(filename,'rb').read())
calendar_items = cal.walk()
pwflow = self.portal_workflow
events_folder = self.events
buff = StringIO()
num_events_created = 0
for cal_item in calendar_items:
if cal_item.name == 'VEVENT':
title = cal_item['SUMMARY'].title()
description = cal_item['DESCRIPTION'].title()
organizer = cal_item['ORGANIZER'].title()
location = cal_item['LOCATION'].title()
start = cal_item['DTSTART'].dt
end = cal_item['DTEND'].dt
ev_id = idnormalizer.normalize(title)
id_extension = 1
keep_trying = True
while keep_trying:
try:
event_id = events_folder.invokeFactory('Event', id=ev_id, title=title)
ev_obj = events_folder[event_id]
ev_obj.setStartDate(start)
ev_obj.setEndDate(end)
ev_obj.setLocation(location)
ev_obj.setText(description)
keep_trying = False
num_events_created +=1
buff.write('Created event with id '+ev_id+'\n')
except Exception, e:
ev_id = ev_id[:len(ev_id)-2]+'-'+str(id_extension)
id_extension += 1
def _read_calendar_object(self, file_contents):
try:
return Calendar.from_ical(file_contents)
except Exception as pe:
msg1 = _("Unable to read calendar data.")
msg2 = "\n\n" + ex_msg(pe)
raise TimelineIOError(msg1 + msg2)
def getFeed(calFeed):
message = ""
date = ""
headers = {"Cache-Control": "no-cache", "Pragma": "no-cache"}
requests.packages.urllib3.disable_warnings()
r = requests.get(calFeed, headers=headers)
if r.status_code == 304:
# read from cached file
cf = open(cachefile, "r")
caldata = cf.read()
else:
caldata = r.content
cf = open(cachefile, "w")
cf.write(caldata)
cf.close()
todayDates = []
tomorrowDates = []
cal = Calendar.from_ical(caldata)
for event in cal.walk("VEVENT"):
message = event.get("SUMMARY")
date = event.get("DTSTART").dt
if date == datetime.today().date():
todayDates.append({"Line": message, "Date": date})
elif date == datetime.today().date() + timedelta(days=1):
tomorrowDates.append({"Line": message, "Date": date})
return [todayDates, tomorrowDates]
def ics(group):
locale.setlocale(locale.LC_ALL, 'fr_FR.utf8')
login, pw = read_credentials()
request = requests.get(
'https://edt.univ-nantes.fr/sciences/' + group + '.ics',
auth=(login, pw))
if not 200 <= request.status_code < 300:
return "Error status while retrieving the ics file."
format = "%Y%m%dT%H%M%SZ"
now = datetime.utcnow().strftime(format)
paris = pytz.timezone('Europe/Paris')
current = '99991231T235959Z'
dtstart = dtend = description = ''
for component in Calendar.from_ical(request.text).walk():
if component.name == 'VEVENT':
current_start = component.get('DTSTART').to_ical()
if now > current_start:
continue
if current_start < current:
current = current_start
description = unicode(component.get('DESCRIPTION'))
start = component.get('DTSTART').to_ical()
end = component.get('DTEND').to_ical()
dtutcstart = utc.localize(datetime.strptime(start, format))
dtutcend = utc.localize(datetime.strptime(end, format))
dtstart = dtutcstart.astimezone(paris)
dtend = dtutcend.astimezone(paris)
result = (u"Prochain cours le {date} de {start} à {end} :\n"
"{description}").format(
date=dtstart.strftime("%A %d/%m/%Y"),
start=dtstart.strftime("%Hh%M"),
end=dtend.strftime("%Hh%M"),
description=description).encode('utf8').strip()
return result
def get_events(ical_url, days=7):
today = datetime.date.today()
max_date = today + datetime.timedelta(days)
ltz = tzlocal.get_localzone()
events = []
ics = urllib.urlopen(ical_url).read()
ical=Calendar.from_ical(ics)
for e in ical.walk():
if 'SUMMARY' in e and 'DTSTART' in e:
event = {
'title': str(e['SUMMARY'].encode('utf-8')),
'location': str(e['LOCATION'].encode('utf-8')),
'description': str(e['DESCRIPTION'].encode('utf-8')),
}
if type(e['DTSTART'].dt) is datetime.datetime:
event['start'] = e['DTSTART'].dt.replace(tzinfo=pytz.utc)
event['date'] = event['start'].astimezone(ltz).date()
else:
event['start'] = e['DTSTART'].dt
event['date'] = event['start']
if 'DTEND' in e:
if type(e['DTEND'].dt) is datetime.datetime:
event['end'] = e['DTEND'].dt.replace(tzinfo=pytz.utc)
else:
event['end'] = e['DTEND'].dt
if today <= event['date'] and event['date'] <= max_date:
events.append(event)
return(sorted(events, key=itemgetter('date')))
def relab(create_event):
"""
<p><strong>Le RElab, premier Fab Lab de Wallonie, est un atelier numérique ouvert au public et une structure de développement créatif local.</strong> La spécificité du RElab réside dans l’utilisation de matériaux de récupération comme matière première et dans l’étude de nouveaux procédés sociaux, créatifs et économiques d’upcycling, en liaison avec les nouveaux moyens de fabrication et de communication numérique.</p>
"""
data = Calendar.from_ical(requests.get("https://www.google.com/calendar/ical/utmnk71g19dcs2d0f88q3hf528%40group.calendar.google.com/public/basic.ics").content)
for event in data.walk()[1:]:
if event.get("DTSTAMP"):
title = str(event["SUMMARY"]) if event.get("SUMMARY") else ""
url = str(event["URL"]) if event.get("URL") else "http://relab.be"
start = str(event["DTSTART"].dt) if event.get("DTSTART") else str(event["DTSTAMP"].dt)
end = str(event["DTEND"].dt) if event.get("DTEND") else None
location = event["LOCATION"]
# timezone removal, the crappy way
if len(start) > 10:
start = start[:-6]
if len(end) > 10:
end = end[:-6]
event = create_event(
title=title,
url=url,
start=start,
end=end,
location=location
)
event.tags.add("fablab")
def order(group):
global request
if request == "":
request = connect(group) # objet reçu de la connexion via la
# fonction connect définie plus bas.
paris = pytz.timezone('Europe/Paris')
format = "%Y%m%dT%H%M%SZ"
datefind = datetime(2014, 4, 16, 11) # careful: 04 is invalid. 4
# is. (octal numbers not allowed in python!)
find = datefind.strftime("%d/%m/%Y/%Hh%M")
ffind = utc.localize(datefind)
fffind = ffind.astimezone(paris)
#semaine de 4 à 22 (19 semaine)
#semaine de 6 jour
#jour de 8 crénaux
#tableau de 19 * 6 * 8 = 912 case
crenaux = [1]*912
for component in Calendar.from_ical(request.text).walk():
if component.name == 'VEVENT':
start = component.get('DTSTART').to_ical()
dtutcstart = utc.localize(datetime.strptime(start, format))
dtstart = dtutcstart.astimezone(paris)
fstart = dtstart.strftime("%d/%m/%Y/%Hh%M")
end = component.get('DTEND').to_ical()
dtutcend = utc.localize(datetime.strptime(end, format))
dtend = dtutcend.astimezone(paris)
fend = dtend.strftime("%d/%m/%Y/%Hh%M")
getCrenaux(crenaux, dtstart, dtend)
return crenaux
def sync_with_ical(self, ical_feed):
"""
Parse an icalendar feed and sync the events in the database with it.
:param ical_feed: ical formatted string.
:return: None
"""
cal = Calendar.from_ical(ical_feed)
current_uids = self.values_list('id', flat=True)
new_uids = []
for event in cal.walk('vevent'):
uid = event.decoded('uid')
sequence = event.decoded('sequence')
new_uids.append(uid)
try:
event_obj = self.get(id=uid)
if event_obj and event_obj.sequence == sequence:
continue
except Event.DoesNotExist:
event_obj = Event()
event_obj.update_from_ical(event)
event_obj.save()
to_delete = set(current_uids) - set(new_uids)
self.filter(id__in=list(to_delete)).delete()
def make_db():
from ..database import Event
print "Converting iCal file into sqlite database..."
with open(ICAL_PATH, 'rb') as f:
ical_data = f.read()
cal = Calendar.from_ical(ical_data)
try:
Event.drop_table()
except:
pass
try:
Event.create_table()
except:
pass
for event in cal.walk("VEVENT"):
Event.create_from_ical_event(event)
print "Imported {} events.".format(
Event.select().count()
)
return True
def fetch(create_event):
data = Calendar.from_ical(requests.get("http://www.meetup.com/{}/events/ical/".format(meetup_name)).content)
for event in data.walk():
if not isinstance(event, icalendarEvent):
continue
title = event.get("SUMMARY", None)
start = event.get("DTSTART", None)
if None in (title, start):
continue
detail = {
"title": title.encode("Utf-8"),
"url": event.get("URL", ""),
"start": start.dt.replace(tzinfo=None),
"location": event.get("LOCATION", "").encode("Utf-8"),
}
if key is None and event.get("URL") and Event.objects.filter(url=event["url"]):
continue
elif callable(key) and key(event_query=Event.objects.filter(source=org_name), detail=detail) is False:
continue
db_event = create_event(**detail)
if filter(lambda x: not callable(x), tags):
db_event.tags.add(*filter(lambda x: not callable(x), tags))
map(lambda tag: tag(db_event), filter(callable, tags))
def __init__(self, start_time, pattern):
super(ICal, self).__init__(start_time, pattern)
cal = Calendar.from_ical(pattern)
vevent = cal.walk('VEVENT')[0]
self.dtstart = start_time
self.min_freq = self._get_min_freq(vevent)
self.rrule_obj = self._get_rrule_obj(vevent, start_time)
def reload(self, sender):
calendar_url = CONFIG.get('feed', 'nag')
try:
result = requests.get(calendar_url)
except IOError:
self.last_pomodoro_name = 'Error loading calendar'
self.last_pomodoro_timestamp = self.now().replace(microsecond=0)
return
cal = Calendar.from_ical(result.text)
recent = None
for entry in cal.subcomponents:
if recent is None:
recent = entry
continue
if 'DTEND' not in entry:
continue
if entry['DTEND'].dt > recent['DTEND'].dt:
recent = entry
self.last_pomodoro_name = recent['SUMMARY']
self.last_pomodoro_timestamp = recent['DTEND'].dt
def update_engineering_events():
r = requests.get('http://engineering.columbia.edu/feeds/events')
soup = BeautifulSoup(r.text)
events = soup.find_all('item')
user = User.query.filter(User.name == "Columbia Engineering").first()
for event in events:
current_soup = BeautifulSoup(event.renderContents())
event_name = current_soup.find('title').text
url = current_soup.find('link').get_text()
u = urlparse.urlparse(url)
event_id = urlparse.parse_qs(u.query)["id"][0]
base = "http://calendar.columbia.edu/sundial/webapi/"
ical_url = base + "iCalendar.php?EventID={}".format(event_id)
url = base + "get.php?vt=detail&id={}&con=standalone".format(event_id)
r_event = requests.get(ical_url)
cal = Calendar.from_ical(r_event.text)
cevent = Event.query.filter(Event.sundial_id == event_id).first()
if cevent is None:
cevent = Event(name=event_name, url=url, sundial_id=event_id,
user_id=user.id)
# only one event in cal
for event in cal.walk('vevent'):
cevent.start = event.get('dtstart').dt.replace(tzinfo=None)
cevent.end = event.get('dtend').dt.replace(tzinfo=None)
cevent.description = event.get('description')
cevent.location = event.get('location')
db.session.add(cevent)
db.session.commit()
def generic_meetup(source, meetup_name, options):
Event.objects.filter(source=source, start__gte=datetime.now()).delete()
data = Calendar.from_ical(requests.get("http://www.meetup.com/{}/events/ical/".format(meetup_name)).content)
for event in data.walk():
if not isinstance(event, icalendarEvent):
continue
title = event.get("SUMMARY", None)
start = event.get("DTSTART", None)
if None in (title, start):
continue
if event.get("URL") and Event.objects.filter(url=event["url"]):
continue
Event.objects.create(
title=title.encode("Utf-8"),
source=source,
url=event.get("URL", ""),
start=start.dt.replace(tzinfo=None),
location=event.get("LOCATION", "").encode("Utf-8")
)
if not options["quiet"]:
print "Adding %s [%s] (%s)..." % (title.encode("Utf-8"), source, event.get("LOCATION", "").encode("Utf-8"))
def _load_calendar():
logging.debug("Loading Calendar from: %r", settings.ICAL_URL)
ical_request = requests.get(settings.ICAL_URL)
cal = Calendar.from_ical(ical_request.text)
for k in cal.subcomponents:
logging.debug('Calendar - %r', k)
return cal
def fetch(create_event):
data = Calendar.from_ical(requests.get("http://www.meetup.com/{}/events/ical/".format(meetup_name)).content)
for event in data.walk():
if not isinstance(event, icalendarEvent):
continue
title = event.get("SUMMARY", None)
start = event.get("DTSTART", None)
if None in (title, start):
continue
if event.get("URL") and Event.objects.filter(url=event["url"]):
continue
db_event = create_event(
title=title.encode("Utf-8"),
url=event.get("URL", ""),
start=start.dt.replace(tzinfo=None),
location=event.get("LOCATION", "").encode("Utf-8"),
)
if tags:
db_event.tags.add(*tags)
def read(ical):
"""
@desc: Read the ical file and parse into a dict.
"""
gcal = Calendar.from_ical(ical)
events = []
for event in gcal.walk('VEVENT'):
end = event.decoded('DTEND')
if type(end) == datetime.date:
now = datetime.date.today()
else:
now = timezone.now()
if end < now:
continue
summary = event.get('SUMMARY')
description = event.get('DESCRIPTION')
location = event.get('LOCATION')
geo = event.get('GEO')
url = event.get('URL')
attach = event.get('ATTACH')
events.append(dict({
"summary": str(summary) if summary else str(),
"start": event.decoded('DTSTART').isoformat(),
"end": event.decoded('DTEND').isoformat(),
"description": str(description) if description else str(),
"location": str(location) if location else str(),
"geo": str(geo) if geo else str(),
"url": str(url) if url else str(),
"attach": str(attach) if attach else str(),
}))
return events
def main(argv):
parser = configargparse.ArgumentParser(description="iCal task importer for Todoist", formatter_class=RawTextHelpFormatter)
parser.add_argument( '-f', '--filename', required=True, type=str, help='iCal file to import' )
parser.add_argument( '-t', '--api_token', required=True, type=str, help='Todoist API token' )
parser.add_argument( '-p', '--project', required=True, type=str, help='Destination Todoist project for these tasks' )
parser.add_argument( '-r', '--reminders', help='Add reminders to tasks that have a due date specified\nREQUIRES TODOIST PREMIUM\nDefault: False', action='store_true')
parser.add_argument( '--debug', help='Run in debug mode (prints more information to the logfile)\nDefault: False', action='store_true')
parser.add_argument( '--noop', help='Parse the iCal data but don\'t actually commit to the Todoist API\nDefault: False', action='store_true')
args=parser.parse_args()
if args.debug:
logger.setLevel(logging.DEBUG)
cal = Calendar.from_ical(
open(args.filename, 'rb').read()
)
tdapi = TodoistAPI(args.api_token, args.noop==False)
project = tdapi.get_project(args.project)
logger.debug('Using project %s' % project.data)
new_items = []
for ical_item in cal.walk('vtodo'):
item = tdapi.add_item(project, ical_item)
new_items.append(item)
tdapi.commit()
if args.reminders:
for item in new_items:
tdapi.add_reminder(item)
tdapi.commit()
def calendar_addics(caldav_conn, args):
"""
Takes an ics from external source and puts it into the calendar.
From the CalDAV RFC:
Calendar components in a calendar collection that have different UID
property values MUST be stored in separate calendar object resources.
This means the inbound .ics has to be split up into one .ics for
each event as long as the uid is different.
"""
if args.file == '-':
input_ical = sys.stdin.read()
else:
with open(args.file, 'r') as f:
input_ical = f.read()
c = Calendar.from_ical(input_ical)
## unfortunately we need to mess around with the object internals,
## since the icalendar library doesn't offer methods out of the
## hat for doing such kind of things
entries = c.subcomponents
## Timezones should be duplicated into each ics, ref the RFC
timezones = [x for x in entries if x.name == 'VTIMEZONE']
## Make a mapping from UID to the other components
uids = {}
for x in entries:
if x.name == 'VTIMEZONE' or not 'UID' in x:
continue
uid = x['UID'].to_ical()
uids[uid] = uids.get(uid, []) + [x]
for uid in uids:
c.subcomponents = timezones + uids[uid]
_calendar_addics(caldav_conn, c.to_ical(), uid, args)
def open_cal():
if os.path.isfile(filename):
if file_extension == 'ics':
print("Extracting events from file:", filename, "\n")
f = open(sys.argv[1], 'rb')
gcal = Calendar.from_ical(f.read())
revents = recurring_ical_events.of(gcal).between(istart, istop)
# for component in gcal.walk():
for component in revents:
event = CalendarEvent("event")
v = (dir(component).count('get')
) # Only proces data if object is a valid event
if (v != 0):
if component.get('TRANSP') == 'TRANSPARENT':
continue #skip all day events and the like
if component.get('SUMMARY') == None:
continue #skip blank items
event.summary = component.get('SUMMARY')
event.uid = component.get('UID')
if hasattr(component.get('dtstart'), 'dt'):
event.start = component.get('dtstart').dt
if hasattr(component.get('dtend'), 'dt'):
event.end = component.get('dtend').dt
event.url = component.get('URL')
events.append(event)
f.close()
else:
print("You entered ", filename, ". ")
print(file_extension.upper(),
" is not a valid file format. Looking for an ICS file.")
exit(0)
else:
print("I can't find the file ", filename, ".")
print(
"Please enter an ics file located in the same folder as this script."
)
exit(0)
def get_race_name_list(target_year, is_place):
"""Getting the race name and event date
Arguments:
target_year {int} -- target year to get the data
is_place {bool} -- [description]
Returns:
[list in dict] -- event date and race name
"""
zip_url = ICAL_PLACE_DOWNLOAD_URL if is_place else ICAL_FILE_DOWNLOAD_URL
ical_name = ICAL_PLACE_NAME if is_place else ICAL_FILE_NAME
url_path = zip_url.format(year=target_year)
file_name = ical_name.format(year=target_year)
zip_obj = requests.get(url_path)
with zipfile.ZipFile(io.BytesIO(zip_obj.content)) as unzipped_obj:
with unzipped_obj.open(file_name) as ical_obj:
cal = Calendar.from_ical(ical_obj.read())
return [{
"date": ev["dtend"].dt,
"title": str(ev["summary"]).split("(")[0]
} for ev in cal.walk() if ev.name == "VEVENT"]
def import_ics(self):
ics = base64.b64decode(self.ics_file)
lines = []
for event in Calendar.from_ical(ics).walk('vevent'):
dtend = event.get('dtend').dt
dtstart = event.get('dtstart').dt
day_count = (dtend - dtstart).days
if day_count > 1:
for dt in (dtstart + timedelta(n) for n in range(day_count)):
lines.extend([(0, 0, {
'name': event.get('summary'),
'date': dt.strftime(DF)
})])
else:
lines.extend([(0, 0, {
'name': event.get('summary'),
'date': dtstart.strftime(DF)
})])
if lines:
holidays = self.env['hr.holidays.public'].browse(
self._context.get('active_id', []))
holidays.write({'line_ids': lines})
def convert_calendar(calendar, date):
# Open file with the ics calendar in it and then read it into an icalendar object.
f = open(calendar, 'rb')
process_cal = Calendar.from_ical(f.read())
f.close()
# cal_events is a list of every event in the calendar.
cal_events = [e for e in process_cal.walk('vevent')]
first_event_date = get_first_event_date(cal_events)
# The offset is how many days we are moving the dates of the calendar.
offset = date - first_event_date
# Every date in every event is moved by the offset.
for e in cal_events:
e['DTSTART'].dt = e['DTSTART'].dt + offset
e['DTEND'].dt = e['DTEND'].dt + offset
# Call function to change weekly dates.
change_weekly(cal_events)
# output to file.
f = open('output.ics', 'wb')
f.write(process_cal.to_ical())
f.close()
def parse_events_from_ics(ics_contents: bytes) -> List[dict]:
parsed_events = []
cal = Calendar.from_ical(ics_contents)
now = epoch_now()
for item in cal.walk():
if item.name == 'VEVENT':
category = item.get('categories').to_ical().decode('utf-8')
summary = item.get('summary').to_ical().decode('utf-8')
timestamp = item.get('dtend', 0).to_ical().decode('utf-8')
summary += f' [{time_from_ics_stamp(timestamp)}]'
timestamp = ics_format_to_epoch(timestamp)
if timestamp < now:
continue
parsed_events.append({
'category': ''.join(category),
'timestamp': timestamp,
'msg': summary
})
return parsed_events
def load_osdc():
cal = Calendar.from_ical(open('data/osdc.ics', 'rb').read())
speakers = {}
osdc1 = Track2.query.get(28)
osdc2 = Track2.query.get(48)
osdc3 = Track2.query.get(49)
for component in cal.walk():
if component.name != 'VEVENT':
continue
title = component['summary']
room_name = component['location']
abstract = component['description']
speaker_name = component['organizer']
starts_at = component['dtstart'].dt
ends_at = component['dtend'].dt
duration = int((ends_at - starts_at).total_seconds() / 60)
speaker = speakers.get(speaker_name, None)
if not speaker:
speaker = Speaker(first_name="", last_name=speaker_name)
speakers[speaker_name] = speaker
talk = Talk(title=title,
abstract=abstract,
starts_at=starts_at,
duration=duration)
talk.speakers.append(speaker)
if 'Gopher' in room_name:
talk.track = osdc3
else:
if starts_at.day == 4:
talk.track = osdc1
else:
talk.track = osdc2
db.session.commit()
def create_event(self,
uid,
title,
message,
location=None,
start=None,
stop=None):
ical = Calendar.from_ical(self.__ical_data)
if uid is None:
uid = md5(title.encode()).hexdigest()
if start is None:
start = datetime.now()
if stop is None:
stop = start
event = Event()
event.add('uid',
str(datetime.now()) + '/' + str(start) + '/' + str(uid))
event.add('summary', title)
event.add('description', message)
if location is not None:
event.add('location', location)
event.add('dtstart', start)
event.add('dtend', stop)
event.add('dtstamp', datetime.now())
ical.add_component(event)
with open(terrariumCalendar.ICS_FILE, 'wb') as fp:
fp.write(ical.to_ical())
self.__ical_data = ical.to_ical()
def load_events(filepath):
with open(filepath) as f:
gcal = Calendar.from_ical(f.read())
events = []
for component in gcal.walk():
if component.name == "VEVENT":
# TODO: Test that timezones work properly
# TODO: Handle recurrence rules
title = component.decoded("summary").decode("utf8")
start = coerce2datetime(component.decoded("dtstart"))
end = coerce2datetime(component.decoded("dtend"))
duration = end - start
attendees = [
str(attendee) for attendee in (component.get("attendee") or [])
]
e = Event(
timestamp=start,
duration=duration,
data={
"title": title,
"attendees": attendees
},
)
events.append(e)
# print(title)
# print(start, duration)
# if attendees:
# for attendee in attendees:
# print(attendee)
# print(e)
# print(component)
# print(80 * "-")
return events
def blogTO():
host = "http://www.blogto.com"
dateRange = getDateRange("%d-%d-%d", numberOfDays, False)
print dateRange
for currentDate in dateRange:
urls = []
soup = getBS(host + "/events/?date=" + currentDate)
for event in soup.select(".event-name a"):
urls.append(host + event.get('href'))
print urls
for url in urls:
#check if feature already exists
if url not in existingFeatures:
print url
r = requests.get(url + "add-to-calendar/?type=ical")
cal = Calendar.from_ical(r.text)
r = requests.get(url)
eventHTML = r.text
img = ""
soup = BeautifulSoup(eventHTML)
for event in soup.select(".detail-img-container > img"):
img = event.get("src")
m = re.search('(coordinates: \'POINT \()(.*)(\s)(.*)(\))', eventHTML)
if m:
long = m.group(2)
lat = m.group(4)
else:
lat, long = lookupVenue(cal = cal, source = "blogTO")
if lat:
readCalendarEventAndSubmit(cal, lat, long, url, "%Y-%m-%d %H:%M:%S", "blogTO", img = img)
def open_cal():
if os.path.isfile(filename):
if file_extension == 'ics':
print("Extracting events from file:", filename, "\n")
f = open(sys.argv[1], 'rb')
gcal = Calendar.from_ical(f.read())
for component in gcal.walk():
event = CalendarEvent("event")
if component.get('TRANSP') == 'TRANSPARENT':
continue #skip event that have not been accepted
if component.get('SUMMARY') == None:
continue #skip blank items
event.summary = component.get('SUMMARY')
event.uid = component.get('UID')
if component.get('DESCRIPTION') == None:
continue #skip blank items
event.description = component.get('DESCRIPTION')
event.location = component.get('LOCATION')
if hasattr(component.get('dtstart'), 'dt'):
event.start = component.get('dtstart').dt
if hasattr(component.get('dtend'), 'dt'):
event.end = component.get('dtend').dt
event.url = component.get('URL')
events.append(event)
f.close()
else:
print("You entered ", filename, ". ")
print(file_extension.upper(),
" is not a valid file format. Looking for an ICS file.")
exit(0)
else:
print("I can't find the file ", filename, ".")
print(
"Please enter an ics file located in the same folder as this script."
)
exit(0)
def getCalendarData(calendar_url):
req = urllib2.Request(calendar_url)
response = urllib2.urlopen(req)
data = response.read()
today = datetime.now().date()
in_future = today + timedelta(days=15)
cal = Calendar.from_ical(data)
events = []
for event in cal.walk('vevent'):
if not "QUIET TIME" in upper(event.get("summary")): continue
if (event.get('rrule')):
start = event.get('dtstart').dt
duration = event.get('dtend').dt - start
try:
rrule = rrulestr(event.get('rrule').to_ical(), dtstart=start)
start = rrule.after(datetime.now(pytz.UTC))
except:
rrule = rrulestr(event.get('rrule').to_ical(), dtstart=start)
start = rrule.after(datetime.now().replace(tzinfo=None))
if start: start.replace(tzinfo=pytz.UTC)
if start:
end = start + duration
else:
continue
else:
start = event.get('dtstart').dt
end = event.get('dtend').dt
if ((to_date(start) >= today) and (to_date(end) <= in_future)):
events.append({
"start": start,
"end": end,
"summary": event.get("summary"),
})
return events
def execute(content):
gcal = Calendar.from_ical(content)
ncal = Calendar()
ncal.add('METHOD', gcal.get("METHOD"))
ncal.add('VERSION', gcal.get("VERSION"))
ncal.add('CALSCALE', gcal.get("CALSCALE"))
ncal.add('X-WR-TIMEZONE', gcal.get("X-WR-TIMEZONE"))
ncal.add('X-PUBLISHED-TTL', gcal.get("X-PUBLISHED-TTL"))
ncal.add('PRODID', gcal.get("PRODID"))
ncal.add('X-WR-CALNAME', gcal.get("X-WR-CALNAME"))
ncal.add('X-WR-CALDESC', gcal.get("X-WR-CALDESC"))
tum_events = []
for component in gcal.walk():
if component.name == "VEVENT":
event = parse_event(component)
duplicate_event = False
for item in tum_events:
if item.is_event(event):
duplicate_event = True
item.add_location(event.location)
break
if not duplicate_event:
tum_events.append(event)
event_str = ''
for event_item in tum_events:
event_str += event_item.summary
cal_event = event_item.gen_event()
ncal.add_component(cal_event)
return ncal.to_ical()
def lookupEventInformation(self,
calendarData,
typeOfEvent,
startTime=None,
endTime=None,
duration=None):
calenderAsObject = Calendar.from_ical(calendarData.calendarData)
eventList = calenderAsObject.walk(
'VEVENT') #grab all the events in the calendar
result = []
if eventList is not None and len(eventList) > 0:
(actualStartTime,
actualEndTime) = self.addEvents(eventList, typeOfEvent, startTime,
endTime, duration)
eventNames = [
self.getEventName(event[COMMENT_KEY])
for event in eventList if self.eventMatches(
event, typeOfEvent, actualStartTime, actualEndTime)
]
if typeOfEvent == TOPIC_ID:
result = [
self.DB_BRIDGE.retrieveTopicFromCacheOrDB(topicId, True)
for topicId in eventNames
]
elif typeOfEvent == TASK_ID:
result = [
self.DB_BRIDGE.retrieveTaskFromCacheOrDB(taskId, True)
for taskId in eventNames
]
#remember to return the result in serializable form.
result = [x.toSerializable() for x in result]
return result
def main():
"""Erase all events and send a new ics file from Emacs.
"""
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('calendar', 'v3', http=http)
# ------------------------------------------------------------
# Clear all events
service.calendars().clear(calendarId='primary').execute()
# ------------------------------------------------------------
# Add event one by one
count = 0
g = open('/home/rafatieppo/Dropbox/emacs_org_mode/rafa.ics', 'rb')
gcal = Calendar.from_ical(g.read())
for component in gcal.walk():
if component.name == "VEVENT":
envent_summary = (component.get('summary'))
event_dtstart = (component.get('dtstart').dt.isoformat() +
'-04:00')
event_dtend = (component.get('dtend').dt.isoformat() + '-04:00')
event = {
'summary': envent_summary,
'start': {
'dateTime': event_dtstart
},
'end': {
'dateTime': event_dtend
}
}
count = count + 1
print(str(count))
print(event)
service.events().insert(calendarId='primary', body=event).execute()
g.close()
def _extract_info_from_message_naive(self, message, cid_pattern,
start_time_pattern, end_time_pattern):
cid = None
start_time = None
end_time = None
message_body = None
for message_part in message.walk():
# Get a message body if this message part has one
if message_part.get_content_type() == "text/plain":
message_body = message_part.get_payload(decode=True)
elif message_part.get_content_type() == "text/html":
message_body = message_part.get_payload(decode=True)
elif message_part.get_content_type() == "text/calendar":
message_body = message_part.get_payload(decode=True)
ics = Calendar.from_ical(message_body)
start_time, end_time = self.extract_times_from_ical(ics)
else:
continue # We don't know how to parse this message part type
if not message_body:
continue # The message part couldn't be decoded. Skip it.
# Parse the message body
message_body = str(message_body)
match = re.search(cid_pattern, message_body, re.IGNORECASE)
if match:
cid = match.group(1)
match = re.search(start_time_pattern, message_body, re.IGNORECASE)
if match:
start_time = match.group(1)
match = re.search(end_time_pattern, message_body, re.IGNORECASE)
if match:
end_time = match.group(1)
# If we have all of the things we need stop looking
#if cid and start_time and end_time:
# break
return cid, start_time, end_time, message_body
def get_checkin_agenda(url, name):
req = Request(url)
req.add_header('User-agent', 'Mozilla 5.10')
gcal = Calendar.from_ical(urlopen(req).read().decode('utf-8'))
agenda = Calendar()
agenda['prodid'] = gcal['prodid']
agenda['version'] = '2.0'
agenda['calscale'] = 'GREGORIAN'
agenda['method'] = 'PUBLISH'
for c in gcal.walk():
if c.name == 'VEVENT' and 'description' in c:
check_in = Event()
check_in['summary'] = "CHECKIN - " + name
check_in['description'] = c['description']
# check_in['location'] = c['location']
check_in['dtstart'] = check_in['dtend'] = c['dtstart']
check_in['uid'] = "checkin-" + c['uid']
agenda.add_component(check_in)
return agenda
def upload_calendar(request):
classes = []
if request.user.is_authenticated:
f = request.FILES["file"]
f.seek(0)
fcal = Calendar.from_ical(f.read())
for component in fcal.walk():
if component.name == "VEVENT":
x = findOrCreateSession(component)
if x not in classes:
classes.append(x)
classes = removePracticals(classes)
for x in classes:
x.save()
if x.course not in request.user.courses.all():
request.user.courses.add(x.course)
request.user.save()
return redirect(request.POST["backurl"])
def get_calendar(self):
url = config.ICAL_URL
try:
with urllib.request.urlopen(url) as response:
data = response.read().decode('utf-8')
except ValueError as e:
logger.error(
"%s Did you remember to preprend http(s?):// URL: '%s'" %
(e, url))
return
except urllib.error.HTTPError as e:
logger.error("Received HTTP error code %s. URL: '%s'" %
(e.code, url))
return
try:
cal = Calendar.from_ical(data)
except ValueError as e:
logger.error("Could not parse response as ical.")
logger.debug("Response was %s" % (data))
return
return cal
def class_finder(self): #This function downloads an ical file from the users input, reads from the file, and then deletes the file from memory
r = requests.get(self.url,allow_redirects=True)
f1 = open('classes.ical', 'wb').write(r.content)
fall_classes_list = []
spring_classes_list = []
spring_ending = [datetime.datetime(2019,4,23,23,59,59)]
from icalendar import Calendar
f = open("classes.ical","rb")
fcal = Calendar.from_ical(f.read())
for component in fcal.walk():
if component.name == "VEVENT":
if component.get("RRULE")["UNTIL"] == spring_ending and component.get("SUMMARY") not in spring_classes_list:
spring_classes_list.append(component.get("SUMMARY"))
elif component.get("RRULE")["UNTIL"] != spring_ending and component.get("SUMMARY") not in fall_classes_list:
fall_classes_list.append(component.get("SUMMARY"))
f = open("people.csv","a")
f.write(self.x + "||")
f.write(self.y + "||")
for entry in spring_classes_list:
f.write(entry + "||")
f.write("\n")
f.close()
os.remove("classes.ical")
def main(url, output_file_name, include_exercise_sessions):
cal_text = read_url(url)
cal_input = Calendar.from_ical(cal_text, True)
cal_output = Calendar()
for event in cal_input[0].walk('vevent'):
try:
event_type = parse_event_type(event)
course_code = parse_course_code(event)
event_room = parse_event_room(event)
course_name = get_course_name(course_code)
if should_ignore_event_type(event_type, include_exercise_sessions):
continue
event['summary'] = generate_event_description(course_code, event_type, event_room, course_name)
cal_output.add_component(event)
except AttributeError:
continue
with open(output_file_name, 'wb') as output_file:
output_file.write(cal_output.to_ical())
def parse_fixture_to_list():
match_list = []
g = open('fixture.ics', 'rb')
gcal = Calendar.from_ical(g.read())
for component in gcal.walk():
g_list = []
game_list = []
if component.name == "VEVENT":
start_date = component.decoded('DTSTART')
match = component.get('DESCRIPTION')
year = start_date.year
if year == 2016:
match = match.replace('\n', ',')
#print match
g_tuple = (re.split(',|\sv\s', match))
#print g_tuple
game_list.append(g_tuple[0])
game_list.append(g_tuple[1])
start_date = start_date.replace(tzinfo=None)
game_list.append(start_date)
match_list.append(game_list)
g.close()
return match_list
def main():
creds = check_credentials()
service = build('calendar', 'v3', credentials=creds)
globalid = '*****@*****.**'
testglobalid = '*****@*****.**'
calendarid = globalid
with open("api_key", "r") as f:
api_key = f.read()
ioc_names = e2g.name2ioc()
for src in sources:
print("importing from {}".format(src.url))
r = requests.get(src.url, headers={'Accept': 'text/calendar'})
if not r.encoding:
r.encoding = 'utf-8'
events = googleify(Calendar.from_ical(r.text), src.tags, api_key,
ioc_names, src.lat, src.lng)
print("importing {} from from {}".format(len(events), src.url))
for event in events:
print(' ' + event['summary'])
insertupdate(calendarid, service, event, event['iCalUID'])
def fetch_events(self, timeout: int = 5) -> None:
"""
Fetch events from Wirtualna Uczelnia
"""
try:
calendar: Calendar = Calendar.from_ical(
requests.get(self._url, verify=False, timeout=timeout).text # nosec
) # type: ignore
except requests.exceptions.ConnectTimeout as e:
raise WUDeadError(e)
except Exception as e:
raise ScheduleFetchError(e)
# create a list of events out of the calendar
self.events = [
Event.from_calendar(component)
for component in calendar.walk()
if component.name == "VEVENT"
]
self.first_day = min(self.events, key=lambda e: e.start).start.date()
self.last_day = max(self.events, key=lambda e: e.start).start.date()
def test_parser(icalendarFile, outputFileName):
try:
data = urlopen(icalendarFile)
print("URL")
except:
data = open(icalendarFile, "r", encoding='utf-8')
print("Path")
datas = data.read()
cal = Calendar.from_ical(datas)
""" Go through the events and parse the information: """
for event in cal.walk('vevent'):
event_info = ','.join(event.get('summary').rsplit('(', 1))
parser = MyCoursesParser()
parser.parse(event_info)
if parser.infos["errors"] is not None:
continue
summary = parser.infos["summary"]
course_code = parser.infos["course_code"]
location = parser.infos["location"]
address = parser.infos["address"]
descr = event.get('description')
description, webPage = form_description(course_code, descr)
geo = getLocation(address)
event['summary'] = summary
event['description'] = description
event['location'] = location
event['geo'] = geo
event['url'] = webPage
outputFile = open(outputFileName, 'wb')
outputFile.write(cal.to_ical())
outputFile.close()
def generate_from_caldav(event: caldav.Event):
def gt(dt_str):
dt, _, us= dt_str.partition(".")
dt= datetime.strptime("{} +0000".format(dt), "%Y-%m-%dT%H:%M:%S %z")
return dt
def obj_hook(obj):
if '__type__' in obj and obj['__type__']=='PnPParty':
return PnPParty(gt(obj['date']),
obj['gm'],
obj['players'],
obj['slot'],
obj['max_players']
)
subcomponents = Calendar.from_ical(event.data).subcomponents
if len(subcomponents) == 1:
tmp_event = subcomponents[0]
json_string = tmp_event.get('DESCRIPTION')
try:
obj = loads(json_string, object_hook=obj_hook)
except TypeError as e:
print('The JSON was malformed: {}'.format(e))
return None
else:
print('There are {} submodules, we need exactly 1'.format(len(subcomponents)))
return None
obj.event = event
obj.title = tmp_event.get('SUMMARY')
if not tmp_event.get("dtstart").dt == obj.date :
print(obj.date, tmp_event.get("dtstart").dt)
logging.warning("json date and dtstart are not equal.")
obj.date = tmp_event.get("dtstart").dt
return obj
def next_occurrence(self):
# if not messages have been queued yet, then the next occurrence
# is the start time
next_occur = None
if (not self.last_occurrence_in_utc):
next_occur = self.start_datetime_in_utc.datetime
next_expire = arrow.get(next_occur).replace(minutes=+10)
if self.end_datetime_in_utc < next_expire:
next_expire = self.end_datetime_in_utc
return next_occur, next_expire
else:
start = self.start_datetime_in_utc.datetime
cal = Calendar.from_ical(self.ical)
if cal.get('RRULE'):
rrule = cal.get('RRULE').to_ical()
rule = rrulestr(rrule, dtstart=start)
next_after_now = rule.after(self.compare_datetime_in_utc
or arrow.utcnow().datetime)
else:
next_after_now = None
if not next_after_now:
logging.info('No next_after_now, so next_occur=N/A')
return 'N/A', self.compare_datetime_in_utc or arrow.utcnow()
next_before_now = rule.before(next_after_now)
if next_before_now and \
(self.last_occurrence_in_utc > next_before_now):
next_occur = next_after_now
else:
next_occur = next_before_now
rule = rrulestr(rrule, dtstart=next_occur)
expires = rule.after(next_occur)
if not expires:
return 'N/A', arrow.utcnow().replace(minutes=+10)
if (expires > self.end_datetime_in_utc):
expires = self.end_datetime_in_utc
return arrow.get(next_occur), arrow.get(expires)
def url_to_ics(): #fetching data from url and transform to .ics
now = datetime.utcnow() #provide a universal standardised reference point
now.replace(tzinfo=pytz.utc) #accounting for daylight savings time
today = datetime.utcnow().replace(tzinfo=pytz.utc).date()
urls = [URL.strip() ] #strip url
combined_cal = Calendar() #create calendar
for url in urls:
req = requests.get(url)
if req.status_code != 200: #error fetching url
print("Error {} fetching {}: {}"
.format(url, req.status_code, req.text))
continue
cal = Calendar.from_ical(req.text)
for event in cal.walk("VEVENT"):
end = event.get('dtend')
if end:
if hasattr(end.dt, 'date'):
date = end.dt.date()
else:
date = end.dt
if date >= today or 'RRULE' in event:
copied_event = Event()
for attr in event:
if type(event[attr]) is list:
for element in event[attr]:
copied_event.add(attr, element)
else:
copied_event.add(attr, event[attr])
combined_cal.add_component(copied_event)
with open("timetable.ics", "wb") as f:
f.write(combined_cal.to_ical())
def import_ics(self):
ics = base64.b64decode(self.ics_file)
lines = []
for event in Calendar.from_ical(ics).walk("vevent"):
dtend = event.get("dtend").dt
dtstart = event.get("dtstart").dt
day_count = (dtend - dtstart).days
if day_count > 1:
for dt in (dtstart + timedelta(n) for n in range(day_count)):
lines.extend(
[
(
0,
0,
{"name": event.get("summary"), "date": dt.strftime(DF)},
)
]
)
else:
lines.extend(
[
(
0,
0,
{
"name": event.get("summary"),
"date": dtstart.strftime(DF),
},
)
]
)
if lines:
holidays = self.env["hr.holidays.public"].browse(
self._context.get("active_id", [])
)
holidays.write({"line_ids": lines})
def parse_events(content, start=None, end=None):
"""
Query the events occurring in a given time range.
:param content: iCal URL/file content as String
:param start: start date for search, default today
:param end: end date for search
:return: events as list
"""
if not start:
start = now()
if not end:
end = start + default_span
if len(content) == 0:
raise ValueError('Content is invalid!')
calendar = Calendar.from_ical(content)
start = normalize(start)
end = normalize(end)
found = []
for component in calendar.walk():
if component.name == "VEVENT":
if component.get('rrule'):
es = create_recurring_events(start, end, component)
if es:
found += es
else:
e = create_event(component)
if e.end >= start and e.start <= end:
found.append(e)
return found
