def create_custom_time_entry(self, container_frame):
listbox = container_frame.winfo_children(
)[0] # TODO: Find a better way to access this listbox than simply quoting the ID.
frame = LabelFrame(container_frame,
text="Custom Time Frame",
padx=10,
pady=10)
start_label = ttk.Label(frame, text="Start Date:")
start_label.grid(row=0, column=0, padx=10, pady=10)
start_select = DateEntry(frame)
start_select.grid(row=0, column=1, padx=10, pady=10)
start_select.bind('<<DateEntrySelected>>',
lambda event: self.timeframe_updated(listbox))
end_label = ttk.Label(frame, text="End Date:")
end_label.grid(row=1, column=0, padx=10, pady=10)
end_select = DateEntry(frame)
end_select.grid(row=1, column=1, padx=10, pady=10)
end_select.bind('<<DateEntrySelected>>',
lambda event: self.timeframe_updated(listbox))
return frame
class Spectral2Spectrum(ttk.LabelFrame):
""" ttk.Frame with all the parameters required for the laser spectrum
"""
def __init__(self, parent: ttk.Frame, row: int, update: Callable[[], None], col: int = 0) -> None:
"""
:param parent:
"""
super(Spectral2Spectrum, self).__init__(parent, text='Spectral2 spectrum')
self.grid(column=col, row=row, sticky=tk.NSEW, pady=15)
# Date and time
self.hour = tk.IntVar(value=12)
self.min = tk.IntVar(value=0)
self.hour.trace_add('write', update)
self.min.trace_add('write', update)
date_label = ttk.Label(self, text="Date")
time_label = ttk.Label(self, text="Time (h:m)")
self.cal = DateEntry(self, foreground='black', year=2018, month=12, day=1)
hour_box = ttk.Combobox(self, values=list(range(0, 24)), textvariable=self.hour, width=5)
min_box = ttk.Combobox(self, values=list(range(0, 60)), textvariable=self.min, width=5)
date_label.grid(column=0, row=0, sticky=tk.NSEW)
time_label.grid(column=1, row=0, columnspan=2, sticky=tk.NSEW)
hour_box.grid(column=1, row=1, sticky=tk.NSEW)
hour_box.bind('<<ComboboxSelected>>', update)
min_box.grid(column=2, row=1, sticky=tk.NSEW)
min_box.bind('<<ComboboxSelected>>', update)
self.cal.grid(column=0, row=1, sticky=tk.NSEW)
self.cal.bind('<<DateEntrySelected>>', update)
class StatisticFrame(Frame):
def __init__(self):
Frame.__init__(self)
self.pack()
# Db
db = Db()
now = datetime.now()
# Station selectbox
stationOptions = {}
for station in db.getStations():
stationOptions[station.name] = station.id
self.stationSelect = Select(self, 'Station:', stationOptions)
self.stationSelect.setEvent(self.updateStatistic)
# Type selectbox
self.statisticTypeSelect = Select(self, 'Type:', {
'Day': 'day',
'Month': 'month',
'Year': 'year'
})
self.statisticTypeSelect.setEvent(self.updateStatistic)
# Date from calendar
self.dateFromSelect = DateEntry(self,
selectmode='day',
date_pattern='dd.mm.y')
self.dateFromSelect.set_date(self.firstDayOfMonth(now))
self.dateFromSelect.bind("<<DateEntrySelected>>", self.updateStatistic)
self.dateFromSelect.pack()
# Date to calendar
self.dateToSelect = DateEntry(self,
selectmode='day',
date_pattern='dd.mm.y')
self.dateToSelect.set_date(self.lastDayOfMonth(now))
self.dateToSelect.bind("<<DateEntrySelected>>", self.updateStatistic)
self.dateToSelect.pack()
# Update statistic
self.updateStatistic()
def updateStatistic(self, *args):
StatisticPrint(self, self.stationSelect.get(),
self.dateFromSelect.get_date(),
self.dateToSelect.get_date(),
self.statisticTypeSelect.get())
def firstDayOfMonth(self, d):
return d.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
def lastDayOfMonth(self, d):
if d.month == 12:
return d.replace(day=31)
return d.replace(month=d.month + 1, day=1) - timedelta(days=1)
class StatisticFrame(Frame):
def __init__(self):
Frame.__init__(self)
self.pack()
# Db
db = Db()
# Datetime now
now = datetime.now()
# Station selectbox
stationOptions = {}
for station in db.getStations():
stationOptions[station.name] = station.id
self.stationSelect = Select(self, 'Station:', stationOptions)
self.stationSelect.setEvent(self.updateStatistic)
# Type selectbox
self.statisticTypeSelect = Select(self, 'Type:', {
'Day': 'D',
'Month': 'm',
'Year': 'Y'
})
self.statisticTypeSelect.setEvent(self.updateStatistic)
self.statisticTypeSelect.setValue('Day')
# Date from calendar (7 Days before now)
self.dateFromSelect = DateEntry(self,
selectmode='day',
date_pattern='dd.mm.y')
self.dateFromSelect.set_date((now - timedelta(days=7)))
self.dateFromSelect.bind("<<DateEntrySelected>>", self.updateStatistic)
self.dateFromSelect.pack()
# Date to calendar
self.dateToSelect = DateEntry(self,
selectmode='day',
date_pattern='dd.mm.y')
self.dateToSelect.set_date(now)
self.dateToSelect.bind("<<DateEntrySelected>>", self.updateStatistic)
self.dateToSelect.pack()
# Statistic
self.statistic = StatisticPrint(self, self.stationSelect.get(),
self.dateFromSelect.get_date(),
self.dateToSelect.get_date(),
self.statisticTypeSelect.get())
def updateStatistic(self, *args):
self.statistic.set(self.stationSelect.get(),
self.dateFromSelect.get_date(),
self.dateToSelect.get_date(),
self.statisticTypeSelect.get())
def calendarDate():
def getDate_Sel(e):
fileCompDate.set(cal.get_date())
cal = DateEntry(window,
width=12,
background='darkblue',
foreground='white',
borderwidth=2)
cal.grid(column=1, row=8, sticky="W")
cal.bind("<<DateEntrySelected>>", getDate_Sel)
def example2():
def print_sel(e):
print(cal.get_date())
top = tk.Toplevel(root)
ttk.Label(top, text='Choose date').pack(padx=10, pady=10)
cal = DateEntry(top, width=12, background='darkblue',
foreground='white', borderwidth=2)
cal.pack(padx=10, pady=10)
cal.bind("<<DateEntrySelected>>", print_sel)
def create_datepicker(self, label, filter_key, column):
tk.Label(self, text=label).grid(row=0, column=column, sticky="W")
container = tk.Frame(self)
date_picker = DateEntry(container, date_pattern=Filters.DATE_PATTERN)
date_picker.config(validate='none')
date_picker.bind('<<DateEntrySelected>>',
self.on_date_pick(filter_key))
date_picker.delete(0, tk.END)
date_picker.grid(row=0, column=0)
clear_btn = tk.Button(
container,
text="x",
command=self.on_clear_date_click(date_picker, filter_key),
)
clear_btn.grid(row=0, column=1, sticky="N")
container.grid(row=1, column=column)
def mainwindow():
lab = Label(root,
text="Age Calculator",
font=("Ariel", 40, "bold"),
bg="red",
padx=500)
lab.grid(row=0, column=0, columnspan=10)
lab1 = Label(root, text="Current Date", font=("Ariel", 30, "bold"))
lab1.grid(row=1, column=0)
entry = Entry(root, textvar=currentv, state=DISABLED)
entry.grid(row=1, column=2)
lab2 = Label(root, text="Date Of Birth", font=("Ariel", 30, "bold"))
lab2.grid(row=2, column=0)
global entry1
entry1 = DateEntry(root, date_pattern="DD-MM-YYYY", state="readonly")
entry1.grid(row=2, column=2)
entry1.bind("<<DateEntrySelected>>", correction)
lab = Label(root,
text="Calculated Age",
font=("Ariel", 40, "bold"),
bg="green",
padx=500)
lab.grid(row=6, column=0, columnspan=10)
lab1 = Label(root, text="Years", font=("Comic Sans MS", 30, "italic"))
lab1.grid(row=8, column=1)
yearsentry = Entry(root, textvar=yearsentryv)
yearsentry.grid(row=9, column=1)
lab2 = Label(root, text="Months", font=("Comic Sans MS", 30, "italic"))
lab2.grid(row=8, column=3)
monthsentry = Entry(root, textvar=monthsentryv)
monthsentry.grid(row=9, column=3)
lab3 = Label(root, text="Days", font=("Comic Sans MS", 30, "italic"))
lab3.grid(row=8, column=5)
daysentry = Entry(root, textvar=daysentryv)
daysentry.grid(row=9, column=5)
def get_meal():
global cal, u
user.withdraw()
u = Toplevel()
u.geometry('420x200')
id = IntVar()
Label(u, text = "Date").grid(row = 0, column = 0)
cal = DateEntry(u)
cal.grid(row = 1, column = 0)
cal._top_cal.overrideredirect(False)
cal.bind("<<DateEntrySelected>>", getdate)
a = Radiobutton(u, text = "By Date", variable = id, value = 1)
a.grid(row = 0, column = 1)
a.select()
all = Radiobutton(u, text = "Get All", variable = id, value = 0)
all.grid(row = 1, column = 1)
e = Radiobutton(u, text = "Expenditure", variable = id, value = 2)
e.grid(row = 2, column = 1)
md = partial(meal_date, id)
Button(u, text = "go", command = md).grid(row = 3, column = 0)
Button(u, text = "Back", command = back_selection).grid(row = 3, column = 1)
def addmeal():
global r, food, u, cal, category
user.withdraw()
u = Toplevel()
u.geometry('400x200')
Label(u, text = "Food Category").grid(row = 0, column = 0)
category = ttk.Combobox(u, values=["Breakfast", "Lunch", "Dinner", "Late Night"], state = "readonly")
category.grid(row = 1, column = 0)
Label(u, text = "Restaurant").grid(row = 2, column = 0)
r = ttk.Combobox(u, values=restaurants, state = "readonly")
r.grid(row = 3, column = 0)
r.bind("<<ComboboxSelected>>", foods)
Label(u, text = "Foods").grid(row = 0, column = 1)
food = ttk.Combobox(u, values = "Nothing", state = "readonly", postcommand=changeFoods)
food.grid(row = 1, column = 1)
Label(u, text = "Date").grid(row = 2, column = 1)
cal = DateEntry(u)
cal.grid(row = 3, column = 1)
cal._top_cal.overrideredirect(False)
cal.bind("<<DateEntrySelected>>", getdate)
Button(u, text = "Add", command = addFoods).grid(row = 4, column = 0)
Button(u, text = "Back", command = back_selection).grid(row = 4, column =1)
class DateSelection(object):
logger = CustomAdapter(logging.getLogger(str(__name__)), None)
# date_selection_dict = {}
# noinspection PyUnusedLocal
@debug(lvl=logging.DEBUG, prefix='')
def __init__(self,
parent,
row,
column,
label_text,
style=None,
*args,
**kwargs):
self.parent = parent
self.label_text = label_text
self.row = row
self.column = column
self.style = style
self.label = ttk.Label(self.parent,
text=self.label_text,
style=self.style)
self.label.grid(row=self.row, column=self.column, sticky=tk.NW)
self.value = None
self.entry = DateEntry(
self.parent, firstweekday="sunday", showweeknumbers=False
) # TODO: Apply some style to this date dropdown
self.entry.grid(row=self.row, column=self.column + 1, sticky=tk.NE)
self.entry.bind("<<DateEntrySelected>>", self.new_date)
# DateSelection.date_selection_dict[label_text] = self
# noinspection PyUnusedLocal
@debug(lvl=logging.DEBUG, prefix='')
def new_date(self, *args):
DateSelection.logger.log(
logging.DEBUG, "{} Selection: {}".format(self.label_text,
self.entry.get_date()))
self.value = self.entry.get_date()
class InputWindow(tk.Tk):
# ----- initialize -----
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# ----- paths -----
icon_path = f"media{os.sep}icons" #use os.sep for tracker to work in different OS
# print(icon_path) #uncomment for troubleshooting
self.img = ImageTk.PhotoImage(Image.open(f"media{os.sep}icons{os.sep}main.png"))
# ----- Data ------
#check for command line arguments
if len(sys.argv) > 1:
print(f"Currently running: {sys.argv[0]}")
print(f"Data loading from: {sys.argv[1]}")
# self.tracker = sys.argv[1]
else:
print('No data...creating new Tracker-object.')
# self.tracker = ''
# ----- Styles -----
style = Style(self)
# colors
self.BG_COL_1 = "#DCDAD5"
# custom styles
style = ttk.Style()
style.theme_use("clam")
f = tkFont.Font(family='helvetica', size=15)
style.configure('Test.TFrame', font=f)
# customed_style.configure('Custom.TNotebook.Tab', padding=[12, 12], font=('Helvetica', 10))
# ----- customize -----
# title
self.title("Health Tracker")
# change taskbar icon
# self.iconphoto(False, ImageTk.PhotoImage(file=os.path.join(icon_path, "main.png")))
self.iconphoto(False, self.img)
# make fullscreen
self.state('zoomed')
# closing function
self.protocol("WM_DELETE_WINDOW", self.on_exit)
# configure rows and columns
self.grid_columnconfigure(0, weight=0)
self.grid_columnconfigure(1, weight=1)
for n in range(20):
self.grid_rowconfigure(n, weight=1)
# save todays date on attribute
self.current_date = datetime.datetime.now().date()
# list to save EntryFrame objects in to use fot latter iterations
self.entry_frames = []
# properties to save info about user logging in
self.user = None
self.sex = None
# list property to collect system processes in --> to be closed on frame exit (e.g. created using subprocess.Popen())
self.sysproc = []
# # ----- Frame Container -----
# # save a ttk frame - object in a variable named "container"
# container = ttk.Frame(self)
# container.grid() #position the frame in the parent widget in a grid
# container.columnconfigure(0, weight=1)
#----- Login and SignUp Screen -----
# add login frame that is placed within "container"
self.login_frame = LoginWindow(self) #initiate Timer-class and pass self as the controller #, self.switch_frame
self.login_frame#.grid(row=0,column=0, rowspan=20, columnspan=2, sticky='EWNS') #configure timer frame placed in the first row and first column and to fill the entire frame ("container")
# add signup frame
self.signup_frame = SignupWindow(self, name="signup")
self.signup_frame#.grid(row=0,column=0, rowspan=20, columnspan=2, sticky='EWNS')
# add signup frame
self.userinfo_frame = UserinfoWindow(self)
# ----- Tabs -----
# initiate ttk.Notebook as parent for tabs
self.tabControl = ttk.Notebook(self)#, style="Custom.TNotebook.Tab")
# create tabs
self.mood_tab = ttk.Frame(self.tabControl)
self.health_tab = ttk.Frame(self.tabControl) #, relief = tk.SUNKEN
self.sleep_tab = ttk.Frame(self.tabControl)
self.food_tab = ttk.Frame(self.tabControl)
self.fitness_tab = ttk.Frame(self.tabControl)
self.period_tab = ttk.Frame(self.tabControl)
self.longterm_tab = ttk.Frame(self.tabControl)
# add tabs
self.tabControl.add(self.mood_tab, text='Mood')
self.tabControl.add(self.health_tab, text='Health')
self.tabControl.add(self.sleep_tab, text='Sleep')
self.tabControl.add(self.food_tab, text='Food')
self.tabControl.add(self.fitness_tab, text='Fitness')
self.tabControl.add(self.period_tab, text='Period')
self.tabControl.add(self.longterm_tab, text='Longterm Changes')
# # pack tabs - to make them visible
# # tabControl.pack(expand=0, fill="both", pady=(10,10))
# self.tabControl.grid(row=0,column=0, rowspan=20, sticky='EWNS')
# self.tabControl.grid_columnconfigure(0, weight=1)
# for n in range(15):
# self.tabControl.grid_rowconfigure(n, weight=1)
# tk.Button(self,text="Change date NOW",command=self.change_date, borderwidth=0, fg='darkslateblue').grid(row=1,column=1,rowspan=1, sticky='N')
# # print(tabControl.tab(tabControl.select(), "text")) #uncomment for troubleshooting
# ----- Labels -----
fontLab = tkFont.Font(family='Verdana', size=40, weight='bold', slant='roman')
ttk.Label(self.mood_tab, text ="How's your head feeling? \n", font=fontLab).grid(row=0, column=0, columnspan=2)
ttk.Label(self.food_tab, text ="How's your stomach feeling? \n", font={'size':12}).grid(row=0, column=0, columnspan=2)
ttk.Label(self.fitness_tab, text ="How's your muscles feeling? \n", font={'size':12}).grid(row=0, column=0, columnspan=2)
ttk.Label(self.longterm_tab, text ="How have you been? \n", font={'size':12}).grid(row=0, column=0, columnspan=2)
ttk.Label(self.health_tab, text ="How's your body feeling? \n", font={'size':12}).grid(row=0, column=0, columnspan=2)
ttk.Label(self.period_tab, text ="How's your uterus feeling? \n", font={'size':12}).grid(row=0, column=0, columnspan=2)
ttk.Label(self.sleep_tab, text ="How's your ZZZZZZZs feeling? \n", font={'size':12}).grid(row=0, column=0, columnspan=2)
# ----- Entry -----
EntryFrame(self.mood_tab, mood_info, self.tabControl.tab(self.mood_tab)['text'], name='mood_tab').grid(row=1, column=0, sticky="NSEW", padx=10, pady=10)
EntryFrame(self.health_tab, health_info, self.tabControl.tab(self.health_tab)['text']).grid(row=1, column=0, sticky="NSEW", padx=10, pady=10)
EntryFrame(self.food_tab, food_info, self.tabControl.tab(self.food_tab)['text']).grid(row=1, column=0, sticky="NSEW", padx=10, pady=10)
EntryFrame(self.sleep_tab, sleep_info, self.tabControl.tab(self.sleep_tab)['text']).grid(row=1, column=0, sticky="NSEW", padx=10, pady=10)
EntryFrame(self.fitness_tab, fitness_info, self.tabControl.tab(self.fitness_tab)['text']).grid(row=1, column=0, sticky="NSEW", padx=10, pady=10)
EntryFrame(self.period_tab, period_info, self.tabControl.tab(self.period_tab)['text']).grid(row=1, column=0, sticky="NSEW", padx=10, pady=10)
EntryFrame(self.longterm_tab, longterm_info, self.tabControl.tab(self.longterm_tab)['text']).grid(row=1, column=0, sticky="NSEW", padx=10, pady=10)
# if self.sex != 'male':
# period_tab = ttk.Frame(self.tabControl)
# self.tabControl.add(period_tab, text='Period')
# ttk.Label(period_tab, text ="How's your uterus feeling? \n", font={'size':12}).grid(row=0, column=0, columnspan=2)
# EntryFrame(period_tab, period_info, self.tabControl.tab(period_tab)['text']).grid(row=1, column=0, sticky="NSEW", padx=10, pady=10)
# self.all_tabs = [mood_tab, food_tab, fitness_tab, period_tab, longterm_tab, health_tab, sleep_tab]
# else:
# self.all_tabs = [mood_tab, food_tab, fitness_tab, longterm_tab, health_tab, sleep_tab]
self.all_tabs = [self.mood_tab, self.food_tab, self.fitness_tab, self.period_tab, self.longterm_tab, self.health_tab, self.sleep_tab]
# current tab
tabName = self.tabControl.select() #get name of current tab
self.active_tab = self.tabControl.nametowidget(tabName) #get widget-object from widget name (string)
# create dictionary to keep track of frames
self.frames = dict()
self.frames_visibility = dict()
# add both frames to dict
self.frames['LoginWindow'] = self.login_frame
self.frames['SignupWindow'] = self.signup_frame
self.frames['UinfoWindow'] = self.userinfo_frame
self.frames['TC'] = self.tabControl
# start with timer_frame in front
self.switch_frame('LoginWindow')
self.tabControl.grid(row=0,column=0, rowspan=20, sticky='EWNS')
self.tabControl.grid_columnconfigure(0, weight=1)
for n in range(15):
self.tabControl.grid_rowconfigure(n, weight=1)
self.date_button = tk.Button(self,text="Change date NOW",command=self.change_date, borderwidth=0, fg='darkslateblue')
# ----- Date Picker ------
self.cal = DateEntry(self, width=12, background='darkblue',
foreground='white', borderwidth=2)
# print([obj.winfo_name() for obj in self.entry_frames])
# function printing selected date from calendar
def print_sel(self, event=None):
"""
Changes selected data in Entryframes
Parameters:
event: event - not None when called by self.change_date(); None when called by self.reset_tracker()
"""
if event:
try:
old_date = self.current_date
except:
old_date = datetime.datetime.now().date()
new_date = self.cal.get_date()
self.current_date = new_date
print(f"Date changed from {old_date} to {self.current_date}")
else:
self.current_date = datetime.datetime.now().date()
date_string = self.current_date.strftime("%Y-%m-%d") #convert datetime object to string in order to be able to pass it to .loc[]
# get data
data = db_transact.query_data_by_date_and_user(date_string, self.user)
# update all EntryFrame fields based on date
for entry_frame in self.entry_frames:
if type(data) != dict: #check if any data was returned from database for specified date and user
entry_frame.create_blank_entryframes()
else:
entry_frame.update_selection(data, date_string)
# ----- method toggling date picker and printing selection ------
def change_date(self):
self.cal.bind("<<DateEntrySelected>>", lambda event: self.print_sel(event=event))
if self.cal.winfo_ismapped():
self.cal.grid_remove()
else:
self.cal.grid(row=3,column=1,rowspan=1, sticky='N')
def on_tab_change(self, *event):
#get EntryFrame of interest from current tab (2nd child object in current tab)
'''
The current tab (saved in self.active_tab) is a custom object parameter is used to save info on current active tab outside of native tkinter functionality ).
The active tab is a ttk.Frame-object, that contains 3 children: a label, an EntryFrame and a Past_Entry_Frame.
--> below: get the 2nd child-object from active tab - this is an EntryFrame-type object
'''
active_entryframe = self.active_tab.winfo_children()[1]
# check if any information was entered in current EntryFrame (-> changes for each information field saved as TRUE-values in value_entry_record-property)
if any(v==True for v in active_entryframe.value_entry_record.values()): #check for any True-values in active_entryframe.value_entry_record-dict
# insert EntryFrame data in database and display success message
active_entryframe.insert_database(self.user, self.current_date)
message = f"""Database table {active_entryframe.tab} filled with values"""
# change all values in entry-dict back to False, in order to avoid unneccesary database connections when re-opening this tab
active_entryframe.value_entry_record = {k: False for k in active_entryframe.value_entry_record}
self.toplevel_message('Success!', message, 1500)
# change value of self.active_tab, as the tab was changed - done AFTER calling active_entryframe.insert_database(), otherwise the un-filled newly opened tab info is inserted to database
tabName = self.tabControl.select()
self.active_tab = self.tabControl.nametowidget(tabName)
# print(self.tabControl.tab(self.tabControl.select(), "text")) #uncomment for troubleshooting
# ----- funtion to run upon closing the window -----
def on_exit(self):
print("Closing down background processes...")
self.kill_processes(self.sysproc)
print("Saving latest changes...")
self.on_tab_change() #save entries of last tab without tab change
print("Exiting app...")
self.destroy() #destroy window
def kill_processes(self, processes):
"""
Kills every process in a list of processes.
Parameters:
processes (list) - list of processes
Returns:
void function
"""
for process in processes:
process.kill()
return
def add_plots(self):
# ----- iterate over all notebook tabs -----
for tab in self.all_tabs:
# save each tab's EntryFrame object in list for latter use
for child in tab.winfo_children():
if type(child)==EntryFrame:
self.entry_frames.append(child)
# get current notebook tab's text
tab_name = self.tabControl.tab(tab)['text']
# create tk.Canvas-objects as plotting area
cur_tab = PastEntryFrame(tab, tab_name)
cur_tab.grid(row=1, column=1, sticky="NSEW", padx=10, pady=10)
cur_tab.display_plots(tab_name)
# ----- function that brings frame on the back to the front -----
def switch_frame(self, container):
# ungrid current frame --> to avoid seeing "background"-frame, as frames are of different size, to avoid seeing "background"-frame
for fname, frame in self.frames.items():
if frame.winfo_viewable():
frame.grid_forget()
# indicate which frame to bring to show
frame = self.frames[container]
# create UI if frame to switch to is 'TC' - important to load TC after login only and to directly load correct user data based on self.user
if frame == self.frames['TC']:
if self.sex == 'male':
self.change_tab_state(self.period_tab)
else:
self.change_tab_state(self.period_tab, method="enable")
self.add_plots()
self.date_button.grid(row=1,column=1,rowspan=1, sticky='N')
frame.grid(row=0,column=0, rowspan=20, sticky='EWNS')
else:
frame.grid(row=0,column=0, rowspan=20, columnspan=2,sticky='EWNS')
#brings indicated frame to the front
frame.tkraise() #keep tk.raise() in addition to .grid_forget() as 'TC' is always loaded to grid
def toplevel_message(self, title, message, duration):
top = tk.Toplevel()
top.title(title)
tk.Message(top, text=message, padx=20, pady=20).pack()
top.after(duration, top.destroy)
def change_tab_state(self, tab, method="disable"):
"""
Changes status of specified ttk.Notebook-tab.
If state change to "enabled", the state needs to be checked, as enabling from hidden vs disabled status use different functions.
Parameters:
tab: variable name of tab (NOT a string) - e.g. mood_tab
method: string - "disable" (default) or "hide" or "enable"
Returns: Void function
"""
if method == "disable":
self.tabControl.tab(tab, state="disabled")
print(self.tabControl.tab(tab)['state'])
elif method == "hide":
self.tabControl.hide(tab)
print(self.tabControl.tab(tab)['state'])
elif method == "enable":
state = self.tabControl.tab(tab)['state']
if state == "hidden":
self.tabControl.add(tab)
elif state == "disabled":
self.tabControl.tab(tab, state="normal")
def reset_tracker(self):
"""
Resets tracker interface (=ttk.Notebook object) and tkcalendar.DateEntry-object, when switching between users.
This method is run from LoginWindow-object.
Returns: Void function
"""
self.tabControl.select(0) #make first tab current tab every time new TC loads
self.current_date = datetime.datetime.now().date()
self.cal.set_date(self.current_date) #reset DateEntry-object
self.print_sel()
if self.cal.winfo_ismapped(): #toggle in
self.cal.grid_remove()
class ExpenseWindow:
def __init__(self, data=''):
self.data = data
print(self.data)
self.win = Tk()
self.canvas = Canvas(self.win, width=600, height=400, bg="white")
self.canvas.pack(expand=YES, fill=BOTH)
# bringing the screen in the centre
width = self.win.winfo_screenwidth()
height = self.win.winfo_screenheight()
x = int(width / 2 - 600 / 2)
y = int(height / 2 - 400 / 2)
strl = "600x400+" + str(x) + "+" + str(y)
self.win.geometry(strl)
# disable resize of the window
self.win.resizable(width=False, height=False)
# change the title of the window
self.win.title("WELCOME | Add Expense | ADMINISTRATOR")
def add_frame(self):
# create an inner frame
self.frame = Frame(self.win, height=400, width=500)
self.frame.place(x=55, y=50)
x, y = 0, 0
self.label = Label(self.frame, text="Add Expense")
self.label.config(font=("Courier", 25, 'bold'), bg='green yellow')
self.label.place(x=120, y=y + 10)
# drop down menu
OPTIONS = ['Food', 'Petrol', 'Shopping', 'Entertainment', 'College']
self.variable = StringVar(self.win)
self.variable.set(OPTIONS[0])
self.label = Label(self.frame, text="Add Expense Source")
self.label.config(font=("Courier", 15, 'bold'))
self.label.place(x=x + 10, y=90)
self.source = OptionMenu(self.frame,
self.variable,
*OPTIONS,
command=self.dropdown)
self.source.place(x=250, y=90)
self.label = Label(self.frame, text="Add amount")
self.label.config(font=("Courier", 15, 'bold'))
self.label.place(x=x + 10, y=120)
self.inc = Entry(self.frame, font='Courier 16')
self.inc.place(x=250, y=120)
# calendar
self.label = Label(self.frame, text="Add date")
self.label.config(font=("Courier", 15, 'bold'))
self.label.place(x=x + 10, y=150)
self.dob = DateEntry(self.frame,
font=('Courier', 12, 'bold'),
bg='darkblue',
fg='white',
borderwidth=2,
command=self.dates,
date_pattern='YYYY/MM/DD')
self.dob.place(x=250, y=150)
# on date change listener
self.dob.bind('<<DateEntrySelected>>', self.dates)
if self.data == '':
self.button = Button(self.frame,
text="SUBMIT",
font=('helvetica', 20, 'underline italic'),
bg='dark green',
fg='white',
command=self.add_expense)
self.button.place(x=x + 80, y=y + 200)
else:
up = dict(self.data).get('values')
# set the values in input boxes
self.inc.insert(0, up[1])
self.dob.insert(0, up[2])
self.button = Button(self.frame,
text="UPDATE",
font=('helvetica', 20, 'underline italic'),
bg='dark green',
fg='white',
command=self.update_expense)
self.button.place(x=x + 80, y=y + 200)
self.lblmsg = Label(self.frame, text='')
self.lblmsg.config(font=('Courier', 12, 'bold'))
self.lblmsg.place(x=x + 100, y=y + 260)
self.win.mainloop()
def dropdown(self, value, *args):
print(self.variable.get())
def dates(self, value, *args):
print(self.dob.get_date())
def add_expense(self):
data = (self.variable.get(), self.inc.get(), self.dob.get())
if self.variable.get() == '':
self.lblmsg.config(fg='red')
self.lblmsg.config(text="please enter expense source")
elif self.inc.get() == '':
self.lblmsg.config(fg='red')
self.lblmsg.config(text='please enter amount')
elif self.dob.get() == '':
self.lblmsg.config(fg='red')
self.lblmsg.config(text='please enter date')
else:
res = db.db.add_expense(data)
if res:
self.lblmsg.config(fg='green')
self.lblmsg.config(text="data added successfully")
else:
self.lblmsg.config(fg='red')
self.lblmsg.config(text='Alert! please try again')
def update_expense(self):
tup = (self.inc.get(), self.dob.get(), dict(self.data).get('text'))
res = db.db.update_expense(tup)
if res:
messagebox.showinfo("Message", "expense updated successfully")
self.win.destroy()
x = expense.showExpense.showExpense()
x.add_frame()
class rsearch(tk.Tk):
def __init__(self, *args, **kwargs):
# __init__ function for class Tk
tk.Tk.__init__(self, *args, **kwargs)
# self = Tk()
current_date = date.today()
tomorrow = date.today() + timedelta(1)
print(type(tomorrow))
self.title("Search")
self.geometry("900x500")
self.config(background="black", pady=10)
label1 = tk.Label(self, text='Check In Date')
label1.place(x='60', y='40')
self.cal = DateEntry(self,
width=12,
year=current_date.year,
month=current_date.month,
day=current_date.day,
mindate=current_date,
date_pattern='y-mm-dd',
background='darkblue',
foreground='white',
borderwidth=2)
self.cal.place(x='60', y='80')
label2 = tk.Label(self, text='Check out Date')
label2.place(x='200', y='40')
self.cal.bind("<<DateEntrySelected>>", self.callback)
date_time_obj = datetime.datetime.strptime(self.cal.get(), '%Y-%m-%d')
print(type(date_time_obj))
# if self.cal.get():
# min_date=self.cal.get()
# else:
# min_date=tomorrow
self.cal1 = DateEntry(self,
width=12,
year=tomorrow.year,
month=tomorrow.month,
day=tomorrow.day,
mindate=tomorrow,
date_pattern='y-mm-dd',
background='darkblue',
foreground='white',
borderwidth=2)
self.cal1.place(x='200', y='80')
# reg = self.register(self.callback)
#
# self.cal1.config(validate="key",
# validatecommand=(reg, '% P'))
button = tk.Button(self, text='Search', command=self.search)
button.place(x='150', y='120')
def search(self):
print(self.cal.get())
print(self.cal1.get())
self.destroy()
bpage = booking()
def callback(self, input):
w = input.widget
date = w.get_date() + timedelta(1)
self.cal1.config(mindate=date)
class Utils:
date_from_cal, date_to_cal = None, None
date_from_lbl, date_to_lbl = None, None
# this is called when a county selection is made, but may not always show.
def show_municipalities(self, central, search):
# municipalities selection will only show if advanced settings has been selected.
if central.advanced:
"""
Check if county selection is all - if so, remove the widgets from frame.
Check if municipality already exists - if so, remove it.
This is done because if county selection is all, you can't pick a municipality. If the municipality
already exists, it gets removed because it may need to be populated with the results of a new county
selection, if county selection isn't already all. """
try:
if search.county.lower() == "all" or central.root.nametowidget('county.municipality') is not None:
central.root.nametowidget('county.lbl_municipalities').grid_forget()
central.root.nametowidget('county.municipality').grid_forget()
except KeyError as e:
print("The issue is that the widget that you are looking for is not in the frame yet.")
print(e)
pass
# if county selection isn't all, then populate the proper municipality data.
if search.county.lower() != "all":
municipalities = scrape.get_municipality(scrape.get_counties()[search.county])
if municipalities is not None:
for widget in central.frame.winfo_children():
if 'row' in widget.grid_info() and widget.grid_info()['row'] > 0:
widget.grid(row=widget.grid_info()['row'] + 1, column=widget.grid_info()['column'])
lbl_municipalities = Label(central.frame, name="lbl_municipalities", text="Municipalities: ")
lbl_municipalities.grid(column=0, row=1, sticky='w')
municipalities_lst = list(municipalities.keys())
municipalities_lst.insert(0, "All")
municipality_menu = ttk.Combobox(central.frame, values=municipalities_lst, name="municipality")
municipality_menu.set(municipalities_lst[0])
def post_municipalities():
search.update('municipality', municipality_menu.get())
if municipality_menu.get() != "ALL":
search.update('municipality_id', municipalities[municipality_menu.get()])
else:
search.update('municipality_id', None)
municipality_menu.bind('<<ComboboxSelected>>', lambda _: post_municipalities())
municipality_menu.grid(column=1, row=1)
def toggle_advanced_settings(self, central, search):
advanced_btn, submit_btn = None, None
central.advanced = (not central.advanced)
for widget in central.frame.winfo_children():
if type(widget) is Button:
if "submit" in widget['text'].lower():
submit_btn = widget
elif "advanced settings" in widget['text'].lower():
advanced_btn = widget
widget.grid_forget()
if central.advanced:
status_label = Label(central.frame, text="Status: ")
filer_label = Label(central.frame, text="Filer: ")
registered_label = Label(central.frame, text="Registered Within: ")
status_opt = [e.name.title() for e in Status]
status = ttk.Combobox(central.frame, values=status_opt)
status.set(status_opt[0])
status.bind('<<ComboboxSelected>>', lambda _: search.update('status', status.get()))
row = 1
registered_opt = [e.name.replace("_", " ").title() for e in Registered]
registered = ttk.Combobox(central.frame, values=registered_opt)
registered.set(registered_opt[0])
registered.bind('<<ComboboxSelected>>', lambda _: self.date_range(search, central, registered.get()))
filer_opt = [e.name.title() for e in Filer]
filer = ttk.Combobox(central.frame, values=filer_opt)
filer.set(filer_opt[0])
filer.bind('<<ComboboxSelected>>', lambda _: search.update('filer', filer.get()))
status_label.grid(column=0, row=row, sticky='w')
status.grid(column=1, row=row)
row += 1
filer_label.grid(column=0, row=row, sticky='w')
filer.grid(column=1, row=row)
row += 1
registered_label.grid(column=0, row=row, sticky='w')
registered.grid(column=1, row=row)
row += 1
submit_btn.grid(column=0, row=row, columnspan=2)
row += 1
advanced_btn.config(text="Hide Advanced Settings")
advanced_btn.grid(column=0, row=row, columnspan=2)
if search.county != "ALL":
self.show_municipalities(central, search)
else:
for item in central.root.winfo_children():
item.grid_forget()
return CountySearch(search, central).county_search()
def date_range(self, search, central, selection):
search.update('registered', selection)
last_row = 0
if selection == "Date Range":
for widget in central.frame.winfo_children():
if 'row' in widget.grid_info():
if type(widget) is not Button:
if last_row < widget.grid_info()['row']:
last_row = widget.grid_info()['row'] + 1
else:
widget.grid(row=(widget.grid_info()['row'] + 2))
self.date_from_lbl = Label(central.frame, text="Date From: ", name='lbl_date_from')
self.date_to_lbl = Label(central.frame, text="Date To: ", name='lbl_date_to')
self.date_from_cal = DateEntry(central.frame)
self.date_from_cal.bind("<<DateEntrySelected>>", lambda _:
search.update(Registered.DATE_RANGE, 'dateFrom', date=self.date_from_cal.get()))
self.date_to_cal = DateEntry(central.frame)
self.date_to_cal.bind("<<DateEntrySelected>>", lambda _:
search.update(Registered.DATE_RANGE, 'dateTo', date=self.date_to_cal.get()))
self.date_from_lbl.grid(column=0, row=last_row)
self.date_from_cal.grid(column=1, row=last_row)
last_row += 1
self.date_to_lbl.grid(column=0, row=last_row)
self.date_to_cal.grid(column=1, row=last_row)
else:
try:
central.root.nametowidget('county.lbl_date_from').grid_forget()
central.root.nametowidget('county.lbl_date_to').grid_forget()
# temporary solution
for widget in central.frame.winfo_children():
if isinstance(widget, DateEntry):
widget.destroy()
except KeyError as e:
print(e)
def show_date_fields(self):
def set_start_sel(event):
self.start_date = start_date_cal.get_date()
self.selected_start_date.set(self.start_date.strftime("%b %d, %Y"))
def set_end_sel(event):
self.end_date = end_date_cal.get_date()
self.selected_end_date.set(self.end_date.strftime("%b %d, %Y"))
date_frame = ttk.Frame(self)
date_title_label = ttk.Label(
date_frame,
text="Select a timeframe to include transactions"
)
date_title_label.grid(
column=0, row=0, columnspan=2, pady=20)
start_date_label = ttk.Label(
date_frame,
text="Start Date",
style='Small.TLabel'
)
start_date_label.grid(column=0, row=1)
start_date_cal = DateEntry(
date_frame, font="Arial 14", selectmode='day', locale='en_US',
date_pattern='MM/dd/yyyy', maxdate=date.today(),
showweeknumbers=False,
firstweekday='sunday',
bordercolor=self.colors['DARK_GREY'],
background=self.colors['DARK_GREY'],
normalbackground=self.colors['DARK_GREY'], normalforeground=self.colors['WHITE'],
weekendbackground=self.colors['MED_GREY'], weekendforeground=self.colors['WHITE'],
disabledbackground=self.colors['LIGHT_GREY'], disabledforeground=self.colors['DARK_GREY'],
disabledselectbackground=self.colors['LIGHT_GREY'], disabledselectforeground=self.colors['DARK_GREY'],
headersbackground=self.colors['DARK_GREY'], headersforeground=self.colors['WHITE'],
othermonthbackground=self.colors['DARK_GREY'], othermonthforeground=self.colors['LIGHT_GREY'],
othermonthwebackground=self.colors['MED_GREY'], othermonthweforeground=self.colors['LIGHT_GREY'],
selectbackground=self.colors['BLUE'], selectforeground=self.colors['WHITE'])
start_date_cal.bind("<<DateEntrySelected>>", set_start_sel)
start_date_cal.grid(column=0, row=2, padx=25)
end_date_label = ttk.Label(
date_frame,
text="End Date",
style='Small.TLabel'
)
end_date_label.grid(column=1, row=1)
end_date_cal = DateEntry(
date_frame, font="Arial 14", selectmode='day', locale='en_US',
date_pattern='MM/dd/yyyy', maxdate=date.today(),
showweeknumbers=False,
firstweekday='sunday',
bordercolor=self.colors['DARK_GREY'],
background=self.colors['DARK_GREY'],
normalbackground=self.colors['DARK_GREY'], normalforeground=self.colors['WHITE'],
weekendbackground=self.colors['MED_GREY'], weekendforeground=self.colors['WHITE'],
disabledbackground=self.colors['LIGHT_GREY'], disabledforeground=self.colors['DARK_GREY'],
disabledselectbackground=self.colors['LIGHT_GREY'], disabledselectforeground=self.colors['DARK_GREY'],
headersbackground=self.colors['DARK_GREY'], headersforeground=self.colors['WHITE'],
othermonthbackground=self.colors['DARK_GREY'], othermonthforeground=self.colors['LIGHT_GREY'],
othermonthwebackground=self.colors['MED_GREY'], othermonthweforeground=self.colors['LIGHT_GREY'],
selectbackground=self.colors['BLUE'], selectforeground=self.colors['WHITE'])
end_date_cal.bind("<<DateEntrySelected>>", set_end_sel)
end_date_cal.grid(column=1, row=2, padx=25)
from_label = ttk.Label(
date_frame,
text="From",
style="TLabel",
padding='10 25 10 10'
)
from_label.grid(column=0, row=3, padx=10)
to_label = ttk.Label(
date_frame,
text="To",
style="TLabel",
padding='10 25 10 10'
)
to_label.grid(column=1, row=3, padx=10)
selected_start_date = ttk.Label(
date_frame,
textvariable=self.selected_start_date,
style="Small.TLabel",
padding='5 5 5 5',
background=self.colors['BLUE']
)
selected_start_date.grid(
column=0, row=4, padx=10)
selected_end_date = ttk.Label(
date_frame,
textvariable=self.selected_end_date,
style="Small.TLabel",
padding='5 5 5 5',
background=self.colors['BLUE']
)
selected_end_date.grid(column=1, row=4, padx=10)
date_frame.grid(column=1, row=1, columnspan=2, pady=20)
button_list = []
loadgrid(date, data=[])
insertgrid(button_list)
picker_frame = LabelFrame(root)
picker_frame.grid(row=7, column=0, columnspan=25)
cal = DateEntry(picker_frame,
width=12,
background='darkblue',
foreground='white',
borderwidth=2,
date_pattern='dd-mm-yyyy')
cal.grid(row=0, column=1, padx=10)
cal.bind('<<DateEntrySelected>>', when_date_changed)
cal.set_date(date)
def r_arrow():
global date
_date = date + timedelta(1)
cal.set_date(_date)
when_date_changed(0)
r_arrow = Button(picker_frame, text='🢂', command=r_arrow)
r_arrow.grid(row=0, column=2)
def l_arrow():
class ProfitPerDayAnalysis():
def __init__(self, username):
self.username = username
db = mysql.connector.connect(host='localhost',
database='medical',
user='******',
passwd='test')
self.dbcursor = db.cursor()
#self.dbcursor.execute("select distinct(Name) from medicine")
#self.result = self.dbcursor.fetchall()
#self.medicines = list(self.result)
#self.dbcursor.execute("select distinct(Category) from medicine")
#self.result = self.dbcursor.fetchall()
#self.category = list(self.result)
#self.med_name = "Chlorpheniramine"
#self.cat_name = "Capsule"
self.sale_in = "Last month"
self.month = date.today().month - 1
self.fromday = "1"
self.interval = 7
self.year = str(d.datetime.now().year)
self.totalBars = 4
self.init_components()
self.showGraph1()
self.showGraph2()
self.showGraph3()
self.configure_components()
self.pack_components()
self.run()
def init_components(self):
self.window = tk.Tk()
#self.selected_med = StringVar()
#self.selected_cat = StringVar()
self.selected_sale_in = StringVar()
self.heading_label = tk.Label(self.window,
text="Profit Analysis",
font="Verdana 18 bold",
fg="white")
self.sale_in_label = tk.Label(self.window,
text="Profit in : ",
font="Verdana 12 ",
anchor=E)
#self.from_label = tk.Label(self.window, text="From : ", font="Verdana 12 ", anchor=E)
self.to_label = tk.Label(self.window, text="To : ", font="Verdana 12 ")
self.sale_in_combo = ttk.Combobox(
self.window,
values=["Last Year", "Last month", "Last week"],
width="25",
textvariable=self.selected_sale_in)
self.From_Cal = DateEntry(self.window,
width=15,
background='darkblue',
foreground='white',
borderwidth=2)
self.To_Cal = DateEntry(self.window,
background='darkblue',
foreground='white',
borderwidth=2,
width=15)
#self.backbtn = tk.Button(self.window, text="Back", bg="#63D792", fg="white", activebackground="#63D7CC")
self.homebtn = tk.Button(self.window,
text="Home",
bg="#D76386",
fg="white",
activebackground="#D763C2",
command=self.home)
self.logoutbtn = tk.Button(self.window,
text="Log Out",
bg="#D79F63",
fg="white",
activebackground="#D77D63",
command=self.logout)
#graph3
self.figure1 = plt.Figure(figsize=(4.5, 5.6), dpi=100)
self.ax1 = self.figure1.add_subplot(111)
self.bar1 = FigureCanvasTkAgg(self.figure1, self.window)
#graph1
self.figure2 = plt.Figure(figsize=(4.5, 5.6), dpi=100)
self.ax2 = self.figure2.add_subplot(111)
self.bar2 = FigureCanvasTkAgg(self.figure2, self.window)
self.profit_on_label = tk.Label(self.window,
text="Profit on : ",
font="Verdana 12 ",
anchor=E)
self.profit_on_Cal = DateEntry(self.window,
background='darkblue',
foreground='white',
borderwidth=2,
width=15)
#graph2
self.figure3 = plt.Figure(figsize=(5, 5.6), dpi=100)
self.ax3 = self.figure3.add_subplot(111)
self.bar3 = FigureCanvasTkAgg(self.figure3, self.window)
def configure_components(self):
self.window.configure(bg="#d7eaf5")
self.heading_label.configure(bg="#0064de")
self.sale_in_label.configure(bg="#d7eaf5")
#self.from_label.configure(bg="#d7eaf5")
self.to_label.configure(bg="#d7eaf5")
self.profit_on_label.configure(bg="#d7eaf5")
self.ax1.patch.set_facecolor("#d7eaf5")
self.ax2.patch.set_facecolor("#d7eaf5")
self.ax2.patch.set_facecolor("#d7eaf5")
def showGraph1(self):
#------------#
self.df = pd.DataFrame()
if self.sale_in == "Last month":
self.month = date.today().month - 1
self.fromday = "1"
self.interval = 7
self.year = str(d.datetime.now().year)
self.totalBars = 4
self.startdate = self.year + "-" + str(
self.month) + "-" + self.fromday
self.startdate = datetime.strptime(self.startdate, '%Y-%m-%d')
self.toDate = self.startdate + timedelta(days=self.interval)
self.bar = 1
while (self.bar <= self.totalBars):
self.dbcursor.execute(
"select medicine.Name, medicine.Tax, medicine.Cost_Price/medicine.No_Of_Medicines_Per_Strip as cp, bill.Amount, bill.Rate, bill.Bill_Quantity,bill.Date from medicine inner join bill on bill.Medicine_Name = medicine.Name and bill.Batch_No = medicine.Batch_No AND Date BETWEEN '"
+ str(self.startdate) + "' AND '" + str(self.toDate) + "'")
#self.dbcursor.execute("select count(Bill_Quantity) from bill where Medicine_Name = '" + self.med_name + "' and Category='" + self.cat_name + "' AND Date BETWEEN '" + str(self.startdate) + "' AND '" + str(self.toDate) + "'")
self.result = self.dbcursor.fetchall()
self.resultlen = self.dbcursor.rowcount
self.df2 = pd.DataFrame(self.result)
if self.resultlen == 0:
self.df2['Profit'] = 0
else:
self.df2['Profit'] = (self.df2[3] -
(self.df2[4] * self.df2[5] * 0.02 *
self.df2[1])) - (self.df2[2] *
self.df2[5])
self.df = self.df.append(
{
'Week': 'week' + str(self.bar),
'Profit': self.df2['Profit'].sum()
},
ignore_index=True)
self.bar = self.bar + 1
self.startdate = self.toDate + timedelta(days=1)
self.toDate = self.startdate + timedelta(days=self.interval)
elif self.sale_in == "Last Year":
self.month = date.today().month
self.fromday = "1"
self.year = str(d.datetime.now().year - 1)
self.totalBars = 12
self.bar = 1
self.startdate = self.year + "-" + str(
self.month) + "-" + self.fromday
self.startdate = datetime.strptime(self.startdate, '%Y-%m-%d')
while (self.bar <= self.totalBars):
self.month = self.startdate.month
self.year = self.startdate.year
self.interval = calendar.monthrange(self.year, self.month)[1]
self.toDate = self.startdate + timedelta(days=self.interval)
self.dbcursor.execute(
"select medicine.Name, medicine.Tax, medicine.Cost_Price/medicine.No_Of_Medicines_Per_Strip as cp, bill.Amount, bill.Rate, bill.Bill_Quantity,bill.Date from medicine inner join bill on bill.Medicine_Name = medicine.Name and bill.Batch_No = medicine.Batch_No AND Date BETWEEN '"
+ str(self.startdate) + "' AND '" + str(self.toDate) + "'")
self.result = self.dbcursor.fetchall()
self.len = self.dbcursor.rowcount
self.df2 = pd.DataFrame(self.result)
if self.len == 0:
self.df2['Profit'] = 0
else:
self.df2['Profit'] = (self.df2[3] -
(self.df2[4] * self.df2[5] * 0.02 *
self.df2[1])) - (self.df2[2] *
self.df2[5])
#self.dbcursor.execute("select count(Bill_Quantity) from bill where Medicine_Name = '" + self.med_name + "' and Category='" + self.cat_name + "' AND Date BETWEEN '" + str(self.startdate) + "' AND '" + str(self.toDate) + "'")
self.xaxis = str(calendar.month_name[self.month])[:3]
self.df = self.df.append(
{
'Week': self.xaxis + str(self.year),
'Profit': self.df2['Profit'].sum()
},
ignore_index=True,
sort=None)
self.bar = self.bar + 1
self.startdate = self.toDate
else:
self.startdate = date.today() - timedelta(days=7)
self.bar = 1
self.totalBars = 7
while (self.bar <= self.totalBars):
self.dbcursor.execute(
"select medicine.Name, medicine.Tax, medicine.Cost_Price/medicine.No_Of_Medicines_Per_Strip as cp, bill.Amount, bill.Rate, bill.Bill_Quantity,bill.Date from medicine inner join bill on bill.Medicine_Name = medicine.Name and bill.Batch_No = medicine.Batch_No AND Date = '"
+ str(self.startdate) + "'")
self.result = self.dbcursor.fetchall()
self.len = self.dbcursor.rowcount
self.df2 = pd.DataFrame(self.result)
if self.len == 0:
self.df2['Profit'] = 0
else:
self.df2['Profit'] = (self.df2[3] -
(self.df2[4] * self.df2[5] * 0.02 *
self.df2[1])) - (self.df2[2] *
self.df2[5])
self.bar = self.bar + 1
self.df = self.df.append(
{
'Week': self.startdate,
'Profit': self.df2['Profit'].sum()
},
ignore_index=True,
sort=None)
self.startdate = self.startdate + timedelta(days=1)
self.bar2.get_tk_widget().grid(row=4, column=0, columnspan=3)
self.ax2.patch.set_facecolor("#d7eaf5")
self.df = self.df[['Week', 'Profit']].groupby('Week', sort=False).sum()
self.df.plot(kind='bar', legend=True, ax=self.ax2, rot=30)
self.ax2.set_title("Profit in " + self.sale_in)
def showGraph2(self):
self.startdate = self.From_Cal.get_date()
self.toDate = self.To_Cal.get_date()
self.dbcursor.execute(
"select medicine.Name, medicine.Tax, medicine.Cost_Price/medicine.No_Of_Medicines_Per_Strip as cp, bill.Amount, bill.Rate, bill.Bill_Quantity,bill.Date from medicine inner join bill on bill.Medicine_Name = medicine.Name and bill.Batch_No = medicine.Batch_No AND Date BETWEEN '"
+ str(self.startdate) + "' AND '" + str(self.toDate) + "'")
self.result = self.dbcursor.fetchall()
self.resultlen = self.dbcursor.rowcount
self.df2 = pd.DataFrame(self.result)
self.x = 0
self.df1 = pd.DataFrame()
if self.resultlen == 0:
self.df2['Profit'] = 0
self.df1 = self.df1.append({
'Date': '',
'Profit': 0
},
ignore_index=True)
else:
self.df2['Profit'] = (self.df2[3] -
(self.df2[4] * self.df2[5] * 0.02 *
self.df2[1])) - (self.df2[2] * self.df2[5])
self.df2['Date'] = self.df2[6]
self.df1 = self.df2.groupby('Date')['Profit'].sum()
#self.df1 = DataFrame({'profit':self.df2.groupby(['Date']).sum()['Profit']}).reset_index()
#for row in self.result:
# self.df1 = self.df1.append({'Date':self.result[1][self.x], 'Sale' : self.result[0][self.x]}, ignore_index=True)
#if(self.resultlen==0):
# self.df1 = self.df1.append({'Date': '', 'Profit' : 0}, ignore_index=True)
#else:
# while(self.x<self.resultlen):
# self.df1 = self.df1.append({'Date':self.result[self.x][1], 'Sale' : self.result[self.x][0]}, ignore_index=True)
# self.x = self.x+1
#print(self.df1)
self.bar1.get_tk_widget().grid(row=4,
column=6,
columnspan=3,
sticky='W')
self.ax1.patch.set_facecolor("#d7eaf5")
#self.df1 = self.df1[['Date','Profit']].groupby('Date').sum()
self.df1.plot(legend=True, ax=self.ax1, rot=30, marker="*")
#self.ax1.plot(self.df1['Date'], self.df1['profit'], color='red')
self.ax1.set_title(str(self.startdate) + " to " + str(self.toDate))
def showGraph3(self):
self.profit_on = self.profit_on_Cal.get_date()
#self.dbcursor.execute("select Medicine_Name, sum(Bill_Quantity) from bill where Date = '" + str(self.profit_on) + "' group by Medicine_Name")
#self.result = self.dbcursor.fetchall()
self.profit = 0
self.dbcursor.execute(
"select medicine.Name, medicine.Tax, medicine.Cost_Price/medicine.No_Of_Medicines_Per_Strip as cp, bill.Amount, bill.Rate, bill.Bill_Quantity,bill.Date from medicine inner join bill on bill.Medicine_Name = medicine.Name and bill.Batch_No = medicine.Batch_No AND Date = '"
+ str(self.profit_on) + "'")
self.result = self.dbcursor.fetchall()
self.resultlen = self.dbcursor.rowcount
self.df1 = pd.DataFrame(self.result)
if self.resultlen == 0:
self.df1 = self.df1.append({
'Item': '',
'Profit': 0
},
ignore_index=True)
else:
self.df1['Item'] = self.df1[0]
self.df1['profit'] = (self.df1[4] - self.df1[2]) * self.df1[5]
self.profit = self.df1['profit'].sum()
self.df1 = self.df1.groupby('Item')['profit'].sum()
self.bar3.get_tk_widget().grid(row=4, column=3, columnspan=3)
self.ax3.patch.set_facecolor("#d7eaf5")
self.df1.plot(kind='bar', legend=True, ax=self.ax3, rot=30)
self.ax3.set_title("total profit : " + str(self.profit))
def pack_components(self):
self.heading_label.grid(row=0,
column=0,
sticky='ew',
columnspan=10,
ipady=20,
ipadx=20,
pady=(0, 20))
#self.backbtn.grid(row = 0, column = 6, ipadx = 15)
self.homebtn.grid(row=0, column=7, ipadx=13)
self.logoutbtn.grid(row=0, column=8, ipadx=10)
self.sale_in_label.grid(row=3, column=1, sticky=W + E, ipady=5, pady=5)
self.sale_in_combo.grid(row=3, column=2, pady=5, padx=30)
self.sale_in_combo.current(1)
self.sale_in_combo.bind("<<ComboboxSelected>>", self.graph1Changed)
self.profit_on_label.grid(row=3,
column=3,
sticky=W + E,
ipady=5,
pady=10)
self.profit_on_Cal.grid(row=3, column=4, sticky=W)
self.profit_on_Cal.bind("<<DateEntrySelected>>", self.graph3Changed)
#self.from_label.grid(row = 3, column = 6, ipady = 5, padx = 0, pady=5)
self.From_Cal.grid(row=3, column=6, pady=5, sticky=E)
self.From_Cal.bind("<<DateEntrySelected>>", self.graph1Changed)
self.to_label.grid(row=3, column=7, ipady=5, padx=0, pady=5)
self.To_Cal.grid(row=3, column=8, pady=0, sticky=W)
self.To_Cal.bind("<<DateEntrySelected>>", self.graph1Changed)
def logout(self):
self.window.destroy()
LoginWindow()
def home(self):
self.window.destroy()
from Admin_Panel import AdminPanel
AdminPanel(self.username)
def graph1Changed(self, eventObject):
self.sale_in = str(self.selected_sale_in.get())
#self.bar2.get_tk_widget().destroy()
self.ax2.clear()
self.figure2 = plt.Figure(figsize=(4.5, 5.6), dpi=100)
self.ax2 = self.figure2.add_subplot(111)
self.bar2 = FigureCanvasTkAgg(self.figure2, self.window)
self.ax1.clear()
self.figure1 = plt.Figure(figsize=(4.5, 5.6), dpi=100)
self.ax1 = self.figure1.add_subplot(111)
self.bar1 = FigureCanvasTkAgg(self.figure1, self.window)
self.showGraph1()
self.showGraph2()
def graph2Changed(self, eventObject):
self.med_name = str(self.selected_med.get())
self.cat_name = str(self.selected_cat.get())
#self.bar1.get_tk_widget().destroy()
self.ax1.clear()
self.figure1 = plt.Figure(figsize=(6, 5), dpi=100)
self.ax1 = self.figure1.add_subplot(111)
self.bar1 = FigureCanvasTkAgg(self.figure1, self.window)
self.showGraph2()
def graph3Changed(self, eventObject):
self.ax3.clear()
self.figure3 = plt.Figure(figsize=(5, 5.6), dpi=100)
self.ax3 = self.figure3.add_subplot(111)
self.bar3 = FigureCanvasTkAgg(self.figure3, self.window)
self.showGraph3()
def run(self):
self.window.geometry("1400x720")
self.window.mainloop()
#ProfitPerDayAnalysis = ProfitPerDayAnalysis()
class Dashboard(tk.Frame):
def __init__(self, master, data_manager: DataManager,
exchange_rates_store: ExchangeRatesStore):
super(Dashboard, self).__init__(master)
self.data_manager = data_manager
self.exchange_rates_store = exchange_rates_store
self.acc_list = None
self.cat_list = None
self.add_trans_popup = None
self.trans_table = None
self.accounts_popup = None
self.categories_popup = None
self.overview = None
self.chosen_accounts = set()
self.chosen_categories = set()
self.__create_widgets()
def __update_acc_list(self):
self.acc_list.update()
if self.add_trans_popup:
self.add_trans_popup.update()
if self.accounts_popup:
self.accounts_popup.update()
def __update_cat_list(self):
self.cat_list.update()
if self.add_trans_popup:
self.add_trans_popup.update()
if self.categories_popup:
self.categories_popup.update()
def __on_context_change(self):
if self.trans_table:
self.trans_table.update()
if self.overview:
self.overview.update()
def __on_acc_select(self, ids: tuple[int]):
self.chosen_accounts = set(ids)
self.__on_context_change()
def __on_cat_select(self, ids: tuple[int]):
self.chosen_categories = set(ids)
self.__on_context_change()
def __reset_accounts_popup(self, top):
top.destroy()
self.accounts_popup = None
def __on_acc_delete(self):
self.__update_acc_list()
self.__on_context_change()
def __open_accounts_popup(self):
if not self.accounts_popup:
top = tk.Toplevel(self)
top.title("Accounts")
top.geometry("500x200")
top.resizable(False, False)
top.protocol('WM_DELETE_WINDOW',
lambda *args: self.__reset_accounts_popup(top))
self.accounts_popup = AccountsPopup(top,
self.data_manager,
self.exchange_rates_store,
onadd=self.__update_acc_list,
onupdate=self.__on_acc_delete,
ondelete=self.__on_acc_delete)
self.accounts_popup.pack(side=tk.LEFT, anchor="nw", padx=5, pady=5)
def __reset_categories_popup(self, top):
top.destroy()
self.categories_popup = None
def __on_cat_delete(self):
self.__update_cat_list()
self.__on_context_change()
def __open_categories_popup(self):
if not self.categories_popup:
top = tk.Toplevel(self)
top.title("Categories")
top.geometry("500x200")
top.resizable(False, False)
top.protocol('WM_DELETE_WINDOW',
lambda *args: self.__reset_categories_popup(top))
self.categories_popup = CategoriesPopup(
top,
self.data_manager,
onadd=self.__update_cat_list,
onupdate=self.__on_cat_delete,
ondelete=self.__on_cat_delete)
self.categories_popup.pack(side=tk.LEFT,
anchor="nw",
padx=5,
pady=5)
def __reset_add_trans_popup(self, top):
top.destroy()
self.add_trans_popup = None
def __on_trans_add_callback(self):
self.__on_context_change()
if self.accounts_popup:
self.accounts_popup.update()
def __open_trans_add_popup(self):
if not self.add_trans_popup:
top = tk.Toplevel(self)
top.title("Add transaction")
top.geometry("300x260")
top.resizable(False, False)
top.protocol('WM_DELETE_WINDOW',
lambda *args: self.__reset_add_trans_popup(top))
self.add_trans_popup = AddTransactionPopup(
top, self.data_manager, self.exchange_rates_store,
self.__on_trans_add_callback)
self.add_trans_popup.pack()
def __trans_data_source(self):
min_d = datetime.fromisoformat(self.min_date_entry.get())
max_d = datetime.fromisoformat(self.max_date_entry.get())
return {
t.id: t
for acc in self.data_manager.accounts.values()
for t in acc.transactions if acc.id in self.chosen_accounts and (
not t.category or t.category.id in self.chosen_categories)
and min_d <= t.date <= max_d
}
def __create_lists(self, frame):
def acc_data_source():
return {
_id: acc.name
for _id, acc in self.data_manager.accounts.items()
}
def cat_data_source():
return {
_id: cat.name
for _id, cat in self.data_manager.categories.items()
}
wrapper = tk.Frame(frame)
acc_wrapper = tk.Frame(wrapper)
label = tk.Label(acc_wrapper,
text="Accounts",
width=Account.NAME_MAX + 2,
anchor="w",
relief=tk.GROOVE)
label.pack()
self.acc_list = Multiselect(acc_wrapper,
acc_data_source,
self.__on_acc_select,
width=Account.NAME_MAX)
self.acc_list.pack()
acc_wrapper.pack(side=tk.LEFT)
cat_wrapper = tk.Frame(wrapper)
label = tk.Label(cat_wrapper,
text="Categories",
width=Category.NAME_MAX + 2,
anchor="w",
relief=tk.GROOVE)
label.pack()
self.cat_list = Multiselect(cat_wrapper,
cat_data_source,
self.__on_cat_select,
width=Category.NAME_MAX)
self.cat_list.pack()
cat_wrapper.pack(side=tk.LEFT)
wrapper.pack()
def __create_navbar(self, frame):
pack_config = {"side": tk.LEFT, "padx": 2, "anchor": "n"}
date_entry_config = {
"width": 12,
"selectmode": "day",
"locale": "en_US",
"date_pattern": "yyyy-mm-dd",
"showweeknumbers": False
}
wrapper = tk.Frame(frame)
lbl = tk.Label(wrapper, text="DATE MIN: ", relief=tk.GROOVE)
lbl.pack(**pack_config)
self.min_date_entry = DateEntry(wrapper,
**date_entry_config,
year=2020,
month=1,
day=1)
self.min_date_entry.bind("<<DateEntrySelected>>",
lambda *args: self.__on_context_change())
self.min_date_entry.pack(**pack_config)
lbl = tk.Label(wrapper, text="DATE MAX: ", relief=tk.GROOVE)
lbl.pack(**pack_config)
self.max_date_entry = DateEntry(wrapper, **date_entry_config)
self.max_date_entry.bind("<<DateEntrySelected>>",
lambda *args: self.__on_context_change())
self.max_date_entry.pack(**pack_config)
btn = tk.Button(wrapper,
text="Accounts",
command=self.__open_accounts_popup)
btn.pack(**pack_config)
btn = tk.Button(wrapper,
text="Categories",
command=self.__open_categories_popup)
btn.pack(**pack_config)
btn = tk.Button(wrapper,
text="Add transaction",
command=self.__open_trans_add_popup)
btn.pack(**pack_config)
wrapper.pack(fill=tk.Y)
def __create_widgets(self):
frame = tk.Frame()
wrapper1 = tk.Frame(frame)
self.__create_lists(wrapper1)
wrapper1.pack(side=tk.LEFT, anchor="nw")
wrapper2 = tk.Frame(frame)
self.__create_navbar(wrapper2)
self.overview = Overview(wrapper2, self.exchange_rates_store,
self.__trans_data_source)
self.overview.pack(side=tk.TOP)
wrapper2.pack(side=tk.LEFT)
frame.pack(fill=tk.X, padx=10, pady=10)
wrapper3 = tk.Frame()
labelframe = tk.LabelFrame(wrapper3, text="Transactions", font=10)
self.trans_table = TransactionTable(
labelframe, self.__trans_data_source,
lambda *args: self.__on_context_change())
self.trans_table.pack(fill=tk.BOTH, expand=1)
labelframe.pack(fill=tk.BOTH, expand="yes")
wrapper3.pack(fill=tk.BOTH, expand="yes", padx=10, pady=10)
class DiplomaFrame(tk.Frame):
#this holds the info needed for the diploma, it holds all info for the diploma in a map
#this frame will pass all the info onto the dip_model
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.controller = controller
label = tk.Label(self, text="Diploma Info")
label.grid(column = 2, row = 0)
button = tk.Button(self, text="< Back",
command=lambda: controller.showFrame("StartPage", controller.model))
button.grid(column = 1, row = 19)
dipDict = {'first': "", 'middle': "", 'last': "", 'degree': "", 'curriculum': "", 'dateDegree': "", 'identificationTail': ""
,'birth_date': "", 'attend_date': "", 'email': "", 'phone': "", 'description': "", 'returned': "", 'payment': "", 'address':""}
self.first_name = tk.StringVar()
self.middle_name = tk.StringVar()
self.last_name = tk.StringVar()
self.degree = tk.StringVar()
self.curriculum = tk.StringVar()
self.date_degree = datetime.date(2000, 1, 1)
self.id_tail = tk.StringVar()
self.birth_date = datetime.date(2000, 1, 1)
self.start_date = datetime.date(2000, 1, 1)
self.end_date = datetime.date(2000, 1, 1)
self.email = tk.StringVar()
self.phone = tk.StringVar()
self.description = tk.StringVar()
self.dip_returned = bool
self.payment = tk.StringVar()
self.address = tk.StringVar()
self.first_name_label = tk.Label(self, text="First Name:", anchor = "w")
self.first_name_entry = tk.Entry(self, textvariable = self.first_name)
self.first_name_label.grid(column = 1, row = 2, padx=(10,5))
self.first_name_entry.grid(column=2, row = 2)
self.middle_name_label = tk.Label(self, text="Middle Name:")
self.middle_name_entry = tk.Entry(self, textvariable = self.middle_name)
self.middle_name_label.grid(column = 1, row = 3, padx=(10,5))
self.middle_name_entry.grid(column=2, row = 3)
self.last_name_label = tk.Label(self, text="Last Name:")
self.last_name_entry = tk.Entry(self, textvariable = self.last_name)
self.last_name_label.grid(column = 1, row = 4, padx=(10,5))
self.last_name_entry.grid(column=2, row = 4)
self.degree_label = tk.Label(self, text="Degree:")
self.degree_entry = tk.Entry(self, textvariable = self.degree)
self.degree_label.grid(column = 1, row = 5, padx=(10,5))
self.degree_entry.grid(column=2, row = 5)
self.curriculum_label = tk.Label(self, text="Curriculum:")
self.curriculum_entry = tk.Entry(self, textvariable = self.curriculum)
self.curriculum_label.grid(column = 1, row = 6, padx=(10,5))
self.curriculum_entry.grid(column=2, row = 6)
self.date_degree_label = tk.Label(self, text="Date of Degree:")
self.date_degree_cal = DateEntry(self)
self.date_degree_cal.bind("<<DateEntrySelected>>", self.setDateDegree())
self.date_degree_label.grid(column=1, row = 7)
self.date_degree_cal.grid(column = 2, row = 7)
self.id_label_1 = tk.Label(self, text="Last 4 Digits of SSN:")
self.id_label_2 = tk.Label(self, text = "or Student ID#")
self.id_entry = tk.Entry(self, textvariable = self.id_tail)
self.id_label_1.grid(column = 1, row = 8, padx=(10,5))
self.id_label_2.grid(column = 1, row = 9)
self.id_entry.grid(column=2, row = 8)
self.birth_date_label = tk.Label(self, text="Date of Birth:")
self.birth_date_cal = DateEntry(self)
self.birth_date_cal.bind("<<DateEntrySelected>>", self.setBirthDate())
self.birth_date_label.grid(column=1, row = 10)
self.birth_date_cal.grid(column = 2, row = 10)
self.start_date_label = tk.Label(self, text="Attendance Start Date")
self.start_date_cal = DateEntry(self, width = 12)
self.start_date_cal.bind("<<DateEntrySelected>>", self.setStartDate())
self.start_date_label.grid(column=1, row = 11)
self.start_date_cal.grid(column = 2, row = 11)
self.end_date_label = tk.Label(self, text="Attendance End Date")
self.end_date_cal = DateEntry(self, width = 12)
self.end_date_cal.bind("<<DateEntrySelected>>", self.setEndDate())
self.end_date_label.grid(column=1, row = 12)
self.end_date_cal.grid(column = 2, row = 12)
self.email_label = tk.Label(self, text="Email:")
self.email_entry = tk.Entry(self, textvariable = self.email)
self.email_label.grid(column = 1, row = 13, padx=(10,5))
self.email_entry.grid(column=2, row = 13)
self.phone_label = tk.Label(self, text="Phone #:")
self.phone_entry = tk.Entry(self, textvariable = self.phone)
self.phone_label.grid(column = 1, row = 14, padx=(10,5))
self.phone_entry.grid(column=2, row = 14)
self.description_label = tk.Label(self, text="Reason for Request:")
self.description_entry = tk.Entry(self, textvariable = self.description)
self.description_label.grid(column = 1, row = 15, padx=(10,5))
self.description_entry.grid(column=2, row = 15)
self.temp_int = tk.IntVar()
self.returned_label = tk.Label(self, text= "Diploma returned?")
self.returned_label.grid(column = 1, row = 16)
self.return_true_dip = tk.Radiobutton(self, text="Yes", value=1, variable=self.temp_int, command = self.setReturned())
self.return_false_dip = tk.Radiobutton(self, text="No", value=0, variable=self.temp_int, command = self.setReturned())
self.return_true_dip.grid(column = 2, row = 16)
self.return_false_dip.grid(column = 3, row = 16)
self.pay_label = tk.Label(self, text="Payment Type ($50):")
self.pay_entry = tk.Entry(self, textvariable = self.payment)
self.pay_label.grid(column = 1, row = 17, padx=(10,5))
self.pay_entry.grid(column=2, row = 17)
self.address_label = tk.Label(self, text="Address:")
self.address_entry = tk.Entry(self, textvariable = self.address)
self.address_label.grid(column = 1, row = 18, padx=(10,5))
self.address_entry.grid(column=2, row = 18)
self.enter_button = tk.Button(self, text="Enter >",
command=lambda: self.updateDipModel(dipDict))
self.enter_button.grid(column = 2, row = 19)
def setDateDegree(self):
self.date_degree = self.date_degree_cal.get_date()
print (self.date_degree)
def setBirthDate(self):
self.birth_date = self.birth_date_cal.get_date()
def setStartDate(self):
self.start_date = self.start_date_cal.get_date()
def setEndDate(self):
self.end_date = self.end_date_cal.get_date()
def setReturned(self):
if self.temp_int == 1:
self.dip_returned = True
else:
self.dip_returned = False
def updateDipModel(self, dict):
dict['first'] = self.first_name.get()
dict['middle'] = self.middle_name.get()
dict['last'] = self.last_name.get()
dict['degree'] = self.degree.get()
dict['curriculum'] = self.curriculum.get()
dict['dateDegree'] = self.date_degree_cal.get()
dict['identificationTail'] = self.id_tail.get()
dict['birth_date'] = self.birth_date_cal.get()
dict['attend_date'] = [self.start_date_cal.get(), self.end_date_cal.get()]
dict['email'] = self.email.get()
dict['phone'] = self.phone.get()
dict['description'] = self.description.get()
dict['returned'] = self.dip_returned
dict['payment'] = self.payment.get()
dict['address'] = self.address.get()
self.controller.dip_model.setInfo(dict)
class EventsWindow:
def __init__(self):
self.win = Tk()
self.canvas = Canvas(self.win, width=600, height=500, bg='white')
self.canvas.pack(expand=YES, fill=BOTH)
width = self.win.winfo_screenwidth()
height = self.win.winfo_screenheight()
x = int(width / 2 - 600 / 2)
y = int(height / 2 - 500 / 2)
str1 = "600x500+" + str(x) + "+" + str(y)
self.win.geometry(str1)
self.win.resizable(width=False, height=False)
self.win.title("Events and Bindings")
def add_frame(self):
self.frame = Frame(self.win, height=400, width=450)
self.frame.place(x=80, y=50)
x, y = 70, 20
self.label = Label(self.frame, text="Events and Bindings")
self.label.config(font=('Courier', 20, 'bold'))
self.label.place(x=x + 10, y=y + 50)
self.label = Label(self.frame, text='Enter name')
self.label.config(font=('Courier', 12, 'bold'))
self.label.place(x=50, y=y + 130)
self.name = Entry(self.frame, font='Courier 12')
self.name.place(x=200, y=y + 130)
self.name.bind('<KeyRelease>', self.keyup)
# calendar in tkinter
self.label = Label(self.frame, text='Select DOB')
self.label.config(font=('Courier', 12, 'bold'))
self.label.place(x=50, y=y + 160)
self.dob = DateEntry(self.frame,
font=('Courier', 12, 'bold'),
bg='darkblue',
fg='white',
borderwidth=2,
command=self.dates)
self.dob.place(x=200, y=y + 160)
#on date change listener
self.dob.bind('<<DateEntrySelected>>', self.dates)
# radio buttons
self.var = StringVar()
self.label = Label(self.frame, text='Select Gender')
self.label.config(font=('Courier', 12, 'bold'))
self.label.place(x=50, y=y + 190)
self.male = Radiobutton(self.frame,
variable=self.var,
font='Courier 12',
text='Male',
value='Male',
command=self.sel)
self.male.place(x=200, y=y + 190)
self.female = Radiobutton(self.frame,
variable=self.var,
font='Courier 12',
text='FeMale',
value='FeMale',
command=self.sel)
self.female.place(x=280, y=y + 190)
# Drop down menu
OPTIONS = ['Jalandhar', 'Amritsar', 'Phagwara']
self.variable = StringVar(self.win)
self.variable.set(OPTIONS[0])
self.label = Label(self.frame, text='Select City')
self.label.config(font=('Courier', 12, 'bold'))
self.label.place(x=50, y=y + 220)
self.city = OptionMenu(self.frame,
self.variable,
*OPTIONS,
command=self.dropdown)
self.city.place(x=200, y=y + 220)
self.win.mainloop()
def keyup(self, value, *args):
print(self.name.get())
def dates(self, value, *args):
print(self.dob.get_date())
def sel(self):
print(self.var.get())
def dropdown(self, value, *args):
print(self.variable.get())
class Form(Toplevel):
def __init__(self, master, event, new=False):
Toplevel.__init__(self, master)
self.minsize(410, 402)
if master.winfo_ismapped():
self.transient(master)
self.protocol('WM_DELETE_WINDOW', self.cancel)
self._only_nb = self.register(only_nb)
self.event = event
if new:
self.title(_('New Event'))
else:
self.title(_('Edit Event'))
self._new = new
self._task = BooleanVar(self, bool(event['Task']))
self._whole_day = BooleanVar(self, event['WholeDay'])
# --- style
style = Style(self)
active_bg = style.lookup('TEntry', 'selectbackground', ('focus', ))
self.alarms = []
notebook = Notebook(self)
notebook.pack(fill='both', expand=True)
Button(self, text=_('Ok'), command=self.ok).pack(pady=(10, 6), padx=4)
# --- event settings
frame_event = Frame(notebook)
notebook.add(frame_event, text=_('Event'), sticky='eswn', padding=4)
frame_event.columnconfigure(1, weight=1)
frame_event.rowconfigure(5, weight=1)
self.img_moins = PhotoImage(master=self, file=IM_DEL)
self.img_bell = PhotoImage(master=self, file=IM_BELL)
Label(frame_event, text=_('Summary')).grid(row=0,
column=0,
padx=4,
pady=6,
sticky='e')
Label(frame_event, text=_('Place')).grid(row=1,
column=0,
padx=4,
pady=6,
sticky='e')
Label(frame_event, text=_('Start')).grid(row=2,
column=0,
padx=4,
pady=6,
sticky='e')
self._end_label = Label(frame_event, text=_('End'))
self._end_label.grid(row=3, column=0, padx=4, pady=6, sticky='e')
frame_task = Frame(frame_event)
frame_task.grid(row=4, column=1, padx=4, pady=6, sticky='w')
Label(frame_event, text=_('Description')).grid(row=5,
column=0,
padx=4,
pady=6,
sticky='e')
Label(frame_event, text=_('Category')).grid(row=6,
column=0,
padx=4,
pady=6,
sticky='e')
Button(frame_event,
image=self.img_bell,
command=self.add_reminder,
padding=0).grid(row=7, column=0, padx=4, pady=6, sticky='en')
self.summary = Entry(frame_event, width=35)
self.summary.insert(0, self.event['Summary'])
self.summary.grid(row=0, column=1, padx=4, pady=6, sticky='ew')
self.place = Entry(frame_event, width=35)
self.place.insert(0, self.event['Place'])
self.place.grid(row=1, column=1, padx=4, pady=6, sticky='ew')
frame_start = Frame(frame_event)
frame_start.grid(row=2, column=1, padx=4, pady=6, sticky='w')
frame_end = Frame(frame_event)
frame_end.grid(row=3, column=1, padx=4, pady=6, sticky='w')
txt_frame = Frame(frame_event,
style='txt.TFrame',
border=1,
relief='sunken')
self.desc = Text(txt_frame,
width=35,
height=4,
highlightthickness=0,
relief='flat',
selectbackground=active_bg)
self.desc.insert('1.0', self.event['Description'])
self.desc.pack(fill='both', expand=True)
txt_frame.grid(row=5, column=1, padx=4, pady=6, sticky='ewsn')
cats = list(CONFIG.options('Categories'))
width = max([len(cat) for cat in cats])
self.category = Combobox(frame_event,
width=width + 2,
values=cats,
state='readonly')
self.category.set(event['Category'])
self.category.grid(row=6, column=1, padx=4, pady=6, sticky='w')
self.frame_alarms = Frame(frame_event)
self.frame_alarms.grid(row=7, column=1, sticky='w')
# --- *--- task
Checkbutton(frame_task,
text=_('Task'),
command=self._change_label,
variable=self._task).pack(side='left')
self.task_progress = Combobox(frame_task,
state='readonly',
width=9,
values=(_('Pending'), _('In Progress'),
_('Completed'), _('Cancelled')))
self.task_progress.pack(side='left', padx=(8, 4))
self.in_progress = Combobox(
frame_task,
state='readonly',
width=5,
values=['{}%'.format(i) for i in range(0, 110, 10)])
self.in_progress.pack(side='left', padx=4)
if not event['Task']:
self.task_progress.set(_('Pending'))
self.in_progress.set('0%')
elif '%' in event['Task']:
self.task_progress.set(_('In Progress'))
self.in_progress.set(event['Task'])
else:
self.task_progress.set(_(event['Task']))
self.in_progress.set('0%')
# calendar settings
prop = {
op: CONFIG.get('Calendar', op)
for op in CONFIG.options('Calendar')
}
prop['font'] = "Liberation\ Sans 9"
prop.update(selectforeground='white', selectbackground=active_bg)
locale = CONFIG.get('General', 'locale')
# --- *--- start date
self.start_date = self.event['Start']
self.start_entry = DateEntry(frame_start,
locale=locale,
width=10,
justify='center',
year=self.start_date.year,
month=self.start_date.month,
day=self.start_date.day,
**prop)
self.start_hour = Combobox(frame_start,
width=3,
justify='center',
state='readonly',
exportselection=False,
values=['%02d' % i for i in range(24)])
self.start_hour.set('%02d' % self.start_date.hour)
self.start_min = Combobox(frame_start,
width=3,
justify='center',
state='readonly',
exportselection=False,
values=['%02d' % i for i in range(0, 60, 5)])
self.start_min.set('%02d' % self.start_date.minute)
self.start_entry.pack(side='left', padx=(0, 18))
self.start_hour.pack(side='left', padx=(4, 0))
self.start_date = self.start_date.date()
Label(frame_start, text=':').pack(side='left')
self.start_min.pack(side='left', padx=(0, 4))
Checkbutton(frame_start,
text=_("whole day"),
variable=self._whole_day,
command=self._toggle_whole_day).pack(side='left', padx=4)
# --- *--- end date
self.end_date = self.event['End']
self.end_entry = DateEntry(frame_end,
justify='center',
locale=locale,
width=10,
year=self.end_date.year,
month=self.end_date.month,
day=self.end_date.day,
**prop)
self.end_hour = Combobox(frame_end,
width=3,
justify='center',
state='readonly',
exportselection=False,
values=['%02d' % i for i in range(24)])
self.end_hour.set('%02d' % self.end_date.hour)
self.end_min = Combobox(frame_end,
width=3,
justify='center',
state='readonly',
exportselection=False,
values=['%02d' % i for i in range(0, 60, 5)])
self.end_min.set('%02d' % self.end_date.minute)
self.end_entry.pack(side='left', padx=(0, 18))
self.end_hour.pack(side='left', padx=(4, 0))
Label(frame_end, text=':').pack(side='left')
self.end_min.pack(side='left', padx=(0, 4))
self.end_date = self.end_date.date()
for date in self.event['Reminders'].values():
self.add_reminder(date)
self._toggle_whole_day()
# --- repetition settings
frame_rep = Frame(notebook)
notebook.add(frame_rep, text=_('Repetition'), padding=4, sticky='eswn')
frame_rep.columnconfigure(0, weight=1)
frame_rep.columnconfigure(1, weight=1)
frame_rep.rowconfigure(1, weight=1)
self._repeat = BooleanVar(self, bool(self.event['Repeat']))
repeat = {
'Frequency': 'year',
'Limit': 'always',
'NbTimes': 1,
'EndDate': (datetime.now() + timedelta(days=1)).date(),
'WeekDays': [self.start_date.isocalendar()[2] - 1]
}
repeat.update(self.event['Repeat'])
self._repeat_freq = StringVar(self, repeat['Frequency'])
Checkbutton(frame_rep,
text=_('Repeat event'),
variable=self._repeat,
command=self._toggle_rep).grid(row=0,
column=0,
columnspan=2,
padx=4,
pady=6,
sticky='w')
# --- *--- Frequency
frame_freq = LabelFrame(frame_rep, text=_('Frequency'))
frame_freq.grid(row=1, column=0, sticky='eswn', padx=(0, 3))
self._lfreq = Label(frame_freq, text=_('Every:'))
self._lfreq.grid(row=0, column=0, padx=4, pady=2, sticky='e')
self._freqs = []
for i, val in enumerate(['Year', 'Month', 'Week']):
r = Radiobutton(frame_freq,
text=_(val),
variable=self._repeat_freq,
value=val.lower(),
command=self._toggle_wd)
r.grid(row=i, column=1, padx=4, pady=2, sticky='nw')
self._freqs.append(r)
frame_days = Frame(frame_freq)
frame_days.grid(row=2, column=2, padx=4, pady=2, sticky='nw')
self._week_days = []
days = get_day_names("wide", locale=locale)
days = [days[i] for i in range(7)]
for day in days:
ch = Checkbutton(frame_days, text=day)
ch.pack(anchor='w')
self._week_days.append(ch)
for d in repeat['WeekDays']:
self._week_days[int(d)].state(('selected', ))
# --- *--- Limit
frame_lim = LabelFrame(frame_rep, text=_('Limit'))
frame_lim.grid(row=1, column=1, sticky='eswn', padx=(3, 0))
frame_lim.grid(row=1, column=1, sticky='eswn', padx=(3, 0))
self._repeat_lim = StringVar(self, repeat['Limit'])
# always
r1 = Radiobutton(frame_lim,
text=_('Always'),
value='always',
variable=self._repeat_lim,
command=self._toggle_lim)
r1.grid(row=0, column=0, sticky='w')
# until
r2 = Radiobutton(frame_lim,
text=_('Until'),
value='until',
variable=self._repeat_lim,
command=self._toggle_lim)
r2.grid(row=1, column=0, sticky='w')
until_date = repeat['EndDate']
self.until_entry = DateEntry(frame_lim,
width=10,
justify='center',
locale=locale,
year=until_date.year,
month=until_date.month,
day=until_date.day,
**prop)
self.until_entry.grid(row=1,
column=1,
columnspan=2,
sticky='w',
padx=(4, 10),
pady=2)
# after
r3 = Radiobutton(frame_lim,
text=_('After'),
value='after',
variable=self._repeat_lim,
command=self._toggle_lim)
r3.grid(row=2, column=0, sticky='w')
frame_after = Frame(frame_lim,
style='txt.TFrame',
relief='sunken',
border=1)
self.s_after = Spinbox(frame_after,
from_=0,
to=100,
width=3,
justify='center',
relief='flat',
highlightthickness=0,
validate='key',
validatecommand=(self._only_nb, '%P'),
disabledbackground='white')
self.s_after.pack()
self.s_after.delete(0, 'end')
self.s_after.insert(0, str(repeat['NbTimes']))
frame_after.grid(row=2, column=1, padx=4, pady=2, sticky='w')
self._llim = Label(frame_lim, text=_('times'))
self._llim.grid(row=2, column=2, padx=0, pady=2, sticky='w')
self._rb_lim = [r1, r2, r3]
self._toggle_rep()
self._change_label()
# --- bindings
self.bind('<Configure>')
self.task_progress.bind('<<ComboboxSelected>>',
self._toggle_in_progress)
self.start_entry.bind('<<DateEntrySelected>>', self._select_start)
self.end_entry.bind('<<DateEntrySelected>>', self._select_end)
self.start_hour.bind("<<ComboboxSelected>>", self._select_start_hour)
self.start_min.bind("<<ComboboxSelected>>", self._select_start_min)
self.end_min.bind("<<ComboboxSelected>>", self._select_end_time)
self.end_hour.bind("<<ComboboxSelected>>", self._select_end_time)
self.bind_class("TCombobox",
"<<ComboboxSelected>>",
self.__clear_selection,
add=True)
# self.wait_visibility(self)
# self.grab_set()
self.summary.focus_set()
def _toggle_lim(self, val=True):
if val:
val = self._repeat_lim.get()
if val == 'until':
self.s_after.configure(state='disabled')
self._llim.state(('disabled', ))
self.until_entry.state(('!disabled', ))
elif val == 'after':
self._llim.state(('!disabled', ))
self.s_after.configure(state='normal')
self.until_entry.state(('disabled', ))
else:
self.s_after.configure(state='disabled')
self._llim.state(('disabled', ))
self.until_entry.state(('disabled', ))
def _toggle_rep(self):
rep = self._repeat.get()
state = state = '!' * int(rep) + "disabled"
for r in self._freqs:
r.state((state, ))
for r in self._rb_lim:
r.state((state, ))
self._lfreq.state((state, ))
self._toggle_wd(rep)
self._toggle_lim(rep)
def _toggle_wd(self, val=True):
if val:
val = self._repeat_freq.get()
state = '!' * int(val == 'week') + "disabled"
for ch in self._week_days:
ch.state((state, ))
def _toggle_whole_day(self):
if self._whole_day.get():
self.start_min.set('00')
self.start_hour.set('00')
self.end_min.set('59')
self.end_hour.set('23')
self.start_min.state(("disabled", ))
self.start_hour.state(("disabled", ))
self.end_min.state(("disabled", ))
self.end_hour.state(("disabled", ))
else:
self.start_min.state(("!disabled", ))
self.start_hour.state(("!disabled", ))
self.end_min.state(("!disabled", ))
self.end_hour.state(("!disabled", ))
def _toggle_in_progress(self, event=None):
if self.task_progress.get() == _('In Progress'):
self.in_progress.state(('!disabled', ))
else:
if self.task_progress.get() == _('Completed'):
self.in_progress.set('100%')
self.in_progress.state(('disabled', ))
def _change_label(self):
if self._task.get():
self.task_progress.state(('!disabled', ))
self._toggle_in_progress()
self._end_label.configure(text=_('Deadline'))
else:
self.task_progress.state(('disabled', ))
self.in_progress.state(('disabled', ))
self._end_label.configure(text=_('End'))
def _on_move(self, event):
self.start_cal.withdraw()
self.end_cal.withdraw()
self.until_cal.withdraw()
@staticmethod
def __clear_selection(event):
combo = event.widget
combo.selection_clear()
def _select_start(self, event=None):
dt = self.start_entry.get_date() - self.start_date
self.end_date = self.end_date + dt
self.end_entry.set_date(self.end_date)
self.start_date = self.start_entry.get_date()
def _select_end(self, event=None):
self.end_date = self.end_entry.get_date()
start = self.start_entry.get_date()
if start >= self.end_date:
self.start_date = self.end_date
self.start_entry.set_date(self.end_date)
start_time = time(int(self.start_hour.get()),
int(self.start_min.get()))
end_time = time(int(self.start_hour.get()),
int(self.end_min.get()))
if start_time > end_time:
self.start_hour.set(self.end_hour.get())
self.start_min.set(self.end_min.get())
def _select_start_hour(self, event):
h = int(self.start_hour.get())
self.end_hour.set('%02d' % ((h + 1) % 24))
def _select_start_min(self, event):
m = int(self.start_min.get())
self.end_min.set('%02d' % m)
def _select_end_time(self, event):
if self.start_entry.get() == self.end_entry.get():
start_time = time(int(self.start_hour.get()),
int(self.start_min.get()))
end_time = time(int(self.end_hour.get()), int(self.end_min.get()))
if start_time > end_time:
self.start_hour.set(self.end_hour.get())
self.start_min.set(self.end_min.get())
def add_reminder(self, date=None):
def remove():
self.alarms.remove((when, what))
rem.destroy()
rem = Frame(self.frame_alarms)
frame_when = Frame(rem, style='txt.TFrame', relief='sunken', border=1)
when = Spinbox(frame_when,
from_=0,
to=59,
width=3,
justify='center',
relief='flat',
highlightthickness=0,
validate='key',
validatecommand=(self._only_nb, '%P'))
when.pack()
when.delete(0, 'end')
what = Combobox(rem,
width=8,
state='readonly',
values=(_('minutes'), _('hours'), _('days')))
if date:
hour = int(self.start_hour.get())
minute = int(self.start_min.get())
dt = datetime.combine(self.start_entry.get_date(),
time(hour=hour, minute=minute)) - date
if dt.days > 0:
when.insert(0, str(dt.days))
what.set(_('days'))
else:
h, m, s = str(dt).split(':')
if h != "0":
when.insert(0, h)
what.set(_('hours'))
else:
when.insert(0, str(int(m)))
what.set(_('minutes'))
else:
when.insert(0, '15')
what.set(_('minutes'))
self.alarms.append((when, what))
Label(rem, text=_('Reminder:')).pack(side='left', padx=4, pady=4)
frame_when.pack(side='left', pady=4, padx=4)
what.pack(side='left', pady=4, padx=4)
Button(rem, image=self.img_moins, padding=0,
command=remove).pack(side='left', padx=4, pady=4)
rem.pack()
def ok(self):
summary = self.summary.get()
if not summary:
showerror(_("Error"),
_("The field 'Summary' cannot be empty."),
parent=self)
return
self.event['Summary'] = summary
self.event['Place'] = self.place.get()
self.event['Start'] = "%s %s:%s" % (
self.start_entry.get_date().strftime("%Y-%m-%d"),
self.start_hour.get(), self.start_min.get())
self.event['End'] = "%s %s:%s" % (self.end_entry.get_date().strftime(
"%Y-%m-%d"), self.end_hour.get(), self.end_min.get())
self.event['Description'] = self.desc.get('1.0', 'end')
self.event['Category'] = self.category.get()
if not self._task.get():
self.event['Task'] = False
else:
prog = self.task_progress.get()
if prog == _('In Progress'):
self.event['Task'] = self.in_progress.get()
else:
self.event['Task'] = TASK_REV_TRANSLATION[prog]
self.event["WholeDay"] = self._whole_day.get()
if not self._repeat.get():
self.event['Repeat'] = {}
else:
days = []
for i in range(7):
if "selected" in self._week_days[i].state():
days.append(i)
repeat = {
'Frequency': self._repeat_freq.get(),
'Limit': self._repeat_lim.get(),
'NbTimes': int(self.s_after.get()),
'EndDate': self.until_entry.get_date(),
'WeekDays': days
}
self.event['Repeat'] = repeat
self.event.reminder_remove_all()
for when, what in self.alarms:
dt = int(when.get())
unit = FREQ_REV_TRANSLATION[what.get()]
date = self.event['Start'] - timedelta(**{unit: dt})
self.event.reminder_add(date)
if self._new:
self.master.event_add(self.event)
else:
self.master.event_configure(self.event.iid)
self.destroy()
def cancel(self):
if not self._new:
self.master.widgets['Calendar'].add_event(self.event)
self.destroy()
class Calendar(Frame):
def __init__(self, parent):
Frame.__init__(self, parent, highlightbackground="black", highlightcolor="black", highlightthickness=2)
self.day_name = StringVar()
self.__calendar()
def __calendar(self):
self.calendar_title_label = Label(self,
text="Fecha",
anchor="center",
relief="groove")
self.calendar_title_label.grid(row=0,
column=0,
padx=(0, CELL_PADDING),
pady=CELL_PADDING,
ipadx=CELL_MARGIN,
ipady=CELL_MARGIN,
sticky=W + E + N + S)
self.calendar_date_entry = DateEntry(self,
width=5,
justify="center",
background='darkblue',
foreground='white',
borderwidth=0,
day=datetime.now().day - 1,
month=datetime.now().month,
year=datetime.now().year,
locale="es_ES",
date_pattern="dd/mm/yyyy")
self.calendar_date_entry.grid(row=1,
column=0,
padx=(0, CELL_PADDING),
pady=CELL_PADDING,
ipadx=CELL_MARGIN,
ipady=CELL_MARGIN,
sticky=W + E + N + S)
self.calendar_date_entry.bind("<<DateEntrySelected>>", self.__print_name_day)
self.calendar_title_label = Label(self,
text="Día",
anchor="center",
relief="groove")
self.calendar_title_label.grid(row=0,
column=1,
padx=(0, CELL_PADDING),
pady=CELL_PADDING,
ipadx=CELL_MARGIN,
ipady=CELL_MARGIN,
sticky=W + E + N + S)
self.calendar_label = Label(self,
anchor="center",
textvariable=self.day_name,
relief="groove")
self.calendar_label.grid(row=1,
column=1,
padx=(0, CELL_PADDING),
pady=CELL_PADDING,
ipadx=CELL_MARGIN,
ipady=CELL_MARGIN,
sticky=W + E + N + S)
def __print_name_day(self, event):
w = event.widget
date = w.get_date()
locale.setlocale(locale.LC_TIME, 'es_ES.UTF-8')
date_with_format = date.strftime("%A, %d de %B de %Y") # Para windows
#date_with_format = date.strftime("%A, %-d de %B de %Y") # Para Linux
self.day_name.set(date_with_format)
def return_date(self):
# Poner alguna condición para que no le devuelva esto si no hay nada en el campo del formato de la fecha.
if self.day_name.get() == "":
variable_return = "0"
else:
variable_return = self.calendar_date_entry.get_date().strftime("%d/%m/%Y")
return variable_return
def clear(self):
self.day_name.set("")
def exportCSV ():
global fin, folder_selected
# export_file_path = filedialog.asksaveasfile(defaultextension='.csv')
folder_selected = os.path.normpath(filedialog.askdirectory(initial = '/'))
def setsame(e):
cal2.set_date(cal1.get_date())
start = Label(root, text = "Start:", pady = 20)
cal1 = DateEntry(width=12, background='darkblue',
foreground='white', borderwidth=2, date_pattern='dd/mm/yy')
cal1.bind("<<DateEntrySelected>>", setsame)
end = Label(root, text = "End:", pady=10)
cal2 = DateEntry(width=12, background='darkblue',
foreground='white', borderwidth=2, date_pattern='dd/mm/yy')
btn = Button(root, text="Download", command=pressed, padx=40)
# path = Label(root, text = folder_selected, pady=5)
curr = Label(root, text = "Current Path : "+folder_selected, padx = 30, pady=5)
locn = Button(root, text="Change Path", command=exportCSV, padx=20)
start.grid(row=2, column=0)
class ChooseDate(tk.Frame):
def __init__(self,master):
tk.Frame.__init__(self,master)
# initialise and reset flag and multiclass variables on ChooseDate page
global sel_hour,sel_minute,dateClassFlag
sel_hour = sel_minute = sel_date = sel_time = dateClassFlag = None
#User Interface of ChooseDate page
#Display Background Image
tk.Label(self,image = master.getImage(img_def)).grid(sticky='nsew')
# Values in dropdownlist for hours and minutes
hours = [i for i in range(25)]
minutes = [i for i in range(60)]
# Arguments for dropdownlist widget (data type declaration for userinput)
hourVar = tk.StringVar()
minuteVar = tk.StringVar()
#Date Label
self.date_prompt = tk.Label(self,text="Date", width=8, bg = "black",fg='PaleTurquoise2', font=standardFont,anchor='center')
self.date_prompt.place(x = 250,y = 50)
# Date picker widget instantiation
self.dateEnt = DateEntry(self,state="readonly",font=standardFont)
self.dateEnt.bind("<<DateEntrySelected>>", self.print_date)
self.dateEnt.place(x = 350,y = 50)
#Display the date in the format of Friday 5 Nov
self.sel_date_lbl = tk.Label(self,text="Today",font=standardFont,bg="black",fg='PaleTurquoise2',anchor='center')
self.sel_date_lbl.place(x = 550,y = 50)
# Dropdown list for hours
self.hour_label = tk.Label(self,text="Hour",width=8, font=standardFont,bg = "black",fg='PaleTurquoise2')
self.hour_cbb = ttk.Combobox(self,state="readonly",font=standardFont,textvariable=hourVar,values=hours,width = 9)
self.hour_cbb.bind("<<ComboboxSelected>>", self.print_time)
self.hour_label.place(x = 250,y = 150)
self.hour_cbb.place(x = 350,y = 150)
# Dropdown list for minutes
self.minute_label = tk.Label(self,text="Min",width=8, font=standardFont,bg = "black",fg='PaleTurquoise2')
self.minute_cbb = ttk.Combobox(self,state="readonly",font=standardFont,textvariable=minuteVar,values=minutes,width = 9)
self.minute_cbb.bind("<<ComboboxSelected>>", self.print_time)
self.minute_label.place(x = 250,y = 200)
self.minute_cbb.place(x = 350,y = 200)
#Display the hour and minutes like like 12:05 if got user input
self.sel_time_lbl = tk.Label(self,text="00:00",font=standardFont,bg = "black",fg='PaleTurquoise2',anchor='center')
self.sel_time_lbl.place(x = 550,y = 150)
#Submit Button
self.submitBtn = tk.Button(self,text="Submit",bg = "green",fg='PaleTurquoise2',borderwidth=0, width = 30, font=standardFont,command=self.submitTime)
self.submitBtn.place(x = 250,y = 350)
#Back Button
self.backBtn = tk.Button(self,text="Back",bg='red',fg='PaleTurquoise2',borderwidth=0, width = 30,font=standardFont,command=lambda: master.switch_frame(Home))
self.backBtn.place(x =250,y = 400)
#Functions for ChooseDate page
#Check the user input for time
def submitTime(self):
global sel_hour,sel_minute,sel_date,sel_time,dateClassFlag
## Validation for empty user input
if len(self.hour_cbb.get()) == 0 or len(self.minute_cbb.get()) == 0:
messagebox.showwarning("Uh Oh!","Please select hours and minutes")
else:
sel_hour = int(self.hour_cbb.get())
sel_minute = int(self.minute_cbb.get())
sel_time = "{0:0=2d}".format(sel_hour) + ":" + "{0:0=2d}".format(sel_minute)
sel_date = self.dateEnt.get_date().strftime("%A")
dateClassFlag = True
self.master.switch_frame(ChooseStore)
#Configure the label based on user input of the date like Tuesday 5 Nov
def print_date(self,e):
selD_display = self.dateEnt.get_date().strftime("%A %d %b")
self.sel_date_lbl.config(text=selD_display)
#Configure the label based on user input of hour and time like 12:05
def print_time(self,e):
if len(self.hour_cbb.get())==0 or len(self.minute_cbb.get())==0:
pass
else:
selT_display = "{0:0=2d}".format(int(self.hour_cbb.get())) + ":" + "{0:0=2d}".format(int(self.minute_cbb.get()))
self.sel_time_lbl.config(text=str(selT_display))
v.bind('<Enter>', setPwd)
v.bind('<Leave>', setPwd)
L3 = Label(root, text="Date Until")
L3.pack(side=LEFT)
L3.place(x=5, y=110)
cal = DateEntry(root,
width=12,
background='darkblue',
foreground='white',
borderwidth=2,
year=2019)
cal.pack(padx=10, pady=10)
cal.place(x=150, y=110)
#cal.bind("<Key>", setDateUntil)
cal.bind("<Enter>", setDateUntil)
cal.bind("<Leave>", setDateUntil)
L4 = Label(root, text="Date Start Filter")
L4.pack(side=LEFT)
L4.place(x=5, y=140)
cal2 = DateEntry(root,
width=12,
background='darkblue',
foreground='white',
borderwidth=2,
year=2019)
cal2.pack(padx=10, pady=10)
cal2.place(x=150, y=140)
#cal2.bind("<Key>", setDateFil)
cal2.bind("<Enter>", setDateFilStart)
class bookingpage(tk.Tk):
def __init__(self,id, *args, **kwargs):
# __init__ function for class Tk
tk.Tk.__init__(self, *args, **kwargs)
self.title("Booking")
self.geometry("900x500")
self.config(background="black", pady=10)
lbs = tk.Label(self, text="Booking", bg="black", fg="white", font=20)
lbs.place(x=110, y=5)
self.id=id
self.details()
def details(self):
lb2_name = tk.Label(self, text="Name - ", bg="black", fg="white")
self.name = tk.Entry(self)
lb2_name.place(x=10, y=40)
self.name.place(x=110, y=40)
lb2_guest = tk.Label(self, text="No of Guest ", bg="black", fg="white")
self.guest = tk.Entry(self)
lb2_guest.place(x=10, y=80)
self.guest.place(x=110, y=80)
self.tkvar = tk.StringVar(self)
# Dictionary with options
choice = {'Standard', 'Deluxe', 'Luxury'}
self.tkvar.set('Select') # set the default option
popupMenu = tk.OptionMenu(self, self.tkvar, *choice,command=self.check_acc)
tk.Label(self, text="Room Type",bg="black", fg="white").place(x=10, y=120)
popupMenu.place(x=110, y=120)
lb2_room = tk.Label(self, text="No Of Room - ", bg="black", fg="white")
self.room = tk.Entry(self)
lb2_room.place(x=10, y=160)
self.room.place(x=110, y=160)
# lb2_s = tk.Label(self, text="Email - ", bg="black", fg="white")
# self.lb2_s2 = tk.Entry(self)
# lb2_s.place(x=10, y=200)
# self.lb2_s2.place(x=110, y=200)
current_date = date.today()
self.cur_date=current_date
tomorrow = date.today() + timedelta(1)
label1 = tk.Label(self, text='Check In Date',bg="black", fg="white")
label1.place(x='10', y='200')
self.cal = DateEntry(self, width=12, year=current_date.year, month=current_date.month, day=current_date.day,
mindate=current_date, date_pattern='y-mm-dd',
background='darkblue', foreground='white', borderwidth=2)
self.cal.place(x='110', y='200')
label2 = tk.Label(self, text='Check out Date',bg="black", fg="white")
label2.place(x='240', y='200')
self.cal.bind("<<DateEntrySelected>>", self.callback)
date_time_obj = datetime.datetime.strptime(self.cal.get(), '%Y-%m-%d')
# print(type(date_time_obj))
# if self.cal.get():
# min_date=self.cal.get()
# else:
# min_date=tomorrow
lb2_s = tk.Label(self, text="Price - ", bg="black", fg="white")
self.price = tk.Label(self,bg="black", fg="white")
lb2_s.place(x=10, y=240)
self.price.place(x=110, y=240)
self.cal1 = DateEntry(self, width=12, year=tomorrow.year, month=tomorrow.month, day=tomorrow.day,
mindate=tomorrow, date_pattern='y-mm-dd',
background='darkblue', foreground='white', borderwidth=2)
self.cal1.place(x='380', y='200')
# reg = self.register(self.callback)
#
# self.cal1.config(validate="key",
# validatecommand=(reg, '% P'))
# button = tk.Button(self, text='Search', command=self.search)
# button.place(x='150', y='120')
try:
mycursor = mydb.cursor()
mycursor.execute("SELECT * FROM hotel_name where id=%s"%self.id)
self.myresult = mycursor.fetchall()
print(self.myresult)
im = Image.open(r"%s" % self.myresult[0][5])
image = im
self.background_image = ImageTk.PhotoImage(im)
lb_hotel = tk.Label(self, text=self.myresult[0][1], bg="black", fg="white", font=20)
lb_hotel.place(x=400, y=40)
row = 50
lb_img = tk.Label(self,image=self.background_image,height=50,width=50)
lb_img.place(x=400, y=80)
lb_img.photo=self.background_image
except:
print("No result")
button = tk.Button(self, text="book", command=self.book)
button.place(x='120', y='280')
def callback(self,input):
w = input.widget
date = w.get_date()+timedelta(1)
self.cal1.config(mindate=date)
def book(self):
try:
mycursor = mydb.cursor()
sql = "INSERT INTO booking (name,no_guest,room_type,checkin,checkout,hot_name,book_date,total) VALUES (%s, %s,%s,%s,%s,%s,%s,%s)"
val = (
self.name.get(), self.guest.get(), self.tkvar.get(), self.cal.get(), self.cal1.get(), self.myresult[0][1],self.cur_date,(self.p*int(self.room.get())))
mycursor.execute(sql, val)
mydb.commit()
print(mycursor.rowcount, "record inserted.")
self.display=tk.Label(self)
self.display2.config(bg="green", fg="white", text="Saved Success")
self.display2.place(x=20, y=1)
except:
self.display = tk.Label(self)
self.display2.config(bg="red", fg="white", text="Not Saved")
self.display2.place(x=20, y=1)
def check_acc(self,event):
selected = self.tkvar.get()
self.dic={'Standard':7,'Deluxe':8,'Luxury':9}
self.dic2 = {'Standard': 2, 'Deluxe': 3, 'Luxury': 4}
if(self.myresult[0][self.dic2[selected]]==0):
lab=tk.Label(self,text="Room Full")
lab.place(x=200,y=120)
else:
if (len(selected) != 0):
self.price.config(text=self.myresult[0][self.dic[selected]], bg="black", fg="white")
self.p=self.myresult[0][self.dic[selected]]
class DateDialog(tk.Toplevel):
def __init__(self, parent, controller):
tk.Toplevel.__init__(self, parent)
self.title("Änderung via Datum")
self.resizable(0,0)
self.controller = controller
self.return_value = None
self.date = datetime.datetime.now()
tk.Label(self, text="Datum auswählen:").pack(side=tk.TOP, pady=8)
values_frame = tk.Frame(self)
values_frame.pack(pady=4)
self.calendar = DateEntry(
values_frame,
year=self.date.year,
month=self.date.month,
day=self.date.day,
locale="de_DE",
)
self.calendar.bind("<<DateEntrySelected>>", self.set_new_date)
self.calendar.pack(pady=6)
self.labels = {
"Stunde" : None,
"Minute" : None,
"Sekunde" : None
}
for label in self.labels:
frame = tk.Frame(values_frame)
frame.pack(side=tk.LEFT, padx=2)
tk.Label(frame, text=label).pack(side=tk.LEFT)
if label == "Stunde":
self.labels[label] = tk.Spinbox(frame, from_=0, to=23, width=5)
else:
self.labels[label] = tk.Spinbox(frame, from_=0, to=60, width=5)
self.labels[label].pack(side=tk.RIGHT, padx=2)
button_frame = tk.Frame(self)
button_frame.pack(side=tk.BOTTOM, pady=6)
self.ok_button = tk.Button(button_frame, text="OK", width=10, command=self.on_ok)
self.cancle_button = tk.Button(button_frame, text="Abbrechen", width=10, command=self.on_cancle)
self.ok_button.pack(side=tk.LEFT, padx=5)
self.cancle_button.pack(side=tk.RIGHT, padx=5)
def set_new_date(self, e):
self.date = self.calendar.get_date()
def on_ok(self, event=None):
self.return_value = datetime.datetime(
year=self.date.year,
month=self.date.month,
day=self.date.day,
hour=int(self.labels["Stunde"].get()),
minute=int(self.labels["Minute"].get()),
second=int(self.labels["Sekunde"].get())
)
self.destroy()
def on_cancle(self, event=None):
self.destroy()
def show(self):
self.wm_deiconify()
self.wait_window()
return self.return_value
screen_width = master.winfo_screenwidth()
screen_height = master.winfo_screenheight()
# calculate position x and y coordinates
x = (screen_width/2) - (width/4)
y = (screen_height/3) - (height/4)
master.geometry('%dx%d+%d+%d' % (width/2.2, height/2.2, x, y))
# frame containing update data button and date selection
dateFrame = tk.Frame(master)
dateFrame.grid(row=0, column=0, sticky='w', padx=10)
tk.Button(dateFrame, text='Update Data', relief='groove', overrelief='sunken', command=updateData).grid(row=0, column=0, sticky='nsew', pady=(4,0))
#tk.Label(buttonFrame, text=' Select date ').grid(row=0, column=0)
cal = DateEntry(dateFrame, width=12, year=int(today[0]), month=int(today[1]), day=int(today[2]), background='darkblue', forground='white', borderwidth=2)
cal.grid(row=1, column=0)
cal.bind('<<DateEntrySelected>>', updateDataHelper)
simFrame = tk.Frame(master)
simFrame.grid(row=0, column=1, sticky='nw')
tk.Button(simFrame, text = "Simulate All", relief='groove', overrelief='sunken', command=simulateAll).grid(row=0, column=0, sticky='nw', pady=4)
tk.Button(simFrame, text = "Simulate Game", relief='groove', overrelief='sunken', command=simulateGame).grid(row=0, column=1, sticky='nw', pady=4)
# frame containing display lineup button and away/home team info
teamsFrame = tk.Frame(master)
teamsFrame.grid(row=1, column=1)
# away team entries
awayFrame = tk.Frame(teamsFrame)
awayFrame.grid(row=1, column=0)
awayTeamVar = tk.StringVar(master)
awayTeamVar.set(teamList[0])
pady=5,
sticky='NW',
columnspan=100)
# create and place date label
# label_space.grid(row=4, column=0, sticky='W')
label_date = ttk.Label(frame_kernal_name, text='Experiment date:')
label_date.grid(row=4, column=1, padx=10, pady=10, sticky='E')
# create, place, and update date selector
cal = DateEntry(frame_kernal_name,
date_pattern='y-mm-dd',
width=12,
borderwidth=2)
cal.grid(row=4, column=2, padx=5, pady=5, sticky='W')
cal.bind("<<DateEntrySelected>>",
save_date) # update date everytime a day is selected on calendar.
# add tool tip for button
Balloon(cal,
headertext=tip_text_header,
text=tip_text_create_structure,
background=None,
image=None)
# create and place name label
# label_space.grid(row=5, column=0, sticky='W')
label_name = ttk.Label(frame_kernal_name, text='Experiment name:')
label_name.grid(row=5, column=1, padx=10, pady=10, sticky='E')
# create and place name entry widget
exp_name_entry = ttk.Entry(frame_kernal_name,
textvariable=experiment_name,
