Share
Ce veți creaMulți oameni jonglează mai multe proiecte cu orare diferite. De la aplicațiile web la programele dedicate, există deja o serie de modalități de a urmări timpul petrecut pentru un proiect. Cei mai mulți necesită un serviciu net și / sau un program care să rămână tot timpul în desfășurare. Adesea acest lucru nu este practic.
Alfred Timekeeper funcționează similar cu un sistem de păstrare a timpului cu cardul de pumn: salvezi un marcaj de timp atunci când începi și nu mai lucra. Deoarece înregistrează doar marcajele temporale, un program sau un serviciu web nu este întotdeauna deschis.
În acest tutorial, presupun că deja sunteți familiarizat cu scrierea fluxurilor de lucru în Alfred. Dacă nu, vă rugăm să consultați aceste tutoriale: Alfred pentru începători, intermediari, utilizatori avansați și Alfred Debugging.
Mulți oameni lucrează cu computere diferite în locații diferite. Acest lucru face ca urmărirea proiectelor și gestionarea timpului să fie mult mai dificilă. Prin utilizarea Dropbox, toate informațiile despre proiect și de gestionare a timpului sunt sincronizate automat.
Această abordare necesită menținerea tuturor informațiilor în fișiere și nu în memoria calculatorului. Această restricție impune utilizarea a două aranjamente de stocare a datelor: director local a informațiilor utilizate numai de programul respectivului sistem și a directorul sincronizat care este partajat cu fiecare computer conectat la el.
Depozitul local conține referința la directorul sincronizat și editorul pentru a edita foile de pontaj. Aceste fișiere se află în locația directorului de date al lui Alfred.
Directorul sincronizat păstrează toate foile de pontaj, listele de proiecte, ultima stare cunoscută a informațiilor de înregistrare și informațiile din fusul orar. Aceasta va fi într-o locație Dropbox. Orice sistem de sincronizare a sistemului de fișiere poate fi folosit, pur și simplu am deja Dropbox.
În Alfred, creați un nou flux de lucru numit Alfred Timekeeper.
Crearea fluxului de lucru În acest nou flux de lucru, trebuie să creați o Filtru fișiere care va lista numai directoarele.
Setați comanda directorului Timesheet Directory Puteți seta Tipuri de fisiere prin glisarea unui director din căutător la Tipuri de fisiere zonă. Seteaza Domeniul de căutare la directorul care conține contul DropBox.
Adauga o Rulați scriptul blocați după acest bloc, dezactivând toate opțiunile de evadare. În acest bloc, adăugați acest script:
######################### # Contani. ######################### VPREFS = "$ HOME /Library/Caches/com.runningwithcrayons.Alfred-2/Workflow Data /" NVPREFS = "$ HOME / Bibliotecă / Suport pentru aplicații / Alfred 2 / Date despre fluxul de lucru /" ################################################################ ############################################### # Citeste bundleid din info.plist fluxul de lucru a lui ########################################### ################################### getBundleId () / usr / libexec / PlistBuddy -c „Print: bundleid "" info.plist " ###################################### ################################ # Obțineți date despre fluxul de lucru dir ######## ################################################## #################### getDataDir () local BUNDLEID = $ (getBundleId) echo "$ NVPREFS $ BUNDLEID" dacă [! -d "$ (getDataDir)"; apoi mkdir -p "$ (getDataDir)"; atingeți "$ (getDataDir) /dir.txt"; atingeți "$ (getDataDir) /editor.txt"; fi # Stocați informațiile din director. echo "interogare"> "$ (getDataDir) /dir.txt"; # Spuneți utilizatorului. echo "Setați directorul la 'query'.";
Acest script verifică existența directorului de date. Dacă nu există, creează directorul și fișierele utilizate pentru fluxul de lucru. Este nevoie de intrare în Interogare macro și o plasează în dir.txt fișier în directorul de date. Apoi notifică utilizatorul despre acțiune.
Conectați Rulați scriptul blocați la un bloc de notificare. Toate Rulați scriptul blocurile de pe aici ar trebui să se conecteze la acest bloc de notificare. Setați ieșirea ca fiind Interogare macro și setați Afișează numai dacă a trecut în argument are conținut.
După salvare, setați directorul de corespondență. În directorul Dropbox, creați un director pentru foi de pontaj și utilizați ATK: setdir comanda pentru a seta acel director. În prezent, rulați un program de cronometrare a sistemului!
Aceasta este rutina de bază de configurare pentru fluxul de lucru. Înainte de a aborda programul principal, trebuie să configurați mediul de lucru.
Cea mai ușoară cale de a instala limba de programare go este prin homebrew. Dacă nu ați instalat homebrew totuși, tutorialul Homebrew demystificat: Managerul de pachete Ultimate pentru OS X vă va arăta cum.
Într-un terminal, tastați:
bea instalare du-te
În directorul de domiciliu, creați directorul merge. Limba go-go va stoca toate bibliotecile descărcate acolo. Adăugați la .bashrc fișier și / sau .zshrc trimiteți această linie:
export GOPATH = "/ Utilizatori //merge"
Dacă utilizați pește, adăugați acest lucru la config.fish fişier:
set-xg GOPATH "/ Utilizatori //merge"
După reîncărcarea shell-ului, puteți instala biblioteca goAlfred tastând:
du-te la github.com/raguay/goAlfred
Această bibliotecă face mult mai ușor să folosească limba goală cu Alfred. Acesta va crea directoarele în zona de stocare a datelor pentru fluxurile de lucru Alfred și va face înregistrarea XML necesară în Script Filtre.
Pentru a crea fișierul principal de program, trebuie să accesați directorul pentru fluxul de lucru. Deschide Rulați scriptul bloc.
Deschiderea directorului fluxului de lucru Apasă pe Deschideți dosarul fluxului de lucru butonul din partea inferioară a butonului script: zonă. Aceasta deschide directorul de flux de lucru în căutător (sau deschizător de drumuri dacă îl aveți). Pentru a deschide directorul într-un shell terminal, puteți utiliza Alfred Workflow TerminalFinder pentru a deschide un director Finder sau Path Finder într-o sesiune terminal (sau iTerm).
Crearea fișierului program în Terminal Odată ce ați terminat programul, tastați:
atinge Timekeeper.go
Deschideți fișierul în editorul ales. Odată deschis, puneți acest cod în:
Accentsconagua
package main // // Program: TimeKeeper.go // // Descriere: Acest program execută logica feedback-ului pentru selectarea stării de pornire / oprire pentru // proiectul curent. // // // Importați bibliotecile pe care le folosim pentru acest program. // import ("fmt" "github.com/raguay/goAlfred" "io" "io / ioutil" "os" "regexp" "strconv" "stringuri" "timpul") // Setup și constantele folosite . // MAXPROJECTS Acesta este numărul maxim de proiecte permise. // TSDir Aceasta păstrează numele directorului pentru foile de oră. Este o cale completă. // const (MAXPROJECTS int = 20) var TSDir = "" // // Funcție: principal // // Descriere: Aceasta este principala funcție a programului TimeKeeper. Este nevoie de linia de comandă // și o analizează pentru funcționalitatea corespunzătoare. // func main () if len (os.Args)> 1 comutator os.Args [1] [0] caz 'm': // // ATK: // luna SystemViewMonth () caz 'w': // // atk: week // SystemViewWeek () caz 't': // // atk: current // SystemViewDate () caz 'r': // // atk: remove // RemoveProject : // // ATK: // proiect ChangeProject () caz 'b': // // ATK: curent // SystemViewDay () cazul 'a': // // ATK: addproject // AddProject () caz „o ': // // atk: state // StopStart () caz' p ': // // Folosit pentru atk: project script fileter // project () case' T ': // // atk: time // SystemAllProjects () caz: implicit fallthrough: // // Folosit pentru filtrul de script pe atk: state // state () // // Funcție: getTimeSheetDir // // Descriere: Această funcție este folosită pentru cache o copie a directorului de timp // și lăsați-o înapoi. / / dir.txt "buf, err: = ioutil.ReadFile (numele fișierului) dacă err == nil // // Conversia căii directorului la un șir și tăierea lui. // TSDir = strings.TrimSpace (șir (buf)) // // Returnați directorul în foile de timp. // return (TSDir) // // Funcție: SystemAllProjects // // Descriere: Această funcție va afișa terminalului timpul pentru toate proiectele de pe // ziua din următoarea linie de comandă. // func SystemAllProjects () // // Obțineți data curentă în cazul în care nu există una pe linia de comandă. // tm: = time.Now () dacă len (os.Args)> 2 if strings.Contains ("today", os.Args [2]) // // Data de astăzi. // tm = time.Now () altceva dacă strings.Contains ("ieri", os.Args [2]) // // Ieri este astăzi minus o zi. // tm = time.Now () tm = tm.AddDate (0, 0, -1) altceva // // Parsează șirul de date dat. // tm, _ = time.Parse ("2006-Jan-02", os.Args [2]) // // Obțineți lista numelor proiectelor. // proj: = GetListOfProjects () // // Pentru fiecare proiect, obțineți timpul petrecut pe el pentru ziua dată. // numproj: = len (proj) - 1 pentru i: = 0; eu < numproj; i++ fmt.Printf("%s: %s\n", proj[i], formatTimeString(GetTimeAtDate(proj[i], tm))) // // Function: SystemViewMonth // // Description: This function will calculate the time the current month for all the projects. // func SystemViewMonth() // // Get the current project. // currentProject := GetCurrentProject() // // Get the time on that project for this month. The current time gives the current month. // tm := GetTimeAtMonth(currentProject, time.Now()) // // format the time string and print it out. // fmt.Print(formatTimeString(tm)) // // Function: GetTimeAtDate // // Description: This function will take a project and calculate the time spent // on that project for a particular date. // func GetTimeAtMonth(project string, date time.Time) int64 tm := int64(0) dateStart := time.Date(date.Year(), date.Month(), 1, 0, 0, 0, 0, time.UTC) // // Get the time added up for the whole week. // for i := 0; i <= date.Day(); i++ tm += GetTimeAtDate(project, dateStart.AddDate(0, 0, i)) // // Return the amount of time calculated. // return (tm) // // Function: SystemViewWeek // // Description: This function will calculate the time the current week for all the projects. // // Inputs: // variable description // func SystemViewWeek() currentProject := GetCurrentProject() tm := GetTimeAtWeek(currentProject, time.Now()) fmt.Print(formatTimeString(tm)) // // Function: GetTimeAtDate // // Description: This function will take a project and calculate the time spent // on that project for a particular date. // func GetTimeAtWeek(project string, date time.Time) int64 tm := int64(0) dateStart := date dateEnd := date switch date.Weekday() case 0: dateEnd = dateEnd.AddDate(0, 0, 6) case 1: dateStart = dateStart.AddDate(0, 0, -1) dateEnd = dateEnd.AddDate(0, 0, 5) case 2: dateStart = dateStart.AddDate(0, 0, -2) dateEnd = dateEnd.AddDate(0, 0, 4) case 3: dateStart = dateStart.AddDate(0, 0, -3) dateEnd = dateEnd.AddDate(0, 0, 3) case 4: dateStart = dateStart.AddDate(0, 0, -4) dateEnd = dateEnd.AddDate(0, 0, 2) case 5: dateStart = dateStart.AddDate(0, 0, -5) dateEnd = dateEnd.AddDate(0, 0, 1) case 6: dateStart = dateStart.AddDate(0, 0, -6) // // Get the time added up for th whole week. // for i := 0; i < 7; i++ tm += GetTimeAtDate(project, dateStart.AddDate(0, 0, i)) return (tm) // // Function: SystemViewDate // // Description: This function will calculate the time for projects at a certain date. // func SystemViewDate() currentProject := GetCurrentProject() tm := GetTimeAtDate(currentProject, time.Now()) fmt.Print(formatTimeString(tm)) // // function: SystemViewDay // // Description: This function is for displaying a nice time for the current project. // func SystemViewDay() currentProject := GetCurrentProject() tm := GetTimeAtDate(currentProject, time.Now()) ctime := formatTimeString(tm) state := GetCurrentState() fmt.Printf("The current time on %s is %s. Current state is %s.", currentProject, ctime, state) // // Function: GetTimeAtDate // // Description: This function will take a project and calculate the time spent // on that project for a particular date. // func GetTimeAtDate(project string, date time.Time) int64 // // Get the current project. // filename := generateTimeLogFileName(project, date) tm := readDayTime(filename) return tm // // Function: formatTimeString // // Description: This function takes the number of seconds and returns a string // in hour:minute:seconds format with zero padding. // // Input: // tm time in seconds (an int64) // func formatTimeString(tm int64) string min := int(tm / 60) sec := tm - int64(min*60) hr := min / 60 min = min - (hr * 60) return fmt.Sprintf("%02d:%02d:%02d", hr, min, sec) // // Function: readDayTime // // Description: This function reads a time sheet file and calculates the time // represented in that file. func readDayTime(filename string) int64 buf, _ := ioutil.ReadFile(filename) times := regexp.MustCompile("\n|\r").Split(string(buf), -1) // // Loop through all the time lines. // tmwork := int64(0) firsttime := int64(0) first := false for i := 0; i < len(times); i++ if !strings.Contains("", times[i]) // // Split by colon to time and action. // parts := strings.Split(times[i], ":") if strings.Contains("start", parts[1]) firsttime, _ = strconv.ParseInt(parts[0], 10, 64) first = true else tm, _ := strconv.ParseInt(parts[0], 10, 64) tmwork += tm - firsttime first = false // // If a start was the last thing processed, that means it is still being timed. Get the // current time to see the overall time. firsttime is the time stamp when the start // was given. // if first currentTime := time.Now() ctime := currentTime.Unix() tmwork += ctime - firsttime // // Return the final Time. // return tmwork // // Function: RemoveProject // // Description: This function will remove a project from the list a valid projects. // func RemoveProject() // // Get the project name from the command line. // proj := GetCommandLineString() // // Get the list of project names. // projects := GetListOfProjects() // // Open the projects file in truncation mode to remove all the old stuff. // Filename := getTimeSheetDir() + "/projects.txt" Fh, err := os.OpenFile(Filename, os.O_TRUNC|os.O_WRONLY|os.O_CREATE, 0666) if err != nil // // The file would not open. Error out. // fmt.Print("Could not open the projects file: ", Filename, "\n") os.Exit(1) // // Loop through all the projects. // for i := 0; i < len(projects); i++ if !strings.Contains(proj, projects[i]) // // It is not the project to be removed. Put it into the file. // Fh.WriteString(projects[i] + "\n") // // Close the file. // Fh.Close() // // Tell the user that the project has been removed. // fmt.Print(proj + " has been removed!") // // Function: ChangeProject // // Description: This function will change the currently active project. If the old // project was started, it will stop it first, then set the new project // and start it. // func ChangeProject() // // Get the project name from the command line. // proj := GetCommandLineString() // // Get the current project. // currentProject := GetCurrentProject() // // Stop the current project. // StopStartProject(currentProject, "stop") // // Save the new project to the data file. // SaveProject(proj) // // Start the new project. // StopStartProject(proj, "start") // // Tell the user it is started. // fmt.Print("The current project is now " + proj + " and is started.") // // Function: GetCommandLineString // // Description: This function is used to get the after the function if there is one. // If not, then just return nothing. // func GetCommandLineString() string // // See if we have any input other then the command. // clstring := "" if len(os.Args) > 2 clstring = strings.TrimSpace (os.Args [2]) // // Returnați șirul. // return (clstring) // // Funcție: AddProject // // Descriere: Această funcție va adăuga un nou proiect la lista proiectelor curente. // func AddProject () // // Obțineți numele proiectului din linia de comandă. // proj: = GetCommandLineString () // // Creați numele fișierului care conține toate proiectele. // projectFile: = getTimeSheetDir () + "/projects.txt" Fh, err: = os.OpenFile (projectFile, os.O_APPEND | os.O_WRONLY | os.O_CREATE, 0666) os.Create (projectFile) dacă err! = nil // // Fișierul nu s-ar deschide. Eroare afară. // fmt.Print ("Nu s-a putut deschide fișierul de proiecte:", projectFile, "\ n") os.Exit (1) // // Scrie noua comandă cu marcajul de timp la buffer. // _, err = io.WriteString (Fh, proj + "\ n") // // Pierdeți fișierul. // Fh.Close () // // Spuneți utilizatorului că proiectul este adăugat. // fmt.Print ("Proiect adăugat" + proj + "în listă.") // // Funcție: stare // // Descriere: Această funcție oferă ieșirea corespunzătoare pentru schimbarea stării. Statul // este primul opus față de starea actuală. // func state () // // Obțineți ultima stare a proiectului curent. // stateFile: = getTimeSheetDir () + "/laststate.txt" buf, _: = ioutil.ReadFile (stateFile) curState: = string (buf) // // Setați prima comandă în opusul stării curente. În acest fel, // utilizatorul împinge pur și simplu la întoarcerea în stările de comutare. // if strings.Contains (curState, "start") goAlfred.AddResult ("stop", "stop", "stop", " .AddResult ( "start", "start", "start", "", "icon.png", "da", "", "") else goAlfred.AddResult ( "start", "start", " start“, "", "icon.png", "da", "", "") goAlfred.AddResult ( "stop", "stop", "stop", "", "icon.png", "da" , "", "") // // Imprimați șirul xml. // fmt.Print (goAlfred.ToXML ()) // // Funcție: project // // Descriere: Această funcție creează o listă a proiectelor și afișează cele // similare cu intrarea. // func project () // // Obțineți numele proiectului din linia de comandă. // proj: = GetCommandLineString () // // Setați șirul nostru implicit. // goAlfred.SetDefaultString ("Alfred Time Keeper: Ne pare rău, nici o potrivire ...") // // Obțineți cel mai recent proiect. // latestproject: = GetCurrentProject () // // Obțineți lista proiectelor. // projects: = make ([] șir, MAXPROJECTS) projects = GetListOfProjects () // // Declarația split regexp dă un șir mai mult decât a fost împărțit. Ultima // șir este o captură. Nu trebuie să fie inclus. // numproj: = len (proiecte) - 1 // // Pentru fiecare proiect, creați o linie de rezultate. Afișați toate punerea proiectului curent. // pentru i: = 0; eu < numproj; i++ if !strings.Contains(projects[i], latestproject) goAlfred.AddResultsSimilar(proj, projects[i], projects[i], projects[i], "", "icon.png", "yes", "", "") // // Print out the xml string. // fmt.Print(goAlfred.ToXML()) // // Function: GetListOfProjects // // Description: This function will return an array of string with the names of the project. // func GetListOfProjects() []string // // Create the projects array and populate it. // projectFile := getTimeSheetDir() + "/projects.txt" buf, _ := ioutil.ReadFile(projectFile) // // Split out the different project names into separate strings. // return (regexp.MustCompile("\n|\r").Split(string(buf), -1)) // // Function: StopStart // // Description: This will place a start or stop time stamp for the current project and // current date. // func StopStart() // // See if we have any input other then the command. If not, assume a stop command. // cmd := "stop" if len(os.Args) > 2 cmd = strings.ToLower (os.Args [2]) // // Obțineți proiectul curent. // currentProject: = GetCurrentProject () // // Rulați funcția corespunzătoare și tipăriți rezultatele. // fmt.Print (StopStartProject (currentProject, cmd)) // // Funcție: GetCurrentProject // // Descriere: Această funcție va prelua proiectul curent din fișierul // state. // func GetCurrentProject () string // // Obțineți proiectul curent. // Filename: = getTimeSheetDir () + "/project.txt" buf, _: = ioutil.ReadFile (Filename) // // Conversia proiectului curent la un șir, tăiați-l și returnați-l. // return (strings.TrimSpace (string (buf))) // // Funcție: SaveProject // // Descriere: Această funcție va salva numele de proiect dat în fișierul // current project. // // Inputs: // proj Numele noului proiect // func SaveProject (proj string) // // Scrie noul proiect. // nume fișier: = getTimeSheetDir () + "/project.txt" err: = ioutil.WriteFile (nume fișier, [] byte (proj), 0666) err! = Nil fmt.Print : "+ Nume fișier) os.Exit (1) // // Funcție: StopStartProject // // Descriere: Această funcție este utilizată pentru a seta starea pentru proiectul dat. // // Inputs: // currentProject Proiectul pentru a efectua starea. // cmd Comanda de pornire sau oprire. // func StopStartProject (șir curentProiect, șir cmd) șir // // Configurarea șirului de rezultate. // resultStr: = "" currentState: = GetCurrentState () // // Starea curentă este aceeași cu noua stare? // if strings.Contains (cmd, currentState) // // Este deja în acea stare. Nu face nimic, dar da un mesaj. // resultStr = "deja" + cmd + "\ n" altceva // // Bine, putem continua cu scrierea noii stări în fișierul proiectului // datat. Deschideți fișierul pentru scriere. // currentTime: = time.Now () Numele fișierului: = generateTimeLogFileName (currentProject, currentTime) Fh, err: = os.OpenFile (nume fișier, os.O_APPEND | os.O_WRONLY | os.O_CREATE, 0666) Fișierul nu se va deschide. Eroare afară. // fmt.Print ("Fișierul de proiect nu a putut fi deschis:", Nume fișier, "\ n") os.Exit (1) // // Scrie noua comandă cu ștampila de timp la buffer. // str: = fmt.Sprintf ("% d:% s \ n", curentTime.Unix (), cmd) _, err = io.WriteString (Fh, str) // Fh.Close () // // Scrieți ultimul fișier cu noua stare. // ioutil.WriteFile (getTimeSheetDir () + "/ laststate.txt", [] octet (cmd), 0666) // // Spuneți utilizatorului că este setat. // resultStr = currentProject + "este acum" + cmd // // Returnați șirul rezultat. // return (resultStr) // // function: GetCurrentState // // Descriere: Aceasta functie devine starea curenta a proiectului. // func GetCurrentState () șir // // Obțineți starea curentă. // nume fișier: = getTimeSheetDir () + "/laststate.txt" buf, err: = ioutil.ReadFile (nume fișier) currentState: = "stop" dacă err == nil // // Conversia proiectului curent într- tăiați-o. // currentState = strings.TrimSpace (șir (buf)) retur curentState // // Funcție: generateTimeLogFileName // // Descriere: Această funcție creează fișierul jurnal de timp bazat pe numele proiectului și // data. // // Inputs: // proj Numele proiectului // dt Data în cauză // func generateTimeLogFileName (proj string, dt time.Time) șir // // Generează numele fișierului potrivit pe numele și data proiectului . // nume fișier: = getTimeSheetDir () + "/" + proj + "_" + dt.Format ("2006-01-02") + ". Acest cod definește toate funcționalitățile Alfred Timekeeper. Proiectarea programului este de a face diferite funcții bazate pe o scrisoare de comandă și pe parametrii de opțiuni după aceasta. Acesta va primi directorul de pontaj de la Alfred și va crea fișierele de proiect și foile de pontaj după cum este necesar.
Trebuie să compilați programul înainte să îl puteți folosi. Limba goală nu este o limbă interpretată, ci o limbă compilată. Acest lucru permite programului să ruleze mult mai repede.
În programul terminal, tastați:
du-te construi Timekeeper.go
Compilarea Timekeeper.go Dacă totul funcționează corect, ar trebui să aveți acum metronom program în acel director. Este în roșu deasupra. Dacă ceva nu a fost copiat corect și compilarea nu reușește, căutați numărul de linie dat și comparați-l cu cel de mai sus. Sau obțineți o copie nouă din descărcarea dată cu acest tutorial.
Cu programul terminat, trebuie să-l suni de la Alfred. Creeaza o cuvinte cheie bloc cu cuvântul cheie setat la ATK: addproject. Conectați-l la a Rulați scriptul blocați și puneți această linie de cod:
./ TimeKeeper o "interogare"
Toate Run Scripts blocurile de aici trebuie să fie setate să ruleze bash scripturi și niciuna dintre opțiunile de scăpare stabilite. Scriptul de mai sus permite crearea de noi proiecte. Utilizați acest lucru pentru a vă crea diferite proiecte. Am proiectele: Envato, CustomCT, și misiuni creat pentru munca pe care o fac.
Acum, când aveți proiecte, trebuie să setați unul ca proiectul curent. Creeaza o Filtru de scripturi ca mai jos:
Filtru de scripturi pentru selectarea unui proiect Adauga o Rulați scriptul blocați după acesta cu următorul script:
./ Timekeeper c "interogare"
Setarea proiectului Acum puteți seta proiectul pe care doriți să lucrați. În mesajul Alfred Prompt, tastați ATK: proiect și ar trebui să apară o listă a proiectelor create. Selectați proiectul dorit și acesta va începe automat sincronizarea pentru dvs..
Prin urmare, dacă ați selectat Tutoriale proiect, există un fișier numit Tutorials_2014-05-05.txt (adică, atâta timp cât l-ați creat pe 5 mai 2014). În interiorul acelui fișier este un timbru de timp, un colon și un start afirmație. Veți avea, de asemenea, project.txt fișier cu proiectul selectat în prezent, laststate.txt fișier cu ultima stare (de exemplu: start sau Stop), si projects.txt fișier cu o listă de proiecte create.
Momentul a început, dar acum trebuie să-l oprești. Creaza un nou Filtru de scripturi bloc cu cuvântul cheie setat la ATK: stare și script-ul setat la:
./ TimeKeeper s "interogare"
Asta ar trebui să se conecteze la a Rulați scriptul blocați cu scriptul setat la:
./ TimeKeeper o "interogare"
s comanda spune programul Timekeeper să genereze o ieșire XML pentru următoarea stare. Acesta va avea în mod automat prima opțiune din XML pentru a fi opusul stării actuale.
Modificarea statelor de sincronizare Acum puteți comuta starea de sincronizare cu un proiect ATK: stare. De asemenea, puteți crea taste rapide pentru a porni și a opri temporizarea. Încercați să faceți acest lucru pe cont propriu. Nu înveți niciodată până nu încerci!
Adăugarea unui declanșator extern S-ar putea să doriți un program extern pentru a seta înregistrarea timpului. Prin urmare, creați un Comandă externă blocați după cum se arată. Conectați acest bloc la cel anterior Rulați scriptul bloc.
Adăugarea unui declanșator extern - Configurație Cod simplu în partea de jos poate fi rulat de orice program AppleScript sensibil pentru a declanșa start Stop acțiuni asupra proiectului actual. Dacă înlocuiți textul Test cu Stop, se va opri calendarul. Dacă înlocuiți textul Test cu start, acesta va începe calendarul. Folosit cu ControlPlane, puteți crea o regulă pentru a dezactiva calendarul atunci când computerul doarme și reia momentul când computerul se trezește.
Acum că începeți și opriți timpul, trebuie să vizualizați timpul petrecut. Creeaza o cuvinte cheie blocați cu ATK: curent. Conectați-l la a Rulați scriptul blocați cu acest script:
echo "./Timekeeper b ';
Conectați-l la Notificare bloc.
Comandamentul timpului curent Când alergi ATK: curent în promptitudinea lui Alfred, veți obține timpul curent petrecut pe proiect și pe starea actuală.
Dacă aveți un alt computer, configurați-l pe Alfred să-l partajeze pe Dropbox. După configurare, toate fluxurile dvs. de lucru se vor actualiza automat de la un computer la altul.
Configurarea sincronizării Alfred Selectează Setați folderul de sincronizare pentru a configura sincronizarea prin Dropbox și pentru a urma instrucțiunile. La cel de-al doilea computer, utilizați comanda ATK: setdir pentru a seta directorul de cotidian creat în Dropbox. Cele două sisteme pot începe și opresc temporizarea proiectului. Asigurați-vă că Dropbox este complet sincronizat între modificările de stare.
Acestea sunt elementele de bază ale Alfred Timekeeper. Fluxul de lucru inclus în pachetul de descărcări este versiunea completă cu alte funcții. Acum înțelegeți cum să vă creați propriul sistem de gestionare a timpului care este scalabil pentru a fi utilizat pe mai multe computere utilizând Dropbox și nu utilizează resursele calculatorului.
Din moment ce folosesc acest lucru în fiecare zi, voi adăuga mai multe caracteristici, cum ar fi o interfață web, pentru a vedea graficul grafic. Dacă puteți să veniți cu alte caracteristici, încercați să le adăugați singuri! Asta e distracția de a lucra cu fluxurile de lucru Alfred.
