def setStudentCalendar(self, selected_students):
Calendar.delete_active_canvas(self.theCalendar)
student_index = selected_students[0]
student = self.student_index[atoi(student_index)]
presentList = getDays(student, True)
absentList = getDays(student, False)
Calendar.buildCalendar(self.theCalendar, presentList, absentList)
def getTotals(self, e):
student_index = e.widget.curselection()[0]
student = self.student_index[atoi(student_index)]
self.present_variable.set(getTotalDays(student, True))
self.absent_variable.set(getTotalDays(student, False))
Calendar.delete_active_canvas(self.theCalendar)
student = self.student_index[atoi(student_index)]
presentList = getDays(student, True)
absentList = getDays(student, False)
Calendar.buildCalendar(self.theCalendar, presentList, absentList)
def test_get_events_with_input_leapyear_and_febuary(self):
year = "2020"
month = "02"
mock_api = Mock()
events = Calendar.get_events_with_input(mock_api, year, month)
self.assertEqual(
mock_api.events.return_value.list.return_value.execute.
return_value.get.call_count, 1)
args, kwargs = mock_api.events.return_value.list.call_args_list[0]
self.assertEqual(kwargs['timeMin'], "2020-02-01T00:00:00Z")
self.assertEqual(kwargs['timeMax'], "2020-02-29T23:59:59Z")
def test_navigate_calendar_path3_navigation_month_31days(self, api):
# Navigation path for Month of 31 days
# Executes the try statement only succesfully
date = datetime.strptime('Oct 10 2020 1:30AM', '%b %d %Y %I:%M%p')
navigation_type = "MONTH"
api.events.return_value.list.return_value.execute.return_value = {
"items": [
{
"summary": "test",
"start": {
"dateTime": "2020-10-10T02:00:00.000000Z"
},
"end": {
"dateTime": "2020-10-11T02:45:00.000000Z"
},
"reminders": {
'useDefault': True,
'overrides': []
},
},
{
"summary": "Halloween",
"start": {
"dateTime": "2020-10-30T02:00:00.000000Z"
},
"end": {
"dateTime": "2020-10-31T02:45:00.000000Z"
},
"reminders": {
'useDefault': True,
'overrides': []
},
},
]
}
result = Calendar.navigate_calendar(api, date, navigation_type)
self.assertEqual(
api.events.return_value.list.return_value.execute.call_count,
2) # Mock method called twice
# First in getting events, second in getting reminders
self.assertIn(
"Halloween",
result) # Assert title of calendar in result string returned
self.assertIn(
"test",
result) # Assert title of calendar in result string returned
self.assertIn("popup 10",
result) # Assert reminder in result string returned
def __init__(self):
self.WINDOWWIDTH = 1000
self.WINDOWHEIGHT = 640
self.window_Surface = pygame.display.set_mode(
(self.WINDOWWIDTH, self.WINDOWHEIGHT), 0, 32)
pygame.display.set_caption('ReciPlanner')
self.tabs = [
pygame.Rect(3, 3, 80, 16),
pygame.Rect(87, 3, 80, 16),
pygame.Rect(171, 3, 80, 16),
pygame.Rect(255, 3, 80, 16)
]
self.tabFont = pygame.font.Font(None, 16)
self.scrollpos = 0
self.recipe_planner = RP.RecipePlanner()
self.ingredient_list = il.Ingredient_List()
self.grocery_list = GL.GroceryList()
self.grocery_list.recreateGross()
self.ingredient_list.recreateDict()
self.recipe_planner.loadRecipes()
self.food_calender = ca.FoodCalendar(
self.recipe_planner.getRecipeList(), self.ingredient_list,
self.grocery_list)
self.food_calender.loadDays()
self.Recipe_Tab = list_recipe(self)
self.Calender_Tab = calender(self)
self.Ingredients_Tab = list_ingredients(self)
self.Groceries_Tab = list_groceries(self)
self.tab_list = [
self.Calender_Tab, self.Recipe_Tab, self.Ingredients_Tab,
self.Groceries_Tab
]
self.selected_tab = self.Calender_Tab
self.tabs[self.selected_tab.number].y += 4
self.tab_biscuits = self.Calender_Tab.biscuits
self.list_font = pygame.font.Font(None, 24)
self.colour_theme = colour.LIGHT
self.colour_theme_shadow = self.shadow(self.colour_theme)
def test_get_events_with_input_year_and_small_month_and_day(self):
year = "2021"
month = "04"
day = "01"
mock_api = Mock()
events = Calendar.get_events_with_input(mock_api, year, month, day)
self.assertEqual(
mock_api.events.return_value.list.return_value.execute.
return_value.get.call_count, 1)
args, kwargs = mock_api.events.return_value.list.call_args_list[0]
self.assertEqual(kwargs['timeMin'], "2021-04-01T00:00:00Z")
self.assertEqual(kwargs['timeMax'], "2021-04-01T23:59:59Z")
def test_run_calendar_navigate_calendar_no_view(self, mocked_input, mocked_output, api):
mocked_input.side_effect = ["navigate", "0", "23 October 2020", "n", "exit"]
api.events.return_value.list.return_value.execute.return_value = {
"items": [
{
"summary": "COVID",
"start": {
"dateTime": "2020-10-03T02:00:00.000000Z"
},
"status": "confirmed",
'creator': {'email': '*****@*****.**', 'self': True},
'created': '2020-10-09T04:10:47.000Z',
"end": {
"dateTime": "2020-10-03T02:45:00.000000Z"
}, "reminders": {
'useDefault': False,
'overrides': [
{'method': 'email', 'minutes': 1},
{'method': 'popup', 'minutes': 10},
]}
},
]}
Calendar.run_calendar(api)
self.assertIn("Exiting Navigation", mocked_output.getvalue())
def test_03_command_add(self):
date = '2019-10-31'
title = 'MAT157 Tutorial'
start_time = 8
end_time = 10
calendar = {}
call = "Calendar.command_add\
('{}, {}, {}')".format(date, start_time, end_time, title,
str(calendar))
expected = True
returned = Calendar.command_add(date, start_time, end_time, title,
calendar)
msg = FAILURE_MESSAGE.format(call, expected, returned)
self.assertEqual(expected, returned, msg)
def test_print_events(self):
"""
This test is for the printing of the user menu
Function involved: print_events(events)
"""
capturedOutput = io.StringIO()
sys.stdout = capturedOutput
Calendar.print_events(self.events)
sys.stdout = sys.__stdout__
# Predicted output calculation
predicted_event = ""
reminder = ""
num = 1
for event in self.events:
start = event['start'].get('dateTime', event['start'].get('date'))
reminder = str(0) + " minutes before"
predicted_event += "Events: " + " " + str(
num) + " " + start + " " + event[
'summary'] + " " + "| Reminder: " + " " + reminder + "\n"
num += 1
self.assertEqual(predicted_event, capturedOutput.getvalue())
def f():
eventList=Email.run(mail,mailbox)
if eventList=="No Unread":
root.data.canvas.delete(root.data.msg)
listMailboxes2(root)
elif eventList!=[]:
createdEvents=Calendar.createEvents(service,eventList)
if createdEvents!=[]:
root.data.canvas.delete(root.data.msg)
listEvents(root,createdEvents)
else:
drawMsg(root,"No events created")
else:
root.data.canvas.delete(root.data.msg)
drawMsg(root,"No events found")
def main():
global path
if IO.exists("/home/pi/"):
path = "/home/pi/MagicMirror/data/running"
else:
path = "MagicMirror/data/running"
IO.create(path)
pg.init()
split()
if path.__contains__("pi"):
display = pg.display.set_mode((1080, 1920), FULLSCREEN)
else:
display = pg.display.set_mode((1080, 1920))
while IO.exists(path):
for event in pg.event.get():
if event.type == QUIT:
IO.delete(path)
elif event.type == KEYDOWN:
if event.key == K_MINUS:
display = pg.display.set_mode((1080, 1920), FULLSCREEN)
if event.key == K_EQUALS:
display = pg.display.set_mode((100, 100))
if event.key == K_LEFTBRACKET:
display = pg.display.set_mode((1080, 1920))
if event.key == K_RIGHTBRACKET:
IO.delete(path)
display.fill((0, 0, 0))
Calendar.draw(0, 250, 700, 700, display)
DisplayMessage.draw(0, 0, 1080, 1920, display, "Hello, Joe")
Weather.draw(700, 0, 380, 600, display)
Time.draw(0, 0, 400, 600, display)
DailyQuote.draw(0, 1920 - 200, 200, 200, display)
pg.display.update()
sleep(1)
p.join()
pg.quit()
def display_calendar(calendar_year, month):
if month == None:
return display_calendar_full(calendar_year)
else:
dater = " S M T W T F S"
YEAR = Cal.construct_cal_year(calendar_year)
out = ""
for j in range(len(YEAR[month])):
if j == 1:
out += dater + "\n"
out += YEAR[month][j] + "\n"
return out[:-1] #removes extra space
return
def test_run_calendar_past_reminders_wrong_date_input(self, mocked_input, mocked_output, api):
# Wrong date input in getting events and reminder
api.events.return_value.list.return_value.execute.return_value = {
"items": [
{
"summary": "test",
"start": {
"dateTime": "2020-10-03T02:00:00.000000Z"
},
"end": {
"dateTime": "2020-10-03T02:45:00.000000Z"
}, "reminders": {
'useDefault': False,
'overrides': [
{'method': 'email', 'minutes': 1},
{'method': 'popup', 'minutes': 10},
], },
},
]}
mocked_input.side_effect = ["past -r", "2020-100-11", "2020-10-01", "past -r", "20202-110-1", "2020-10-01",
"exit"]
Calendar.run_calendar(api)
# String printed to console if date input wrong
self.assertIn("Wrong format please try again", mocked_output.getvalue())
def addCalendarEventText(eventLabelTitleWithDay,
day,
row,
column,
actionType="add"):
currentDate = DayAssignment.translateWeekOfDate(day, getDateEntry())
eventName = Calendar.getCalendarEvents(currentDate,
checkNonMealCalendars=True,
returnEventObject=False)
if not eventName: eventName = "--"
if actionType == "add":
app.addLabel(eventLabelTitleWithDay, eventName, row=row, column=column)
app.setLabelBg(eventLabelTitleWithDay, "darkseagreen")
elif actionType == "update":
app.setLabel(eventLabelTitleWithDay, eventName)
def test_get_event_with_keyword(self):
mock_api = Mock()
mock_api.events.return_value.list.return_value.execute.return_value = {
"items": [{
"summary": "testSearch",
"id": "12345"
}, {
"summary": "testDontSeeThis",
"id": "24680"
}]
}
found_events = Calendar.get_events_with_keyword(mock_api, "Search")
self.assertIn("testSearch", found_events[0]["summary"])
self.assertNotIn("testDontSeeThis", found_events[0]["summary"])
def test_09_command_add(self):
date = '2017-03-11'
title = 'Python class'
start_time = 29
end_time = 38
calendar = {}
call = "Calendar.command_add\
('{}, {}, {}')".format(date, start_time, end_time, title,
str(calendar))
expected = False
result = Calendar.command_add(date, start_time, end_time, title,
calendar)
returned = calendar
msg = FAILURE_MESSAGE.format(call, expected, result)
self.assertEqual(expected, result, msg)
def test_reminder_deleted_default(self):
event = {
'id': "test123",
'reminders': {"useDefault": True, "overrides": []}
}
api = Mock()
api.events.return_value.update.return_value.execute.return_value = {
'id': "test123",
'reminders': {"useDefault": False, "overrides": []},
'updated': "2020-10-10T23:20:50.52Z"
}
result = Calendar.delete_reminders(api, event)
self.assertEqual(api.events.return_value.update.return_value.execute.call_count, 1)
self.assertTrue(result)
def display_calendar_full(calendar_year):
dater = " S M T W T F S"
YEAR = Cal.construct_cal_year(calendar_year)
i = 1
out = ""
while i < 13:
for j in range(len(YEAR[i])):
if j == 1:
out += dater + "\n"
out += YEAR[i][j] + "\n"
if i <12: #only print new line from Jan to Nov
out += "\n"
i+=1
return out[:-1] #removes extra spacing
def test_get_detailed_event_visibility_set_attendees_set_location_set(
self):
# This test for the events that have no visibility key aka
# default visibility
event = {
"summary":
"Debate",
"start": {
"dateTime": "2020-06-10T02:00:00.000000Z"
},
"end": {
"dateTime": "2020-06-10T02:45:00.000000Z"
},
"reminders": {
'useDefault': True,
'overrides': []
},
"status":
"confirmed",
'creator': {
'email': '*****@*****.**',
'self': True
},
'created':
'2020-10-09T04:10:47.000Z',
'visibility':
"private",
'location':
'Monash University, Wellington Rd, Clayton VIC 3800, Australia',
'attendees': [{
'email': '*****@*****.**',
'responseStatus': 'needsAction'
}, {
'email': '*****@*****.**',
'responseStatus': 'needsAction'
}],
}
detailed_event = Calendar.get_detailed_event(event)
# Assert all keys found succesfully and string containing the information is printed
self.assertIn("Visibility: private", detailed_event)
self.assertIn(
"Location: Monash University, Wellington Rd, Clayton VIC 3800, Australia",
detailed_event)
self.assertIn("Attendees: [email protected], [email protected]",
detailed_event)
def test_reminders_found_default(self):
query = "testing this string"
api = Mock()
api.events.return_value.list.return_value.execute.return_value = {
"items": [
{
"summary": query,
"reminders": {
'useDefault': True,
'overrides': [], },
},
]}
reminders = Calendar.get_searched_reminders(api, query)
self.assertEqual(api.events.return_value.list.return_value.execute.call_count, 1)
self.assertEqual(reminders, query + ",Reminder through popup 10 minutes before event starts\n")
def test_navigate_events(self):
"""
This test navigates to a certain date and sees if the correct arguments are called as per the function specifies:
Function involved: navigate_events(api, time_year: int, time_month: int, time_day: int):
"""
# Reset call count of api.events().list()
self.mock_api = MagicMock()
self.mock_api.events.return_value.list.call_count = 0
time_year = 2020
time_month = 10
time_day = 3
events = Calendar.navigate_events(self.mock_api, time_year, time_month,
time_day)
self.mock_api.events.return_value.list.return_value.execute.return_value = [
{
"id": "ABCDEFIGHIG",
"summary": "test",
"start": {
"dateTime": "2020-10-03T02:00:00+09:00"
},
"end": {
"dateTime": "2020-10-03T02:45:00+09:00"
},
"reminders": {
"useDefault": True
}
},
]
events = self.mock_api.events.return_value.list.return_value.execute.return_value
# Calculate starting_time and time_max
# Concatenate the strings to properly be fitted in the format
starting_time = str(time_year) + "-" + str(time_month) + "-" + str(
time_day) + "T00:00:00.0000" + 'Z'
time_Max = str(time_year) + "-" + str(time_month) + "-" + str(
time_day) + "T23:59:59.0000" + 'Z'
# Check if the function is called correctly:
self.assertEqual(self.mock_api.events.return_value.list.call_count, 1)
args, kwargs = self.mock_api.events.return_value.list.call_args_list[0]
self.assertEqual(kwargs['timeMax'], time_Max)
self.assertEqual(kwargs['timeMin'], starting_time)
def test_26_save_calendar(self):
calendar = {
'2019-07-18': [{
"start": 14,
"end": 15,
"title": "MAT157 Tutorial"
}, {
"start": 16,
"end": 18,
"title": "Gym"
}],
'2019-02-10': [{
"start": 17,
"end": 20,
"title": "python assignment"
}, {
"start": 19,
"end": 21,
"title": "take study break"
}, {
"start": 20,
"end": 22,
"title": "finish reading"
}]
}
expected_list = [
'2019-07-18:14-15 MAT157 Tutorial\t16-18 Gym\n',
'2019-02-10:17-20 python assignment\t19-21 take study break\t20-22 finish reading\n'
]
call = "Calendar.save_calendar\
('{}')".format(str(calendar))
result = Calendar.save_calendar(calendar)
returned_list = []
if os.path.exists("calendar.txt"):
f = open("calendar.txt")
returned_list = [x for x in f]
f.close()
expected = True
returned = True
for s in returned_list:
returned = returned and (s in expected_list)
msg = FAILURE_MESSAGE.format(call, expected_list, returned_list)
self.assertEqual(expected, returned, msg)
def test_search_events(self):
"""
This test searches an event and sees if the correct arguments are called as per the function specifies:
Function involved: search_all_events(api, time_now, key_word):
"""
mock_api = MagicMock()
search_term = MagicMock()
time_now = MagicMock()
events = Calendar.search_all_events(mock_api, time_now, search_term)
self.assertEqual(
mock_api.events.return_value.list.return_value.execute.
return_value.get.call_count, 1)
args, kwargs = mock_api.events.return_value.list.call_args_list[0]
self.assertEqual(kwargs['q'], search_term)
def test_07_command_add(self):
date = '2020-09-02'
title = 'Python Tutorial'
start_time = 9
end_time = 12
calendar = {
'2019-07-18': [{
"start": 14,
"end": 15,
"title": "MAT157 Tutorial"
}, {
"start": 16,
"end": 18,
"title": "Gym"
}]
}
call = "Calendar.command_add\
('{}, {}, {}')".format(date, start_time, end_time, title,
str(calendar))
expected = {
date: [{
"start": start_time,
"end": end_time,
"title": title
}],
'2019-07-18': [{
"start": 14,
"end": 15,
"title": "MAT157 Tutorial"
}, {
"start": 16,
"end": 18,
"title": "Gym"
}]
}
result = Calendar.command_add(date, start_time, end_time, title,
calendar)
returned = calendar
msg = FAILURE_MESSAGE.format(call, expected, returned)
self.assertEqual(expected, returned, msg)
def test_get_detailed_reminders_path3_no_reminder_set(self):
event = {
"summary": "test",
"start": {
"dateTime": "2020-10-03T02:00:00.000000Z"
},
"end": {
"dateTime": "2020-10-03T02:45:00.000000Z"
},
"reminders": {
'useDefault': False,
'overrides': [],
},
}
reminders = Calendar.get_detailed_reminders(event)
self.assertEqual(
reminders, "\n"
) # A newline is returned due to the outer for loop being executed
def test_15_command_delete(self):
calendar = {
'2020-05-19': [{
"start": 6,
"end": 8,
"title": "wake up for school"
}],
'2019-07-18': [{
"start": 14,
"end": 15,
"title": "MAT157 Tutorial"
}, {
"start": 16,
"end": 18,
"title": "Gym"
}]
}
expected = {
'2020-05-19': [{
"start": 6,
"end": 8,
"title": "wake up for school"
}],
'2019-07-18': [{
"start": 14,
"end": 15,
"title": "MAT157 Tutorial"
}, {
"start": 16,
"end": 18,
"title": "Gym"
}]
}
date = '2020-05-19'
entry = 7
call = "Calendar.command_delete\
('{}, {}, {}')".format(date, entry, str(calendar))
result = Calendar.command_delete(date, entry, calendar)
returned = calendar
msg = FAILURE_MESSAGE.format(call, expected, returned)
self.assertEqual(expected, returned, msg)
def test_navigate_calendar_path4_month_30days(self, api):
#navigate through a month of 30 days
date = datetime.strptime('Jun 10 2020 1:30AM', '%b %d %Y %I:%M%p')
navigation_type = "MONTH"
api.events.return_value.list.return_value.execute.return_value = {
"items": [
{
"summary": "test",
"start": {
"dateTime": "2020-06-10T02:00:00.000000Z"
},
"end": {
"dateTime": "2020-06-11T02:45:00.000000Z"
},
"reminders": {
'useDefault': True,
'overrides': []
},
},
{
"summary": "Birthday Party",
"start": {
"dateTime": "2020-06-30T02:00:00.000000Z"
},
"end": {
"dateTime": "2020-06-30T02:45:00.000000Z"
},
"reminders": {
'useDefault': True,
'overrides': []
},
},
]
}
result = Calendar.navigate_calendar(api, date, navigation_type)
self.assertEqual(
api.events.return_value.list.return_value.execute.call_count,
2) # Mock method called twice
# First in getting events, second in getting reminders
self.assertIn("test", result) # Assert title in result
self.assertIn("Birthday Party", result) # Assert title in result
self.assertIn("popup 10", result) # Assert reminder in result
def test_get_upcoming_events_number(self):
"""
This test gets upcoming events up to 10 and check if the number of events returned is the same set.
Also, to check if argument of timeMin is five years from now.
"""
mock_api = MagicMock()
num_events = 10
time = datetime.datetime.utcnow()
events = Calendar.get_all_events(mock_api, time)
self.assertEqual(
mock_api.events.return_value.list.return_value.execute.
return_value.get.call_count, 1)
args, kwargs = mock_api.events.return_value.list.call_args_list[0]
self.assertEqual(kwargs['maxResults'], num_events)
# Check if the timeMax is 2 years from now and timeMin is 5 years ago
self.assertEqual(kwargs['timeMin'],
time.replace(time.year - 5).isoformat() + 'Z')
self.assertEqual(kwargs['timeMax'],
time.replace(time.year + 2).isoformat() + 'Z')
def test_get_selected_reminders_key_error(self, mocked_input,mocked_output):
mocked_input.side_effect = ["25"]
event = {
"summary": "test1",
"start": {
"dateTime": "2020-10-03T02:00:00.000000Z"
},
"end": {
"dateTime": "2020-10-03T02:45:00.000000Z"
}, "reminders": {
'useDefault': False,
'overrides': [
{'method': 'email', 'minutes': 1},
{'method': 'popup', 'minutes': 10},
]}
}
userselect = Calendar.get_selected_reminders(event)
self.assertIsNone(userselect)
self.assertNotIn("Selected reminder:", mocked_output.getvalue())
def test_get_selected_reminders_default(self, mocked_input):
mocked_input.side_effect = ["1"]
event = {
"summary": "test1",
"start": {
"dateTime": "2020-10-03T02:00:00.000000Z"
},
"end": {
"dateTime": "2020-10-03T02:45:00.000000Z"
}, "reminders": {
'useDefault': True,
'overrides': [
{'method': 'email', 'minutes': 1},
{'method': 'popup', 'minutes': 10},
]}
}
userselect = Calendar.get_selected_reminders(event)
self.assertIsNotNone(userselect)
self.assertEqual(-1, userselect)
def test_get_upcoming_events_non_empty_events(self, api):
#This test is to test getting upcoming events but for non empty events(for loop is executed) """
ex_time = "2020-10-03T00:00:00.000000Z"
api.events.return_value.list.return_value.execute.return_value = {
"items": [
{
"summary": "test",
"start": {
"dateTime": "2020-10-03T02:00:00.000000Z"
},
"end": {
"dateTime": "2020-10-03T02:45:00.000000Z"
},
},
]
}
upcoming_events = Calendar.get_upcoming_events(api, ex_time)
self.assertEqual(
api.events.return_value.list.return_value.execute.call_count, 1)
self.assertEqual(upcoming_events, "test,2020-10-03T02:00:00.000000Z\n")
def test_get_detailed_reminders_path4_default_reminder(self):
# Path 5 where if statement to check date validity succeeds, outer for loop is executed, and if
# branch is executed which is default reminders
event = {
"summary": "test",
"start": {
"dateTime": "2020-10-03T02:00:00.000000Z"
},
"end": {
"dateTime": "2020-10-03T02:45:00.000000Z"
},
"reminders": {
'useDefault': True,
'overrides': [],
},
}
reminders = Calendar.get_detailed_reminders(event)
self.assertEqual(
reminders,
"test,Reminder through popup 10 minutes before event starts\n")
def test_11_command_show(self):
calendar = {
'2019-07-18': [{
"start": 14,
"end": 15,
"title": "MAT157 Tutorial"
}, {
"start": 16,
"end": 18,
"title": "Gym"
}]
}
expected = "\n2019-07-18 : \n start : 14:00,\n end : 15:00,\n title : MAT157 Tutorial\n\n start : 16:00,\n end : 18:00,\n title : Gym"
call = "Calendar.command_show\
('{}')".format(str(calendar))
returned = Calendar.command_show(calendar)
msg = FAILURE_MESSAGE.format(call, expected, returned)
self.assertEqual(expected, returned, msg)
def checkEmailCalendar(root):
account=root.data.account.get()
password=root.data.password.get()
if account=="" or password=="":
drawErrMsg(root,"Please enter your account and password")
else:
check=Email.checkAccount(account,password)
if check==None:
drawErrMsg(root,"Wrong account or password!")
else:
try:
service=Calendar.checkAccount(account)
if service!=None:
root.data.service=service
root.data.mail,root.data.mailboxes=check
removeAll(root.data.initFrame)
listMailboxes(root)
else:
drawErrMsg(root,"Cannot connect to the calendar")
except:
drawErrMsg(root,"Unable to find Google server")
def body(self, master):
v = IntVar()
if self.isPresent:
v.set(1)
else:
v.set(2)
if not self.isAdding:
nameLabel = Label(self, text="Status " + self.student + " on " + self.date)
nameLabel.pack()
else:
nameLabel = Label(self, text="Please select a date and a status below")
nameLabel.pack()
calendar_frame = Frame(self)
editButton = Button(calendar_frame, pady=10, text="Edit Day", command=self.setStudentCalendar)
editButton.pack(side=TOP)
self.theCalendar = Calendar.newCalendar(calendar_frame, True)
calendar_frame.pack(side=TOP)
CLASSES = [
("Present",1),
("Absent",2),
]
def ShowChoice():
if v.get() == 1:
self.status = "Present"
elif v.get() == 2:
self.status = "Absent"
for txt, val in CLASSES:
Radiobutton(master, text=txt, padx = 20, variable=v, command=ShowChoice, value=val).pack(anchor=W)
return
def test_calendar(self):
cal = Calendar()
self.assertEqual(0, cal.get_date())
cal.advance()
self.assertEqual(1, cal.get_date())
def setStudentCalendar(self):
Calendar.delete_active_canvas(self.theCalendar)
Calendar.buildEditCalendar(self.theCalendar, self.date, self.daysPresent, self.daysAbsent)
def clearStudentCalendar(self):
Calendar.delete_active_canvas(self.theCalendar)
def initUI(self, students):
note=Notebook(self.parent)
#Tabs
external_tab = Frame(note)
records_tab = Frame(note)
edit_tab = Frame(note)
note.config()
note.add(external_tab, text = "Attendance")
note.add(records_tab, text=" Records ")
note.add(edit_tab, text=" Edit ")
#Create the scrollable list on the left side
scrollbar = tk.Scrollbar(external_tab, orient="vertical")
lb = tk.Listbox(external_tab, selectmode=MULTIPLE, width=30, height=20, yscrollcommand=scrollbar.set)
scrollbar.config(command=lb.yview)
scrollbar.pack(side="left", fill="y")
lb.pack(side="left",fill="y")
self.setList(students, lb)
#Add dialogue box for new student
frame1 = Frame(external_tab, relief=GROOVE, borderwidth=0)
info_frame2 = Frame(records_tab, relief=GROOVE, borderwidth=3)
name = tk.Entry(frame1)
name.pack(anchor=CENTER, side=BOTTOM)
frame1.pack(fill=BOTH, expand=1)
self.pack(fill=BOTH, expand=1)
#Add the buttons on the right to manipulate the list
frame = Frame(external_tab, relief=RAISED, borderwidth=0)
addButton = Button(frame, text="Add Student", command= lambda : self.addStudent(name.get(), lb, lb2, lb3))
addButton.pack()
deleteButton = Button(frame, text="Remove Student", command= lambda : self.deleteStudent(lb.curselection(), lb, lb2, lb3))
deleteButton.pack(anchor=E, pady=20, side=RIGHT)
frame.pack()
markCalendarFrame = Frame(external_tab)
self.markCalendar = Calendar.newCalendar(markCalendarFrame, True)
markCalendarFrame.pack()
#Add the reset button and the mark absent button
frame2 = Frame(external_tab, relief=RAISED, borderwidth=0)
absentButton = Button(frame2, text="Mark as Absent", command= lambda: self.markAbsent(lb.curselection()))
absentButton.pack(side=TOP, pady=20)
resetButton = Button(frame2, text="Reset Today's Attendance", command=self.resetDay)
resetButton.pack(side=TOP, pady=20)
frame2.pack(fill=BOTH, expand=1)
self.pack(fill=BOTH, expand=1)
#Create the Records Listbox
scrollbar2 = tk.Scrollbar(records_tab, orient="vertical")
lb2 = tk.Listbox(records_tab, selectmode=BROWSE, width=30, height=20, yscrollcommand=scrollbar2.set)
scrollbar2.config(command=lb2.yview)
scrollbar2.pack(side="left", fill="y")
#Bind a click to finding attendance
lb2.bind('<<ListboxSelect>>', self.getTotals)
lb2.pack(side="left",fill="y")
self.setList(students, lb2)
#Create the text that updates in real time based on selection
self.present_variable.set('')
self.absent_variable.set('')
info_frame = Frame(records_tab, relief=GROOVE, borderwidth=3)
present_setup = tk.Message(records_tab, anchor=W, justify=CENTER, width=100, text="Days Present: ")
present_setup.pack(fill=X, side=TOP)
present_message = tk.Message(records_tab, anchor=E, justify=CENTER, width=100, textvariable= self.present_variable)
present_message.pack(fill=X, side=TOP)
info_frame.pack(side=TOP)
absent_setup = tk.Message(records_tab, anchor=W, justify=CENTER, width=100, text="Days Absent: ")
absent_setup.pack(fill=X, side=TOP)
absent_variable = tk.Message(records_tab, anchor=E, justify=CENTER, width=100, textvariable= self.absent_variable)
absent_variable.pack(fill=X, side=TOP)
info_frame2.pack(side=TOP)
#Create a see Calendar Button
# calendarButton = Button(records_tab, text="See Specific Days", command= lambda : self.setStudentCalendar(lb2.curselection()))
# calendarButton.pack(side=TOP)
calendar_frame = Frame(records_tab, relief=GROOVE, borderwidth=3, width = 300)
self.theCalendar = Calendar.newCalendar(calendar_frame, False)
calendar_frame.pack(side=TOP, pady = 20)
clearCalendarButton = Button(records_tab, text="Clear Calendar", command=self.clearStudentCalendar)
clearCalendarButton.pack(side=TOP)
# close and excel buttons
bottomFrame = Frame(width=20)
excelButton = Button(bottomFrame, text="Generate Excel", command=self.generateExcel)
excelButton.pack(side=LEFT, padx=5, pady=5)
closeButton = Button(bottomFrame, text="Close", command=self.closeButton)
closeButton.pack(side=RIGHT, padx=10, pady=5)
bottomFrame.pack(side=BOTTOM)
scrollbar3 = tk.Scrollbar(edit_tab, orient="vertical")
lb3 = tk.Listbox(edit_tab, selectmode=BROWSE, width=30, height=20, yscrollcommand=scrollbar3.set)
scrollbar3.config(command=lb3.yview)
scrollbar3.pack(side="left", fill="y")
lb3.bind('<<ListboxSelect>>', self.get_dates)
lb3.pack(side="left",fill="y")
self.setList(students, lb3)
addFrame = Frame(edit_tab)
remove_date = Button(addFrame, text="Remove Date", command= lambda : self.remove_date(self.lbedit.curselection(), self.lbedit2.curselection(), True))
remove_date.pack(side=TOP, pady=2)
add_dates = Button(addFrame, text="Add Date", command= lambda : self.add_date(lb3.curselection()))
add_dates.pack(side=LEFT, pady=2)
edit_selection = Button(addFrame, text="Edit Date", command= lambda : self.edit_date(self.lbedit.curselection(), self.lbedit2.curselection()))
edit_selection.pack(side=LEFT, pady=2)
addFrame.pack(side=TOP)
dateFrame = Frame(edit_tab)
presentLabel = Label(dateFrame, text="Present")
presentLabel.pack(side=TOP)
scrollbar4 = tk.Scrollbar(dateFrame, orient="vertical")
self.lbedit = tk.Listbox(dateFrame, selectmode=BROWSE, width=29, height=9, yscrollcommand=scrollbar4.set)
self.lbedit.pack(side=TOP)
absentLabel = Label(dateFrame, text="Absent")
absentLabel.pack(side=TOP)
scrollbar5 = tk.Scrollbar(dateFrame, orient="vertical")
self.lbedit2 = tk.Listbox(dateFrame, selectmode=BROWSE, width=29, height=8, yscrollcommand=scrollbar5.set)
self.lbedit2.pack(side=TOP, fill="y")
dateFrame.pack(side=LEFT, fill="y")
self.pack(fill=BOTH, expand=1)
note.pack(fill=BOTH, expand=1)
