def create_report_and_update_filename(self, event=None):
try:
MIS_Database_Functions.generate_csv_report()
self.filename = (
str(os.getcwd())
+ "\\Reports\\"
+ MIS_Database_Functions.get_most_recent_event_date()
+ "_Attendance_Report.csv"
)
self.feedback_label.config(style="SuccessLabel.TLabel")
self.feedback_label["text"] = "Report File Created Successfully.\nReview for accuracy."
except PermissionError:
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label["text"] = (
"There is an issue with file permissions.\n"
"Make sure the file is not open.\n"
"If the problem persistsContact the Tech Director."
)
except OSError:
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label["text"] = (
"There was an issue with the operating system call.\n" "Try again or contact the Technical Director."
)
except TypeError:
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label["text"] = (
"The file was not created, likely because there was\n" "no data to put into the report."
)
def create_event(self):
company_to_create = self.create_event_company.get()
topic_to_create = self.create_event_topic.get()
date_to_create = self.create_event_date.get()
try:
MIS_Database_Functions.create_event(company_to_create, topic_to_create, date_to_create)
except IOError as e: # Temporary solution
print(str(e))
except Exception as e:
print(str(e))
finally:
self.create_event_company.delete(0, len(company_to_create))
self.create_event_topic.delete(0, len(topic_to_create))
self.create_event_date.delete(0, len(date_to_create))
def get_event_log_file(eventID=None):
"""
This function selects data from the database and uses it to construct a file path and name.
:return: The string value representing the directory path to the log file
"""
working_directory = os.getcwd()
working_directory += "\\Logs\\EventLogs\\"
connection = MIS_Database_Functions.get_connection()
cursor = connection.cursor()
cursor.execute("SELECT semester_tag FROM Semester WHERE semester_num = (SELECT MAX(semester_num) FROM Semester)")
file_name = cursor.fetchone()[0]
if eventID is None:
cursor.execute("SELECT MAX(eventID) FROM Event")
else:
cursor.execute("SELECT eventID FROM Event WHERE eventID = %d" % eventID)
event_id = cursor.fetchone()[0]
cursor.execute("SELECT company FROM Event WHERE (eventID = \'" + str(event_id) + "\')")
company_name = cursor.fetchone()[0]
file_name += "_ID" + str(event_id) + "_" + company_name
file_name = file_name.replace(" ", "_")
log_file = working_directory + file_name
return log_file
def populate_event_label(self):
semester_tag = MIS_Database_Functions.get_most_recent_semester_tag()
if semester_tag is None: # Failure State
self.current_label.config(style="ErrorLabel.TLabel")
self.current_label['text'] = 'No semester created yet!\n' \
'Create one first, then\n' \
'restart this system. :)'
return
event_id = MIS_Database_Functions.get_most_recent_event_id()
if event_id is not None:
event_data = MIS_Database_Functions.get_event_data(event_id)
self.current_label['text'] = 'Newest Event:\n%s' % (event_data['company'])
else:
self.feedback_label.config(style="ErrorLabel.TLabel")
self.current_label['text'] = 'No event yet.\nCreate one here.'
def get_data(self):
self.member_netID_to_create = self.create_netID_entry.get()
self.member_major_to_create = self.create_major_entry.get()
self.member_classification_to_create = self.create_classification_entry.get()
self.member_name_to_create = self.create_name_entry.get()
select_sql_string = "SELECT * FROM Member WHERE netID='"+self.member_netID_to_create+"'"
connection = MIS_Database_Functions.get_connection()
cursor = connection.cursor()
cursor.execute(select_sql_string)
member_data = cursor.fetchone()
if member_data is None:
raw_html = Info_IaState_Scraper.get_raw_html(self.member_netID_to_create)
parsed_data = Info_IaState_Scraper.parse_student_data(raw_html)
self.create_classification_entry.insert(0, parsed_data['classification'])
self.create_major_entry.insert(0, parsed_data['major'])
if 'Individual Search Results' not in parsed_data['name']:
self.create_name_entry.insert(0, parsed_data['name'])
self.trial_checkbox.select()
else:
self.create_classification_entry.insert(0, member_data[3])
self.create_major_entry.insert(0, member_data[2])
self.create_name_entry.insert(0, member_data[4])
if member_data[5] == 2:
self.two_semesters_checkbox.select()
elif member_data[5] == 1:
self.one_semester_checkbox.select()
else:
for i in range(4):
self.trial_checkbox.flash()
self.one_semester_checkbox.flash()
self.two_semesters_checkbox.flash()
def set_focus(self):
# Populate information in the currency labels
event_id = MIS_Database_Functions.get_most_recent_event_id()
if event_id is not None:
data = MIS_Database_Functions.get_event_data(event_id)
self.currency_label['text'] = "Current Check In:\n%s" % data['company']
else:
self.currency_label['text'] = "Not ready to check in yet.\nPlease create an event."
self.currency_label.config(style='ErrorLabel.TLabel')
# Set the tab indexes
tab_order_tuple = (self.net_id_entry, self.get_data_button, self.submit_data_button, self.clear_all_button,
self.verify_button)
for widget in tab_order_tuple:
widget.lift()
tab_order_tuple[0].focus()
def check_in_member(self):
self.member_netID_to_create = self.create_netID_entry.get()
self.member_major_to_create = self.create_major_entry.get()
self.member_classification_to_create = self.create_classification_entry.get()
self.member_name_to_create = self.create_name_entry.get()
if self.member_netID_to_create is None:
return
if self.trial == 0 and self.one_semester == 0 and self.two_semesters == 0:
return
select_sql_string = "SELECT * FROM Member WHERE netID='"+self.member_netID_to_create+"'"
connection = MIS_Database_Functions.get_connection()
cursor = connection.cursor()
cursor.execute(select_sql_string)
member_data = cursor.fetchone()
cursor.execute("SELECT eventID FROM event WHERE eventID=(SELECT MAX(eventID) FROM event)")
event_id = cursor.fetchone()
if member_data is None:
# Create the new member in the DB
insert_sql_string = "INSERT INTO Member VALUES('"+str(self.member_netID_to_create)+"', '" + \
str(self.member_netID_to_create) + "@iastate.edu', '"\
+ str(self.member_major_to_create) + \
"', '"+str(self.member_classification_to_create)+"', '"\
+ str(self.member_name_to_create)+"', "
if self.trial.get() == 1:
insert_sql_string += "0)"
elif self.one_semester.get() == 1:
insert_sql_string += "1)"
elif self.two_semesters.get() == 1:
insert_sql_string += "2)"
else:
raise Exception("No Check box Marked")
cursor.execute(insert_sql_string)
create_ticket_sql_string = "INSERT INTO Ticket VALUES("+str(event_id[0])+", '" + \
self.member_netID_to_create+"')"
print(create_ticket_sql_string)
try:
cursor.execute(create_ticket_sql_string)
self.notification['text'] = "Welcome to the Event "+self.member_name_to_create+"!"
except IOError as e:
self.notification['text'] = "Error "+str(e)
print(str(e))
except Exception as e:
if "UNIQUE" in str(e):
self.notification['text'] = "Seems you are already checked in. Welcome!"
else:
self.notification['text'] = "Error "+str(e)
print(str(e))
finally:
connection.commit()
self.notification.pack()
self.create_major_entry.delete(0, len(self.member_major_to_create))
self.create_classification_entry.delete(0, len(self.member_classification_to_create))
self.create_name_entry.delete(0, len(self.member_name_to_create))
self.create_netID_entry.delete(0, len(self.member_netID_to_create))
self.trial_checkbox.deselect()
self.one_semester_checkbox.deselect()
self.two_semesters_checkbox.deselect()
def run_end_of_semester(self, event=None):
verification_code = self.verification_entry.get()
if verification_code.lower() != "mis exec":
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = 'Please remember to enter the verification code.\n' \
'This is to prevent accidental end of semester updates.\n' \
'The verification code is <<mis exec>> without the << >>.'
else:
try:
MIS_Database_Functions.run_end_of_semester()
self.feedback_label.config(style="SuccessLabel.TLabel")
self.feedback_label['text'] = 'End of Semester Transaction was run.\n' \
'Please see the logs for more detailed information.'
except sqlite3.DatabaseError:
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = 'There has been an issue with the database.\n' \
'Please try again or consult the technical director.'
except IOError:
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = 'There has been an IO error.\n' \
'Please try again or consult the technical director.'
def create_event(self, event=None):
event_date = self.event_date_entry.get().strip()
company_name = self.company_name_entry.get().strip()
event_topic = self.event_topic_entry.get().strip()
if event_date == '' or company_name == '' or event_topic == '':
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = "Please provide at least some\nvalue for each field."
return
if len(event_date) != 11 or event_date[2] != '/' or event_date[6] != '/':
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = "Provide dates in format DD/MMM/YYYY\nExample: 12/AUG/2015"
return
semester_tag = MIS_Database_Functions.get_most_recent_semester_tag()
month = event_date[3:6]
if semester_tag[0] == 'F' and month not in fall_months:
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = "Check date.\nMonth is incorrect for current semester." \
"\nYou may have forgotten to create a new semester."
return
elif semester_tag[0] == 'S' and month not in spring_months:
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = "Check date.\nMonth is incorrect for current semester." \
"\nYou may have forgotten to create a new semester."
return
results = MIS_Database_Functions.create_event(company_name, event_topic, event_date)
if results[0]: # Success state
self.feedback_label.config(style="SuccessLabel.TLabel")
self.feedback_label['text'] = "The new event was added.\n Event ID: %s\n" \
"Restart the system before checking in." % str(results[1])
else: # Failure state
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = "An error occurred:\n" + str(results[1])
self.company_name_entry.delete(START, len(company_name))
self.event_date_entry.delete(START, len(event_date))
self.event_topic_entry.delete(START, len(event_topic))
self.populate_event_label()
self.set_focus()
def gather_data(self):
#TODO: Alias MIS_Database_Functions, these lines are way to long
prev_event_aggregates = MIS_Database_Functions.get_event_aggregates(
MIS_Database_Functions.get_most_recent_event_id()) # Event that just happened
curr_event_aggregates = MIS_Database_Functions.get_event_aggregates(
MIS_Database_Functions.get_most_recent_event_id()-1) # Event before that
prev_event_classifications = MIS_Database_Functions.get_event_classification_aggregates(
MIS_Database_Functions.get_most_recent_event_id())
curr_event_classifications = MIS_Database_Functions.get_event_classification_aggregates(
MIS_Database_Functions.get_most_recent_event_id()-1)
self.target_major = MIS_Database_Functions.select_config_info('target_major')
for aggregate in prev_event_aggregates:
self.prev_event_data[aggregate] = prev_event_aggregates[aggregate]
for aggregate in curr_event_aggregates:
self.curr_event_data[aggregate] = curr_event_aggregates[aggregate]
for classification in prev_event_classifications:
self.prev_event_data['classification'][classification] = prev_event_classifications[classification]
for classification in curr_event_classifications:
self.curr_event_data['classification'][classification] = curr_event_classifications[classification]
return True
def __init__(self, parent, controller):
ttk.Frame.__init__(self, parent)
##############################################################
# SIDE FRAME #
##############################################################
self.logo_border = ttk.Label(self, border=border_default, relief=relief_default, takefocus=False)
self.logo_border.grid(row=0, column=0, rowspan=4, columnspan=3, sticky="nsew")
self.logo_label = ttk.Label(self, image=controller.image, takefocus=False)
self.logo_label.image = controller.image
self.logo_label.grid(row=0, column=0, rowspan=4, columnspan=3)
self.side_frame = ttk.Label(self, border=border_default, relief=relief_default, takefocus=False)
self.side_frame.grid(row=4, column=0, rowspan=6, columnspan=3, sticky="nsew")
self.frame_title = ttk.Label(self, text="SEMESTER CREATION", font=Superhead, takefocus=False)
self.frame_title.grid(row=4, column=0, columnspan=3, rowspan=1)
current_sem_tag = MIS_Database_Functions.get_most_recent_semester_tag()
if current_sem_tag is not None:
self.currency_label = ttk.Label(self, text="Current Semester: %s" % current_sem_tag, font=Head)
else:
self.currency_label = ttk.Label(self, text="No Semester Created!\n"
"Create one then restart\n"
"this system.", font=Head)
self.currency_label.config(style="ErrorLabel.TLabel")
self.currency_label.grid(row=5, column=0, columnspan=3, rowspan=2)
self.instructions = ttk.Label(self, text="At the beginning of each semester\n"
"come here and create a new entry \n"
"for the database. This is needed \n"
"for data verification, and makes \n"
"aggregating much easier.")
self.instructions.grid(row=7, column=0, columnspan=3, rowspan=3, sticky="nw", padx=(10, 10))
self.content_border_label = ttk.Label(self, border=border_default, relief=relief_default)
self.content_border_label.grid(row=0, column=3, sticky="nsew", rowspan=7, columnspan=7)
#############################################################
# MAIN CONTENTS #
#############################################################
self.big_label = ttk.Label(self, text="NEW SEMESTER DATES", font=Head)
self.big_label.grid(row=0, column=5, columnspan=3)
self.semester_start_label = ttk.Label(self, text="Semester Start:", font=Subhead)
self.semester_start_label.grid(row=1, column=3, columnspan=2, sticky="n")
self.semester_start_entry = ttk.Entry(self)
self.semester_start_entry.grid(row=1, column=5, sticky="new", columnspan=2)
self.semester_end_label = ttk.Label(self, text="End of Semester:", font=Subhead)
self.semester_end_label.grid(row=1, column=3, columnspan=2, sticky="s")
self.semester_end_entry = ttk.Entry(self)
self.semester_end_entry.grid(row=1, column=5, sticky="sew", columnspan=2)
self.feedback_label_border = ttk.Label(self, border=border_default, relief=relief_default)
self.feedback_label_border.grid(row=7, column=3, rowspan=3, columnspan=7, sticky="nsew")
self.feedback_label = ttk.Label(self, text="Awaiting new semester entry.",
font=Subhead)
self.feedback_label.grid(row=7, column=3, rowspan=3, columnspan=7, pady=(5, 5), padx=(5, 5))
self.semester_submitter_button = ttk.Button(self, text="Submit Semester",
command=lambda: self.create_semester(),
style="DataSubmitter.TButton")
self.semester_submitter_button.bind("<Return>", lambda e: self.create_semester())
self.semester_submitter_button.grid(row=3, column=5, sticky="ew", columnspan=2)
# This code only matters for systems whose databases do not have any semesters in them
if current_sem_tag is None:
self.semester_tag_label = ttk.Label(self, text="Semester Tag:", font=Subhead)
self.semester_tag_label.grid(row=2, column=3, sticky="n", columnspan=2, pady=(10, 0))
self.semester_tag_entry = ttk.Entry(self)
self.semester_tag_entry.grid(row=2, column=5, sticky="new", columnspan=2, pady=(10, 0))
self.feedback_label['text'] = 'Only for this semester you will need\n' \
'to provide a semester tag in the format\n' \
'F## where F is either F or S (fall or\n ' \
'spring), and ## is the year. In the \n' \
'future this will be automatic.'
self.semester_submitter_button.bind("<Return>", lambda e: self.create_semester(
semester_tag=self.semester_tag_entry.get()))
self.semester_submitter_button.config(command=lambda: self.create_semester(
semester_tag=self.semester_tag_entry.get()))
def create_semester(self, event=None, semester_tag=None):
start = self.semester_start_entry.get().strip()
end = self.semester_end_entry.get().strip()
if len(start) != 11 or len(end) != 11 or start[2] != '/' or end[2] != '/':
self.feedback_label.config(style='ErrorLabel.TLabel')
self.feedback_label['text'] = "Please enter dates in the format:\n" \
"DD/MMM/YYYY.\n" \
"Example: 12/AUG/2015"
return # Failure state
# Normal Semester Creation with automated Semester Tag generation
if not hasattr(self, 'semester_tag_entry'):
start_month = start[3:6]
end_month = end[3:6]
previous_semester_tag = MIS_Database_Functions.get_most_recent_semester_tag()
try:
previous_semester_tag_year = int(previous_semester_tag[1:])
except ValueError:
self.feedback_label.config(style='ErrorLabel.TLabel')
self.feedback_label['text'] = "The previous semester's tag is incorrect.\n" \
"Have the technical director correct this issue before proceeding."
return
if previous_semester_tag[0] == 'F':
new_semester_tag_year = previous_semester_tag_year + 1
new_semester_tag = 'S'
else:
new_semester_tag = 'F'
new_semester_tag_year = previous_semester_tag_year
new_semester_tag += str(new_semester_tag_year)
# Checks to make sure the start and end dates are in the right months for the new Semester
if start_month not in months or end_month not in months:
self.feedback_label.config(style='ErrorLabel.TLabel')
self.feedback_label['text'] = "The month in at least one of the dates\n" \
"is not correct for semester %s." % new_semester_tag
if new_semester_tag[0] == 'F' and (start_month not in fall_months or end_month not in fall_months):
self.feedback_label.config(style='ErrorLabel.TLabel')
self.feedback_label['text'] = "The month in at least one of the dates\n" \
"is not correct for semester %s." % new_semester_tag
return
if new_semester_tag[0] == 'S' and (start_month not in spring_months or end_month not in spring_months):
self.feedback_label.config(style='ErrorLabel.TLabel')
self.feedback_label['text'] = "The month in at least one of the dates\n" \
"is not correct for semester %s." % new_semester_tag
return
start_year = int(start[9:])
end_year = int(end[9:])
if start_year != new_semester_tag_year or end_year != new_semester_tag_year:
self.feedback_label.config(style='ErrorLabel.TLabel')
self.feedback_label['text'] = 'Incorrect year. It should be \'%s' \
% str(new_semester_tag_year)
return
self.feedback_label.config(style="SuccessLabel.TLabel")
self.feedback_label['text'] = "Semester created successfully.\n" \
" You are ready to create events and check in members."
MIS_Database_Functions.create_semester(new_semester_tag, start, end)
self.semester_end_entry.delete(0, len(self.semester_end_entry.get()))
self.semester_start_entry.delete(0, len(self.semester_start_entry.get()))
# Semester Creation from the blank slate
else:
MIS_Database_Functions.create_semester(semester_tag, start, end)
self.feedback_label.config(style="SuccessLabel.TLabel")
self.feedback_label['text'] = "Semester created successfully.\n" \
"You are ready to create events."
def __init__(self, parent, controller):
ttk.Frame.__init__(self, parent)
event_date = MIS_Database_Functions.get_most_recent_event_date()
if event_date is not None:
self.filename = str(os.getcwd()) + "\\Reports\\" + event_date + "_Attendance_Report.csv"
else:
self.filename = ""
#####################################################
# SIDE FRAME #
#####################################################
self.logo_border = ttk.Label(self, border=border_default, relief=relief_default, takefocus=False)
self.logo_border.grid(row=0, column=0, rowspan=4, columnspan=3, sticky="nsew")
self.logo_label = ttk.Label(self, image=controller.image, takefocus=False)
self.logo_label.image = controller.image
self.logo_label.grid(row=0, column=0, rowspan=4, columnspan=3)
self.side_frame = ttk.Label(self, border=border_default, relief=relief_default, takefocus=False)
self.side_frame.grid(row=4, column=0, rowspan=6, columnspan=3, sticky="nsew")
self.frame_title = ttk.Label(self, text="REPORTS", font=Superhead, takefocus=False)
self.frame_title.grid(row=4, column=0, columnspan=3, rowspan=1)
self.file_label = ttk.Label(self, text="Data Administration", font=Head)
self.file_label.grid(row=5, column=0, columnspan=3, rowspan=2)
self.instructions = ttk.Label(
self,
text="Use the buttons to manage reports.\n\n"
"1) Create the report.\n"
"2) Review it with Excel.\n"
"3) Email it",
)
self.instructions.grid(row=7, column=0, columnspan=3, rowspan=3, sticky="nw", padx=(10, 10))
#####################################################
# MAIN CONTENTS #
#####################################################
self.content_border_label = ttk.Label(self, border=border_default, relief=relief_default, takefocus=False)
self.content_border_label.grid(row=0, column=3, sticky="nsew", rowspan=7, columnspan=7)
self.generate_label = ttk.Label(self, text="REPORT GENERATION", font=Head, takefocus=False)
self.generate_label.grid(row=0, column=5, columnspan=3, sticky="n", pady=(10, 0))
self.generate_report_button = ttk.Button(
self,
text="CREATE REPORT",
command=lambda: self.create_report_and_update_filename(),
style="DataSubmitter.TButton",
)
self.generate_report_button.bind("<Return>", lambda e: self.create_report_and_update_filename())
self.generate_report_button.grid(row=0, column=5, columnspan=3, sticky="sew")
self.review_label = ttk.Label(self, text="REVIEW REPORTS", font=Head, takefocus=False)
self.review_label.grid(row=2, column=5, columnspan=3, sticky="n", pady=(10, 0))
self.review_button = ttk.Button(
self, text="REVIEW", command=lambda: self.review_report(), style="DataGetter.TButton"
)
self.review_button.bind("<Return>", lambda e: self.review_report())
self.review_button.grid(row=2, column=5, columnspan=3, sticky="sew")
self.email_label = ttk.Label(self, text="EMAIL REPORTS", font=Head, takefocus=False)
self.email_label.grid(row=4, column=5, columnspan=3, sticky="n", pady=(10, 0))
self.email_button = ttk.Button(
self, text="EMAIL", command=lambda: self.email_report(), style="DataSubmitter.TButton"
)
self.email_button.bind("<Return>", lambda e: self.email_report())
self.email_button.grid(row=4, column=5, columnspan=3, sticky="sew")
self.feedback_label_border = ttk.Label(self, border=border_default, relief=relief_default, takefocus=False)
self.feedback_label_border.grid(row=7, column=3, rowspan=3, columnspan=7, sticky="nsew")
self.feedback_label = ttk.Label(
self,
text="Use the buttons above to\n"
"generate, open, and email reports.\n"
"Please note you can also find these\n"
"CSV files in the Reports directory.",
font=Subhead,
takefocus=False,
)
self.feedback_label.grid(row=7, column=3, rowspan=3, columnspan=7, pady=(5, 5), padx=(5, 5))
def __init__(self):
tk.Tk.__init__(self)
#tk.Tk.iconbitmap(self, default="Images/mis_logo.ico") ==> this was making Linux cry,
# if you can get it to work go ahead
tk.Tk.wm_title(self, "Club Check In")
image_location = MIS_Database_Functions.select_config_info('logo_location')
self.image = PhotoImage(file=image_location)
# This container will contain all the other frames.
container = ttk.Frame(self)
container.pack(expand=True, fill="both")
container.grid_rowconfigure(0, weight=1)
container.grid_columnconfigure(0, weight=1)
self.container = container
# Menu bar => contains the drop down menus
menu_bar = tk.Menu(container, font=Body)
# Other menu variables are the actual content of the drop down menus
# Check in menu contains the systems primary functions (i.e. event creation and checking in members)
check_in_menu = tk.Menu(menu_bar, tearoff=0, font=Body)
check_in_menu.add_command(label="Home", command=lambda: self.show_frame(StartPageAlt))
check_in_menu.add_separator()
check_in_menu.add_command(label="Check In Members", command=lambda: self.show_frame(CheckInFrameAlt))
check_in_menu.add_separator()
check_in_menu.add_command(label="Create An Event", command=lambda: self.show_frame(CreateEventFrameAlt))
check_in_menu.add_separator()
check_in_menu.add_command(label="Quit", command=quit)
check_in_menu.add_separator()
menu_bar.add_cascade(menu=check_in_menu, label="Main")
# Data menu contains functions for viewing data and sending it to those who need it.
data_menu = tk.Menu(menu_bar, tearoff=0, font=Body)
data_menu.add_command(label="Generate Report", command=lambda: self.show_frame(ReportGeneratorFrameAlt))
data_menu.add_separator()
data_menu.add_command(label="Analysis", command=lambda: self.show_frame(AnalyzeFrameAlt))
menu_bar.add_cascade(menu=data_menu, label="Data")
# Admin menu contains information
admin_menu = tk.Menu(menu_bar, tearoff=0, font=Body)
admin_menu.add_command(label="Manage Email Recipients", command=lambda: self.show_frame(EmailManagerFrameAlt))
admin_menu.add_separator()
admin_menu.add_command(label="New Semester", command=lambda: self.show_frame(SemesterCreatorAlt))
admin_menu.add_separator()
admin_menu.add_command(label="End of Semester", command=lambda: self.show_frame(EndOfSemesterAlt))
menu_bar.add_cascade(menu=admin_menu, label="Admin")
tk.Tk.config(self, menu=menu_bar)
# Universal Style to be used by SOMMS
data_getter_style = ttk.Style()
data_getter_style.configure('DataGetter.TButton', foreground='#006600')
data_remover_style = ttk.Style()
data_remover_style.configure('DataRemover.TButton', foreground='#CC0000')
data_submitter_style = ttk.Style()
data_submitter_style.configure('DataSubmitter.TButton', foreground='#000066')
error_label = ttk.Style()
error_label.configure('ErrorLabel.TLabel', foreground='#CC0000')
success_label = ttk.Style()
success_label.configure('SuccessLabel.TLabel', foreground='#000066')
# Set the size of the primary window
self.geometry(newGeometry="800x600")
# This dictionary will hold all the frames for the GUI, call show_frame with the name of the class
# to bring them to the front of the primary window
self.frames = {}
# If new frames need to be added remember to add them to the END of the tuple to protect the key bindings.
self.frame_set = (StartPageAlt, CheckInFrameAlt, CreateEventFrameAlt,
ReportGeneratorFrameAlt,
AnalyzeFrameAlt, EmailManagerFrameAlt, SemesterCreatorAlt, EndOfSemesterAlt)
for f in self.frame_set:
frame = f(container, self)
for x in range(10):
frame.rowconfigure(x, minsize=600/10)
frame.columnconfigure(x, minsize=800/10)
self.frames[f] = frame
frame.grid(row=0, column=0, sticky="nsew")
for f in self.container.children:
bind_keys(self, self.container.children[f])
self.show_frame(StartPageAlt)
def submit_data(self, event=None):
major = self.major_entry.get().strip()
classification = self.classification_entry.get().strip()
name = self.name_entry.get().strip()
netid = self.net_id_entry.get().strip()
for x in (major, classification, name, netid):
if x == "":
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = 'Make sure there is an entry for every field.'
return
if self.dues.get() == "two":
dues = 2
elif self.dues.get() == "one":
dues = 1
else:
dues = 0
data = MIS_Database_Functions.check_member(netid)
if data is not None:
if data['major'] != major:
MIS_Database_Functions.set_major(netid, major)
Logger.write_to_log(Logger.get_event_log_file(), "Major updated to %s for net id %s\n" % (major, netid))
if data['classification'] != classification:
MIS_Database_Functions.set_classification(netid, classification)
Logger.write_to_log(Logger.get_event_log_file(), "Classification updated to '%s' for net id '%s'\n" %
(classification, netid))
if data['name'] != name:
MIS_Database_Functions.set_name(netid, name)
Logger.write_to_log(Logger.get_event_log_file(), "Name updated to %s for net id %s\n" % (name, netid))
if data['dues_paid'] != dues and dues > 0:
MIS_Database_Functions.update_payment(netid, dues)
Logger.write_to_log(Logger.get_event_log_file(), "Payment made for %s, %d semesters paid for\n"
% (netid, dues))
if self.payment_made.get() == 0:
Logger.write_to_log(Logger.get_event_log_file(), "Payment above NOT collected\n")
else:
MIS_Database_Functions.create_member(netid, name, major, classification, dues)
Logger.write_to_log(Logger.get_event_log_file(),
'New Member: (%s, %s, %s, %s, %d)\n' % (netid, name, major, classification, dues))
if dues > 0:
Logger.write_to_log(Logger.get_event_log_file(), "Payment made for %s semesters for net id %s\n"
% (str(dues), netid))
if self.payment_made.get() == 0:
Logger.write_to_log(Logger.get_event_log_file(), "Payment above NOT collected\n")
event_id = MIS_Database_Functions.get_most_recent_event_id()
# Weird edge case: when user accidentally presses trial button, may end up recording a trial meeting for a
# a user who has already paid for the semester. Code is corrected to make sure the users payment information is
# not affected, this just makes sure the logs don't falsely record a trial meeting.
if data is None and dues == 0:
Logger.write_to_log(Logger.get_event_log_file(), "Trial Meeting for %s\n" % netid)
elif hasattr(data, 'dues_paid'):
if data['dues_paid'] == 0:
Logger.write_to_log(Logger.get_event_log_file(), "Trial Meeting for %s\n" % netid)
MIS_Database_Functions.create_ticket(event_id, netid)
Logger.write_to_log(Logger.get_event_log_file(), "\n\n")
self.clear_all()
self.feedback_label.config(style="SuccessLabel.TLabel")
self.feedback_label['text'] = name.split(" ")[1] + " was checked in successfully!\n" \
"Welcome them to the meeting!"
def get_data(self, net_id, event=None):
if net_id is None or net_id.strip() == "":
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = "No net ID entered yet."
return # Failure state
if self.major_entry.get() and self.classification_entry.get():
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = "Make sure to clear the entries\n" \
"before trying to gather data."
return # Failure State
data = MIS_Database_Functions.check_member(net_id)
if data is not None:
self.name_entry.insert(START, data['name'])
self.major_entry.insert(START, data['major'])
self.classification_entry.insert(START, data['classification'])
if data['dues_paid'] == 2:
self.two_semesters.invoke()
elif data['dues_paid'] == 1:
self.one_semester.invoke()
else:
self.dues.set("trial")
attendance_data = \
MIS_Database_Functions.get_attendance_data(net_id,
MIS_Database_Functions.get_most_recent_semester_tag())
if attendance_data is not None:
if attendance_data['meetings_attended'] > 0 and attendance_data['dues'] < 1:
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = "Member %s has already used their trial meeting.\n" \
"They have not yet paid dues.\n" \
"Collect payment as necessary." % net_id
else:
self.feedback_label.config(style="SuccessLabel.TLabel")
self.feedback_label['text'] = "Member %s is paid for %d more semester(s).\n" \
"They have attended %d meetings this semester." % \
(net_id, attendance_data['dues'],
attendance_data['meetings_attended'])
else:
self.feedback_label.config(style="SuccessLabel.TLabel")
self.feedback_label['text'] = "This member has not yet used their trial meeting.\n" \
"They are good to go.\n" \
"Collect payment only if they want to pay now."
else:
try:
data = Info_IaState_Scraper.get_raw_html(net_id)
data = Info_IaState_Scraper.parse_student_data(data)
if data is not None:
self.name_entry.insert(START, data['name'])
self.major_entry.insert(START, data['major'])
self.classification_entry.insert(START, data['classification'])
self.feedback_label.config(style="SuccessLabel.TLabel")
self.feedback_label['text'] = "No current data on %s.\n" \
"Found data in the directory.\n" \
"New members receive 1 trial meeting." % net_id
else:
self.feedback_label.config(style="SuccessLabel.TLabel")
self.feedback_label['text'] = "No current data on this net id: %s.\n" \
"Nothing found on the directory either. \n" \
"Make sure their net ID is correct.\n" \
"If it is then ask them to type in data " \
"for the other fields.\n" \
"New members receive 1 trial meeting." % net_id
except URLError:
self.feedback_label.config(style="ErrorLabel.TLabel")
self.feedback_label['text'] = 'No current data on net id: %s.\n' \
'Directory request failed.\n' \
'Check internet connection then try again.\n' \
'If all else fails, enter data manually.' % net_id
