import os
import sys
import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.graph_objects as go
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
from dash_app.knowledge_base.last_activity import last_recorded_activity
from dash_app.knowledge_base.backmarket_work_analysis import get_bm_start_times_graph_data
last_activity = last_recorded_activity()
bm_start_time_graph = get_bm_start_times_graph_data()
colors = {
    'background': '#111111',
    'text': '#7FDBFF'
}
app.layout = html.Div(style={'backgroundColor': colors['background']}, children=[
    html.H1(
        children='Hello Dash',
        style={
            'textAlign': 'center',
            'color': colors['text']
        }
    ),
    html.Div(children='Dash: A web application framework for Python.', style={
        'textAlign': 'center',
        'color': colors['text']
    }),
    html.Div(f"""Currently working on {last_activity["project"]}""", style={'textAlign': 'center', 'color': colors['text']}),
    html.Div(f"""It started on {last_activity["start_time"]}""", style={'textAlign': 'center', 'color': colors['text']}),
    html.Div(f"""end_date is {last_activity["end_time"]}""", style={'textAlign': 'center', 'color': colors['text']}),
    dcc.Graph(
        id='backmarket-analysis-1',
        figure={
            'data': [
                {'x': bm_start_time_graph[0], 'y': bm_start_time_graph[1]}
            ]
        }
    )
])
if __name__ == '__main__':
    app.run_server(debug=True)

import os
from pymongo import MongoClient
class DBManager:
    def __init__(self):
        self.connection = MongoClient(os.getenv("MONGODB_URI"))
        if os.getenv("MONGODB_URI"):
            # This covers the case where DB name is provided in the URI
            self.db = self.connection.get_database()
        else:
            self.db = self.connection.ptc
        self.projects_collection = self.db['projects']
    def projects(self):
        return self.projects_collection.find()
    @staticmethod
    def serialize_log(log):
        start = log["start"]
        hour, minute, second = start.split(":")
        if len(hour) == 1:
            hour = "0" + hour
        if len(minute) == 1:
            minute = "0" + minute
        if len(second) == 1:
            second = "0" + second
        log["start"] = f"{hour}:{minute}:{second}"
        from datetime import datetime, timedelta
        start_time = datetime.fromisoformat("{}T{}".format(log["date"], log.pop("start")))
        log["start_time"] = start_time
        if log["end"] == "Not yet.":
            log["end_time"] = None
            return
        hour, minute, second = log["end"].split(":")
        if len(hour) == 1:
            hour = "0" + hour
        if len(minute) == 1:
            minute = "0" + minute
        if len(second) == 1:
            second = "0" + second
        log["end"] = f"{hour}:{minute}:{second}"
        end_time = datetime.fromisoformat("{}T{}".format(log["date"], log.pop("end")))
        if end_time < start_time:
            end_time += timedelta(days=1)
        log["end_time"] = end_time
    def logs(self):
        logs = []
        for project in self.projects():
            for log in project["logs"]:
                log["project"] = project["name"]
            logs.extend(project["logs"])
        for log in logs:
            self.serialize_log(log)
        return logs
db_manager = DBManager()

"""
This file provides the following functionality
- Data analysis for day vs backmarket work start time
"""
from dash_app.engine import db_manager
from datetime import date
def get_bm_start_times_graph_data():
    logs = db_manager.logs()
    logs = [log for log in logs if log["project"] == "backmarket"]  # Only backmarket projects
    for log in logs:
        log.update({"day": date.fromisoformat(log["date"]), "start_time": log["start_time"].time().hour})
    # logs = [log for log in logs if log["day"].month == 10]
    logs = [log for log in logs if 6 <= log["start_time"] <= 15]
    logs_as_dict = {}
    for log in logs:
        if log["day"] not in logs_as_dict:
            logs_as_dict[log["day"]] = log["start_time"]
            continue
        if log["start_time"] < logs_as_dict[log["day"]]:
            logs_as_dict[log["day"]] = log["start_time"]
    return list(logs_as_dict.keys()), list(logs_as_dict.values())

from datetime import datetime
from ..engine import db_manager
def last_recorded_activity():
    logs = db_manager.logs()
    logs = sorted(logs, key=lambda log: log["start_time"])
    return logs[-1]

import os
from pymongo import MongoClient
from app.fms import FileManager
class ProjectsMongoSynchronizer:
    def __init__(self):
        self.connection = MongoClient(os.getenv("MONGODB_URI"))
        if os.getenv("MONGODB_URI"):
            # This covers the case where DB name is provided in the URI
            self.db = self.connection.get_database()
        else:
            self.db = self.connection.ptc
        # self.users_collection = self.db['User']
        self.projects_collection = self.db['projects']
    def synchronize(self):
        projects = FileManager.read('projects')
        projects = [project for project in projects if not projects[project].get('archived')]
        for project in projects:
            self.sync_project_data(project)
    def sync_project_data(self, project_name):
        updated_logs = FileManager.read('logs/{}'.format(project_name))
        if not self.projects_collection.count_documents({"name": project_name}):
            print(f"Adding new project.. {project_name}")
            return self.projects_collection.insert({
                "name": project_name,
                "logs": updated_logs
            })
        print(f"Updating existing project.. {project_name}")
        return self.projects_collection.update({"name": project_name}, {"logs": updated_logs})

Name: File Management System.
Details:
import json
            p_file.seek(0)
            p_file.truncate()
            p_file.write(simplejson.dumps(objects, indent=4))
    @staticmethod
    def update(file_name, objects, mode='r+'):
        with open('data/' + file_name + '.json', mode) as p_file:
            objects = json.load(p_file)
        return objects
    @staticmethod
    def read(file_name: str):
        with open(BASE_DIR + '/data/' + file_name + '.json', 'r') as p_file:
class FileManager(object):
    """File manager to read or write to files with Json objects."""
import simplejson
from .settings import BASE_DIR
    this file should implement A manager class for reading, writing to/from files.
Author:
    Zee93
"""
"""

class Log(object):
    def __init__(self, start, end=None):
        self.start = Time()
        self.start.set_string(start)
        self.end = Time()
        self.set_string(end)
    def stop(self):
        self.end.set_current_time()
        self.date = "00/00/00"
from .p_time import Time

# handles time
import time
class Time(object):
    def set_string(self, string):
        if string is None:
        t = list(map(int, string.split(":")))
        self.seconds = t[2]
        self.minutes = t[1]
        self.hours = t[0]
    def __str__(self):
        return "{}:{}:{}".format(self.hours, self.minutes, self.seconds)
    def set_seconds(self, seconds):
        self.seconds = seconds % 60
    def get_seconds(self):
    def log_time(log):
        if log is None:
            print("No logs for this day")
            return 0
        start = Time(str_time=log['start'])
        end = Time(str_time=log['end'])
        end.minues(start)
        return end
    def greater_than(self, time):
        return self.get_seconds() > time.get_seconds()
    @staticmethod
        # 'yyyy-mm-dd'
        return str(datetime.now().date())
    @staticmethod
    def date():
    def minues(self, before):
        if self.greater_than(before):  # before midnight
            seconds = abs(self.get_seconds() - before.get_seconds())
            return self.set_seconds(seconds)
        else:                          # after midnight
            before_midnight = Time('24:00:00').minues(before)
            return self.add_time(before_midnight)
    def add_time(self, t):
        return self.set_seconds(self.get_seconds() + t.get_seconds())
        return self.hours * 3600 + self.minutes * 60 + self.seconds
        return self
        self.hours = int(seconds / 3600)
        self.minutes = int(seconds / 60) - self.hours * 60
            return 0
        if string.startswith('Not'):
            string = time.ctime().split()[-2]
            # print("WARNING: you have an unclosed time log.")
            # print("This is you total time so far.")
    has 3 distinct attributes Hour, Minute, Second.
    Every new method or modification on old methods must work on them as
    def __init__(self, str_time=None, sec_time=None):
        if str_time:
            self.set_string(str_time)
        elif sec_time or sec_time == 0:
            self.set_seconds(sec_time)
        else:
            self.set_string(time.ctime().split()[-2])
    the main properties that define the object.
    """
    """
from datetime import datetime

import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

Name: Project Management System.
Details:
## this file should implement A manager class for reading, writing and deleting to/from projects file.
## Also it should convert the extracted information to the proper type.
## the operations that should be implemented are CRUD "Create - Read - Update - Delete"
Author: Zee93
import json
import simplejson
from .settings import BASE_DIR
        return projects
    @staticmethod
    def update(projects, file_name='projects'):
        with open(BASE_DIR + '/data/' + file_name + '.json', 'r+') as projects_file:
            projects_file.seek(0)
            projects_file.truncate()
            projects_file.write(simplejson.dumps(projects, indent=4))
    @staticmethod
    def read(file_name='projects'):
        with open(BASE_DIR + '/data/' + file_name + '.json', 'r+') as projects_file:
            projects = json.load(projects_file)
class ProjectsManager:
"""
"""

import json
import gspread as gs
from oauth2client.client import SignedJwtAssertionCredentials
from calendar import month_name
def upload_to_spread_sheet(p_name, spreadsheet, month, cells_time):  # cells_time= {cells_row: time}
    print("Syncing: \n" + str(cells_time) + "...")
    json_key = json.load(open('cred-ptc.json'))
    credentials = SignedJwtAssertionCredentials(json_key['client_email'],
                                                bytes(json_key['private_key'], 'utf-8'),
                                                json_key['scope'])
    print('Authenticating....')
    gc = gs.authorize(credentials)
    print('opening your sheet...')
    sheet = gc.open(spreadsheet)
    month_sheet = sheet.worksheet(month_name[month])
    rows_left = len(cells_time)
    for (row, value) in cells_time.items():
        print("Writing value in row number: " + row)
        print(str(rows_left) + " items left.")
        rows_left -= 1
        # update start
        month_sheet.update_acell('B' + row, '00:00:00')
        # update end
        month_sheet.update_acell('c' + row, value)
    print('finished writing')

#!/usr/bin/env python3
import sys
if __name__ == "__main__":
    execute_from_command_line(sys.argv[1:])
from execute import execute_from_command_line
# Projects Time Control

        print("Creating project...")
        print("Happy coding...")
        start_timer_on_project(*args)
        print("your projects are: " + str(list_projects()))
        return get_time_for_certain_day(*args)
        print(Time.date())
        try:
            try:
            except:
        except:
        return sync()
        return get_status()
    elif action == "sync_mongodb":
        return sync_to_mongo_db()
    elif action == "status":
    elif action == "sync":
            return get_total_monthly_time_on_project(args[0])
                return get_total_monthly_time_on_project(args[0], month)
                year = int(args[2])
                return get_total_monthly_time_on_project(args[0], month, year)
            month = int(args[1])
    elif action == "month_time_for":
    else:
        print("Wrong Command")
    elif action == "date":
    elif action == "yesterday_time_for":
        date = datetime.date.today() - datetime.timedelta(days=1)
        return get_time_for_certain_day(args[0], date=str(date))
    elif action == "total_time_for":
        print(get_total_time_for_project(args[0]))
    elif action == "draw":
        total_time_for_all_projects()
    elif action == "today_time_for":
    elif action == "list":
    elif action == "stop":
        print("Stopping timer...")
        stop_timer_on_project(*args)
    elif action == "start":
        create_project(*args)
def list_projects():
def get_time_for_certain_day(p_name, date=Time.date()):
    print(total_time)
    if action == "createp":
def execute_from_command_line(args):
    action = args.pop(0)
def sync_to_mongo_db():
    from app.sync_to_mongo import ProjectsMongoSynchronizer
    engine = ProjectsMongoSynchronizer()
    engine.synchronize()
    return str(total_time)
    all_logs = FileManager.read('logs/{}'.format(p_name))
                      int(log.get('date').split('-')[1]) == 6])
    cells_time = {}
    for day_date in month_days:
        cell_row = str(int(day_date.split('-')[2]) + 1)  # we start from 2 not 1
        cells_time.update(
            {cell_row: get_time_for_certain_day(p_name, date=day_date)})
    # return upload_to_spread_sheet(p_name=p_name, spreadsheet=spreadsheet, month=month, cells_time=cells_time)
    return 0
    month_days = set([log['date'] for log in all_logs if log.get('date', None) and
def sync(p_name='cube', spreadsheet='WorkSheet', month=datetime.date.month):
    all_logs = FileManager.read('logs/{}'.format(p_name))
    day_logs = [log for log in all_logs if log.get('date', None) == date]
    total_time = Time(sec_time=sum([Time.log_time(log).get_seconds() for log in day_logs]))
    print(total_time)
    return str(total_time)
    all_logs = FileManager.read('logs/{}'.format(p_name))
    total_time = Time(sec_time=sum([Time.log_time(log).get_seconds() for log in month_logs]))
    month_logs = [log for log in all_logs if log.get('date', None) and
                  int(log.get('date').split('-')[1]) == month]  # filtered by month
    month_logs = [log for log in month_logs if log.get('date', None) and int(log.get('date').split('-')[0]) == year]
def get_total_time_for_project(project_name):
    all_logs = FileManager.read('logs/{}'.format(project_name))
    total_time = Time(sec_time=sum([Time.log_time(log).get_seconds() for log in all_logs]))
    average_per_log = str(total_time.hours / (len(all_logs) or 1))[:4]
    return "{} - with average per log: {} - number of logs: {}".format(total_time, average_per_log, len(all_logs))
def total_time_for_all_projects():
    print("Project: Total time")
    for project in list_projects():
        print("{}: {}".format(project, get_total_time_for_project(project)))
    total_time = None
    for project in list_projects():
        project_time = Time(sec_time=sum([Time.log_time(log).get_seconds() for log in FileManager.read('logs/{}'.format(project))]))
        if not total_time:
            total_time = project_time
        else:
            total_time.add_time(project_time)
    print("total user recorded time: {}".format(total_time))
def get_total_monthly_time_on_project(p_name, month=datetime.date.today().month, year=datetime.date.today().year):
    projects = FileManager.read('projects')
    return [project for project in projects if not projects[project].get('archived')]
    # GET PROJECT NAME.
    # UPDATE THE LOG.
    # CHANGE PROJECT STATE TO OFF.
    projects = FileManager.read('projects')
    # ADD THE ELAPSED TIME.
    total_time.add_time(elapsed_time)
    print("Elapsed time: " + str(elapsed_time))
    FileManager.update('projects', projects)
    current_project["total_spent_time"] = str(total_time)
    projects[p_name] = current_project
    total_time = Time(str_time=current_project["total_spent_time"])
    current_project = projects.get(p_name)
    current_project["state"] = "OFF"
    logs = FileManager.read('logs/{}'.format(p_name))
    if logs[-1]["end"] != "Not yet.":
    logs[-1]["end"] = str(now)
    FileManager.update('logs/{}'.format(p_name), logs)
    start = Time()
    start.set_string(logs[-1]["start"])
    now.minues(start)
    elapsed_time = now
        print("Error. Either you don't have a running log or the program is writing on the wrong log instance.")
        return
    settings = FileManager.read('settings')
    p_name = settings["working on"]
def stop_timer_on_project(time=None):
    print("stopping Time: " + str(now))
    now = Time(str_time=time) if time else Time()
    # START LOG TIME
    # put the project in workon in the settings file.
    settings["working on"] = p_name
    FileManager.update('settings', settings)
    settings = FileManager.read('settings')
    logs = FileManager.read('logs/{}'.format(p_name))
    FileManager.update('logs/{}'.format(p_name), logs)
    logs.append({'start': str(now), 'end': 'Not yet.', 'date': Time.date()})
    # CHANGE PROJECT STATE TO ON
    projects = FileManager.read('projects')
        print("We don't have a project with this name dear.")
    projects.get(p_name)["state"] = "ON"
    FileManager.update('projects', projects)
        return
    if not projects.get(p_name):
def get_status():
    settings = FileManager.read('settings')
    project_name = settings['working on']
    projects = FileManager.read('projects')
    status = projects.get(project_name)["state"]
    print('last project: {} and its status: {}'.format(project_name, status))
def start_timer_on_project(p_name, time=None):
    if time:
        now = Time(str_time=time)
    else:
        now = Time()
    print("Time now: {}".format(now))
def create_project(p_name, details='', p_estimatedtime="Unknown"):
    project = {
        'estimated time': p_estimatedtime,
        'details': details,
    }
    print('project created.')
    projects = FileManager.read('projects')
    projects.update({p_name: project})
    FileManager.update('logs/{}'.format(p_name), [], mode='w')
    FileManager.update('projects', projects)
        'state': 'OFF',
        'total_spent_time': "0:0:0"
import os
import sys
# from spread import upload_to_spread_sheet
import datetime
from app.fms import FileManager
from app.p_time import Time
sys.path.append(os.path.dirname(os.path.abspath(__file__)))