id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
4,900 | go-playground/log | handlers/email/email.go | New | func New(host string, port int, username string, password string, from string, to []string) *Email {
e := &Email{
enabled: true,
timestampFormat: log.DefaultTimeFormat,
host: host,
port: port,
username: username,
password: password,
from: from,
to: to,
formatFunc: defaultFormatFunc,
}
e.SetTemplate(defaultTemplate)
return e
} | go | func New(host string, port int, username string, password string, from string, to []string) *Email {
e := &Email{
enabled: true,
timestampFormat: log.DefaultTimeFormat,
host: host,
port: port,
username: username,
password: password,
from: from,
to: to,
formatFunc: defaultFormatFunc,
}
e.SetTemplate(defaultTemplate)
return e
} | [
"func",
"New",
"(",
"host",
"string",
",",
"port",
"int",
",",
"username",
"string",
",",
"password",
"string",
",",
"from",
"string",
",",
"to",
"[",
"]",
"string",
")",
"*",
"Email",
"{",
"e",
":=",
"&",
"Email",
"{",
"enabled",
":",
"true",
",",... | // New returns a new instance of the email logger | [
"New",
"returns",
"a",
"new",
"instance",
"of",
"the",
"email",
"logger"
] | fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19 | https://github.com/go-playground/log/blob/fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19/handlers/email/email.go#L54-L68 |
4,901 | go-playground/log | handlers/email/email.go | SetTemplate | func (email *Email) SetTemplate(htmlTemplate string) {
email.rw.Lock()
defer email.rw.Unlock()
// parse email htmlTemplate, will panic if fails
email.template = template.Must(template.New("email").Funcs(
template.FuncMap{
"ts": func(e log.Entry) (ts string) {
ts = e.Timestamp.Format(email.timestampFormat)
return
},
},
).Parse(htmlTemplate))
} | go | func (email *Email) SetTemplate(htmlTemplate string) {
email.rw.Lock()
defer email.rw.Unlock()
// parse email htmlTemplate, will panic if fails
email.template = template.Must(template.New("email").Funcs(
template.FuncMap{
"ts": func(e log.Entry) (ts string) {
ts = e.Timestamp.Format(email.timestampFormat)
return
},
},
).Parse(htmlTemplate))
} | [
"func",
"(",
"email",
"*",
"Email",
")",
"SetTemplate",
"(",
"htmlTemplate",
"string",
")",
"{",
"email",
".",
"rw",
".",
"Lock",
"(",
")",
"\n",
"defer",
"email",
".",
"rw",
".",
"Unlock",
"(",
")",
"\n\n",
"// parse email htmlTemplate, will panic if fails"... | // SetTemplate sets Email's html template to be used for email body | [
"SetTemplate",
"sets",
"Email",
"s",
"html",
"template",
"to",
"be",
"used",
"for",
"email",
"body"
] | fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19 | https://github.com/go-playground/log/blob/fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19/handlers/email/email.go#L71-L84 |
4,902 | go-playground/log | handlers/email/email.go | SetFormatFunc | func (email *Email) SetFormatFunc(fn FormatFunc) {
email.rw.Lock()
defer email.rw.Unlock()
email.formatFunc = fn
} | go | func (email *Email) SetFormatFunc(fn FormatFunc) {
email.rw.Lock()
defer email.rw.Unlock()
email.formatFunc = fn
} | [
"func",
"(",
"email",
"*",
"Email",
")",
"SetFormatFunc",
"(",
"fn",
"FormatFunc",
")",
"{",
"email",
".",
"rw",
".",
"Lock",
"(",
")",
"\n",
"defer",
"email",
".",
"rw",
".",
"Unlock",
"(",
")",
"\n\n",
"email",
".",
"formatFunc",
"=",
"fn",
"\n",... | // SetFormatFunc sets FormatFunc each worker will call to get
// a Formatter func | [
"SetFormatFunc",
"sets",
"FormatFunc",
"each",
"worker",
"will",
"call",
"to",
"get",
"a",
"Formatter",
"func"
] | fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19 | https://github.com/go-playground/log/blob/fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19/handlers/email/email.go#L112-L117 |
4,903 | go-playground/log | handlers/email/email.go | SetEmailConfig | func (email *Email) SetEmailConfig(host string, port int, username string, password string, from string, to []string) {
email.rw.Lock()
defer email.rw.Unlock()
email.host = host
email.port = port
email.username = username
email.password = password
email.from = from
email.to = to
email.formatter = email.formatFunc(email)
} | go | func (email *Email) SetEmailConfig(host string, port int, username string, password string, from string, to []string) {
email.rw.Lock()
defer email.rw.Unlock()
email.host = host
email.port = port
email.username = username
email.password = password
email.from = from
email.to = to
email.formatter = email.formatFunc(email)
} | [
"func",
"(",
"email",
"*",
"Email",
")",
"SetEmailConfig",
"(",
"host",
"string",
",",
"port",
"int",
",",
"username",
"string",
",",
"password",
"string",
",",
"from",
"string",
",",
"to",
"[",
"]",
"string",
")",
"{",
"email",
".",
"rw",
".",
"Lock... | // SetEmailConfig allows updating of the email config in flight and is thread safe. | [
"SetEmailConfig",
"allows",
"updating",
"of",
"the",
"email",
"config",
"in",
"flight",
"and",
"is",
"thread",
"safe",
"."
] | fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19 | https://github.com/go-playground/log/blob/fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19/handlers/email/email.go#L120-L131 |
4,904 | go-playground/log | handlers/email/email.go | SetEnabled | func (email *Email) SetEnabled(enabled bool) {
email.rw.Lock()
defer email.rw.Unlock()
email.enabled = enabled
} | go | func (email *Email) SetEnabled(enabled bool) {
email.rw.Lock()
defer email.rw.Unlock()
email.enabled = enabled
} | [
"func",
"(",
"email",
"*",
"Email",
")",
"SetEnabled",
"(",
"enabled",
"bool",
")",
"{",
"email",
".",
"rw",
".",
"Lock",
"(",
")",
"\n",
"defer",
"email",
".",
"rw",
".",
"Unlock",
"(",
")",
"\n\n",
"email",
".",
"enabled",
"=",
"enabled",
"\n",
... | // SetEnabled enables or disables the email handler sending emails | [
"SetEnabled",
"enables",
"or",
"disables",
"the",
"email",
"handler",
"sending",
"emails"
] | fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19 | https://github.com/go-playground/log/blob/fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19/handlers/email/email.go#L134-L139 |
4,905 | go-playground/log | _examples/custom-handler/main.go | Log | func (c *CustomHandler) Log(e log.Entry) {
// below prints to os.Stderr but could marshal to JSON
// and send to central logging server
// ---------
// |----------> | console |
// | ---------
// i.e. ----------------- ----------------- Unmarshal ------------- --------
// | app log handler | -- json --> | central log app | -- to -> | log handler | --> | syslog |
// ----------------- ----------------- Entry ------------- --------
// | ---------
// |----------> | DataDog |
// ---------
b := new(bytes.Buffer)
b.Reset()
b.WriteString(e.Message)
for _, f := range e.Fields {
fmt.Fprintf(b, " %s=%v", f.Key, f.Value)
}
fmt.Println(b.String())
} | go | func (c *CustomHandler) Log(e log.Entry) {
// below prints to os.Stderr but could marshal to JSON
// and send to central logging server
// ---------
// |----------> | console |
// | ---------
// i.e. ----------------- ----------------- Unmarshal ------------- --------
// | app log handler | -- json --> | central log app | -- to -> | log handler | --> | syslog |
// ----------------- ----------------- Entry ------------- --------
// | ---------
// |----------> | DataDog |
// ---------
b := new(bytes.Buffer)
b.Reset()
b.WriteString(e.Message)
for _, f := range e.Fields {
fmt.Fprintf(b, " %s=%v", f.Key, f.Value)
}
fmt.Println(b.String())
} | [
"func",
"(",
"c",
"*",
"CustomHandler",
")",
"Log",
"(",
"e",
"log",
".",
"Entry",
")",
"{",
"// below prints to os.Stderr but could marshal to JSON",
"// and send to central logging server",
"//\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t ---------",
"// \t\t\t\t ... | // Log accepts log entries to be processed | [
"Log",
"accepts",
"log",
"entries",
"to",
"be",
"processed"
] | fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19 | https://github.com/go-playground/log/blob/fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19/_examples/custom-handler/main.go#L16-L37 |
4,906 | go-playground/log | handlers/http/http.go | New | func New(remoteHost string, method string, header stdhttp.Header) (*HTTP, error) {
if _, err := url.Parse(remoteHost); err != nil {
return nil, err
}
h := &HTTP{
remoteHost: remoteHost,
timestampFormat: log.DefaultTimeFormat,
header: header,
method: method,
client: stdhttp.Client{},
formatFunc: defaultFormatFunc,
}
return h, nil
} | go | func New(remoteHost string, method string, header stdhttp.Header) (*HTTP, error) {
if _, err := url.Parse(remoteHost); err != nil {
return nil, err
}
h := &HTTP{
remoteHost: remoteHost,
timestampFormat: log.DefaultTimeFormat,
header: header,
method: method,
client: stdhttp.Client{},
formatFunc: defaultFormatFunc,
}
return h, nil
} | [
"func",
"New",
"(",
"remoteHost",
"string",
",",
"method",
"string",
",",
"header",
"stdhttp",
".",
"Header",
")",
"(",
"*",
"HTTP",
",",
"error",
")",
"{",
"if",
"_",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"remoteHost",
")",
";",
"err",
"!=",... | // New returns a new instance of the http logger | [
"New",
"returns",
"a",
"new",
"instance",
"of",
"the",
"http",
"logger"
] | fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19 | https://github.com/go-playground/log/blob/fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19/handlers/http/http.go#L43-L57 |
4,907 | go-playground/log | handlers/http/hipchat/hipchat.go | New | func New(api APIVersion, remoteHost string, contentType string, authToken string, application string) (*HipChat, error) {
// test here https://developer.atlassian.com/hipchat/guide/hipchat-rest-api that api token has access
authToken = "Bearer " + authToken
client := &stdhttp.Client{}
req, err := stdhttp.NewRequest("GET", remoteHost+"?auth_test=true", nil)
if err != nil {
return nil, err
}
req.Header.Add("Authorization", authToken)
resp, err := client.Do(req)
if err != nil {
return nil, err
}
if resp.StatusCode != stdhttp.StatusAccepted {
bt, _ := ioutil.ReadAll(resp.Body)
return nil, fmt.Errorf("HipChat authorization failed\n %s", string(bt))
}
header := make(stdhttp.Header)
header.Set("Content-Type", contentType)
header.Set("Authorization", authToken)
hc := &HipChat{
colors: defaultColors,
api: api,
application: application,
}
// not checking error because url.Parse() is the only thin that can fail,
// and we've already checked above that it was OK sending the test request
hc.HTTP, _ = http.New(strings.TrimRight(remoteHost, "/")+"/notification", method, header)
hc.HTTP.SetFormatFunc(formatFunc(hc))
hc.SetTemplate(defaultTemplate)
return hc, nil
} | go | func New(api APIVersion, remoteHost string, contentType string, authToken string, application string) (*HipChat, error) {
// test here https://developer.atlassian.com/hipchat/guide/hipchat-rest-api that api token has access
authToken = "Bearer " + authToken
client := &stdhttp.Client{}
req, err := stdhttp.NewRequest("GET", remoteHost+"?auth_test=true", nil)
if err != nil {
return nil, err
}
req.Header.Add("Authorization", authToken)
resp, err := client.Do(req)
if err != nil {
return nil, err
}
if resp.StatusCode != stdhttp.StatusAccepted {
bt, _ := ioutil.ReadAll(resp.Body)
return nil, fmt.Errorf("HipChat authorization failed\n %s", string(bt))
}
header := make(stdhttp.Header)
header.Set("Content-Type", contentType)
header.Set("Authorization", authToken)
hc := &HipChat{
colors: defaultColors,
api: api,
application: application,
}
// not checking error because url.Parse() is the only thin that can fail,
// and we've already checked above that it was OK sending the test request
hc.HTTP, _ = http.New(strings.TrimRight(remoteHost, "/")+"/notification", method, header)
hc.HTTP.SetFormatFunc(formatFunc(hc))
hc.SetTemplate(defaultTemplate)
return hc, nil
} | [
"func",
"New",
"(",
"api",
"APIVersion",
",",
"remoteHost",
"string",
",",
"contentType",
"string",
",",
"authToken",
"string",
",",
"application",
"string",
")",
"(",
"*",
"HipChat",
",",
"error",
")",
"{",
"// test here https://developer.atlassian.com/hipchat/guid... | // New returns a new instance of the HipChat logger | [
"New",
"returns",
"a",
"new",
"instance",
"of",
"the",
"HipChat",
"logger"
] | fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19 | https://github.com/go-playground/log/blob/fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19/handlers/http/hipchat/hipchat.go#L121-L159 |
4,908 | go-playground/log | handlers/http/hipchat/hipchat.go | SetTemplate | func (hc *HipChat) SetTemplate(htmlTemplate string) {
hc.template = template.Must(template.New("hipchat").Funcs(
template.FuncMap{
"ts": func(e log.Entry) (ts string) {
ts = e.Timestamp.Format(hc.TimestampFormat())
return
},
},
).Parse(htmlTemplate))
} | go | func (hc *HipChat) SetTemplate(htmlTemplate string) {
hc.template = template.Must(template.New("hipchat").Funcs(
template.FuncMap{
"ts": func(e log.Entry) (ts string) {
ts = e.Timestamp.Format(hc.TimestampFormat())
return
},
},
).Parse(htmlTemplate))
} | [
"func",
"(",
"hc",
"*",
"HipChat",
")",
"SetTemplate",
"(",
"htmlTemplate",
"string",
")",
"{",
"hc",
".",
"template",
"=",
"template",
".",
"Must",
"(",
"template",
".",
"New",
"(",
"\"",
"\"",
")",
".",
"Funcs",
"(",
"template",
".",
"FuncMap",
"{"... | // SetTemplate sets Hipchats html template to be used for email body | [
"SetTemplate",
"sets",
"Hipchats",
"html",
"template",
"to",
"be",
"used",
"for",
"email",
"body"
] | fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19 | https://github.com/go-playground/log/blob/fdcdf507e3bf20900bc1a44b0cbd73fee5bcbe19/handlers/http/hipchat/hipchat.go#L162-L171 |
4,909 | itsabot/itsabot | core/util.go | RandAlphaNumSeq | func RandAlphaNumSeq(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = alphaNum[rand.Intn(len(alphaNum))]
}
return string(b)
} | go | func RandAlphaNumSeq(n int) string {
b := make([]rune, n)
for i := range b {
b[i] = alphaNum[rand.Intn(len(alphaNum))]
}
return string(b)
} | [
"func",
"RandAlphaNumSeq",
"(",
"n",
"int",
")",
"string",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"rune",
",",
"n",
")",
"\n",
"for",
"i",
":=",
"range",
"b",
"{",
"b",
"[",
"i",
"]",
"=",
"alphaNum",
"[",
"rand",
".",
"Intn",
"(",
"len",
"("... | // RandAlphaNumSeq generates a random sequence of alpha-numeric characters of
// length n. | [
"RandAlphaNumSeq",
"generates",
"a",
"random",
"sequence",
"of",
"alpha",
"-",
"numeric",
"characters",
"of",
"length",
"n",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/util.go#L26-L32 |
4,910 | itsabot/itsabot | shared/datatypes/scheduled_event.go | Send | func (s *ScheduledEvent) Send(c *sms.Conn) error {
switch s.FlexIDType {
case FIDTPhone:
if err := c.Send(s.FlexID, s.Content); err != nil {
return err
}
default:
return fmt.Errorf("unrecognized flexidtype: %d", s.FlexIDType)
}
return nil
} | go | func (s *ScheduledEvent) Send(c *sms.Conn) error {
switch s.FlexIDType {
case FIDTPhone:
if err := c.Send(s.FlexID, s.Content); err != nil {
return err
}
default:
return fmt.Errorf("unrecognized flexidtype: %d", s.FlexIDType)
}
return nil
} | [
"func",
"(",
"s",
"*",
"ScheduledEvent",
")",
"Send",
"(",
"c",
"*",
"sms",
".",
"Conn",
")",
"error",
"{",
"switch",
"s",
".",
"FlexIDType",
"{",
"case",
"FIDTPhone",
":",
"if",
"err",
":=",
"c",
".",
"Send",
"(",
"s",
".",
"FlexID",
",",
"s",
... | // Send a scheduled event. Currently only phones are supported. | [
"Send",
"a",
"scheduled",
"event",
".",
"Currently",
"only",
"phones",
"are",
"supported",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/scheduled_event.go#L20-L30 |
4,911 | itsabot/itsabot | core/process.go | preprocess | func preprocess(r *http.Request) (*dt.Msg, error) {
req := &dt.Request{}
err := json.NewDecoder(r.Body).Decode(req)
if err != nil {
log.Info("could not parse empty body", err)
return nil, err
}
sendPostReceiveEvent(&req.CMD)
u, err := dt.GetUser(db, req)
if err != nil {
return nil, err
}
sendPreProcessingEvent(&req.CMD, u)
// TODO trigger training if needed (see buildInput)
return NewMsg(u, req.CMD)
} | go | func preprocess(r *http.Request) (*dt.Msg, error) {
req := &dt.Request{}
err := json.NewDecoder(r.Body).Decode(req)
if err != nil {
log.Info("could not parse empty body", err)
return nil, err
}
sendPostReceiveEvent(&req.CMD)
u, err := dt.GetUser(db, req)
if err != nil {
return nil, err
}
sendPreProcessingEvent(&req.CMD, u)
// TODO trigger training if needed (see buildInput)
return NewMsg(u, req.CMD)
} | [
"func",
"preprocess",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"dt",
".",
"Msg",
",",
"error",
")",
"{",
"req",
":=",
"&",
"dt",
".",
"Request",
"{",
"}",
"\n",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"r",
".",
"Body",
")",
... | // preprocess converts a user input into a Msg that's been persisted to the
// database | [
"preprocess",
"converts",
"a",
"user",
"input",
"into",
"a",
"Msg",
"that",
"s",
"been",
"persisted",
"to",
"the",
"database"
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/process.go#L20-L35 |
4,912 | itsabot/itsabot | core/message.go | NewMsg | func NewMsg(u *dt.User, cmd string) (*dt.Msg, error) {
tokens := TokenizeSentence(cmd)
stems := StemTokens(tokens)
si := ner.classifyTokens(tokens)
// Get the intents as determined by each plugin
for pluginID, c := range bClassifiers {
scores, idx, _ := c.ProbScores(stems)
log.Debug("intent score", pluginIntents[pluginID][idx],
scores[idx])
if scores[idx] > 0.7 {
si.Intents = append(si.Intents,
string(pluginIntents[pluginID][idx]))
}
}
m := &dt.Msg{
User: u,
Sentence: cmd,
Tokens: tokens,
Stems: stems,
StructuredInput: si,
}
if err := saveContext(db, m); err != nil {
return nil, err
}
if err := addContext(db, m); err != nil {
return nil, err
}
return m, nil
} | go | func NewMsg(u *dt.User, cmd string) (*dt.Msg, error) {
tokens := TokenizeSentence(cmd)
stems := StemTokens(tokens)
si := ner.classifyTokens(tokens)
// Get the intents as determined by each plugin
for pluginID, c := range bClassifiers {
scores, idx, _ := c.ProbScores(stems)
log.Debug("intent score", pluginIntents[pluginID][idx],
scores[idx])
if scores[idx] > 0.7 {
si.Intents = append(si.Intents,
string(pluginIntents[pluginID][idx]))
}
}
m := &dt.Msg{
User: u,
Sentence: cmd,
Tokens: tokens,
Stems: stems,
StructuredInput: si,
}
if err := saveContext(db, m); err != nil {
return nil, err
}
if err := addContext(db, m); err != nil {
return nil, err
}
return m, nil
} | [
"func",
"NewMsg",
"(",
"u",
"*",
"dt",
".",
"User",
",",
"cmd",
"string",
")",
"(",
"*",
"dt",
".",
"Msg",
",",
"error",
")",
"{",
"tokens",
":=",
"TokenizeSentence",
"(",
"cmd",
")",
"\n",
"stems",
":=",
"StemTokens",
"(",
"tokens",
")",
"\n",
"... | // NewMsg builds a message struct with Tokens, Stems, and a Structured Input. | [
"NewMsg",
"builds",
"a",
"message",
"struct",
"with",
"Tokens",
"Stems",
"and",
"a",
"Structured",
"Input",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/message.go#L9-L39 |
4,913 | itsabot/itsabot | shared/datatypes/message.go | GetMsg | func GetMsg(db *sqlx.DB, id uint64) (*Msg, error) {
q := `SELECT id, sentence, abotsent
FROM messages
WHERE id=$1`
m := &Msg{}
if err := db.Get(m, q, id); err != nil {
return nil, err
}
return m, nil
} | go | func GetMsg(db *sqlx.DB, id uint64) (*Msg, error) {
q := `SELECT id, sentence, abotsent
FROM messages
WHERE id=$1`
m := &Msg{}
if err := db.Get(m, q, id); err != nil {
return nil, err
}
return m, nil
} | [
"func",
"GetMsg",
"(",
"db",
"*",
"sqlx",
".",
"DB",
",",
"id",
"uint64",
")",
"(",
"*",
"Msg",
",",
"error",
")",
"{",
"q",
":=",
"`SELECT id, sentence, abotsent\n\t FROM messages\n\t WHERE id=$1`",
"\n",
"m",
":=",
"&",
"Msg",
"{",
"}",
"\n",
"... | // GetMsg returns a message for a given message ID. | [
"GetMsg",
"returns",
"a",
"message",
"for",
"a",
"given",
"message",
"ID",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/message.go#L35-L44 |
4,914 | itsabot/itsabot | shared/datatypes/message.go | Update | func (m *Msg) Update(db *sqlx.DB) error {
q := `UPDATE messages SET needstraining=$1 WHERE id=$2`
if _, err := db.Exec(q, m.NeedsTraining, m.ID); err != nil {
return err
}
return nil
} | go | func (m *Msg) Update(db *sqlx.DB) error {
q := `UPDATE messages SET needstraining=$1 WHERE id=$2`
if _, err := db.Exec(q, m.NeedsTraining, m.ID); err != nil {
return err
}
return nil
} | [
"func",
"(",
"m",
"*",
"Msg",
")",
"Update",
"(",
"db",
"*",
"sqlx",
".",
"DB",
")",
"error",
"{",
"q",
":=",
"`UPDATE messages SET needstraining=$1 WHERE id=$2`",
"\n",
"if",
"_",
",",
"err",
":=",
"db",
".",
"Exec",
"(",
"q",
",",
"m",
".",
"NeedsT... | // Update a message as needing training. | [
"Update",
"a",
"message",
"as",
"needing",
"training",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/message.go#L47-L53 |
4,915 | itsabot/itsabot | shared/datatypes/message.go | Save | func (m *Msg) Save(db *sqlx.DB) error {
var pluginName string
if m.Plugin != nil {
pluginName = m.Plugin.Config.Name
}
q := `INSERT INTO messages
(userid, sentence, plugin, route, abotsent, needstraining, flexid,
flexidtype, trained)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING id`
row := db.QueryRowx(q, m.User.ID, m.Sentence, pluginName, m.Route,
m.AbotSent, m.NeedsTraining, m.User.FlexID, m.User.FlexIDType,
m.Trained)
if err := row.Scan(&m.ID); err != nil {
return err
}
return nil
} | go | func (m *Msg) Save(db *sqlx.DB) error {
var pluginName string
if m.Plugin != nil {
pluginName = m.Plugin.Config.Name
}
q := `INSERT INTO messages
(userid, sentence, plugin, route, abotsent, needstraining, flexid,
flexidtype, trained)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING id`
row := db.QueryRowx(q, m.User.ID, m.Sentence, pluginName, m.Route,
m.AbotSent, m.NeedsTraining, m.User.FlexID, m.User.FlexIDType,
m.Trained)
if err := row.Scan(&m.ID); err != nil {
return err
}
return nil
} | [
"func",
"(",
"m",
"*",
"Msg",
")",
"Save",
"(",
"db",
"*",
"sqlx",
".",
"DB",
")",
"error",
"{",
"var",
"pluginName",
"string",
"\n",
"if",
"m",
".",
"Plugin",
"!=",
"nil",
"{",
"pluginName",
"=",
"m",
".",
"Plugin",
".",
"Config",
".",
"Name",
... | // Save a message to the database, updating the message ID. | [
"Save",
"a",
"message",
"to",
"the",
"database",
"updating",
"the",
"message",
"ID",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/message.go#L56-L72 |
4,916 | itsabot/itsabot | shared/datatypes/message.go | GetLastPlugin | func (m *Msg) GetLastPlugin(db *sqlx.DB) (string, string, error) {
var res struct {
Plugin string
Route string
}
var err error
if m.User.ID > 0 {
q := `SELECT route, plugin FROM messages
WHERE userid=$1 AND abotsent IS FALSE
ORDER BY createdat DESC`
err = db.Get(&res, q, m.User.ID)
} else {
q := `SELECT route, plugin FROM messages
WHERE flexid=$1 AND flexidtype=$2 AND abotsent IS FALSE
ORDER BY createdat DESC`
err = db.Get(&res, q, m.User.FlexID, m.User.FlexIDType)
}
if err != nil && err != sql.ErrNoRows {
return "", "", err
}
return res.Plugin, res.Route, nil
} | go | func (m *Msg) GetLastPlugin(db *sqlx.DB) (string, string, error) {
var res struct {
Plugin string
Route string
}
var err error
if m.User.ID > 0 {
q := `SELECT route, plugin FROM messages
WHERE userid=$1 AND abotsent IS FALSE
ORDER BY createdat DESC`
err = db.Get(&res, q, m.User.ID)
} else {
q := `SELECT route, plugin FROM messages
WHERE flexid=$1 AND flexidtype=$2 AND abotsent IS FALSE
ORDER BY createdat DESC`
err = db.Get(&res, q, m.User.FlexID, m.User.FlexIDType)
}
if err != nil && err != sql.ErrNoRows {
return "", "", err
}
return res.Plugin, res.Route, nil
} | [
"func",
"(",
"m",
"*",
"Msg",
")",
"GetLastPlugin",
"(",
"db",
"*",
"sqlx",
".",
"DB",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"var",
"res",
"struct",
"{",
"Plugin",
"string",
"\n",
"Route",
"string",
"\n",
"}",
"\n",
"var",
"e... | // GetLastPlugin for a given user so the previous plugin can be called again if
// no new trigger is detected. | [
"GetLastPlugin",
"for",
"a",
"given",
"user",
"so",
"the",
"previous",
"plugin",
"can",
"be",
"called",
"again",
"if",
"no",
"new",
"trigger",
"is",
"detected",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/message.go#L76-L97 |
4,917 | itsabot/itsabot | shared/interface/emailsender/emailsender.go | Open | func Open(driverName, auth string) (*Conn, error) {
driversMu.RLock()
driveri, ok := drivers[driverName]
driversMu.RUnlock()
if !ok {
return nil, fmt.Errorf("sms: unknown driver %q (forgotten import?)",
driverName)
}
conn, err := driveri.Open(auth)
if err != nil {
return nil, err
}
c := &Conn{
driver: driveri,
conn: conn,
}
return c, nil
} | go | func Open(driverName, auth string) (*Conn, error) {
driversMu.RLock()
driveri, ok := drivers[driverName]
driversMu.RUnlock()
if !ok {
return nil, fmt.Errorf("sms: unknown driver %q (forgotten import?)",
driverName)
}
conn, err := driveri.Open(auth)
if err != nil {
return nil, err
}
c := &Conn{
driver: driveri,
conn: conn,
}
return c, nil
} | [
"func",
"Open",
"(",
"driverName",
",",
"auth",
"string",
")",
"(",
"*",
"Conn",
",",
"error",
")",
"{",
"driversMu",
".",
"RLock",
"(",
")",
"\n",
"driveri",
",",
"ok",
":=",
"drivers",
"[",
"driverName",
"]",
"\n",
"driversMu",
".",
"RUnlock",
"(",... | // Open a connection to a registered driver. | [
"Open",
"a",
"connection",
"to",
"a",
"registered",
"driver",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/interface/emailsender/emailsender.go#L52-L69 |
4,918 | itsabot/itsabot | shared/interface/emailsender/emailsender.go | SendHTML | func (c *Conn) SendHTML(to []string, from, subj, html string) error {
return c.conn.SendHTML(to, from, subj, html)
} | go | func (c *Conn) SendHTML(to []string, from, subj, html string) error {
return c.conn.SendHTML(to, from, subj, html)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"SendHTML",
"(",
"to",
"[",
"]",
"string",
",",
"from",
",",
"subj",
",",
"html",
"string",
")",
"error",
"{",
"return",
"c",
".",
"conn",
".",
"SendHTML",
"(",
"to",
",",
"from",
",",
"subj",
",",
"html",
")... | // SendHTML email through the opened driver connection. | [
"SendHTML",
"email",
"through",
"the",
"opened",
"driver",
"connection",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/interface/emailsender/emailsender.go#L72-L74 |
4,919 | itsabot/itsabot | shared/interface/emailsender/emailsender.go | SendPlainText | func (c *Conn) SendPlainText(to []string, from, subj, plaintext string) error {
return c.conn.SendPlainText(to, from, subj, plaintext)
} | go | func (c *Conn) SendPlainText(to []string, from, subj, plaintext string) error {
return c.conn.SendPlainText(to, from, subj, plaintext)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"SendPlainText",
"(",
"to",
"[",
"]",
"string",
",",
"from",
",",
"subj",
",",
"plaintext",
"string",
")",
"error",
"{",
"return",
"c",
".",
"conn",
".",
"SendPlainText",
"(",
"to",
",",
"from",
",",
"subj",
",",... | // SendPlainText email through the opened driver connection. | [
"SendPlainText",
"email",
"through",
"the",
"opened",
"driver",
"connection",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/interface/emailsender/emailsender.go#L77-L79 |
4,920 | itsabot/itsabot | core/context.go | saveContext | func saveContext(db *sqlx.DB, in *dt.Msg) error {
if err := saveTimeContext(db, in); err != nil {
return err
}
if err := savePeopleContext(db, in); err != nil {
return err
}
return nil
} | go | func saveContext(db *sqlx.DB, in *dt.Msg) error {
if err := saveTimeContext(db, in); err != nil {
return err
}
if err := savePeopleContext(db, in); err != nil {
return err
}
return nil
} | [
"func",
"saveContext",
"(",
"db",
"*",
"sqlx",
".",
"DB",
",",
"in",
"*",
"dt",
".",
"Msg",
")",
"error",
"{",
"if",
"err",
":=",
"saveTimeContext",
"(",
"db",
",",
"in",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if"... | // saveContext records context in the database across multiple categories. | [
"saveContext",
"records",
"context",
"in",
"the",
"database",
"across",
"multiple",
"categories",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/context.go#L22-L30 |
4,921 | itsabot/itsabot | core/context.go | saveTimeContext | func saveTimeContext(db *sqlx.DB, in *dt.Msg) error {
if len(in.StructuredInput.Times) == 0 {
return nil
}
byt, err := json.Marshal(in.StructuredInput.Times)
if err != nil {
return err
}
if in.User.ID > 0 {
q := `INSERT INTO states (key, value, userid, pluginname)
VALUES ($1, $2, $3, '')
ON CONFLICT (userid, pluginname, key)
DO UPDATE SET value=$2`
_, err = db.Exec(q, keyContextTime, byt, in.User.ID)
} else {
q := `INSERT INTO states
(key, value, flexid, flexidtype, pluginname)
VALUES ($1, $2, $3, $4, '')
ON CONFLICT (flexid, flexidtype, pluginname, key)
DO UPDATE SET value=$2`
_, err = db.Exec(q, keyContextTime, byt, in.User.FlexID,
in.User.FlexIDType)
}
if err != nil {
return err
}
return nil
} | go | func saveTimeContext(db *sqlx.DB, in *dt.Msg) error {
if len(in.StructuredInput.Times) == 0 {
return nil
}
byt, err := json.Marshal(in.StructuredInput.Times)
if err != nil {
return err
}
if in.User.ID > 0 {
q := `INSERT INTO states (key, value, userid, pluginname)
VALUES ($1, $2, $3, '')
ON CONFLICT (userid, pluginname, key)
DO UPDATE SET value=$2`
_, err = db.Exec(q, keyContextTime, byt, in.User.ID)
} else {
q := `INSERT INTO states
(key, value, flexid, flexidtype, pluginname)
VALUES ($1, $2, $3, $4, '')
ON CONFLICT (flexid, flexidtype, pluginname, key)
DO UPDATE SET value=$2`
_, err = db.Exec(q, keyContextTime, byt, in.User.FlexID,
in.User.FlexIDType)
}
if err != nil {
return err
}
return nil
} | [
"func",
"saveTimeContext",
"(",
"db",
"*",
"sqlx",
".",
"DB",
",",
"in",
"*",
"dt",
".",
"Msg",
")",
"error",
"{",
"if",
"len",
"(",
"in",
".",
"StructuredInput",
".",
"Times",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"byt",
",",
... | // saveTimeContext records contextual information about the time being
// discussed, enabling Abot to replace things like "then" with the time it
// should represent. | [
"saveTimeContext",
"records",
"contextual",
"information",
"about",
"the",
"time",
"being",
"discussed",
"enabling",
"Abot",
"to",
"replace",
"things",
"like",
"then",
"with",
"the",
"time",
"it",
"should",
"represent",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/context.go#L35-L62 |
4,922 | itsabot/itsabot | core/context.go | savePeopleContext | func savePeopleContext(db *sqlx.DB, in *dt.Msg) error {
if len(in.StructuredInput.People) == 0 {
return nil
}
byt, err := json.Marshal(in.StructuredInput.People)
if err != nil {
return err
}
if in.User.ID > 0 {
q := `INSERT INTO states (key, value, userid, pluginname)
VALUES ($1, $2, $3, '')
ON CONFLICT (userid, pluginname, key)
DO UPDATE SET value=$2`
_, err = db.Exec(q, keyContextPeople, byt, in.User.ID)
} else {
q := `INSERT INTO states
(key, value, flexid, flexidtype, pluginname)
VALUES ($1, $2, $3, $4, '')
ON CONFLICT (flexid, flexidtype, pluginname, key)
DO UPDATE SET value=$2`
_, err = db.Exec(q, keyContextPeople, byt, in.User.FlexID,
in.User.FlexIDType)
}
if err != nil {
return err
}
return nil
} | go | func savePeopleContext(db *sqlx.DB, in *dt.Msg) error {
if len(in.StructuredInput.People) == 0 {
return nil
}
byt, err := json.Marshal(in.StructuredInput.People)
if err != nil {
return err
}
if in.User.ID > 0 {
q := `INSERT INTO states (key, value, userid, pluginname)
VALUES ($1, $2, $3, '')
ON CONFLICT (userid, pluginname, key)
DO UPDATE SET value=$2`
_, err = db.Exec(q, keyContextPeople, byt, in.User.ID)
} else {
q := `INSERT INTO states
(key, value, flexid, flexidtype, pluginname)
VALUES ($1, $2, $3, $4, '')
ON CONFLICT (flexid, flexidtype, pluginname, key)
DO UPDATE SET value=$2`
_, err = db.Exec(q, keyContextPeople, byt, in.User.FlexID,
in.User.FlexIDType)
}
if err != nil {
return err
}
return nil
} | [
"func",
"savePeopleContext",
"(",
"db",
"*",
"sqlx",
".",
"DB",
",",
"in",
"*",
"dt",
".",
"Msg",
")",
"error",
"{",
"if",
"len",
"(",
"in",
".",
"StructuredInput",
".",
"People",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"byt",
",",... | // savePeopleContext records contextual information about people being
// discussed, enabling Abot to replace things like "him", "her", or "they" with
// the names the pronouns represent. | [
"savePeopleContext",
"records",
"contextual",
"information",
"about",
"people",
"being",
"discussed",
"enabling",
"Abot",
"to",
"replace",
"things",
"like",
"him",
"her",
"or",
"they",
"with",
"the",
"names",
"the",
"pronouns",
"represent",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/context.go#L67-L94 |
4,923 | itsabot/itsabot | core/context.go | addTimeContext | func addTimeContext(db *sqlx.DB, in *dt.Msg) error {
var addContext bool
for _, stem := range in.Stems {
if stem == "then" {
addContext = true
break
}
}
if !addContext {
return nil
}
var byt []byte
var err error
if in.User.ID > 0 {
q := `SELECT value FROM states WHERE userid=$1 AND key=$2`
err = db.Get(&byt, q, in.User.ID, keyContextTime)
} else {
q := `SELECT value FROM states
WHERE flexid=$1 AND flexidtype=$2 AND key=$3`
err = db.Get(&byt, q, in.User.FlexID, in.User.FlexIDType,
keyContextTime)
}
if err == sql.ErrNoRows {
return nil
}
if err != nil {
return err
}
var times []time.Time
if err = json.Unmarshal(byt, ×); err != nil {
return err
}
in.StructuredInput.Times = times
return nil
} | go | func addTimeContext(db *sqlx.DB, in *dt.Msg) error {
var addContext bool
for _, stem := range in.Stems {
if stem == "then" {
addContext = true
break
}
}
if !addContext {
return nil
}
var byt []byte
var err error
if in.User.ID > 0 {
q := `SELECT value FROM states WHERE userid=$1 AND key=$2`
err = db.Get(&byt, q, in.User.ID, keyContextTime)
} else {
q := `SELECT value FROM states
WHERE flexid=$1 AND flexidtype=$2 AND key=$3`
err = db.Get(&byt, q, in.User.FlexID, in.User.FlexIDType,
keyContextTime)
}
if err == sql.ErrNoRows {
return nil
}
if err != nil {
return err
}
var times []time.Time
if err = json.Unmarshal(byt, ×); err != nil {
return err
}
in.StructuredInput.Times = times
return nil
} | [
"func",
"addTimeContext",
"(",
"db",
"*",
"sqlx",
".",
"DB",
",",
"in",
"*",
"dt",
".",
"Msg",
")",
"error",
"{",
"var",
"addContext",
"bool",
"\n",
"for",
"_",
",",
"stem",
":=",
"range",
"in",
".",
"Stems",
"{",
"if",
"stem",
"==",
"\"",
"\"",
... | // addTimeContext adds a time context to a Message if the word "then" is found. | [
"addTimeContext",
"adds",
"a",
"time",
"context",
"to",
"a",
"Message",
"if",
"the",
"word",
"then",
"is",
"found",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/context.go#L114-L148 |
4,924 | itsabot/itsabot | core/context.go | addPeopleContext | func addPeopleContext(db *sqlx.DB, in *dt.Msg) error {
var addContext, singular bool
var sex dt.Sex
for _, stem := range in.Stems {
switch stem {
case "us":
addContext = true
case "him", "he":
addContext, singular = true, true
if sex == dt.SexFemale {
sex = dt.SexEither
} else if sex != dt.SexEither {
sex = dt.SexMale
}
case "her", "she":
addContext, singular = true, true
if sex == dt.SexMale {
sex = dt.SexEither
} else if sex != dt.SexEither {
sex = dt.SexFemale
}
case "them":
addContext = true
sex = dt.SexEither
}
}
if !addContext {
return nil
}
var byt []byte
var err error
if in.User.ID > 0 {
q := `SELECT value FROM states WHERE userid=$1 AND key=$2`
err = db.Get(&byt, q, in.User.ID, keyContextPeople)
} else {
q := `SELECT value FROM states
WHERE flexid=$1 AND flexidtype=$2 AND key=$3`
err = db.Get(&byt, q, in.User.FlexID, in.User.FlexIDType,
keyContextPeople)
}
if err == sql.ErrNoRows {
return nil
}
if err != nil {
return err
}
var people []dt.Person
if err = json.Unmarshal(byt, &people); err != nil {
return err
}
// Filter our people in context by criteria, like sex.
if !singular {
in.StructuredInput.People = people
return nil
}
if sex == dt.SexEither {
// To reach this point, we have at least one person in context.
in.StructuredInput.People = []dt.Person{people[0]}
return nil
}
for _, person := range people {
if person.Sex == sex {
in.StructuredInput.People = []dt.Person{person}
break
}
}
return nil
} | go | func addPeopleContext(db *sqlx.DB, in *dt.Msg) error {
var addContext, singular bool
var sex dt.Sex
for _, stem := range in.Stems {
switch stem {
case "us":
addContext = true
case "him", "he":
addContext, singular = true, true
if sex == dt.SexFemale {
sex = dt.SexEither
} else if sex != dt.SexEither {
sex = dt.SexMale
}
case "her", "she":
addContext, singular = true, true
if sex == dt.SexMale {
sex = dt.SexEither
} else if sex != dt.SexEither {
sex = dt.SexFemale
}
case "them":
addContext = true
sex = dt.SexEither
}
}
if !addContext {
return nil
}
var byt []byte
var err error
if in.User.ID > 0 {
q := `SELECT value FROM states WHERE userid=$1 AND key=$2`
err = db.Get(&byt, q, in.User.ID, keyContextPeople)
} else {
q := `SELECT value FROM states
WHERE flexid=$1 AND flexidtype=$2 AND key=$3`
err = db.Get(&byt, q, in.User.FlexID, in.User.FlexIDType,
keyContextPeople)
}
if err == sql.ErrNoRows {
return nil
}
if err != nil {
return err
}
var people []dt.Person
if err = json.Unmarshal(byt, &people); err != nil {
return err
}
// Filter our people in context by criteria, like sex.
if !singular {
in.StructuredInput.People = people
return nil
}
if sex == dt.SexEither {
// To reach this point, we have at least one person in context.
in.StructuredInput.People = []dt.Person{people[0]}
return nil
}
for _, person := range people {
if person.Sex == sex {
in.StructuredInput.People = []dt.Person{person}
break
}
}
return nil
} | [
"func",
"addPeopleContext",
"(",
"db",
"*",
"sqlx",
".",
"DB",
",",
"in",
"*",
"dt",
".",
"Msg",
")",
"error",
"{",
"var",
"addContext",
",",
"singular",
"bool",
"\n",
"var",
"sex",
"dt",
".",
"Sex",
"\n",
"for",
"_",
",",
"stem",
":=",
"range",
... | // addPeopleContext adds people based on context to the sentence when
// appropriate pronouns are found, like "us", "him", "her", or "them". | [
"addPeopleContext",
"adds",
"people",
"based",
"on",
"context",
"to",
"the",
"sentence",
"when",
"appropriate",
"pronouns",
"are",
"found",
"like",
"us",
"him",
"her",
"or",
"them",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/context.go#L152-L220 |
4,925 | itsabot/itsabot | core/nlp.go | classifyTokens | func (c classifier) classifyTokens(tokens []string) *dt.StructuredInput {
var s dt.StructuredInput
var sections []string
for _, t := range tokens {
var found bool
lower := strings.ToLower(t)
_, exists := c["C"+lower]
if exists {
s.Commands = append(s.Commands, lower)
found = true
}
_, exists = c["O"+lower]
if exists {
s.Objects = append(s.Objects, lower)
found = true
}
// Identify the sex of any people being discussed.
var sex dt.Sex
_, exists = c["PM"+lower]
if exists {
_, exists = c["PF"+lower]
if exists {
sex = dt.SexEither
} else {
sex = dt.SexMale
}
person := dt.Person{
Name: t,
Sex: sex,
}
s.People = append(s.People, person)
found = true
}
// If we haven't found a male or male+female name yet, check
// for female.
if sex == dt.SexInvalid {
_, exists = c["PF"+lower]
if exists {
person := dt.Person{
Name: t,
Sex: dt.SexFemale,
}
s.People = append(s.People, person)
found = true
}
}
// Each time we find an object, add a separator to sections,
// enabling us to check for times only along continuous
// stretches of a sentence (i.e. a single time won't appear on
// either side of the word "Jim" or "Bring")
if found || len(sections) == 0 {
sections = append(sections, t)
} else {
switch t {
case ".", ",", ";", "?", "-", "_", "=", "+", "#", "@",
"!", "$", "%", "^", "&", "*", "(", ")", "'":
continue
}
sections[len(sections)-1] += " " + t
}
}
for _, sec := range sections {
if len(sec) == 0 {
continue
}
s.Times = append(s.Times, timeparse.Parse(sec)...)
}
return &s
} | go | func (c classifier) classifyTokens(tokens []string) *dt.StructuredInput {
var s dt.StructuredInput
var sections []string
for _, t := range tokens {
var found bool
lower := strings.ToLower(t)
_, exists := c["C"+lower]
if exists {
s.Commands = append(s.Commands, lower)
found = true
}
_, exists = c["O"+lower]
if exists {
s.Objects = append(s.Objects, lower)
found = true
}
// Identify the sex of any people being discussed.
var sex dt.Sex
_, exists = c["PM"+lower]
if exists {
_, exists = c["PF"+lower]
if exists {
sex = dt.SexEither
} else {
sex = dt.SexMale
}
person := dt.Person{
Name: t,
Sex: sex,
}
s.People = append(s.People, person)
found = true
}
// If we haven't found a male or male+female name yet, check
// for female.
if sex == dt.SexInvalid {
_, exists = c["PF"+lower]
if exists {
person := dt.Person{
Name: t,
Sex: dt.SexFemale,
}
s.People = append(s.People, person)
found = true
}
}
// Each time we find an object, add a separator to sections,
// enabling us to check for times only along continuous
// stretches of a sentence (i.e. a single time won't appear on
// either side of the word "Jim" or "Bring")
if found || len(sections) == 0 {
sections = append(sections, t)
} else {
switch t {
case ".", ",", ";", "?", "-", "_", "=", "+", "#", "@",
"!", "$", "%", "^", "&", "*", "(", ")", "'":
continue
}
sections[len(sections)-1] += " " + t
}
}
for _, sec := range sections {
if len(sec) == 0 {
continue
}
s.Times = append(s.Times, timeparse.Parse(sec)...)
}
return &s
} | [
"func",
"(",
"c",
"classifier",
")",
"classifyTokens",
"(",
"tokens",
"[",
"]",
"string",
")",
"*",
"dt",
".",
"StructuredInput",
"{",
"var",
"s",
"dt",
".",
"StructuredInput",
"\n",
"var",
"sections",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"t",
... | // classifyTokens builds a StructuredInput from a tokenized sentence. | [
"classifyTokens",
"builds",
"a",
"StructuredInput",
"from",
"a",
"tokenized",
"sentence",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/nlp.go#L24-L95 |
4,926 | itsabot/itsabot | core/nlp.go | buildOffensiveMap | func buildOffensiveMap() (map[string]struct{}, error) {
o := map[string]struct{}{}
p := filepath.Join("data", "offensive.txt")
fi, err := os.Open(p)
if err != nil {
return o, err
}
scanner := bufio.NewScanner(fi)
scanner.Split(bufio.ScanLines)
for scanner.Scan() {
o[scanner.Text()] = struct{}{}
}
err = fi.Close()
return o, err
} | go | func buildOffensiveMap() (map[string]struct{}, error) {
o := map[string]struct{}{}
p := filepath.Join("data", "offensive.txt")
fi, err := os.Open(p)
if err != nil {
return o, err
}
scanner := bufio.NewScanner(fi)
scanner.Split(bufio.ScanLines)
for scanner.Scan() {
o[scanner.Text()] = struct{}{}
}
err = fi.Close()
return o, err
} | [
"func",
"buildOffensiveMap",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
",",
"error",
")",
"{",
"o",
":=",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
"{",
"}",
"\n",
"p",
":=",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",... | // buildOffensiveMap creates a map of offensive terms for which Abot will refuse
// to respond. This helps ensure that users are somewhat respectful to Abot and
// her human trainers, since sentences caught by the OffensiveMap are rejected
// before any human ever sees them. | [
"buildOffensiveMap",
"creates",
"a",
"map",
"of",
"offensive",
"terms",
"for",
"which",
"Abot",
"will",
"refuse",
"to",
"respond",
".",
"This",
"helps",
"ensure",
"that",
"users",
"are",
"somewhat",
"respectful",
"to",
"Abot",
"and",
"her",
"human",
"trainers"... | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/nlp.go#L193-L207 |
4,927 | itsabot/itsabot | core/nlp.go | RespondWithNicety | func RespondWithNicety(in *dt.Msg) string {
for _, w := range in.Stems {
// Since these are stems, some of them look incorrectly spelled.
// Needless to say, these are the correct Porter2 Snowball stems
switch w {
case "thank":
return "You're welcome!"
case "cool", "sweet", "awesom", "neat", "perfect":
return "I know!"
case "sorri":
return "That's OK. I forgive you."
case "hi", "hello":
return "Hi there. :)"
}
}
return ""
} | go | func RespondWithNicety(in *dt.Msg) string {
for _, w := range in.Stems {
// Since these are stems, some of them look incorrectly spelled.
// Needless to say, these are the correct Porter2 Snowball stems
switch w {
case "thank":
return "You're welcome!"
case "cool", "sweet", "awesom", "neat", "perfect":
return "I know!"
case "sorri":
return "That's OK. I forgive you."
case "hi", "hello":
return "Hi there. :)"
}
}
return ""
} | [
"func",
"RespondWithNicety",
"(",
"in",
"*",
"dt",
".",
"Msg",
")",
"string",
"{",
"for",
"_",
",",
"w",
":=",
"range",
"in",
".",
"Stems",
"{",
"// Since these are stems, some of them look incorrectly spelled.",
"// Needless to say, these are the correct Porter2 Snowball... | // RespondWithNicety replies to niceties that humans use, but Abot can ignore.
// Words like "Thank you" are not necessary for a robot, but it's important Abot
// respond correctly nonetheless. | [
"RespondWithNicety",
"replies",
"to",
"niceties",
"that",
"humans",
"use",
"but",
"Abot",
"can",
"ignore",
".",
"Words",
"like",
"Thank",
"you",
"are",
"not",
"necessary",
"for",
"a",
"robot",
"but",
"it",
"s",
"important",
"Abot",
"respond",
"correctly",
"n... | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/nlp.go#L212-L228 |
4,928 | itsabot/itsabot | core/nlp.go | RespondWithHelp | func RespondWithHelp(in *dt.Msg) string {
if len(in.StructuredInput.Commands) != 1 {
return ""
}
if in.StructuredInput.Commands[0] != "help" {
return ""
}
if in.Plugin != nil {
use := randUseForPlugin(in.Plugin)
use2 := randUseForPlugin(in.Plugin)
if use == use2 {
return fmt.Sprintf("Try telling me %q", use)
}
return fmt.Sprintf("Try telling me %q or %q", use, use2)
}
switch len(PluginsGo) {
case 0:
return ""
case 1:
return fmt.Sprintf("Try saying %q", randUse())
default:
use := randUse()
use2 := randUse()
if use == use2 {
return fmt.Sprintf("Try telling me %q", use)
}
return fmt.Sprintf("Try telling me %q or %q", use, use2)
}
} | go | func RespondWithHelp(in *dt.Msg) string {
if len(in.StructuredInput.Commands) != 1 {
return ""
}
if in.StructuredInput.Commands[0] != "help" {
return ""
}
if in.Plugin != nil {
use := randUseForPlugin(in.Plugin)
use2 := randUseForPlugin(in.Plugin)
if use == use2 {
return fmt.Sprintf("Try telling me %q", use)
}
return fmt.Sprintf("Try telling me %q or %q", use, use2)
}
switch len(PluginsGo) {
case 0:
return ""
case 1:
return fmt.Sprintf("Try saying %q", randUse())
default:
use := randUse()
use2 := randUse()
if use == use2 {
return fmt.Sprintf("Try telling me %q", use)
}
return fmt.Sprintf("Try telling me %q or %q", use, use2)
}
} | [
"func",
"RespondWithHelp",
"(",
"in",
"*",
"dt",
".",
"Msg",
")",
"string",
"{",
"if",
"len",
"(",
"in",
".",
"StructuredInput",
".",
"Commands",
")",
"!=",
"1",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"in",
".",
"StructuredInput",
".",
"... | // RespondWithHelp replies to the user when he or she asks for "help". | [
"RespondWithHelp",
"replies",
"to",
"the",
"user",
"when",
"he",
"or",
"she",
"asks",
"for",
"help",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/nlp.go#L231-L259 |
4,929 | itsabot/itsabot | core/nlp.go | RespondWithHelpConfused | func RespondWithHelpConfused(in *dt.Msg) string {
if in.Plugin != nil {
use := randUseForPlugin(in.Plugin)
use2 := randUseForPlugin(in.Plugin)
if use == use2 {
return fmt.Sprintf("%s You can try telling me %q",
ConfusedLang(), use)
}
return fmt.Sprintf("%s You can try telling me %q or %q",
ConfusedLang(), use, use2)
}
if len(PluginsGo) == 0 {
return ConfusedLang()
}
use := randUse()
use2 := randUse()
if use == use2 {
return fmt.Sprintf("%s How about %q", ConfusedLang(), use)
}
return fmt.Sprintf("%s How about %q or %q", ConfusedLang(), use, use2)
} | go | func RespondWithHelpConfused(in *dt.Msg) string {
if in.Plugin != nil {
use := randUseForPlugin(in.Plugin)
use2 := randUseForPlugin(in.Plugin)
if use == use2 {
return fmt.Sprintf("%s You can try telling me %q",
ConfusedLang(), use)
}
return fmt.Sprintf("%s You can try telling me %q or %q",
ConfusedLang(), use, use2)
}
if len(PluginsGo) == 0 {
return ConfusedLang()
}
use := randUse()
use2 := randUse()
if use == use2 {
return fmt.Sprintf("%s How about %q", ConfusedLang(), use)
}
return fmt.Sprintf("%s How about %q or %q", ConfusedLang(), use, use2)
} | [
"func",
"RespondWithHelpConfused",
"(",
"in",
"*",
"dt",
".",
"Msg",
")",
"string",
"{",
"if",
"in",
".",
"Plugin",
"!=",
"nil",
"{",
"use",
":=",
"randUseForPlugin",
"(",
"in",
".",
"Plugin",
")",
"\n",
"use2",
":=",
"randUseForPlugin",
"(",
"in",
"."... | // RespondWithHelpConfused replies to the user when Abot is confused. | [
"RespondWithHelpConfused",
"replies",
"to",
"the",
"user",
"when",
"Abot",
"is",
"confused",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/nlp.go#L262-L282 |
4,930 | itsabot/itsabot | core/nlp.go | randUse | func randUse() string {
if len(PluginsGo) == 0 {
return ""
}
pluginUses := PluginsGo[rand.Intn(len(PluginsGo))].Usage
if pluginUses == nil || len(pluginUses) == 0 {
return ""
}
return pluginUses[rand.Intn(len(pluginUses))]
} | go | func randUse() string {
if len(PluginsGo) == 0 {
return ""
}
pluginUses := PluginsGo[rand.Intn(len(PluginsGo))].Usage
if pluginUses == nil || len(pluginUses) == 0 {
return ""
}
return pluginUses[rand.Intn(len(pluginUses))]
} | [
"func",
"randUse",
"(",
")",
"string",
"{",
"if",
"len",
"(",
"PluginsGo",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"pluginUses",
":=",
"PluginsGo",
"[",
"rand",
".",
"Intn",
"(",
"len",
"(",
"PluginsGo",
")",
")",
"]",
".",
"U... | // randUse returns a random use from among all plugins. | [
"randUse",
"returns",
"a",
"random",
"use",
"from",
"among",
"all",
"plugins",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/nlp.go#L285-L294 |
4,931 | itsabot/itsabot | core/nlp.go | randUseForPlugin | func randUseForPlugin(plugin *dt.Plugin) string {
if plugin.Config.Usage == nil {
return ""
}
return plugin.Config.Usage[rand.Intn(len(plugin.Config.Usage))]
} | go | func randUseForPlugin(plugin *dt.Plugin) string {
if plugin.Config.Usage == nil {
return ""
}
return plugin.Config.Usage[rand.Intn(len(plugin.Config.Usage))]
} | [
"func",
"randUseForPlugin",
"(",
"plugin",
"*",
"dt",
".",
"Plugin",
")",
"string",
"{",
"if",
"plugin",
".",
"Config",
".",
"Usage",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"plugin",
".",
"Config",
".",
"Usage",
"[",
"rand... | // randUseForPlugin returns a random use from a specific plugin. | [
"randUseForPlugin",
"returns",
"a",
"random",
"use",
"from",
"a",
"specific",
"plugin",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/nlp.go#L297-L302 |
4,932 | itsabot/itsabot | core/nlp.go | RespondWithOffense | func RespondWithOffense(in *dt.Msg) string {
for _, w := range in.Stems {
_, ok := offensive[w]
if ok {
return "I'm sorry, but I don't respond to rude language."
}
}
return ""
} | go | func RespondWithOffense(in *dt.Msg) string {
for _, w := range in.Stems {
_, ok := offensive[w]
if ok {
return "I'm sorry, but I don't respond to rude language."
}
}
return ""
} | [
"func",
"RespondWithOffense",
"(",
"in",
"*",
"dt",
".",
"Msg",
")",
"string",
"{",
"for",
"_",
",",
"w",
":=",
"range",
"in",
".",
"Stems",
"{",
"_",
",",
"ok",
":=",
"offensive",
"[",
"w",
"]",
"\n",
"if",
"ok",
"{",
"return",
"\"",
"\"",
"\n... | // RespondWithOffense is a one-off function to respond to rude user language by
// refusing to process the command. | [
"RespondWithOffense",
"is",
"a",
"one",
"-",
"off",
"function",
"to",
"respond",
"to",
"rude",
"user",
"language",
"by",
"refusing",
"to",
"process",
"the",
"command",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/nlp.go#L306-L314 |
4,933 | itsabot/itsabot | shared/helpers/address/address.go | Parse | func Parse(s string) (*dt.Address, error) {
s = regexAddress.FindString(s)
if len(s) == 0 {
log.Debug("missing address")
return nil, ErrInvalidAddress
}
log.Debug("address", s)
tmp := regexZip.FindStringIndex(s)
var zip string
if tmp != nil {
zip = s[tmp[0]:tmp[1]]
s = s[:tmp[0]]
} else {
log.Debug("no zip found")
}
tmp2 := regexState.FindStringIndex(s)
if tmp2 == nil && tmp == nil {
log.Debug("no state found AND no zip found")
return &dt.Address{}, ErrInvalidAddress
}
var city, state string
if tmp2 != nil {
state = s[tmp2[0]:tmp2[1]]
s = s[:tmp2[0]]
state = strings.Trim(state, ", \n")
if len(state) > 2 {
state = strings.ToLower(state)
state = states[state]
}
tmp = regexCity.FindStringIndex(s)
if tmp == nil {
log.Debug("no city found")
return &dt.Address{}, ErrInvalidAddress
}
city = s[tmp[0]:tmp[1]]
s = s[:tmp[0]]
} else {
log.Debug("no state found")
}
tmp = regexApartment.FindStringIndex(s)
var apartment string
if tmp != nil {
apartment = s[tmp[0]:tmp[1]]
s2 := s[:tmp[0]]
if len(s2) == 0 {
apartment = ""
} else {
s = s2
}
} else {
log.Debug("no apartment found")
}
tmp = regexStreet.FindStringIndex(s)
if tmp == nil {
log.Debug(s)
log.Debug("no street found")
return &dt.Address{}, ErrInvalidAddress
}
street := s[tmp[0]:tmp[1]]
return &dt.Address{
Line1: strings.Trim(street, " \n,"),
Line2: strings.Trim(apartment, " \n,"),
City: strings.Trim(city, " \n,"),
State: strings.Trim(state, " \n,"),
Zip: strings.Trim(zip, " \n,"),
Country: "USA",
}, nil
} | go | func Parse(s string) (*dt.Address, error) {
s = regexAddress.FindString(s)
if len(s) == 0 {
log.Debug("missing address")
return nil, ErrInvalidAddress
}
log.Debug("address", s)
tmp := regexZip.FindStringIndex(s)
var zip string
if tmp != nil {
zip = s[tmp[0]:tmp[1]]
s = s[:tmp[0]]
} else {
log.Debug("no zip found")
}
tmp2 := regexState.FindStringIndex(s)
if tmp2 == nil && tmp == nil {
log.Debug("no state found AND no zip found")
return &dt.Address{}, ErrInvalidAddress
}
var city, state string
if tmp2 != nil {
state = s[tmp2[0]:tmp2[1]]
s = s[:tmp2[0]]
state = strings.Trim(state, ", \n")
if len(state) > 2 {
state = strings.ToLower(state)
state = states[state]
}
tmp = regexCity.FindStringIndex(s)
if tmp == nil {
log.Debug("no city found")
return &dt.Address{}, ErrInvalidAddress
}
city = s[tmp[0]:tmp[1]]
s = s[:tmp[0]]
} else {
log.Debug("no state found")
}
tmp = regexApartment.FindStringIndex(s)
var apartment string
if tmp != nil {
apartment = s[tmp[0]:tmp[1]]
s2 := s[:tmp[0]]
if len(s2) == 0 {
apartment = ""
} else {
s = s2
}
} else {
log.Debug("no apartment found")
}
tmp = regexStreet.FindStringIndex(s)
if tmp == nil {
log.Debug(s)
log.Debug("no street found")
return &dt.Address{}, ErrInvalidAddress
}
street := s[tmp[0]:tmp[1]]
return &dt.Address{
Line1: strings.Trim(street, " \n,"),
Line2: strings.Trim(apartment, " \n,"),
City: strings.Trim(city, " \n,"),
State: strings.Trim(state, " \n,"),
Zip: strings.Trim(zip, " \n,"),
Country: "USA",
}, nil
} | [
"func",
"Parse",
"(",
"s",
"string",
")",
"(",
"*",
"dt",
".",
"Address",
",",
"error",
")",
"{",
"s",
"=",
"regexAddress",
".",
"FindString",
"(",
"s",
")",
"\n",
"if",
"len",
"(",
"s",
")",
"==",
"0",
"{",
"log",
".",
"Debug",
"(",
"\"",
"\... | // Parse a string to return a fully-validated U.S. address. | [
"Parse",
"a",
"string",
"to",
"return",
"a",
"fully",
"-",
"validated",
"U",
".",
"S",
".",
"address",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/helpers/address/address.go#L98-L165 |
4,934 | itsabot/itsabot | core/boot.go | compileAssets | func compileAssets() error {
p := filepath.Join("cmd", "compileassets.sh")
outC, err := exec.
Command("/bin/sh", "-c", p).
CombinedOutput()
if err != nil {
log.Debug(string(outC))
return err
}
return nil
} | go | func compileAssets() error {
p := filepath.Join("cmd", "compileassets.sh")
outC, err := exec.
Command("/bin/sh", "-c", p).
CombinedOutput()
if err != nil {
log.Debug(string(outC))
return err
}
return nil
} | [
"func",
"compileAssets",
"(",
")",
"error",
"{",
"p",
":=",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"outC",
",",
"err",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"p",
")",
".",
"CombinedO... | // compileAssets compresses and merges assets from Abot core and all plugins on
// boot. In development, this step is repeated on each server HTTP request prior
// to serving any assets. | [
"compileAssets",
"compresses",
"and",
"merges",
"assets",
"from",
"Abot",
"core",
"and",
"all",
"plugins",
"on",
"boot",
".",
"In",
"development",
"this",
"step",
"is",
"repeated",
"on",
"each",
"server",
"HTTP",
"request",
"prior",
"to",
"serving",
"any",
"... | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/boot.go#L165-L175 |
4,935 | itsabot/itsabot | core/boot.go | ConnectDB | func ConnectDB(name string) (*sqlx.DB, error) {
if len(name) == 0 {
dir, err := os.Getwd()
if err != nil {
return nil, err
}
name = filepath.Base(dir)
}
dbConnStr := DBConnectionString(name)
log.Debug("connecting to db")
return sqlx.Connect("postgres", dbConnStr)
} | go | func ConnectDB(name string) (*sqlx.DB, error) {
if len(name) == 0 {
dir, err := os.Getwd()
if err != nil {
return nil, err
}
name = filepath.Base(dir)
}
dbConnStr := DBConnectionString(name)
log.Debug("connecting to db")
return sqlx.Connect("postgres", dbConnStr)
} | [
"func",
"ConnectDB",
"(",
"name",
"string",
")",
"(",
"*",
"sqlx",
".",
"DB",
",",
"error",
")",
"{",
"if",
"len",
"(",
"name",
")",
"==",
"0",
"{",
"dir",
",",
"err",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // ConnectDB opens a connection to the database. The name is the name of the
// database to connect to. If empty, it defaults to the current directory's
// name. | [
"ConnectDB",
"opens",
"a",
"connection",
"to",
"the",
"database",
".",
"The",
"name",
"is",
"the",
"name",
"of",
"the",
"database",
"to",
"connect",
"to",
".",
"If",
"empty",
"it",
"defaults",
"to",
"the",
"current",
"directory",
"s",
"name",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/boot.go#L207-L218 |
4,936 | itsabot/itsabot | core/boot.go | DBConnectionString | func DBConnectionString(name string) string {
dbConnStr := os.Getenv("ABOT_DATABASE_URL")
if dbConnStr == "" {
dbConnStr = "host=127.0.0.1 user=postgres"
}
if len(dbConnStr) <= 11 || dbConnStr[:11] != "postgres://" {
dbConnStr += " sslmode=disable dbname=" + name
if strings.ToLower(os.Getenv("ABOT_ENV")) == "test" {
dbConnStr += "_test"
}
}
return dbConnStr
} | go | func DBConnectionString(name string) string {
dbConnStr := os.Getenv("ABOT_DATABASE_URL")
if dbConnStr == "" {
dbConnStr = "host=127.0.0.1 user=postgres"
}
if len(dbConnStr) <= 11 || dbConnStr[:11] != "postgres://" {
dbConnStr += " sslmode=disable dbname=" + name
if strings.ToLower(os.Getenv("ABOT_ENV")) == "test" {
dbConnStr += "_test"
}
}
return dbConnStr
} | [
"func",
"DBConnectionString",
"(",
"name",
"string",
")",
"string",
"{",
"dbConnStr",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"dbConnStr",
"==",
"\"",
"\"",
"{",
"dbConnStr",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"len",
"(",
... | // DBConnectionString returns the connection parameters for connecting to the
// database. | [
"DBConnectionString",
"returns",
"the",
"connection",
"parameters",
"for",
"connecting",
"to",
"the",
"database",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/boot.go#L222-L234 |
4,937 | itsabot/itsabot | core/boot.go | LoadConf | func LoadConf() error {
p := filepath.Join("plugins.json")
okVal := fmt.Sprintf("open %s: no such file or directory", p)
contents, err := ioutil.ReadFile(p)
if err != nil && err.Error() != okVal {
return err
}
return json.Unmarshal(contents, conf)
} | go | func LoadConf() error {
p := filepath.Join("plugins.json")
okVal := fmt.Sprintf("open %s: no such file or directory", p)
contents, err := ioutil.ReadFile(p)
if err != nil && err.Error() != okVal {
return err
}
return json.Unmarshal(contents, conf)
} | [
"func",
"LoadConf",
"(",
")",
"error",
"{",
"p",
":=",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
")",
"\n",
"okVal",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
")",
"\n",
"contents",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
... | // LoadConf plugins.json into a usable struct. | [
"LoadConf",
"plugins",
".",
"json",
"into",
"a",
"usable",
"struct",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/boot.go#L237-L245 |
4,938 | itsabot/itsabot | core/boot.go | LoadEnvVars | func LoadEnvVars() error {
if envLoaded {
return nil
}
if len(os.Getenv("ABOT_PATH")) == 0 {
p := filepath.Join(os.Getenv("GOPATH"), "src", "github.com",
"itsabot", "abot")
log.Debug("ABOT_PATH not set. defaulting to", p)
if err := os.Setenv("ABOT_PATH", p); err != nil {
return err
}
}
if len(os.Getenv("ITSABOT_URL")) == 0 {
log.Debug("ITSABOT_URL not set, using https://www.itsabot.org")
err := os.Setenv("ITSABOT_URL", "https://www.itsabot.org")
if err != nil {
return err
}
}
p := filepath.Join("abot.env")
fi, err := os.Open(p)
if os.IsNotExist(err) {
// Assume the user has loaded their env variables into their
// path
return nil
}
if err != nil {
return err
}
defer func() {
if err = fi.Close(); err != nil {
log.Info("failed to close file")
}
}()
scn := bufio.NewScanner(fi)
for scn.Scan() {
line := scn.Text()
fields := strings.SplitN(line, "=", 2)
if len(fields) != 2 {
continue
}
key := strings.TrimSpace(fields[0])
if len(key) == 0 {
continue
}
if len(os.Getenv(fields[0])) > 0 {
continue
}
val := strings.TrimSpace(fields[1])
if len(val) >= 2 {
if val[0] == '"' || val[0] == '\'' {
val = val[1 : len(val)-1]
}
}
if err = os.Setenv(key, val); err != nil {
return err
}
}
if err = scn.Err(); err != nil {
return err
}
envLoaded = true
return nil
} | go | func LoadEnvVars() error {
if envLoaded {
return nil
}
if len(os.Getenv("ABOT_PATH")) == 0 {
p := filepath.Join(os.Getenv("GOPATH"), "src", "github.com",
"itsabot", "abot")
log.Debug("ABOT_PATH not set. defaulting to", p)
if err := os.Setenv("ABOT_PATH", p); err != nil {
return err
}
}
if len(os.Getenv("ITSABOT_URL")) == 0 {
log.Debug("ITSABOT_URL not set, using https://www.itsabot.org")
err := os.Setenv("ITSABOT_URL", "https://www.itsabot.org")
if err != nil {
return err
}
}
p := filepath.Join("abot.env")
fi, err := os.Open(p)
if os.IsNotExist(err) {
// Assume the user has loaded their env variables into their
// path
return nil
}
if err != nil {
return err
}
defer func() {
if err = fi.Close(); err != nil {
log.Info("failed to close file")
}
}()
scn := bufio.NewScanner(fi)
for scn.Scan() {
line := scn.Text()
fields := strings.SplitN(line, "=", 2)
if len(fields) != 2 {
continue
}
key := strings.TrimSpace(fields[0])
if len(key) == 0 {
continue
}
if len(os.Getenv(fields[0])) > 0 {
continue
}
val := strings.TrimSpace(fields[1])
if len(val) >= 2 {
if val[0] == '"' || val[0] == '\'' {
val = val[1 : len(val)-1]
}
}
if err = os.Setenv(key, val); err != nil {
return err
}
}
if err = scn.Err(); err != nil {
return err
}
envLoaded = true
return nil
} | [
"func",
"LoadEnvVars",
"(",
")",
"error",
"{",
"if",
"envLoaded",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"len",
"(",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
")",
"==",
"0",
"{",
"p",
":=",
"filepath",
".",
"Join",
"(",
"os",
".",
"Gete... | // LoadEnvVars from abot.env into memory | [
"LoadEnvVars",
"from",
"abot",
".",
"env",
"into",
"memory"
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/boot.go#L248-L311 |
4,939 | itsabot/itsabot | core/boot.go | LoadPluginsGo | func LoadPluginsGo() error {
p := filepath.Join("plugins.go")
okVal := fmt.Sprintf("open %s: no such file or directory", p)
contents, err := ioutil.ReadFile(p)
if err != nil && err.Error() != okVal {
return err
}
var val []byte
var foundStart bool
var nestLvl int
for _, b := range contents {
switch b {
case '{':
nestLvl++
if nestLvl == 1 {
foundStart = true
}
case '}':
nestLvl--
if nestLvl == 0 {
val = append(val, b)
val = append(val, []byte(",")...)
foundStart = false
}
}
if !foundStart {
continue
}
val = append(val, b)
}
if len(val) == 0 {
return nil
}
val = append([]byte("["), val...)
val = append(val[:len(val)-1], []byte("]")...)
return json.Unmarshal(val, &PluginsGo)
} | go | func LoadPluginsGo() error {
p := filepath.Join("plugins.go")
okVal := fmt.Sprintf("open %s: no such file or directory", p)
contents, err := ioutil.ReadFile(p)
if err != nil && err.Error() != okVal {
return err
}
var val []byte
var foundStart bool
var nestLvl int
for _, b := range contents {
switch b {
case '{':
nestLvl++
if nestLvl == 1 {
foundStart = true
}
case '}':
nestLvl--
if nestLvl == 0 {
val = append(val, b)
val = append(val, []byte(",")...)
foundStart = false
}
}
if !foundStart {
continue
}
val = append(val, b)
}
if len(val) == 0 {
return nil
}
val = append([]byte("["), val...)
val = append(val[:len(val)-1], []byte("]")...)
return json.Unmarshal(val, &PluginsGo)
} | [
"func",
"LoadPluginsGo",
"(",
")",
"error",
"{",
"p",
":=",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
")",
"\n",
"okVal",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
")",
"\n",
"contents",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
... | // LoadPluginsGo loads the plugins.go file into memory. | [
"LoadPluginsGo",
"loads",
"the",
"plugins",
".",
"go",
"file",
"into",
"memory",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/boot.go#L314-L350 |
4,940 | itsabot/itsabot | core/boot.go | trainClassifiers | func trainClassifiers() error {
for _, pconf := range PluginsGo {
ss, err := fetchTrainingSentences(pconf.ID, pconf.Name)
if err != nil {
return err
}
// Assemble list of Bayesian classes from all trained intents
// for this plugin. m is used to keep track of the classes
// already taught to each classifier.
m := map[string]struct{}{}
for _, s := range ss {
_, ok := m[s.Intent]
if ok {
continue
}
log.Debug("learning intent", s.Intent)
m[s.Intent] = struct{}{}
pluginIntents[s.PluginID] = append(pluginIntents[s.PluginID],
bayesian.Class(s.Intent))
}
// Build classifier from complete sets of intents
for _, s := range ss {
intents := pluginIntents[s.PluginID]
// Calling bayesian.NewClassifier() with 0 or 1
// classes causes a panic.
if len(intents) == 0 {
break
}
if len(intents) == 1 {
intents = append(intents, bayesian.Class("__no_intent"))
}
c := bayesian.NewClassifier(intents...)
bClassifiers[s.PluginID] = c
}
// With classifiers initialized, train each of them on a
// sentence's stems.
for _, s := range ss {
tokens := TokenizeSentence(s.Sentence)
stems := StemTokens(tokens)
c, exists := bClassifiers[s.PluginID]
if exists {
c.Learn(stems, bayesian.Class(s.Intent))
}
}
}
return nil
} | go | func trainClassifiers() error {
for _, pconf := range PluginsGo {
ss, err := fetchTrainingSentences(pconf.ID, pconf.Name)
if err != nil {
return err
}
// Assemble list of Bayesian classes from all trained intents
// for this plugin. m is used to keep track of the classes
// already taught to each classifier.
m := map[string]struct{}{}
for _, s := range ss {
_, ok := m[s.Intent]
if ok {
continue
}
log.Debug("learning intent", s.Intent)
m[s.Intent] = struct{}{}
pluginIntents[s.PluginID] = append(pluginIntents[s.PluginID],
bayesian.Class(s.Intent))
}
// Build classifier from complete sets of intents
for _, s := range ss {
intents := pluginIntents[s.PluginID]
// Calling bayesian.NewClassifier() with 0 or 1
// classes causes a panic.
if len(intents) == 0 {
break
}
if len(intents) == 1 {
intents = append(intents, bayesian.Class("__no_intent"))
}
c := bayesian.NewClassifier(intents...)
bClassifiers[s.PluginID] = c
}
// With classifiers initialized, train each of them on a
// sentence's stems.
for _, s := range ss {
tokens := TokenizeSentence(s.Sentence)
stems := StemTokens(tokens)
c, exists := bClassifiers[s.PluginID]
if exists {
c.Learn(stems, bayesian.Class(s.Intent))
}
}
}
return nil
} | [
"func",
"trainClassifiers",
"(",
")",
"error",
"{",
"for",
"_",
",",
"pconf",
":=",
"range",
"PluginsGo",
"{",
"ss",
",",
"err",
":=",
"fetchTrainingSentences",
"(",
"pconf",
".",
"ID",
",",
"pconf",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // trainClassifiers trains classifiers for each plugin. | [
"trainClassifiers",
"trains",
"classifiers",
"for",
"each",
"plugin",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/boot.go#L353-L402 |
4,941 | itsabot/itsabot | shared/datatypes/slice.go | Scan | func (u *Uint64Slice) Scan(src interface{}) error {
asBytes, ok := src.([]byte)
if !ok {
return errors.New("scan source was not []bytes")
}
str := string(asBytes)
str = str[1 : len(str)-1]
csvReader := csv.NewReader(strings.NewReader(str))
slice, err := csvReader.Read()
if err != nil && err.Error() != "EOF" {
return err
}
var s []uint64
for _, sl := range slice {
tmp, err := strconv.ParseUint(sl, 10, 64)
if err != nil {
return err
}
s = append(s, tmp)
}
*u = Uint64Slice(s)
return nil
} | go | func (u *Uint64Slice) Scan(src interface{}) error {
asBytes, ok := src.([]byte)
if !ok {
return errors.New("scan source was not []bytes")
}
str := string(asBytes)
str = str[1 : len(str)-1]
csvReader := csv.NewReader(strings.NewReader(str))
slice, err := csvReader.Read()
if err != nil && err.Error() != "EOF" {
return err
}
var s []uint64
for _, sl := range slice {
tmp, err := strconv.ParseUint(sl, 10, 64)
if err != nil {
return err
}
s = append(s, tmp)
}
*u = Uint64Slice(s)
return nil
} | [
"func",
"(",
"u",
"*",
"Uint64Slice",
")",
"Scan",
"(",
"src",
"interface",
"{",
"}",
")",
"error",
"{",
"asBytes",
",",
"ok",
":=",
"src",
".",
"(",
"[",
"]",
"byte",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
... | // Scan converts to a slice of uint64. | [
"Scan",
"converts",
"to",
"a",
"slice",
"of",
"uint64",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/slice.go#L16-L38 |
4,942 | itsabot/itsabot | shared/datatypes/slice.go | Value | func (u Uint64Slice) Value() (driver.Value, error) {
var ss []string
for i := 0; i < len(u); i++ {
tmp := strconv.FormatUint(u[i], 10)
ss = append(ss, tmp)
}
return "{" + strings.Join(ss, ",") + "}", nil
} | go | func (u Uint64Slice) Value() (driver.Value, error) {
var ss []string
for i := 0; i < len(u); i++ {
tmp := strconv.FormatUint(u[i], 10)
ss = append(ss, tmp)
}
return "{" + strings.Join(ss, ",") + "}", nil
} | [
"func",
"(",
"u",
"Uint64Slice",
")",
"Value",
"(",
")",
"(",
"driver",
".",
"Value",
",",
"error",
")",
"{",
"var",
"ss",
"[",
"]",
"string",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"u",
")",
";",
"i",
"++",
"{",
"tmp",
":=... | // Value converts to a slice of uint64. | [
"Value",
"converts",
"to",
"a",
"slice",
"of",
"uint64",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/slice.go#L41-L48 |
4,943 | itsabot/itsabot | shared/datatypes/slice.go | String | func (s StringSlice) String() string {
if len(s) == 0 {
return ""
}
var ss string
for _, w := range s {
ss += " " + w
}
return ss[1:]
} | go | func (s StringSlice) String() string {
if len(s) == 0 {
return ""
}
var ss string
for _, w := range s {
ss += " " + w
}
return ss[1:]
} | [
"func",
"(",
"s",
"StringSlice",
")",
"String",
"(",
")",
"string",
"{",
"if",
"len",
"(",
"s",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"var",
"ss",
"string",
"\n",
"for",
"_",
",",
"w",
":=",
"range",
"s",
"{",
"ss",
"+="... | // String converts a StringSlice into a string with each word separated by
// spaces. | [
"String",
"converts",
"a",
"StringSlice",
"into",
"a",
"string",
"with",
"each",
"word",
"separated",
"by",
"spaces",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/slice.go#L103-L112 |
4,944 | itsabot/itsabot | shared/datatypes/slice.go | Map | func (s StringSlice) Map() map[string]struct{} {
m := map[string]struct{}{}
for _, w := range s {
m[w] = struct{}{}
}
return m
} | go | func (s StringSlice) Map() map[string]struct{} {
m := map[string]struct{}{}
for _, w := range s {
m[w] = struct{}{}
}
return m
} | [
"func",
"(",
"s",
"StringSlice",
")",
"Map",
"(",
")",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
"{",
"}",
"\n",
"for",
"_",
",",
"w",
":=",
"range",
"s",
"{",
"m",
"[",
"w... | // Map converts a StringSlice into a map to check quickly if words exist within
// it. | [
"Map",
"converts",
"a",
"StringSlice",
"into",
"a",
"map",
"to",
"check",
"quickly",
"if",
"words",
"exist",
"within",
"it",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/slice.go#L128-L134 |
4,945 | itsabot/itsabot | core/template/forgot_password_email.go | ForgotPasswordEmail | func ForgotPasswordEmail(name, secret string) string {
h := `<html><body>`
h += fmt.Sprintf("<p>Hi %s:</p>", name)
h += "<p>Please click the following link to reset your password. This link will expire in 30 minutes.</p>"
h += fmt.Sprintf("<p>%s</p>", os.Getenv("ABOT_URL")+"/reset_password?s="+secret)
h += "<p>If you received this email in error, please ignore it.</p>"
h += "<p>Have a great day!</p>"
h += "<p>-Abot</p>"
h += "</body></html>"
return h
} | go | func ForgotPasswordEmail(name, secret string) string {
h := `<html><body>`
h += fmt.Sprintf("<p>Hi %s:</p>", name)
h += "<p>Please click the following link to reset your password. This link will expire in 30 minutes.</p>"
h += fmt.Sprintf("<p>%s</p>", os.Getenv("ABOT_URL")+"/reset_password?s="+secret)
h += "<p>If you received this email in error, please ignore it.</p>"
h += "<p>Have a great day!</p>"
h += "<p>-Abot</p>"
h += "</body></html>"
return h
} | [
"func",
"ForgotPasswordEmail",
"(",
"name",
",",
"secret",
"string",
")",
"string",
"{",
"h",
":=",
"`<html><body>`",
"\n",
"h",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"h",
"+=",
"\"",
"\"",
"\n",
"h",
"+=",
"fmt",
".... | // ForgotPasswordEmail takes a user's name and a secret token stored in the
// database and returns an HTML-format email. | [
"ForgotPasswordEmail",
"takes",
"a",
"user",
"s",
"name",
"and",
"a",
"secret",
"token",
"stored",
"in",
"the",
"database",
"and",
"returns",
"an",
"HTML",
"-",
"format",
"email",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/template/forgot_password_email.go#L13-L23 |
4,946 | itsabot/itsabot | core/websocket/websocket.go | NewAtomicWebSocketSet | func NewAtomicWebSocketSet() AtomicWebSocketSet {
return AtomicWebSocketSet{
sockets: map[uint64]*websocket.Conn{},
mutex: &sync.Mutex{},
}
} | go | func NewAtomicWebSocketSet() AtomicWebSocketSet {
return AtomicWebSocketSet{
sockets: map[uint64]*websocket.Conn{},
mutex: &sync.Mutex{},
}
} | [
"func",
"NewAtomicWebSocketSet",
"(",
")",
"AtomicWebSocketSet",
"{",
"return",
"AtomicWebSocketSet",
"{",
"sockets",
":",
"map",
"[",
"uint64",
"]",
"*",
"websocket",
".",
"Conn",
"{",
"}",
",",
"mutex",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"}... | // NewAtomicWebSocketSet returns an AtomicWebSocketSet to maintain open
// WebSocket connections on a per-user basis. | [
"NewAtomicWebSocketSet",
"returns",
"an",
"AtomicWebSocketSet",
"to",
"maintain",
"open",
"WebSocket",
"connections",
"on",
"a",
"per",
"-",
"user",
"basis",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/websocket/websocket.go#L24-L29 |
4,947 | itsabot/itsabot | core/websocket/websocket.go | Get | func (as AtomicWebSocketSet) Get(userID uint64) *websocket.Conn {
var conn *websocket.Conn
as.mutex.Lock()
conn = as.sockets[userID]
as.mutex.Unlock()
runtime.Gosched()
return conn
} | go | func (as AtomicWebSocketSet) Get(userID uint64) *websocket.Conn {
var conn *websocket.Conn
as.mutex.Lock()
conn = as.sockets[userID]
as.mutex.Unlock()
runtime.Gosched()
return conn
} | [
"func",
"(",
"as",
"AtomicWebSocketSet",
")",
"Get",
"(",
"userID",
"uint64",
")",
"*",
"websocket",
".",
"Conn",
"{",
"var",
"conn",
"*",
"websocket",
".",
"Conn",
"\n",
"as",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"conn",
"=",
"as",
".",
"soc... | // Get returns a WebSocket connection for a given userID in a thread-safe way. | [
"Get",
"returns",
"a",
"WebSocket",
"connection",
"for",
"a",
"given",
"userID",
"in",
"a",
"thread",
"-",
"safe",
"way",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/websocket/websocket.go#L32-L39 |
4,948 | itsabot/itsabot | core/websocket/websocket.go | NotifySockets | func (as AtomicWebSocketSet) NotifySockets(uid uint64, cmd, ret string) error {
s := as.Get(uid)
if s == nil {
// Trainer is not online.
return nil
}
t := time.Now()
data := []struct {
Sentence string
AvaSent bool
CreatedAt *time.Time
}{
{
Sentence: cmd,
AvaSent: false,
CreatedAt: &t,
},
}
if len(ret) > 0 {
data = append(data, struct {
Sentence string
AvaSent bool
CreatedAt *time.Time
}{
Sentence: ret,
AvaSent: true,
CreatedAt: &t,
})
}
return websocket.JSON.Send(s, &data)
} | go | func (as AtomicWebSocketSet) NotifySockets(uid uint64, cmd, ret string) error {
s := as.Get(uid)
if s == nil {
// Trainer is not online.
return nil
}
t := time.Now()
data := []struct {
Sentence string
AvaSent bool
CreatedAt *time.Time
}{
{
Sentence: cmd,
AvaSent: false,
CreatedAt: &t,
},
}
if len(ret) > 0 {
data = append(data, struct {
Sentence string
AvaSent bool
CreatedAt *time.Time
}{
Sentence: ret,
AvaSent: true,
CreatedAt: &t,
})
}
return websocket.JSON.Send(s, &data)
} | [
"func",
"(",
"as",
"AtomicWebSocketSet",
")",
"NotifySockets",
"(",
"uid",
"uint64",
",",
"cmd",
",",
"ret",
"string",
")",
"error",
"{",
"s",
":=",
"as",
".",
"Get",
"(",
"uid",
")",
"\n",
"if",
"s",
"==",
"nil",
"{",
"// Trainer is not online.",
"ret... | // NotifySockets sends listening clients new messages over WebSockets,
// eliminating the need for trainers to constantly reload the page. | [
"NotifySockets",
"sends",
"listening",
"clients",
"new",
"messages",
"over",
"WebSockets",
"eliminating",
"the",
"need",
"for",
"trainers",
"to",
"constantly",
"reload",
"the",
"page",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/websocket/websocket.go#L51-L81 |
4,949 | itsabot/itsabot | core/plugin.go | Get | func (pm PkgMap) Get(k string) *dt.Plugin {
var p *dt.Plugin
pm.mutex.Lock()
p = pm.plugins[k]
pm.mutex.Unlock()
runtime.Gosched()
return p
} | go | func (pm PkgMap) Get(k string) *dt.Plugin {
var p *dt.Plugin
pm.mutex.Lock()
p = pm.plugins[k]
pm.mutex.Unlock()
runtime.Gosched()
return p
} | [
"func",
"(",
"pm",
"PkgMap",
")",
"Get",
"(",
"k",
"string",
")",
"*",
"dt",
".",
"Plugin",
"{",
"var",
"p",
"*",
"dt",
".",
"Plugin",
"\n",
"pm",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"p",
"=",
"pm",
".",
"plugins",
"[",
"k",
"]",
"\n... | // Get is a thread-safe, locking way to access the values of a PkgMap. | [
"Get",
"is",
"a",
"thread",
"-",
"safe",
"locking",
"way",
"to",
"access",
"the",
"values",
"of",
"a",
"PkgMap",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/plugin.go#L43-L50 |
4,950 | itsabot/itsabot | core/plugin.go | Set | func (pm PkgMap) Set(k string, v *dt.Plugin) {
pm.mutex.Lock()
pm.plugins[k] = v
pm.mutex.Unlock()
runtime.Gosched()
} | go | func (pm PkgMap) Set(k string, v *dt.Plugin) {
pm.mutex.Lock()
pm.plugins[k] = v
pm.mutex.Unlock()
runtime.Gosched()
} | [
"func",
"(",
"pm",
"PkgMap",
")",
"Set",
"(",
"k",
"string",
",",
"v",
"*",
"dt",
".",
"Plugin",
")",
"{",
"pm",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"pm",
".",
"plugins",
"[",
"k",
"]",
"=",
"v",
"\n",
"pm",
".",
"mutex",
".",
"Unloc... | // Set is a thread-safe, locking way to set the values of a PkgMap. | [
"Set",
"is",
"a",
"thread",
"-",
"safe",
"locking",
"way",
"to",
"set",
"the",
"values",
"of",
"a",
"PkgMap",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/plugin.go#L53-L58 |
4,951 | itsabot/itsabot | core/plugin.go | GetPlugin | func GetPlugin(db *sqlx.DB, m *dt.Msg) (p *dt.Plugin, route string, directroute,
followup bool, err error) {
// Iterate through all intents to see if any plugin has been registered
// for the route
for _, i := range m.StructuredInput.Intents {
route = "I_" + strings.ToLower(i)
log.Debug("searching for route", route)
if p = RegPlugins.Get(route); p != nil {
// Found route. Return it
return p, route, true, false, nil
}
}
log.Debug("getting last plugin route")
prevPlugin, prevRoute, err := m.GetLastPlugin(db)
if err != nil && err != sql.ErrNoRows {
return nil, "", false, false, err
}
if len(prevPlugin) > 0 {
log.Debugf("found user's last plugin route: %s - %s\n",
prevPlugin, prevRoute)
}
// Iterate over all command/object pairs and see if any plugin has been
// registered for the resulting route
eng := porter2.Stemmer
for _, c := range m.StructuredInput.Commands {
c = strings.ToLower(eng.Stem(c))
for _, o := range m.StructuredInput.Objects {
o = strings.ToLower(eng.Stem(o))
route := "CO_" + c + "_" + o
log.Debug("searching for route", route)
if p = RegPlugins.Get(route); p != nil {
// Found route. Return it
followup := prevPlugin == p.Config.Name
return p, route, true, followup, nil
}
}
}
// The user input didn't match any plugins. Let's see if the previous
// route does
if prevRoute != "" {
if p = RegPlugins.Get(prevRoute); p != nil {
// Prev route matches a pkg! Return it
return p, prevRoute, false, true, nil
}
}
// Sadly, if we've reached this point, we are at a loss.
log.Debug("could not match user input to any plugin")
return nil, "", false, false, errMissingPlugin
} | go | func GetPlugin(db *sqlx.DB, m *dt.Msg) (p *dt.Plugin, route string, directroute,
followup bool, err error) {
// Iterate through all intents to see if any plugin has been registered
// for the route
for _, i := range m.StructuredInput.Intents {
route = "I_" + strings.ToLower(i)
log.Debug("searching for route", route)
if p = RegPlugins.Get(route); p != nil {
// Found route. Return it
return p, route, true, false, nil
}
}
log.Debug("getting last plugin route")
prevPlugin, prevRoute, err := m.GetLastPlugin(db)
if err != nil && err != sql.ErrNoRows {
return nil, "", false, false, err
}
if len(prevPlugin) > 0 {
log.Debugf("found user's last plugin route: %s - %s\n",
prevPlugin, prevRoute)
}
// Iterate over all command/object pairs and see if any plugin has been
// registered for the resulting route
eng := porter2.Stemmer
for _, c := range m.StructuredInput.Commands {
c = strings.ToLower(eng.Stem(c))
for _, o := range m.StructuredInput.Objects {
o = strings.ToLower(eng.Stem(o))
route := "CO_" + c + "_" + o
log.Debug("searching for route", route)
if p = RegPlugins.Get(route); p != nil {
// Found route. Return it
followup := prevPlugin == p.Config.Name
return p, route, true, followup, nil
}
}
}
// The user input didn't match any plugins. Let's see if the previous
// route does
if prevRoute != "" {
if p = RegPlugins.Get(prevRoute); p != nil {
// Prev route matches a pkg! Return it
return p, prevRoute, false, true, nil
}
}
// Sadly, if we've reached this point, we are at a loss.
log.Debug("could not match user input to any plugin")
return nil, "", false, false, errMissingPlugin
} | [
"func",
"GetPlugin",
"(",
"db",
"*",
"sqlx",
".",
"DB",
",",
"m",
"*",
"dt",
".",
"Msg",
")",
"(",
"p",
"*",
"dt",
".",
"Plugin",
",",
"route",
"string",
",",
"directroute",
",",
"followup",
"bool",
",",
"err",
"error",
")",
"{",
"// Iterate throug... | // GetPlugin attempts to find a plugin and route for the given msg input if none
// can be found, it checks the database for the last route used and gets the
// plugin for that. If there is no previously used plugin, we return
// errMissingPlugin. The bool value return indicates whether this plugin is
// different from the last plugin used by the user. | [
"GetPlugin",
"attempts",
"to",
"find",
"a",
"plugin",
"and",
"route",
"for",
"the",
"given",
"msg",
"input",
"if",
"none",
"can",
"be",
"found",
"it",
"checks",
"the",
"database",
"for",
"the",
"last",
"route",
"used",
"and",
"gets",
"the",
"plugin",
"fo... | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/plugin.go#L65-L118 |
4,952 | itsabot/itsabot | core/analytics.go | updateAnalytics | func updateAnalytics(interval time.Duration) {
t := time.NewTicker(time.Hour)
select {
case now := <-t.C:
updateAnalyticsTick(now)
updateAnalytics(interval)
}
} | go | func updateAnalytics(interval time.Duration) {
t := time.NewTicker(time.Hour)
select {
case now := <-t.C:
updateAnalyticsTick(now)
updateAnalytics(interval)
}
} | [
"func",
"updateAnalytics",
"(",
"interval",
"time",
".",
"Duration",
")",
"{",
"t",
":=",
"time",
".",
"NewTicker",
"(",
"time",
".",
"Hour",
")",
"\n",
"select",
"{",
"case",
"now",
":=",
"<-",
"t",
".",
"C",
":",
"updateAnalyticsTick",
"(",
"now",
... | // updateAnalytics recursively calls itself to continue running. | [
"updateAnalytics",
"recursively",
"calls",
"itself",
"to",
"continue",
"running",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/analytics.go#L21-L28 |
4,953 | itsabot/itsabot | shared/datatypes/plugin.go | DeleteMemory | func (p *Plugin) DeleteMemory(in *Msg, k string) {
var err error
if in.User.ID > 0 {
q := `DELETE FROM states
WHERE userid=$1 AND pluginname=$2 AND key=$3`
_, err = p.DB.Exec(q, in.User.ID, p.Config.Name, k)
} else {
q := `DELETE FROM states
WHERE flexid=$1 AND flexidtype=$2 AND pluginname=$3
AND key=$4`
_, err = p.DB.Exec(q, in.User.FlexID, in.User.FlexIDType,
p.Config.Name, k)
}
if err != nil {
p.Log.Infof("could not delete memory for key %s. %s", k,
err.Error())
}
} | go | func (p *Plugin) DeleteMemory(in *Msg, k string) {
var err error
if in.User.ID > 0 {
q := `DELETE FROM states
WHERE userid=$1 AND pluginname=$2 AND key=$3`
_, err = p.DB.Exec(q, in.User.ID, p.Config.Name, k)
} else {
q := `DELETE FROM states
WHERE flexid=$1 AND flexidtype=$2 AND pluginname=$3
AND key=$4`
_, err = p.DB.Exec(q, in.User.FlexID, in.User.FlexIDType,
p.Config.Name, k)
}
if err != nil {
p.Log.Infof("could not delete memory for key %s. %s", k,
err.Error())
}
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"DeleteMemory",
"(",
"in",
"*",
"Msg",
",",
"k",
"string",
")",
"{",
"var",
"err",
"error",
"\n",
"if",
"in",
".",
"User",
".",
"ID",
">",
"0",
"{",
"q",
":=",
"`DELETE FROM states\n\t\t WHERE userid=$1 AND plug... | // DeleteMemory deletes a memory for a given key. It is not an error to delete
// a key that does not exist. | [
"DeleteMemory",
"deletes",
"a",
"memory",
"for",
"a",
"given",
"key",
".",
"It",
"is",
"not",
"an",
"error",
"to",
"delete",
"a",
"key",
"that",
"does",
"not",
"exist",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/plugin.go#L220-L237 |
4,954 | itsabot/itsabot | shared/datatypes/plugin.go | GetSetting | func (p *Plugin) GetSetting(name string) string {
if p.Config.Settings[name] == nil {
pluginName := p.Config.Name
if len(pluginName) == 0 {
pluginName = "plugin"
}
m := fmt.Sprintf(
"missing setting %s. please declare it in the %s's plugin.json",
name, pluginName)
log.Fatal(m)
}
var val string
q := `SELECT value FROM settings WHERE name=$1 AND pluginname=$2`
err := p.DB.Get(&val, q, name, p.Config.Name)
if err == sql.ErrNoRows {
return p.Config.Settings[name].Default
}
if err != nil {
log.Info("failed to get plugin setting.", err)
return ""
}
return val
} | go | func (p *Plugin) GetSetting(name string) string {
if p.Config.Settings[name] == nil {
pluginName := p.Config.Name
if len(pluginName) == 0 {
pluginName = "plugin"
}
m := fmt.Sprintf(
"missing setting %s. please declare it in the %s's plugin.json",
name, pluginName)
log.Fatal(m)
}
var val string
q := `SELECT value FROM settings WHERE name=$1 AND pluginname=$2`
err := p.DB.Get(&val, q, name, p.Config.Name)
if err == sql.ErrNoRows {
return p.Config.Settings[name].Default
}
if err != nil {
log.Info("failed to get plugin setting.", err)
return ""
}
return val
} | [
"func",
"(",
"p",
"*",
"Plugin",
")",
"GetSetting",
"(",
"name",
"string",
")",
"string",
"{",
"if",
"p",
".",
"Config",
".",
"Settings",
"[",
"name",
"]",
"==",
"nil",
"{",
"pluginName",
":=",
"p",
".",
"Config",
".",
"Name",
"\n",
"if",
"len",
... | // GetSetting retrieves a specific setting's value. It throws a fatal error if
// the setting has not been declared in the plugin's plugin.json file. | [
"GetSetting",
"retrieves",
"a",
"specific",
"setting",
"s",
"value",
".",
"It",
"throws",
"a",
"fatal",
"error",
"if",
"the",
"setting",
"has",
"not",
"been",
"declared",
"in",
"the",
"plugin",
"s",
"plugin",
".",
"json",
"file",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/plugin.go#L241-L263 |
4,955 | itsabot/itsabot | shared/language/language.go | Greeting | func Greeting(r *rand.Rand, name string) string {
var n int
if len(name) == 0 {
n = r.Intn(3)
switch n {
case 0:
return fmt.Sprintf("Hi, %s.", name)
case 1:
return fmt.Sprintf("Hello, %s.", name)
case 2:
return fmt.Sprintf("Hi there, %s.", name)
}
} else {
n = r.Intn(3)
switch n {
case 0:
return "Hi. How can I help you?"
case 1:
return "Hello. What can I do for you?"
}
}
log.Debug("greeting failed to return a response")
return ""
} | go | func Greeting(r *rand.Rand, name string) string {
var n int
if len(name) == 0 {
n = r.Intn(3)
switch n {
case 0:
return fmt.Sprintf("Hi, %s.", name)
case 1:
return fmt.Sprintf("Hello, %s.", name)
case 2:
return fmt.Sprintf("Hi there, %s.", name)
}
} else {
n = r.Intn(3)
switch n {
case 0:
return "Hi. How can I help you?"
case 1:
return "Hello. What can I do for you?"
}
}
log.Debug("greeting failed to return a response")
return ""
} | [
"func",
"Greeting",
"(",
"r",
"*",
"rand",
".",
"Rand",
",",
"name",
"string",
")",
"string",
"{",
"var",
"n",
"int",
"\n",
"if",
"len",
"(",
"name",
")",
"==",
"0",
"{",
"n",
"=",
"r",
".",
"Intn",
"(",
"3",
")",
"\n",
"switch",
"n",
"{",
... | // Greeting returns a randomized greeting. | [
"Greeting",
"returns",
"a",
"randomized",
"greeting",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/language/language.go#L69-L92 |
4,956 | itsabot/itsabot | shared/language/language.go | SuggestedPlace | func SuggestedPlace(s string) string {
n := rand.Intn(4)
switch n {
case 0:
return "How does this place look? " + s
case 1:
return "How about " + s + "?"
case 2:
return "Have you been here before? " + s
case 3:
return "You could try this: " + s
}
log.Debug("suggestedPlace failed to return a response")
return ""
} | go | func SuggestedPlace(s string) string {
n := rand.Intn(4)
switch n {
case 0:
return "How does this place look? " + s
case 1:
return "How about " + s + "?"
case 2:
return "Have you been here before? " + s
case 3:
return "You could try this: " + s
}
log.Debug("suggestedPlace failed to return a response")
return ""
} | [
"func",
"SuggestedPlace",
"(",
"s",
"string",
")",
"string",
"{",
"n",
":=",
"rand",
".",
"Intn",
"(",
"4",
")",
"\n",
"switch",
"n",
"{",
"case",
"0",
":",
"return",
"\"",
"\"",
"+",
"s",
"\n",
"case",
"1",
":",
"return",
"\"",
"\"",
"+",
"s",... | // SuggestedPlace returns a randomized place suggestion useful for recommending
// restaurants, businesses, etc. | [
"SuggestedPlace",
"returns",
"a",
"randomized",
"place",
"suggestion",
"useful",
"for",
"recommending",
"restaurants",
"businesses",
"etc",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/language/language.go#L130-L144 |
4,957 | itsabot/itsabot | shared/language/language.go | SuggestedProduct | func SuggestedProduct(s string, num uint) string {
var n int
var val, flair string
if num > 0 {
n = rand.Intn(3)
switch n {
case 0, 1:
flair = ", then"
case 2: // do nothing
}
}
n = rand.Intn(6)
switch n {
case 0:
val = "I found just the thing"
case 1:
val = "This is the one for you"
case 2:
val = "You'll love this"
case 3:
val = "This is a real treat"
case 4:
val = "This will amaze you"
case 5:
val = "I found just the thing for you"
}
return val + flair + ". " + s
} | go | func SuggestedProduct(s string, num uint) string {
var n int
var val, flair string
if num > 0 {
n = rand.Intn(3)
switch n {
case 0, 1:
flair = ", then"
case 2: // do nothing
}
}
n = rand.Intn(6)
switch n {
case 0:
val = "I found just the thing"
case 1:
val = "This is the one for you"
case 2:
val = "You'll love this"
case 3:
val = "This is a real treat"
case 4:
val = "This will amaze you"
case 5:
val = "I found just the thing for you"
}
return val + flair + ". " + s
} | [
"func",
"SuggestedProduct",
"(",
"s",
"string",
",",
"num",
"uint",
")",
"string",
"{",
"var",
"n",
"int",
"\n",
"var",
"val",
",",
"flair",
"string",
"\n",
"if",
"num",
">",
"0",
"{",
"n",
"=",
"rand",
".",
"Intn",
"(",
"3",
")",
"\n",
"switch",... | // SuggestedProduct returns natural language, randomized text for a product
// suggestion. | [
"SuggestedProduct",
"returns",
"natural",
"language",
"randomized",
"text",
"for",
"a",
"product",
"suggestion",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/language/language.go#L148-L175 |
4,958 | itsabot/itsabot | shared/language/language.go | QuestionLocation | func QuestionLocation(loc string) string {
if len(loc) == 0 {
n := rand.Intn(10)
switch n {
case 0:
return "Where are you?"
case 1:
return "Where are you now?"
case 2:
return "Sure thing. Where are you?"
case 3:
return "Sure thing. Where are you now?"
case 4:
return "Happy to help. Where are you?"
case 5:
return "Happy to help. Where are you now?"
case 6:
return "I can help with that. Where are you?"
case 7:
return "I can help with that. Where are you now?"
case 8:
return "I can help solve this. Where are you?"
case 9:
return "I can help solve this. Where are you now?"
}
}
return fmt.Sprintf("Are you still near %s?", loc)
} | go | func QuestionLocation(loc string) string {
if len(loc) == 0 {
n := rand.Intn(10)
switch n {
case 0:
return "Where are you?"
case 1:
return "Where are you now?"
case 2:
return "Sure thing. Where are you?"
case 3:
return "Sure thing. Where are you now?"
case 4:
return "Happy to help. Where are you?"
case 5:
return "Happy to help. Where are you now?"
case 6:
return "I can help with that. Where are you?"
case 7:
return "I can help with that. Where are you now?"
case 8:
return "I can help solve this. Where are you?"
case 9:
return "I can help solve this. Where are you now?"
}
}
return fmt.Sprintf("Are you still near %s?", loc)
} | [
"func",
"QuestionLocation",
"(",
"loc",
"string",
")",
"string",
"{",
"if",
"len",
"(",
"loc",
")",
"==",
"0",
"{",
"n",
":=",
"rand",
".",
"Intn",
"(",
"10",
")",
"\n",
"switch",
"n",
"{",
"case",
"0",
":",
"return",
"\"",
"\"",
"\n",
"case",
... | // QuestionLocation returns a randomized question asking a user where they are. | [
"QuestionLocation",
"returns",
"a",
"randomized",
"question",
"asking",
"a",
"user",
"where",
"they",
"are",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/language/language.go#L415-L442 |
4,959 | itsabot/itsabot | shared/language/language.go | Yes | func Yes(s string) bool {
s = strings.ToLower(s)
_, ok := yes[s]
return ok
} | go | func Yes(s string) bool {
s = strings.ToLower(s)
_, ok := yes[s]
return ok
} | [
"func",
"Yes",
"(",
"s",
"string",
")",
"bool",
"{",
"s",
"=",
"strings",
".",
"ToLower",
"(",
"s",
")",
"\n",
"_",
",",
"ok",
":=",
"yes",
"[",
"s",
"]",
"\n",
"return",
"ok",
"\n",
"}"
] | // Yes determines if a specific word is a positive "Yes" response. For example,
// "yeah" returns true. | [
"Yes",
"determines",
"if",
"a",
"specific",
"word",
"is",
"a",
"positive",
"Yes",
"response",
".",
"For",
"example",
"yeah",
"returns",
"true",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/language/language.go#L446-L450 |
4,960 | itsabot/itsabot | shared/language/language.go | No | func No(s string) bool {
s = strings.ToLower(s)
_, ok := no[s]
return ok
} | go | func No(s string) bool {
s = strings.ToLower(s)
_, ok := no[s]
return ok
} | [
"func",
"No",
"(",
"s",
"string",
")",
"bool",
"{",
"s",
"=",
"strings",
".",
"ToLower",
"(",
"s",
")",
"\n",
"_",
",",
"ok",
":=",
"no",
"[",
"s",
"]",
"\n",
"return",
"ok",
"\n",
"}"
] | // No determines if a specific word is a "No" response. For example, "nah"
// returns true. | [
"No",
"determines",
"if",
"a",
"specific",
"word",
"is",
"a",
"No",
"response",
".",
"For",
"example",
"nah",
"returns",
"true",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/language/language.go#L454-L458 |
4,961 | itsabot/itsabot | shared/language/language.go | RemoveStopWords | func RemoveStopWords(ss []string) []string {
var removal []int
for i, s := range ss {
if Contains(StopWords, s) {
removal = append(removal, i)
}
}
for _, i := range removal {
ss = append(ss[:i], ss[i+1:]...)
}
return ss
} | go | func RemoveStopWords(ss []string) []string {
var removal []int
for i, s := range ss {
if Contains(StopWords, s) {
removal = append(removal, i)
}
}
for _, i := range removal {
ss = append(ss[:i], ss[i+1:]...)
}
return ss
} | [
"func",
"RemoveStopWords",
"(",
"ss",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"var",
"removal",
"[",
"]",
"int",
"\n",
"for",
"i",
",",
"s",
":=",
"range",
"ss",
"{",
"if",
"Contains",
"(",
"StopWords",
",",
"s",
")",
"{",
"removal",
"=... | // RemoveStopWords finds and removes stopwords from a slice of strings. | [
"RemoveStopWords",
"finds",
"and",
"removes",
"stopwords",
"from",
"a",
"slice",
"of",
"strings",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/language/language.go#L573-L584 |
4,962 | itsabot/itsabot | core/log/log.go | New | func New(pluginName string) *Logger {
lg := log.New(os.Stdout, "", log.Ldate|log.Ltime)
if len(pluginName) == 0 {
return &Logger{logger: lg}
}
return &Logger{
prefix: fmt.Sprintf("[%s] ", pluginName),
logger: lg,
}
} | go | func New(pluginName string) *Logger {
lg := log.New(os.Stdout, "", log.Ldate|log.Ltime)
if len(pluginName) == 0 {
return &Logger{logger: lg}
}
return &Logger{
prefix: fmt.Sprintf("[%s] ", pluginName),
logger: lg,
}
} | [
"func",
"New",
"(",
"pluginName",
"string",
")",
"*",
"Logger",
"{",
"lg",
":=",
"log",
".",
"New",
"(",
"os",
".",
"Stdout",
",",
"\"",
"\"",
",",
"log",
".",
"Ldate",
"|",
"log",
".",
"Ltime",
")",
"\n",
"if",
"len",
"(",
"pluginName",
")",
"... | // New returns a Logger which supports a custom prefix representing a plugin's
// name. | [
"New",
"returns",
"a",
"Logger",
"which",
"supports",
"a",
"custom",
"prefix",
"representing",
"a",
"plugin",
"s",
"name",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/log/log.go#L100-L109 |
4,963 | itsabot/itsabot | core/log/log.go | Fatal | func (l *Logger) Fatal(v ...interface{}) {
l.logger.Fatalf("%s", l.prefix+fmt.Sprintln(v...))
} | go | func (l *Logger) Fatal(v ...interface{}) {
l.logger.Fatalf("%s", l.prefix+fmt.Sprintln(v...))
} | [
"func",
"(",
"l",
"*",
"Logger",
")",
"Fatal",
"(",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"logger",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"l",
".",
"prefix",
"+",
"fmt",
".",
"Sprintln",
"(",
"v",
"...",
")",
")",
"\n",
"}"
] | // Fatal logs a statement and kills the running process. | [
"Fatal",
"logs",
"a",
"statement",
"and",
"kills",
"the",
"running",
"process",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/log/log.go#L142-L144 |
4,964 | itsabot/itsabot | shared/task/iterate.go | Iterate | func Iterate(p *dt.Plugin, label string, opts OptsIterate) []dt.State {
if len(label) == 0 {
label = "__iterableStart"
}
return []dt.State{
{
Label: label,
OnEntry: func(in *dt.Msg) string {
var ss []string
mem := p.GetMemory(in, opts.IterableMemKey)
if len(mem.Val) == 0 {
mem.Val = []byte(`[]`)
}
err := json.Unmarshal(mem.Val, &ss)
if err != nil {
p.Log.Info("failed to get iterable memory.", err)
return ""
}
if len(ss) == 0 {
return "I'm afraid I couldn't find any results like that."
}
var idx int64
if p.HasMemory(in, keySelection) {
idx = p.GetMemory(in, keySelection).Int64() + 1
}
if idx >= int64(len(ss)) {
return "I'm afraid that's all I have."
}
p.SetMemory(in, keySelection, idx)
return fmt.Sprintf("How about %s?", ss[idx])
},
OnInput: func(in *dt.Msg) {
yes, err := language.ExtractYesNo(in.Sentence)
if err != nil {
// Yes/No answer not found
return
}
if yes {
idx := p.GetMemory(in, keySelection).Int64()
p.SetMemory(in, opts.ResultMemKeyIdx, idx)
return
}
// TODO handle "next", "something else", etc.
},
Complete: func(in *dt.Msg) (bool, string) {
if p.HasMemory(in, opts.ResultMemKeyIdx) {
return true, ""
}
return false, p.SM.ReplayState(in)
},
},
}
} | go | func Iterate(p *dt.Plugin, label string, opts OptsIterate) []dt.State {
if len(label) == 0 {
label = "__iterableStart"
}
return []dt.State{
{
Label: label,
OnEntry: func(in *dt.Msg) string {
var ss []string
mem := p.GetMemory(in, opts.IterableMemKey)
if len(mem.Val) == 0 {
mem.Val = []byte(`[]`)
}
err := json.Unmarshal(mem.Val, &ss)
if err != nil {
p.Log.Info("failed to get iterable memory.", err)
return ""
}
if len(ss) == 0 {
return "I'm afraid I couldn't find any results like that."
}
var idx int64
if p.HasMemory(in, keySelection) {
idx = p.GetMemory(in, keySelection).Int64() + 1
}
if idx >= int64(len(ss)) {
return "I'm afraid that's all I have."
}
p.SetMemory(in, keySelection, idx)
return fmt.Sprintf("How about %s?", ss[idx])
},
OnInput: func(in *dt.Msg) {
yes, err := language.ExtractYesNo(in.Sentence)
if err != nil {
// Yes/No answer not found
return
}
if yes {
idx := p.GetMemory(in, keySelection).Int64()
p.SetMemory(in, opts.ResultMemKeyIdx, idx)
return
}
// TODO handle "next", "something else", etc.
},
Complete: func(in *dt.Msg) (bool, string) {
if p.HasMemory(in, opts.ResultMemKeyIdx) {
return true, ""
}
return false, p.SM.ReplayState(in)
},
},
}
} | [
"func",
"Iterate",
"(",
"p",
"*",
"dt",
".",
"Plugin",
",",
"label",
"string",
",",
"opts",
"OptsIterate",
")",
"[",
"]",
"dt",
".",
"State",
"{",
"if",
"len",
"(",
"label",
")",
"==",
"0",
"{",
"label",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"retur... | // Iterate through a set of options allowing the user to select one before
// continuing. | [
"Iterate",
"through",
"a",
"set",
"of",
"options",
"allowing",
"the",
"user",
"to",
"select",
"one",
"before",
"continuing",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/task/iterate.go#L27-L79 |
4,965 | itsabot/itsabot | shared/task/iterate.go | ResetIterate | func ResetIterate(p *dt.Plugin, in *dt.Msg) {
p.DeleteMemory(in, keySelection)
} | go | func ResetIterate(p *dt.Plugin, in *dt.Msg) {
p.DeleteMemory(in, keySelection)
} | [
"func",
"ResetIterate",
"(",
"p",
"*",
"dt",
".",
"Plugin",
",",
"in",
"*",
"dt",
".",
"Msg",
")",
"{",
"p",
".",
"DeleteMemory",
"(",
"in",
",",
"keySelection",
")",
"\n",
"}"
] | // ResetIterate should be called from within your plugin's SetOnReset function
// if you use the Iterable task. | [
"ResetIterate",
"should",
"be",
"called",
"from",
"within",
"your",
"plugin",
"s",
"SetOnReset",
"function",
"if",
"you",
"use",
"the",
"Iterable",
"task",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/task/iterate.go#L83-L85 |
4,966 | itsabot/itsabot | shared/datatypes/http_route.go | AddRoutes | func (hm HandlerMap) AddRoutes(prefix string, r *httprouter.Router) {
for httpRoute, h := range hm {
p := path.Join("/", prefix, httpRoute.Path)
r.HandlerFunc(httpRoute.Method, p, h)
}
} | go | func (hm HandlerMap) AddRoutes(prefix string, r *httprouter.Router) {
for httpRoute, h := range hm {
p := path.Join("/", prefix, httpRoute.Path)
r.HandlerFunc(httpRoute.Method, p, h)
}
} | [
"func",
"(",
"hm",
"HandlerMap",
")",
"AddRoutes",
"(",
"prefix",
"string",
",",
"r",
"*",
"httprouter",
".",
"Router",
")",
"{",
"for",
"httpRoute",
",",
"h",
":=",
"range",
"hm",
"{",
"p",
":=",
"path",
".",
"Join",
"(",
"\"",
"\"",
",",
"prefix"... | // AddRoutes to the router dynamically, enabling drivers to add routes to an
// application at runtime usually as part of their initialization. | [
"AddRoutes",
"to",
"the",
"router",
"dynamically",
"enabling",
"drivers",
"to",
"add",
"routes",
"to",
"an",
"application",
"at",
"runtime",
"usually",
"as",
"part",
"of",
"their",
"initialization",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/http_route.go#L29-L34 |
4,967 | itsabot/itsabot | shared/datatypes/http_route.go | NewHandlerMap | func NewHandlerMap(rhs []RouteHandler) HandlerMap {
hm := HandlerMap{}
for _, rh := range rhs {
route := HTTPRoute{
Path: rh.Path,
Method: rh.Method,
}
hm[route] = rh.Handler
}
return hm
} | go | func NewHandlerMap(rhs []RouteHandler) HandlerMap {
hm := HandlerMap{}
for _, rh := range rhs {
route := HTTPRoute{
Path: rh.Path,
Method: rh.Method,
}
hm[route] = rh.Handler
}
return hm
} | [
"func",
"NewHandlerMap",
"(",
"rhs",
"[",
"]",
"RouteHandler",
")",
"HandlerMap",
"{",
"hm",
":=",
"HandlerMap",
"{",
"}",
"\n",
"for",
"_",
",",
"rh",
":=",
"range",
"rhs",
"{",
"route",
":=",
"HTTPRoute",
"{",
"Path",
":",
"rh",
".",
"Path",
",",
... | // NewHandlerMap builds a HandlerMap from a slice of RouteHandlers. This is a
// convenience function, since using RouteHandlers directly is very verbose for
// plugins. | [
"NewHandlerMap",
"builds",
"a",
"HandlerMap",
"from",
"a",
"slice",
"of",
"RouteHandlers",
".",
"This",
"is",
"a",
"convenience",
"function",
"since",
"using",
"RouteHandlers",
"directly",
"is",
"very",
"verbose",
"for",
"plugins",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/http_route.go#L39-L49 |
4,968 | itsabot/itsabot | shared/interface/sms/sms.go | Send | func (c *Conn) Send(to, msg string) error {
return c.conn.Send(to, msg)
} | go | func (c *Conn) Send(to, msg string) error {
return c.conn.Send(to, msg)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"Send",
"(",
"to",
",",
"msg",
"string",
")",
"error",
"{",
"return",
"c",
".",
"conn",
".",
"Send",
"(",
"to",
",",
"msg",
")",
"\n",
"}"
] | // Send an SMS message through an opened driver connection. The from number is
// handled by the driver. | [
"Send",
"an",
"SMS",
"message",
"through",
"an",
"opened",
"driver",
"connection",
".",
"The",
"from",
"number",
"is",
"handled",
"by",
"the",
"driver",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/interface/sms/sms.go#L77-L79 |
4,969 | itsabot/itsabot | shared/language/summarize.go | Contains | func Contains(wordList []string, s string) bool {
s = strings.TrimRight(strings.ToLower(s), ".,;:!?'\"")
for _, word := range wordList {
if s == word {
return true
}
}
return false
} | go | func Contains(wordList []string, s string) bool {
s = strings.TrimRight(strings.ToLower(s), ".,;:!?'\"")
for _, word := range wordList {
if s == word {
return true
}
}
return false
} | [
"func",
"Contains",
"(",
"wordList",
"[",
"]",
"string",
",",
"s",
"string",
")",
"bool",
"{",
"s",
"=",
"strings",
".",
"TrimRight",
"(",
"strings",
".",
"ToLower",
"(",
"s",
")",
",",
"\"",
"\\\"",
"\"",
")",
"\n",
"for",
"_",
",",
"word",
":="... | // Contains determines whether a slice of strings contains a specific word. | [
"Contains",
"determines",
"whether",
"a",
"slice",
"of",
"strings",
"contains",
"a",
"specific",
"word",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/language/summarize.go#L6-L14 |
4,970 | itsabot/itsabot | core/handlers.go | newRouter | func newRouter() *httprouter.Router {
router := httprouter.New()
router.ServeFiles("/public/*filepath", http.Dir("public"))
if os.Getenv("ABOT_ENV") != "production" {
initCMDGroup(router)
}
// Web routes
router.HandlerFunc("GET", "/", hIndex)
router.HandlerFunc("POST", "/", hMain)
router.HandlerFunc("OPTIONS", "/", hOptions)
// Route any unknown request to our single page app front-end
router.NotFound = http.HandlerFunc(hIndex)
// API routes (no restrictions)
router.HandlerFunc("POST", "/api/login.json", hapiLoginSubmit)
router.HandlerFunc("POST", "/api/logout.json", hapiLogoutSubmit)
router.HandlerFunc("POST", "/api/signup.json", hapiSignupSubmit)
router.HandlerFunc("POST", "/api/forgot_password.json", hapiForgotPasswordSubmit)
router.HandlerFunc("POST", "/api/reset_password.json", hapiResetPasswordSubmit)
router.HandlerFunc("GET", "/api/admin_exists.json", hapiAdminExists)
// API routes (restricted by login)
router.HandlerFunc("GET", "/api/user/profile.json", hapiProfile)
router.HandlerFunc("PUT", "/api/user/profile.json", hapiProfileView)
// API routes (restricted to admins)
router.HandlerFunc("GET", "/api/admin/plugins.json", hapiPlugins)
router.HandlerFunc("GET", "/api/admin/conversations_need_training.json", hapiConversationsNeedTraining)
router.Handle("GET", "/api/admin/conversations/:uid/:fid/:fidt/:off", hapiConversation)
router.HandlerFunc("PATCH", "/api/admin/conversations.json", hapiConversationsUpdate)
router.HandlerFunc("POST", "/api/admins/send_message.json", hapiSendMessage)
router.HandlerFunc("GET", "/api/admins.json", hapiAdmins)
router.HandlerFunc("PUT", "/api/admins.json", hapiAdminsUpdate)
router.HandlerFunc("GET", "/api/admin/remote_tokens.json", hapiRemoteTokens)
router.HandlerFunc("POST", "/api/admin/remote_tokens.json", hapiRemoteTokensSubmit)
router.HandlerFunc("DELETE", "/api/admin/remote_tokens.json", hapiRemoteTokensDelete)
router.HandlerFunc("PUT", "/api/admin/settings.json", hapiSettingsUpdate)
router.HandlerFunc("GET", "/api/admin/dashboard.json", hapiDashboard)
return router
} | go | func newRouter() *httprouter.Router {
router := httprouter.New()
router.ServeFiles("/public/*filepath", http.Dir("public"))
if os.Getenv("ABOT_ENV") != "production" {
initCMDGroup(router)
}
// Web routes
router.HandlerFunc("GET", "/", hIndex)
router.HandlerFunc("POST", "/", hMain)
router.HandlerFunc("OPTIONS", "/", hOptions)
// Route any unknown request to our single page app front-end
router.NotFound = http.HandlerFunc(hIndex)
// API routes (no restrictions)
router.HandlerFunc("POST", "/api/login.json", hapiLoginSubmit)
router.HandlerFunc("POST", "/api/logout.json", hapiLogoutSubmit)
router.HandlerFunc("POST", "/api/signup.json", hapiSignupSubmit)
router.HandlerFunc("POST", "/api/forgot_password.json", hapiForgotPasswordSubmit)
router.HandlerFunc("POST", "/api/reset_password.json", hapiResetPasswordSubmit)
router.HandlerFunc("GET", "/api/admin_exists.json", hapiAdminExists)
// API routes (restricted by login)
router.HandlerFunc("GET", "/api/user/profile.json", hapiProfile)
router.HandlerFunc("PUT", "/api/user/profile.json", hapiProfileView)
// API routes (restricted to admins)
router.HandlerFunc("GET", "/api/admin/plugins.json", hapiPlugins)
router.HandlerFunc("GET", "/api/admin/conversations_need_training.json", hapiConversationsNeedTraining)
router.Handle("GET", "/api/admin/conversations/:uid/:fid/:fidt/:off", hapiConversation)
router.HandlerFunc("PATCH", "/api/admin/conversations.json", hapiConversationsUpdate)
router.HandlerFunc("POST", "/api/admins/send_message.json", hapiSendMessage)
router.HandlerFunc("GET", "/api/admins.json", hapiAdmins)
router.HandlerFunc("PUT", "/api/admins.json", hapiAdminsUpdate)
router.HandlerFunc("GET", "/api/admin/remote_tokens.json", hapiRemoteTokens)
router.HandlerFunc("POST", "/api/admin/remote_tokens.json", hapiRemoteTokensSubmit)
router.HandlerFunc("DELETE", "/api/admin/remote_tokens.json", hapiRemoteTokensDelete)
router.HandlerFunc("PUT", "/api/admin/settings.json", hapiSettingsUpdate)
router.HandlerFunc("GET", "/api/admin/dashboard.json", hapiDashboard)
return router
} | [
"func",
"newRouter",
"(",
")",
"*",
"httprouter",
".",
"Router",
"{",
"router",
":=",
"httprouter",
".",
"New",
"(",
")",
"\n",
"router",
".",
"ServeFiles",
"(",
"\"",
"\"",
",",
"http",
".",
"Dir",
"(",
"\"",
"\"",
")",
")",
"\n\n",
"if",
"os",
... | // newRouter initializes and returns a router. | [
"newRouter",
"initializes",
"and",
"returns",
"a",
"router",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L42-L84 |
4,971 | itsabot/itsabot | core/handlers.go | hIndex | func hIndex(w http.ResponseWriter, r *http.Request) {
var err error
env := os.Getenv("ABOT_ENV")
if env != "production" && env != "test" {
p := filepath.Join("assets", "html", "layout.html")
tmplLayout, err = template.ParseFiles(p)
if err != nil {
writeErrorInternal(w, err)
return
}
if err = compileAssets(); err != nil {
writeErrorInternal(w, err)
return
}
}
data := struct {
IsProd bool
ItsAbotURL string
}{
IsProd: os.Getenv("ABOT_ENV") == "production",
ItsAbotURL: os.Getenv("ITSABOT_URL"),
}
if err = tmplLayout.Execute(w, data); err != nil {
writeErrorInternal(w, err)
}
} | go | func hIndex(w http.ResponseWriter, r *http.Request) {
var err error
env := os.Getenv("ABOT_ENV")
if env != "production" && env != "test" {
p := filepath.Join("assets", "html", "layout.html")
tmplLayout, err = template.ParseFiles(p)
if err != nil {
writeErrorInternal(w, err)
return
}
if err = compileAssets(); err != nil {
writeErrorInternal(w, err)
return
}
}
data := struct {
IsProd bool
ItsAbotURL string
}{
IsProd: os.Getenv("ABOT_ENV") == "production",
ItsAbotURL: os.Getenv("ITSABOT_URL"),
}
if err = tmplLayout.Execute(w, data); err != nil {
writeErrorInternal(w, err)
}
} | [
"func",
"hIndex",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"var",
"err",
"error",
"\n",
"env",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"env",
"!=",
"\"",
"\"",
"&&",
"env",
"... | // hIndex presents the homepage to the user and populates the HTML with
// server-side variables. | [
"hIndex",
"presents",
"the",
"homepage",
"to",
"the",
"user",
"and",
"populates",
"the",
"HTML",
"with",
"server",
"-",
"side",
"variables",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L88-L113 |
4,972 | itsabot/itsabot | core/handlers.go | hMain | func hMain(w http.ResponseWriter, r *http.Request) {
errMsg := "Something went wrong with my wiring... I'll get that fixed up soon."
ret, err := ProcessText(r)
if err != nil {
if len(ret) > 0 {
ret = errMsg
}
log.Info("failed to process text.", err)
// TODO notify plugins listening for errors
}
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type,Access-Control-Allow-Origin")
_, err = fmt.Fprint(w, ret)
if err != nil {
writeErrorInternal(w, err)
}
} | go | func hMain(w http.ResponseWriter, r *http.Request) {
errMsg := "Something went wrong with my wiring... I'll get that fixed up soon."
ret, err := ProcessText(r)
if err != nil {
if len(ret) > 0 {
ret = errMsg
}
log.Info("failed to process text.", err)
// TODO notify plugins listening for errors
}
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type,Access-Control-Allow-Origin")
_, err = fmt.Fprint(w, ret)
if err != nil {
writeErrorInternal(w, err)
}
} | [
"func",
"hMain",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"errMsg",
":=",
"\"",
"\"",
"\n",
"ret",
",",
"err",
":=",
"ProcessText",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"len",
... | // hMain is the endpoint to hit when you want a direct response via JSON.
// The Abot console uses this endpoint. | [
"hMain",
"is",
"the",
"endpoint",
"to",
"hit",
"when",
"you",
"want",
"a",
"direct",
"response",
"via",
"JSON",
".",
"The",
"Abot",
"console",
"uses",
"this",
"endpoint",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L117-L133 |
4,973 | itsabot/itsabot | core/handlers.go | hOptions | func hOptions(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type,Access-Control-Allow-Origin")
w.WriteHeader(http.StatusOK)
} | go | func hOptions(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type,Access-Control-Allow-Origin")
w.WriteHeader(http.StatusOK)
} | [
"func",
"hOptions",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"("... | // hOptions sets appropriate response headers in cases like browser-based
// communication with Abot. | [
"hOptions",
"sets",
"appropriate",
"response",
"headers",
"in",
"cases",
"like",
"browser",
"-",
"based",
"communication",
"with",
"Abot",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L137-L141 |
4,974 | itsabot/itsabot | core/handlers.go | hapiLogoutSubmit | func hapiLogoutSubmit(w http.ResponseWriter, r *http.Request) {
cookie, err := r.Cookie("id")
if err != nil {
writeError(w, err)
return
}
uid := cookie.Value
if uid == "null" {
http.Error(w, "id was null", http.StatusBadRequest)
return
}
q := `DELETE FROM sessions WHERE userid=$1`
if _, err = db.Exec(q, uid); err != nil {
writeError(w, err)
return
}
w.WriteHeader(http.StatusOK)
} | go | func hapiLogoutSubmit(w http.ResponseWriter, r *http.Request) {
cookie, err := r.Cookie("id")
if err != nil {
writeError(w, err)
return
}
uid := cookie.Value
if uid == "null" {
http.Error(w, "id was null", http.StatusBadRequest)
return
}
q := `DELETE FROM sessions WHERE userid=$1`
if _, err = db.Exec(q, uid); err != nil {
writeError(w, err)
return
}
w.WriteHeader(http.StatusOK)
} | [
"func",
"hapiLogoutSubmit",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"cookie",
",",
"err",
":=",
"r",
".",
"Cookie",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"writeError",
"(",
"w",... | // hapiLogoutSubmit processes a logout request deleting the session from
// the server. | [
"hapiLogoutSubmit",
"processes",
"a",
"logout",
"request",
"deleting",
"the",
"session",
"from",
"the",
"server",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L145-L162 |
4,975 | itsabot/itsabot | core/handlers.go | hapiLoginSubmit | func hapiLoginSubmit(w http.ResponseWriter, r *http.Request) {
var req struct {
Email string
Password string
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorInternal(w, err)
return
}
var u struct {
ID uint64
Password []byte
Admin bool
}
q := `SELECT id, password, admin FROM users WHERE email=$1`
err := db.Get(&u, q, req.Email)
if err == sql.ErrNoRows {
writeErrorAuth(w, ErrInvalidUserPass)
return
} else if err != nil {
writeErrorInternal(w, err)
return
}
if u.ID == 0 {
writeErrorAuth(w, ErrInvalidUserPass)
return
}
err = bcrypt.CompareHashAndPassword(u.Password, []byte(req.Password))
if err == bcrypt.ErrMismatchedHashAndPassword || err == bcrypt.ErrHashTooShort {
writeErrorAuth(w, ErrInvalidUserPass)
return
} else if err != nil {
writeErrorInternal(w, err)
return
}
user := &dt.User{
ID: u.ID,
Email: req.Email,
Admin: u.Admin,
}
csrfToken, err := createCSRFToken(user)
if err != nil {
writeErrorInternal(w, err)
return
}
header, token, err := getAuthToken(user)
if err != nil {
writeErrorInternal(w, err)
return
}
resp := struct {
ID uint64
Email string
Scopes []string
AuthToken string
IssuedAt int64
CSRFToken string
}{
ID: user.ID,
Email: user.Email,
Scopes: header.Scopes,
AuthToken: token,
IssuedAt: header.IssuedAt,
CSRFToken: csrfToken,
}
writeBytes(w, resp)
} | go | func hapiLoginSubmit(w http.ResponseWriter, r *http.Request) {
var req struct {
Email string
Password string
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorInternal(w, err)
return
}
var u struct {
ID uint64
Password []byte
Admin bool
}
q := `SELECT id, password, admin FROM users WHERE email=$1`
err := db.Get(&u, q, req.Email)
if err == sql.ErrNoRows {
writeErrorAuth(w, ErrInvalidUserPass)
return
} else if err != nil {
writeErrorInternal(w, err)
return
}
if u.ID == 0 {
writeErrorAuth(w, ErrInvalidUserPass)
return
}
err = bcrypt.CompareHashAndPassword(u.Password, []byte(req.Password))
if err == bcrypt.ErrMismatchedHashAndPassword || err == bcrypt.ErrHashTooShort {
writeErrorAuth(w, ErrInvalidUserPass)
return
} else if err != nil {
writeErrorInternal(w, err)
return
}
user := &dt.User{
ID: u.ID,
Email: req.Email,
Admin: u.Admin,
}
csrfToken, err := createCSRFToken(user)
if err != nil {
writeErrorInternal(w, err)
return
}
header, token, err := getAuthToken(user)
if err != nil {
writeErrorInternal(w, err)
return
}
resp := struct {
ID uint64
Email string
Scopes []string
AuthToken string
IssuedAt int64
CSRFToken string
}{
ID: user.ID,
Email: user.Email,
Scopes: header.Scopes,
AuthToken: token,
IssuedAt: header.IssuedAt,
CSRFToken: csrfToken,
}
writeBytes(w, resp)
} | [
"func",
"hapiLoginSubmit",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"var",
"req",
"struct",
"{",
"Email",
"string",
"\n",
"Password",
"string",
"\n",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"NewDecode... | // hapiLoginSubmit processes a logout request deleting the session from
// the server. | [
"hapiLoginSubmit",
"processes",
"a",
"logout",
"request",
"deleting",
"the",
"session",
"from",
"the",
"server",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L166-L232 |
4,976 | itsabot/itsabot | core/handlers.go | hapiProfile | func hapiProfile(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isLoggedIn(w, r) {
return
}
}
cookie, err := r.Cookie("id")
if err != nil {
writeErrorInternal(w, err)
return
}
uid := cookie.Value
var user struct {
Name string
Email string
Phones []dt.Phone
}
q := `SELECT name, email FROM users WHERE id=$1`
err = db.Get(&user, q, uid)
if err != nil {
writeErrorInternal(w, err)
return
}
q = `SELECT flexid FROM userflexids
WHERE flexidtype=2 AND userid=$1
LIMIT 10`
err = db.Select(&user.Phones, q, uid)
if err != nil && err != sql.ErrNoRows {
writeErrorInternal(w, err)
return
}
writeBytes(w, user)
} | go | func hapiProfile(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isLoggedIn(w, r) {
return
}
}
cookie, err := r.Cookie("id")
if err != nil {
writeErrorInternal(w, err)
return
}
uid := cookie.Value
var user struct {
Name string
Email string
Phones []dt.Phone
}
q := `SELECT name, email FROM users WHERE id=$1`
err = db.Get(&user, q, uid)
if err != nil {
writeErrorInternal(w, err)
return
}
q = `SELECT flexid FROM userflexids
WHERE flexidtype=2 AND userid=$1
LIMIT 10`
err = db.Select(&user.Phones, q, uid)
if err != nil && err != sql.ErrNoRows {
writeErrorInternal(w, err)
return
}
writeBytes(w, user)
} | [
"func",
"hapiProfile",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"isLoggedIn",
"(",
"w",
",",
"r",
")",
"{",
"ret... | // hapiProfile shows a user profile with the user's current addresses, credit
// cards, and contact information. | [
"hapiProfile",
"shows",
"a",
"user",
"profile",
"with",
"the",
"user",
"s",
"current",
"addresses",
"credit",
"cards",
"and",
"contact",
"information",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L346-L378 |
4,977 | itsabot/itsabot | core/handlers.go | hapiForgotPasswordSubmit | func hapiForgotPasswordSubmit(w http.ResponseWriter, r *http.Request) {
var req struct{ Email string }
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorInternal(w, err)
return
}
var user dt.User
q := `SELECT id, name, email FROM users WHERE email=$1`
err := db.Get(&user, q, req.Email)
if err == sql.ErrNoRows {
writeError(w, errors.New("Sorry, there's no record of that email. Are you sure that's the email you used to sign up with and that you typed it correctly?"))
return
}
if err != nil {
writeError(w, err)
return
}
secret := RandSeq(40)
q = `INSERT INTO passwordresets (userid, secret) VALUES ($1, $2)`
if _, err = db.Exec(q, user.ID, secret); err != nil {
writeError(w, err)
return
}
if len(emailsender.Drivers()) == 0 {
writeError(w, errors.New("Sorry, this feature is not enabled. To be enabled, an email driver must be imported."))
return
}
w.WriteHeader(http.StatusOK)
} | go | func hapiForgotPasswordSubmit(w http.ResponseWriter, r *http.Request) {
var req struct{ Email string }
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorInternal(w, err)
return
}
var user dt.User
q := `SELECT id, name, email FROM users WHERE email=$1`
err := db.Get(&user, q, req.Email)
if err == sql.ErrNoRows {
writeError(w, errors.New("Sorry, there's no record of that email. Are you sure that's the email you used to sign up with and that you typed it correctly?"))
return
}
if err != nil {
writeError(w, err)
return
}
secret := RandSeq(40)
q = `INSERT INTO passwordresets (userid, secret) VALUES ($1, $2)`
if _, err = db.Exec(q, user.ID, secret); err != nil {
writeError(w, err)
return
}
if len(emailsender.Drivers()) == 0 {
writeError(w, errors.New("Sorry, this feature is not enabled. To be enabled, an email driver must be imported."))
return
}
w.WriteHeader(http.StatusOK)
} | [
"func",
"hapiForgotPasswordSubmit",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"var",
"req",
"struct",
"{",
"Email",
"string",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"r",
".",
"Body"... | // hapiForgotPasswordSubmit asks the server to send the user a "Forgot
// Password" email with instructions for resetting their password. | [
"hapiForgotPasswordSubmit",
"asks",
"the",
"server",
"to",
"send",
"the",
"user",
"a",
"Forgot",
"Password",
"email",
"with",
"instructions",
"for",
"resetting",
"their",
"password",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L429-L457 |
4,978 | itsabot/itsabot | core/handlers.go | hapiResetPasswordSubmit | func hapiResetPasswordSubmit(w http.ResponseWriter, r *http.Request) {
var req struct {
Password string
Secret string
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorInternal(w, err)
return
}
if len(req.Password) < 8 {
writeError(w, errors.New("Your password must be at least 8 characters"))
return
}
var uid uint64
q := `SELECT userid FROM passwordresets
WHERE secret=$1 AND
createdat >= CURRENT_TIMESTAMP - interval '30 minutes'`
err := db.Get(&uid, q, req.Secret)
if err == sql.ErrNoRows {
writeError(w, errors.New("Sorry, that information doesn't match our records."))
return
}
if err != nil {
writeError(w, err)
return
}
hpw, err := bcrypt.GenerateFromPassword([]byte(req.Password), 10)
if err != nil {
writeError(w, err)
return
}
tx, err := db.Begin()
if err != nil {
writeError(w, err)
return
}
q = `UPDATE users SET password=$1 WHERE id=$2`
if _, err = tx.Exec(q, hpw, uid); err != nil {
writeError(w, err)
return
}
q = `DELETE FROM passwordresets WHERE secret=$1`
if _, err = tx.Exec(q, req.Secret); err != nil {
writeError(w, err)
return
}
if err = tx.Commit(); err != nil {
writeError(w, err)
return
}
w.WriteHeader(http.StatusOK)
} | go | func hapiResetPasswordSubmit(w http.ResponseWriter, r *http.Request) {
var req struct {
Password string
Secret string
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorInternal(w, err)
return
}
if len(req.Password) < 8 {
writeError(w, errors.New("Your password must be at least 8 characters"))
return
}
var uid uint64
q := `SELECT userid FROM passwordresets
WHERE secret=$1 AND
createdat >= CURRENT_TIMESTAMP - interval '30 minutes'`
err := db.Get(&uid, q, req.Secret)
if err == sql.ErrNoRows {
writeError(w, errors.New("Sorry, that information doesn't match our records."))
return
}
if err != nil {
writeError(w, err)
return
}
hpw, err := bcrypt.GenerateFromPassword([]byte(req.Password), 10)
if err != nil {
writeError(w, err)
return
}
tx, err := db.Begin()
if err != nil {
writeError(w, err)
return
}
q = `UPDATE users SET password=$1 WHERE id=$2`
if _, err = tx.Exec(q, hpw, uid); err != nil {
writeError(w, err)
return
}
q = `DELETE FROM passwordresets WHERE secret=$1`
if _, err = tx.Exec(q, req.Secret); err != nil {
writeError(w, err)
return
}
if err = tx.Commit(); err != nil {
writeError(w, err)
return
}
w.WriteHeader(http.StatusOK)
} | [
"func",
"hapiResetPasswordSubmit",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"var",
"req",
"struct",
"{",
"Password",
"string",
"\n",
"Secret",
"string",
"\n",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"... | // hapiResetPasswordSubmit is arrived at through the email generated by
// hapiForgotPasswordSubmit. This endpoint resets the user password with
// another bcrypt hash after validating on the server that their new password is
// sufficient. | [
"hapiResetPasswordSubmit",
"is",
"arrived",
"at",
"through",
"the",
"email",
"generated",
"by",
"hapiForgotPasswordSubmit",
".",
"This",
"endpoint",
"resets",
"the",
"user",
"password",
"with",
"another",
"bcrypt",
"hash",
"after",
"validating",
"on",
"the",
"server... | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L463-L517 |
4,979 | itsabot/itsabot | core/handlers.go | hapiAdminExists | func hapiAdminExists(w http.ResponseWriter, r *http.Request) {
var count int
q := `SELECT COUNT(*) FROM users WHERE admin=TRUE LIMIT 1`
if err := db.Get(&count, q); err != nil {
writeErrorInternal(w, err)
return
}
byt, err := json.Marshal(count > 0)
if err != nil {
writeErrorInternal(w, err)
return
}
_, err = w.Write(byt)
if err != nil {
log.Info("failed writing response header.", err)
}
} | go | func hapiAdminExists(w http.ResponseWriter, r *http.Request) {
var count int
q := `SELECT COUNT(*) FROM users WHERE admin=TRUE LIMIT 1`
if err := db.Get(&count, q); err != nil {
writeErrorInternal(w, err)
return
}
byt, err := json.Marshal(count > 0)
if err != nil {
writeErrorInternal(w, err)
return
}
_, err = w.Write(byt)
if err != nil {
log.Info("failed writing response header.", err)
}
} | [
"func",
"hapiAdminExists",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"var",
"count",
"int",
"\n",
"q",
":=",
"`SELECT COUNT(*) FROM users WHERE admin=TRUE LIMIT 1`",
"\n",
"if",
"err",
":=",
"db",
".",
"Get",
"... | // hapiAdminExists checks if an admin exists in the database. | [
"hapiAdminExists",
"checks",
"if",
"an",
"admin",
"exists",
"in",
"the",
"database",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L520-L536 |
4,980 | itsabot/itsabot | core/handlers.go | hapiPlugins | func hapiPlugins(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
}
var settings []struct {
Name string
Value string
PluginName string
}
q := `SELECT name, value, pluginname FROM settings`
if err := db.Select(&settings, q); err != nil {
writeErrorInternal(w, err)
return
}
type respT struct {
ID uint64
Name string
Icon string
Maintainer string
Settings map[string]string
}
var resp []respT
for _, plugin := range PluginsGo {
data := respT{
ID: plugin.ID,
Name: plugin.Name,
Icon: plugin.Icon,
Maintainer: plugin.Maintainer,
Settings: map[string]string{},
}
for k, v := range plugin.Settings {
data.Settings[k] = v.Default
}
for _, setting := range settings {
if setting.PluginName != plugin.Name {
continue
}
data.Settings[setting.Name] = setting.Value
}
resp = append(resp, data)
}
writeBytes(w, resp)
} | go | func hapiPlugins(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
}
var settings []struct {
Name string
Value string
PluginName string
}
q := `SELECT name, value, pluginname FROM settings`
if err := db.Select(&settings, q); err != nil {
writeErrorInternal(w, err)
return
}
type respT struct {
ID uint64
Name string
Icon string
Maintainer string
Settings map[string]string
}
var resp []respT
for _, plugin := range PluginsGo {
data := respT{
ID: plugin.ID,
Name: plugin.Name,
Icon: plugin.Icon,
Maintainer: plugin.Maintainer,
Settings: map[string]string{},
}
for k, v := range plugin.Settings {
data.Settings[k] = v.Default
}
for _, setting := range settings {
if setting.PluginName != plugin.Name {
continue
}
data.Settings[setting.Name] = setting.Value
}
resp = append(resp, data)
}
writeBytes(w, resp)
} | [
"func",
"hapiPlugins",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"isAdmin",
"(",
"w",
",",
"r",
")",
"{",
"return... | // hapiPlugins responds with all of the server's installed plugin
// configurations from each their respective plugin.json files and
// database-stored configuration. | [
"hapiPlugins",
"responds",
"with",
"all",
"of",
"the",
"server",
"s",
"installed",
"plugin",
"configurations",
"from",
"each",
"their",
"respective",
"plugin",
".",
"json",
"files",
"and",
"database",
"-",
"stored",
"configuration",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L541-L588 |
4,981 | itsabot/itsabot | core/handlers.go | hapiConversationsNeedTraining | func hapiConversationsNeedTraining(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
}
msgs := []struct {
Sentence string
FlexID *string
CreatedAt time.Time
UserID uint64
FlexIDType *int
}{}
q := `SELECT * FROM (
SELECT DISTINCT ON (flexid)
userid, flexid, flexidtype, sentence, createdat
FROM messages
WHERE needstraining=TRUE AND trained=FALSE AND abotsent=FALSE AND sentence<>''
) t ORDER BY createdat DESC`
err := db.Select(&msgs, q)
if err == sql.ErrNoRows {
w.WriteHeader(http.StatusOK)
}
if err != nil {
writeErrorInternal(w, err)
return
}
byt, err := json.Marshal(msgs)
if err != nil {
writeErrorInternal(w, err)
return
}
_, err = w.Write(byt)
if err != nil {
log.Info("failed to write response.", err)
}
} | go | func hapiConversationsNeedTraining(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
}
msgs := []struct {
Sentence string
FlexID *string
CreatedAt time.Time
UserID uint64
FlexIDType *int
}{}
q := `SELECT * FROM (
SELECT DISTINCT ON (flexid)
userid, flexid, flexidtype, sentence, createdat
FROM messages
WHERE needstraining=TRUE AND trained=FALSE AND abotsent=FALSE AND sentence<>''
) t ORDER BY createdat DESC`
err := db.Select(&msgs, q)
if err == sql.ErrNoRows {
w.WriteHeader(http.StatusOK)
}
if err != nil {
writeErrorInternal(w, err)
return
}
byt, err := json.Marshal(msgs)
if err != nil {
writeErrorInternal(w, err)
return
}
_, err = w.Write(byt)
if err != nil {
log.Info("failed to write response.", err)
}
} | [
"func",
"hapiConversationsNeedTraining",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"isAdmin",
"(",
"w",
",",
"r",
")"... | // hapiConversationsNeedTraining returns a list of all sentences that require a
// human response. | [
"hapiConversationsNeedTraining",
"returns",
"a",
"list",
"of",
"all",
"sentences",
"that",
"require",
"a",
"human",
"response",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L592-L631 |
4,982 | itsabot/itsabot | core/handlers.go | hapiSendMessage | func hapiSendMessage(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
if !isValidCSRF(w, r) {
return
}
}
var req struct {
UserID uint64
FlexID string
FlexIDType dt.FlexIDType
Name string
Sentence string
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorBadRequest(w, err)
return
}
msg := &dt.Msg{
User: &dt.User{ID: req.UserID},
FlexID: req.FlexID,
FlexIDType: req.FlexIDType,
Sentence: req.Sentence,
AbotSent: true,
}
switch req.FlexIDType {
case dt.FIDTPhone:
if smsConn == nil {
writeErrorInternal(w, errors.New("No SMS driver installed."))
return
}
if err := smsConn.Send(msg.FlexID, msg.Sentence); err != nil {
writeErrorInternal(w, err)
return
}
case dt.FIDTEmail:
/*
// TODO
if emailConn == nil {
writeErrorInternal(w, errors.New("No email driver installed."))
return
}
adminEmail := os.Getenv("ABOT_EMAIL")
email := template.GenericEmail(req.Name)
err := emailConn.SendHTML(msg.FlexID, adminEmail, "SUBJ", email)
if err != nil {
writeErrorInternal(w, err)
return
}
*/
case dt.FIDTSession:
/*
// TODO
if err := ws.NotifySocketSession(); err != nil {
}
*/
default:
writeErrorInternal(w, errors.New("invalid flexidtype"))
return
}
if err := msg.Save(db); err != nil {
writeErrorInternal(w, err)
return
}
w.WriteHeader(http.StatusOK)
} | go | func hapiSendMessage(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
if !isValidCSRF(w, r) {
return
}
}
var req struct {
UserID uint64
FlexID string
FlexIDType dt.FlexIDType
Name string
Sentence string
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorBadRequest(w, err)
return
}
msg := &dt.Msg{
User: &dt.User{ID: req.UserID},
FlexID: req.FlexID,
FlexIDType: req.FlexIDType,
Sentence: req.Sentence,
AbotSent: true,
}
switch req.FlexIDType {
case dt.FIDTPhone:
if smsConn == nil {
writeErrorInternal(w, errors.New("No SMS driver installed."))
return
}
if err := smsConn.Send(msg.FlexID, msg.Sentence); err != nil {
writeErrorInternal(w, err)
return
}
case dt.FIDTEmail:
/*
// TODO
if emailConn == nil {
writeErrorInternal(w, errors.New("No email driver installed."))
return
}
adminEmail := os.Getenv("ABOT_EMAIL")
email := template.GenericEmail(req.Name)
err := emailConn.SendHTML(msg.FlexID, adminEmail, "SUBJ", email)
if err != nil {
writeErrorInternal(w, err)
return
}
*/
case dt.FIDTSession:
/*
// TODO
if err := ws.NotifySocketSession(); err != nil {
}
*/
default:
writeErrorInternal(w, errors.New("invalid flexidtype"))
return
}
if err := msg.Save(db); err != nil {
writeErrorInternal(w, err)
return
}
w.WriteHeader(http.StatusOK)
} | [
"func",
"hapiSendMessage",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"isAdmin",
"(",
"w",
",",
"r",
")",
"{",
"re... | // hapiSendMessage enables an admin to send a message to a user on behalf of
// Abot from the Response Panel. | [
"hapiSendMessage",
"enables",
"an",
"admin",
"to",
"send",
"a",
"message",
"to",
"a",
"user",
"on",
"behalf",
"of",
"Abot",
"from",
"the",
"Response",
"Panel",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L780-L850 |
4,983 | itsabot/itsabot | core/handlers.go | hapiAdmins | func hapiAdmins(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
}
var admins []struct {
ID uint64
Name string
Email string
}
q := `SELECT id, name, email FROM users WHERE admin=TRUE`
err := db.Select(&admins, q)
if err != nil && err != sql.ErrNoRows {
writeErrorInternal(w, err)
return
}
b, err := json.Marshal(admins)
if err != nil {
writeErrorInternal(w, err)
return
}
_, err = w.Write(b)
if err != nil {
log.Info("failed to write response.", err)
}
} | go | func hapiAdmins(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
}
var admins []struct {
ID uint64
Name string
Email string
}
q := `SELECT id, name, email FROM users WHERE admin=TRUE`
err := db.Select(&admins, q)
if err != nil && err != sql.ErrNoRows {
writeErrorInternal(w, err)
return
}
b, err := json.Marshal(admins)
if err != nil {
writeErrorInternal(w, err)
return
}
_, err = w.Write(b)
if err != nil {
log.Info("failed to write response.", err)
}
} | [
"func",
"hapiAdmins",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"isAdmin",
"(",
"w",
",",
"r",
")",
"{",
"return"... | // hapiAdmins returns a list of all admins with the training and manage team
// permissions. | [
"hapiAdmins",
"returns",
"a",
"list",
"of",
"all",
"admins",
"with",
"the",
"training",
"and",
"manage",
"team",
"permissions",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L854-L883 |
4,984 | itsabot/itsabot | core/handlers.go | hapiAdminsUpdate | func hapiAdminsUpdate(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
if !isValidCSRF(w, r) {
return
}
}
var req struct {
ID uint64
Email string
Admin bool
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorBadRequest(w, err)
return
}
// This is a clever way to update the user using EITHER email or ID
// (whatever the client had available). Then we return the ID of the
// updated entry to send back to the client for faster future requests.
if req.ID > 0 && len(req.Email) > 0 {
writeErrorBadRequest(w, errors.New("only one value allowed: ID or Email"))
return
}
q := `UPDATE users SET admin=$1 WHERE id=$2 OR email=$3 RETURNING id`
err := db.QueryRow(q, req.Admin, req.ID, req.Email).Scan(&req.ID)
if err == sql.ErrNoRows {
// This error is frequently user-facing.
writeErrorBadRequest(w, errors.New("User not found."))
return
}
if err != nil {
writeErrorInternal(w, err)
return
}
var user struct {
ID uint64
Email string
Name string
}
q = `SELECT id, email, name FROM users WHERE id=$1`
if err = db.Get(&user, q, req.ID); err != nil {
writeErrorInternal(w, err)
return
}
byt, err := json.Marshal(user)
if err != nil {
writeErrorInternal(w, err)
return
}
_, err = w.Write(byt)
if err != nil {
log.Info("failed to write response.", err)
}
} | go | func hapiAdminsUpdate(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
if !isValidCSRF(w, r) {
return
}
}
var req struct {
ID uint64
Email string
Admin bool
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorBadRequest(w, err)
return
}
// This is a clever way to update the user using EITHER email or ID
// (whatever the client had available). Then we return the ID of the
// updated entry to send back to the client for faster future requests.
if req.ID > 0 && len(req.Email) > 0 {
writeErrorBadRequest(w, errors.New("only one value allowed: ID or Email"))
return
}
q := `UPDATE users SET admin=$1 WHERE id=$2 OR email=$3 RETURNING id`
err := db.QueryRow(q, req.Admin, req.ID, req.Email).Scan(&req.ID)
if err == sql.ErrNoRows {
// This error is frequently user-facing.
writeErrorBadRequest(w, errors.New("User not found."))
return
}
if err != nil {
writeErrorInternal(w, err)
return
}
var user struct {
ID uint64
Email string
Name string
}
q = `SELECT id, email, name FROM users WHERE id=$1`
if err = db.Get(&user, q, req.ID); err != nil {
writeErrorInternal(w, err)
return
}
byt, err := json.Marshal(user)
if err != nil {
writeErrorInternal(w, err)
return
}
_, err = w.Write(byt)
if err != nil {
log.Info("failed to write response.", err)
}
} | [
"func",
"hapiAdminsUpdate",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"isAdmin",
"(",
"w",
",",
"r",
")",
"{",
"r... | // hapiAdminsUpdate adds or removes admin permission from a given user. | [
"hapiAdminsUpdate",
"adds",
"or",
"removes",
"admin",
"permission",
"from",
"a",
"given",
"user",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L886-L944 |
4,985 | itsabot/itsabot | core/handlers.go | hapiRemoteTokens | func hapiRemoteTokens(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
}
// We initialize the variable here because we want empty slices to
// marshal to [], not null
auths := []struct {
Token string
Email string
CreatedAt time.Time
PluginIDs dt.Uint64Slice
}{}
q := `SELECT token, email, pluginids, createdat FROM remotetokens`
err := db.Select(&auths, q)
if err != nil && err != sql.ErrNoRows {
writeErrorInternal(w, err)
return
}
byt, err := json.Marshal(auths)
if err != nil {
writeErrorInternal(w, err)
return
}
_, err = w.Write(byt)
if err != nil {
log.Info("failed to write response.", err)
}
} | go | func hapiRemoteTokens(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
}
// We initialize the variable here because we want empty slices to
// marshal to [], not null
auths := []struct {
Token string
Email string
CreatedAt time.Time
PluginIDs dt.Uint64Slice
}{}
q := `SELECT token, email, pluginids, createdat FROM remotetokens`
err := db.Select(&auths, q)
if err != nil && err != sql.ErrNoRows {
writeErrorInternal(w, err)
return
}
byt, err := json.Marshal(auths)
if err != nil {
writeErrorInternal(w, err)
return
}
_, err = w.Write(byt)
if err != nil {
log.Info("failed to write response.", err)
}
} | [
"func",
"hapiRemoteTokens",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"isAdmin",
"(",
"w",
",",
"r",
")",
"{",
"r... | // hapiRemoteTokens returns the final six bytes of each auth token used to
// authenticate to the remote service and when. | [
"hapiRemoteTokens",
"returns",
"the",
"final",
"six",
"bytes",
"of",
"each",
"auth",
"token",
"used",
"to",
"authenticate",
"to",
"the",
"remote",
"service",
"and",
"when",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L948-L981 |
4,986 | itsabot/itsabot | core/handlers.go | hapiRemoteTokensSubmit | func hapiRemoteTokensSubmit(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
if !isValidCSRF(w, r) {
return
}
}
var req struct {
Token string
PluginIDs dt.Uint64Slice
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorBadRequest(w, err)
return
}
cookie, err := r.Cookie("email")
if err != nil {
writeErrorBadRequest(w, err)
return
}
q := `INSERT INTO remotetokens (token, email, pluginids)
VALUES ($1, $2, $3)`
_, err = db.Exec(q, req.Token, cookie.Value, req.PluginIDs)
if err != nil {
if err.Error() == `pq: duplicate key value violates unique constraint "remotetokens_token_key"` {
writeErrorBadRequest(w, errors.New("Token has already been added."))
return
}
writeErrorInternal(w, err)
return
}
w.WriteHeader(http.StatusOK)
} | go | func hapiRemoteTokensSubmit(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
if !isValidCSRF(w, r) {
return
}
}
var req struct {
Token string
PluginIDs dt.Uint64Slice
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorBadRequest(w, err)
return
}
cookie, err := r.Cookie("email")
if err != nil {
writeErrorBadRequest(w, err)
return
}
q := `INSERT INTO remotetokens (token, email, pluginids)
VALUES ($1, $2, $3)`
_, err = db.Exec(q, req.Token, cookie.Value, req.PluginIDs)
if err != nil {
if err.Error() == `pq: duplicate key value violates unique constraint "remotetokens_token_key"` {
writeErrorBadRequest(w, errors.New("Token has already been added."))
return
}
writeErrorInternal(w, err)
return
}
w.WriteHeader(http.StatusOK)
} | [
"func",
"hapiRemoteTokensSubmit",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"isAdmin",
"(",
"w",
",",
"r",
")",
"{"... | // hapiRemoteTokensSubmit adds a remote token for modifying ITSABOT_URL's
// plugin training data. | [
"hapiRemoteTokensSubmit",
"adds",
"a",
"remote",
"token",
"for",
"modifying",
"ITSABOT_URL",
"s",
"plugin",
"training",
"data",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L985-L1022 |
4,987 | itsabot/itsabot | core/handlers.go | hapiRemoteTokensDelete | func hapiRemoteTokensDelete(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
if !isValidCSRF(w, r) {
return
}
}
var req struct {
Token string
Email string
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorBadRequest(w, err)
return
}
q := `DELETE FROM remotetokens WHERE token=$1`
res, err := db.Exec(q, req.Token)
if err != nil {
writeErrorInternal(w, err)
return
}
rows, err := res.RowsAffected()
if err != nil {
writeErrorInternal(w, err)
return
}
if rows == 0 {
writeErrorBadRequest(w, errors.New("invalid token or email"))
return
}
w.WriteHeader(http.StatusOK)
} | go | func hapiRemoteTokensDelete(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
if !isValidCSRF(w, r) {
return
}
}
var req struct {
Token string
Email string
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorBadRequest(w, err)
return
}
q := `DELETE FROM remotetokens WHERE token=$1`
res, err := db.Exec(q, req.Token)
if err != nil {
writeErrorInternal(w, err)
return
}
rows, err := res.RowsAffected()
if err != nil {
writeErrorInternal(w, err)
return
}
if rows == 0 {
writeErrorBadRequest(w, errors.New("invalid token or email"))
return
}
w.WriteHeader(http.StatusOK)
} | [
"func",
"hapiRemoteTokensDelete",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"isAdmin",
"(",
"w",
",",
"r",
")",
"{"... | // hapiRemoteTokensDelete removes a remote token from the DB and responds with
// 200 OK. | [
"hapiRemoteTokensDelete",
"removes",
"a",
"remote",
"token",
"from",
"the",
"DB",
"and",
"responds",
"with",
"200",
"OK",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L1026-L1062 |
4,988 | itsabot/itsabot | core/handlers.go | hapiSettingsUpdate | func hapiSettingsUpdate(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
}
var req map[string]map[string]string
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorBadRequest(w, err)
return
}
tx, err := db.Begin()
if err != nil {
writeErrorInternal(w, err)
return
}
for plugin, data := range req {
for k, v := range data {
q := `INSERT INTO settings (name, value, pluginname)
VALUES ($1, $2, $3)
ON CONFLICT (name, pluginname) DO
UPDATE SET value=$2`
_, err = tx.Exec(q, k, v, plugin)
if err != nil {
writeErrorInternal(w, err)
return
}
}
}
if err = tx.Commit(); err != nil {
writeErrorInternal(w, err)
return
}
w.WriteHeader(http.StatusOK)
} | go | func hapiSettingsUpdate(w http.ResponseWriter, r *http.Request) {
if os.Getenv("ABOT_ENV") != "test" {
if !isAdmin(w, r) {
return
}
if !isLoggedIn(w, r) {
return
}
}
var req map[string]map[string]string
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErrorBadRequest(w, err)
return
}
tx, err := db.Begin()
if err != nil {
writeErrorInternal(w, err)
return
}
for plugin, data := range req {
for k, v := range data {
q := `INSERT INTO settings (name, value, pluginname)
VALUES ($1, $2, $3)
ON CONFLICT (name, pluginname) DO
UPDATE SET value=$2`
_, err = tx.Exec(q, k, v, plugin)
if err != nil {
writeErrorInternal(w, err)
return
}
}
}
if err = tx.Commit(); err != nil {
writeErrorInternal(w, err)
return
}
w.WriteHeader(http.StatusOK)
} | [
"func",
"hapiSettingsUpdate",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"isAdmin",
"(",
"w",
",",
"r",
")",
"{",
... | // hapiSettingsUpdate updates settings in the database for plugins. | [
"hapiSettingsUpdate",
"updates",
"settings",
"in",
"the",
"database",
"for",
"plugins",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L1065-L1102 |
4,989 | itsabot/itsabot | core/handlers.go | createCSRFToken | func createCSRFToken(u *dt.User) (token string, err error) {
q := `INSERT INTO sessions (token, userid, label)
VALUES ($1, $2, 'csrfToken')
ON CONFLICT (userid, label) DO UPDATE SET token=$1`
token = RandSeq(32)
if _, err := db.Exec(q, token, u.ID); err != nil {
return "", err
}
return token, nil
} | go | func createCSRFToken(u *dt.User) (token string, err error) {
q := `INSERT INTO sessions (token, userid, label)
VALUES ($1, $2, 'csrfToken')
ON CONFLICT (userid, label) DO UPDATE SET token=$1`
token = RandSeq(32)
if _, err := db.Exec(q, token, u.ID); err != nil {
return "", err
}
return token, nil
} | [
"func",
"createCSRFToken",
"(",
"u",
"*",
"dt",
".",
"User",
")",
"(",
"token",
"string",
",",
"err",
"error",
")",
"{",
"q",
":=",
"`INSERT INTO sessions (token, userid, label)\n\t VALUES ($1, $2, 'csrfToken')\n\t ON CONFLICT (userid, label) DO UPDATE SET token=$1`",... | // createCSRFToken creates a new token, invalidating any existing token. | [
"createCSRFToken",
"creates",
"a",
"new",
"token",
"invalidating",
"any",
"existing",
"token",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L1196-L1205 |
4,990 | itsabot/itsabot | core/handlers.go | getAuthToken | func getAuthToken(u *dt.User) (header *Header, authToken string, err error) {
scopes := []string{}
if u.Admin {
scopes = append(scopes, "admin")
}
header = &Header{
ID: u.ID,
Email: u.Email,
Scopes: scopes,
IssuedAt: time.Now().Unix(),
}
byt, err := json.Marshal(header)
if err != nil {
return nil, "", err
}
hash := hmac.New(sha512.New, []byte(os.Getenv("ABOT_SECRET")))
_, err = hash.Write(byt)
if err != nil {
return nil, "", err
}
authToken = base64.StdEncoding.EncodeToString(hash.Sum(nil))
return header, authToken, nil
} | go | func getAuthToken(u *dt.User) (header *Header, authToken string, err error) {
scopes := []string{}
if u.Admin {
scopes = append(scopes, "admin")
}
header = &Header{
ID: u.ID,
Email: u.Email,
Scopes: scopes,
IssuedAt: time.Now().Unix(),
}
byt, err := json.Marshal(header)
if err != nil {
return nil, "", err
}
hash := hmac.New(sha512.New, []byte(os.Getenv("ABOT_SECRET")))
_, err = hash.Write(byt)
if err != nil {
return nil, "", err
}
authToken = base64.StdEncoding.EncodeToString(hash.Sum(nil))
return header, authToken, nil
} | [
"func",
"getAuthToken",
"(",
"u",
"*",
"dt",
".",
"User",
")",
"(",
"header",
"*",
"Header",
",",
"authToken",
"string",
",",
"err",
"error",
")",
"{",
"scopes",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"if",
"u",
".",
"Admin",
"{",
"scopes",
"=... | // getAuthToken returns a token used for future client authorization with a CSRF
// token. | [
"getAuthToken",
"returns",
"a",
"token",
"used",
"for",
"future",
"client",
"authorization",
"with",
"a",
"CSRF",
"token",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L1209-L1231 |
4,991 | itsabot/itsabot | core/handlers.go | isValidCSRF | func isValidCSRF(w http.ResponseWriter, r *http.Request) bool {
// TODO look into other session-based temporary storage systems for
// these csrf tokens to prevent hitting the database. Whatever is
// selected must *not* introduce an external (system) dependency like
// memcached/Redis. Bolt might be an option.
log.Debug("validating csrf")
var label string
q := `SELECT label FROM sessions
WHERE userid=$1 AND label='csrfToken' AND token=$2`
cookie, err := r.Cookie("id")
if err == http.ErrNoCookie {
writeErrorAuth(w, err)
return false
}
if err != nil {
writeErrorInternal(w, err)
return false
}
uid := cookie.Value
cookie, err = r.Cookie("csrfToken")
if err == http.ErrNoCookie {
writeErrorAuth(w, err)
return false
}
if err != nil {
writeErrorInternal(w, err)
return false
}
err = db.Get(&label, q, uid, cookie.Value)
if err == sql.ErrNoRows {
writeErrorAuth(w, errors.New("invalid CSRF token"))
return false
}
if err != nil {
writeErrorInternal(w, err)
return false
}
log.Debug("validated csrf")
return true
} | go | func isValidCSRF(w http.ResponseWriter, r *http.Request) bool {
// TODO look into other session-based temporary storage systems for
// these csrf tokens to prevent hitting the database. Whatever is
// selected must *not* introduce an external (system) dependency like
// memcached/Redis. Bolt might be an option.
log.Debug("validating csrf")
var label string
q := `SELECT label FROM sessions
WHERE userid=$1 AND label='csrfToken' AND token=$2`
cookie, err := r.Cookie("id")
if err == http.ErrNoCookie {
writeErrorAuth(w, err)
return false
}
if err != nil {
writeErrorInternal(w, err)
return false
}
uid := cookie.Value
cookie, err = r.Cookie("csrfToken")
if err == http.ErrNoCookie {
writeErrorAuth(w, err)
return false
}
if err != nil {
writeErrorInternal(w, err)
return false
}
err = db.Get(&label, q, uid, cookie.Value)
if err == sql.ErrNoRows {
writeErrorAuth(w, errors.New("invalid CSRF token"))
return false
}
if err != nil {
writeErrorInternal(w, err)
return false
}
log.Debug("validated csrf")
return true
} | [
"func",
"isValidCSRF",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"// TODO look into other session-based temporary storage systems for",
"// these csrf tokens to prevent hitting the database. Whatever is",
"// selected must ... | // isValidCSRF ensures that any forms posted to Abot are protected against
// Cross-Site Request Forgery. Without this function, Abot would be vulnerable
// to the attack because tokens are stored client-side in cookies. | [
"isValidCSRF",
"ensures",
"that",
"any",
"forms",
"posted",
"to",
"Abot",
"are",
"protected",
"against",
"Cross",
"-",
"Site",
"Request",
"Forgery",
".",
"Without",
"this",
"function",
"Abot",
"would",
"be",
"vulnerable",
"to",
"the",
"attack",
"because",
"tok... | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/handlers.go#L1414-L1453 |
4,992 | itsabot/itsabot | shared/language/extract.go | ExtractCurrency | func ExtractCurrency(s string) (int64, error) {
s = regexCurrency.FindString(s)
if len(s) == 0 {
return 0, ErrNotFound
}
val, err := strconv.ParseFloat(s, 64)
if err != nil {
return 0, err
}
log.Debug("found value", val)
// Convert parsed float into an int64 with precision of 2 decimal places
return int64(val * 100), nil
} | go | func ExtractCurrency(s string) (int64, error) {
s = regexCurrency.FindString(s)
if len(s) == 0 {
return 0, ErrNotFound
}
val, err := strconv.ParseFloat(s, 64)
if err != nil {
return 0, err
}
log.Debug("found value", val)
// Convert parsed float into an int64 with precision of 2 decimal places
return int64(val * 100), nil
} | [
"func",
"ExtractCurrency",
"(",
"s",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"s",
"=",
"regexCurrency",
".",
"FindString",
"(",
"s",
")",
"\n",
"if",
"len",
"(",
"s",
")",
"==",
"0",
"{",
"return",
"0",
",",
"ErrNotFound",
"\n",
"}",
... | // ExtractCurrency returns an int64 if a currency is found, and throws an
// error if one isn't. | [
"ExtractCurrency",
"returns",
"an",
"int64",
"if",
"a",
"currency",
"is",
"found",
"and",
"throws",
"an",
"error",
"if",
"one",
"isn",
"t",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/language/extract.go#L30-L42 |
4,993 | itsabot/itsabot | shared/language/extract.go | ExtractCities | func ExtractCities(db *sqlx.DB, in *dt.Msg) ([]dt.City, error) {
// Interface type is used to expand the args in db.Select below.
// Although we're only storing strings, []string{} doesn't work.
var args []interface{}
// Look for "at", "in", "on" prepositions to signal that locations
// follow, skipping everything before
var start int
for i := range in.Stems {
switch in.Stems[i] {
case "at", "in", "on":
start = i
break
}
}
// Prepare sentence for iteration
tmp := regexNonWords.ReplaceAllString(in.Sentence, "")
words := strings.Fields(strings.Title(tmp))
// Iterate through words and bigrams to assemble a DB query
for i := start; i < len(words); i++ {
args = append(args, words[i])
}
bgs := bigrams(words, start)
for i := 0; i < len(bgs); i++ {
args = append(args, bgs[i])
}
cities := []dt.City{}
q := `SELECT name, countrycode FROM cities
WHERE countrycode='US' AND name IN (?)
ORDER BY LENGTH(name) DESC`
query, arguments, err := sqlx.In(q, args)
query = db.Rebind(query)
rows, err := db.Query(query, arguments...)
if err != nil {
return nil, err
}
defer func() {
if err = rows.Close(); err != nil {
log.Info("failed to close db rows.", err)
}
}()
for rows.Next() {
city := dt.City{}
if err = rows.Scan(&city.Name, &city.CountryCode); err != nil {
return nil, err
}
cities = append(cities, city)
}
if err = rows.Err(); err != nil {
return nil, err
}
if len(cities) == 0 {
return nil, ErrNotFound
}
return cities, nil
} | go | func ExtractCities(db *sqlx.DB, in *dt.Msg) ([]dt.City, error) {
// Interface type is used to expand the args in db.Select below.
// Although we're only storing strings, []string{} doesn't work.
var args []interface{}
// Look for "at", "in", "on" prepositions to signal that locations
// follow, skipping everything before
var start int
for i := range in.Stems {
switch in.Stems[i] {
case "at", "in", "on":
start = i
break
}
}
// Prepare sentence for iteration
tmp := regexNonWords.ReplaceAllString(in.Sentence, "")
words := strings.Fields(strings.Title(tmp))
// Iterate through words and bigrams to assemble a DB query
for i := start; i < len(words); i++ {
args = append(args, words[i])
}
bgs := bigrams(words, start)
for i := 0; i < len(bgs); i++ {
args = append(args, bgs[i])
}
cities := []dt.City{}
q := `SELECT name, countrycode FROM cities
WHERE countrycode='US' AND name IN (?)
ORDER BY LENGTH(name) DESC`
query, arguments, err := sqlx.In(q, args)
query = db.Rebind(query)
rows, err := db.Query(query, arguments...)
if err != nil {
return nil, err
}
defer func() {
if err = rows.Close(); err != nil {
log.Info("failed to close db rows.", err)
}
}()
for rows.Next() {
city := dt.City{}
if err = rows.Scan(&city.Name, &city.CountryCode); err != nil {
return nil, err
}
cities = append(cities, city)
}
if err = rows.Err(); err != nil {
return nil, err
}
if len(cities) == 0 {
return nil, ErrNotFound
}
return cities, nil
} | [
"func",
"ExtractCities",
"(",
"db",
"*",
"sqlx",
".",
"DB",
",",
"in",
"*",
"dt",
".",
"Msg",
")",
"(",
"[",
"]",
"dt",
".",
"City",
",",
"error",
")",
"{",
"// Interface type is used to expand the args in db.Select below.",
"// Although we're only storing strings... | // ExtractCities efficiently from a user's message. | [
"ExtractCities",
"efficiently",
"from",
"a",
"user",
"s",
"message",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/language/extract.go#L168-L226 |
4,994 | itsabot/itsabot | shared/language/extract.go | ExtractEmails | func ExtractEmails(s string) ([]string, error) {
emails := regexEmail.FindAllString(s, -1)
if emails == nil {
return []string{}, ErrNotFound
}
return emails, nil
} | go | func ExtractEmails(s string) ([]string, error) {
emails := regexEmail.FindAllString(s, -1)
if emails == nil {
return []string{}, ErrNotFound
}
return emails, nil
} | [
"func",
"ExtractEmails",
"(",
"s",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"emails",
":=",
"regexEmail",
".",
"FindAllString",
"(",
"s",
",",
"-",
"1",
")",
"\n",
"if",
"emails",
"==",
"nil",
"{",
"return",
"[",
"]",
"string... | // ExtractEmails from a user's message. | [
"ExtractEmails",
"from",
"a",
"user",
"s",
"message",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/language/extract.go#L229-L235 |
4,995 | itsabot/itsabot | core/scheduled_event.go | sendEvents | func sendEvents(evtChan chan *dt.ScheduledEvent, interval time.Duration) {
t := time.NewTicker(time.Minute)
select {
case now := <-t.C:
sendEventsTick(evtChan, now)
sendEvents(evtChan, interval)
}
} | go | func sendEvents(evtChan chan *dt.ScheduledEvent, interval time.Duration) {
t := time.NewTicker(time.Minute)
select {
case now := <-t.C:
sendEventsTick(evtChan, now)
sendEvents(evtChan, interval)
}
} | [
"func",
"sendEvents",
"(",
"evtChan",
"chan",
"*",
"dt",
".",
"ScheduledEvent",
",",
"interval",
"time",
".",
"Duration",
")",
"{",
"t",
":=",
"time",
".",
"NewTicker",
"(",
"time",
".",
"Minute",
")",
"\n",
"select",
"{",
"case",
"now",
":=",
"<-",
... | // sendEvents recursively calls itself to continue running. | [
"sendEvents",
"recursively",
"calls",
"itself",
"to",
"continue",
"running",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/core/scheduled_event.go#L11-L18 |
4,996 | itsabot/itsabot | shared/datatypes/state_machine.go | NewStateMachine | func NewStateMachine(p *Plugin) *StateMachine {
sm := StateMachine{
state: 0,
plugin: p,
}
sm.states = map[string]int{}
sm.resetFn = func(*Msg) {}
return &sm
} | go | func NewStateMachine(p *Plugin) *StateMachine {
sm := StateMachine{
state: 0,
plugin: p,
}
sm.states = map[string]int{}
sm.resetFn = func(*Msg) {}
return &sm
} | [
"func",
"NewStateMachine",
"(",
"p",
"*",
"Plugin",
")",
"*",
"StateMachine",
"{",
"sm",
":=",
"StateMachine",
"{",
"state",
":",
"0",
",",
"plugin",
":",
"p",
",",
"}",
"\n",
"sm",
".",
"states",
"=",
"map",
"[",
"string",
"]",
"int",
"{",
"}",
... | // NewStateMachine initializes a stateMachine to its starting state. | [
"NewStateMachine",
"initializes",
"a",
"stateMachine",
"to",
"its",
"starting",
"state",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/state_machine.go#L79-L87 |
4,997 | itsabot/itsabot | shared/datatypes/state_machine.go | LoadState | func (sm *StateMachine) LoadState(in *Msg) {
tmp, err := json.Marshal(sm.state)
if err != nil {
sm.plugin.Log.Info("failed to marshal state for db.", err)
return
}
// Using upsert to either insert and return a value or on conflict to
// update and return a value doesn't work, leading to this longer form.
// Could it be a Postgres bug? This can and should be optimized.
if in.User.ID > 0 {
q := `INSERT INTO states
(key, userid, value, pluginname) VALUES ($1, $2, $3, $4)`
_, err = sm.plugin.DB.Exec(q, StateKey, in.User.ID, tmp,
sm.plugin.Config.Name)
} else {
q := `INSERT INTO states
(key, flexid, flexidtype, value, pluginname) VALUES ($1, $2, $3, $4, $5)`
_, err = sm.plugin.DB.Exec(q, StateKey, in.User.FlexID,
in.User.FlexIDType, tmp, sm.plugin.Config.Name)
}
if err != nil {
if err.Error() != `pq: duplicate key value violates unique constraint "states_userid_pkgname_key_key"` &&
err.Error() != `pq: duplicate key value violates unique constraint "states_flexid_flexidtype_pluginname_key_key"` {
sm.plugin.Log.Info("could not insert value into states.", err)
sm.state = 0
return
}
if in.User.ID > 0 {
q := `SELECT value FROM states
WHERE userid=$1 AND key=$2 AND pluginname=$3`
err = sm.plugin.DB.Get(&tmp, q, in.User.ID, StateKey,
sm.plugin.Config.Name)
} else {
q := `SELECT value FROM states
WHERE flexid=$1 AND flexidtype=$2 AND key=$3 AND pluginname=$4`
err = sm.plugin.DB.Get(&tmp, q, in.User.FlexID,
in.User.FlexIDType, StateKey, sm.plugin.Config.Name)
}
if err != nil {
sm.plugin.Log.Info("failed to get value from state.", err)
return
}
}
var val int
if err = json.Unmarshal(tmp, &val); err != nil {
sm.plugin.Log.Info("failed unmarshaling state from db.", err)
return
}
sm.state = val
// Have we already entered a state?
sm.stateEntered = sm.plugin.GetMemory(in, stateEnteredKey).Bool()
return
} | go | func (sm *StateMachine) LoadState(in *Msg) {
tmp, err := json.Marshal(sm.state)
if err != nil {
sm.plugin.Log.Info("failed to marshal state for db.", err)
return
}
// Using upsert to either insert and return a value or on conflict to
// update and return a value doesn't work, leading to this longer form.
// Could it be a Postgres bug? This can and should be optimized.
if in.User.ID > 0 {
q := `INSERT INTO states
(key, userid, value, pluginname) VALUES ($1, $2, $3, $4)`
_, err = sm.plugin.DB.Exec(q, StateKey, in.User.ID, tmp,
sm.plugin.Config.Name)
} else {
q := `INSERT INTO states
(key, flexid, flexidtype, value, pluginname) VALUES ($1, $2, $3, $4, $5)`
_, err = sm.plugin.DB.Exec(q, StateKey, in.User.FlexID,
in.User.FlexIDType, tmp, sm.plugin.Config.Name)
}
if err != nil {
if err.Error() != `pq: duplicate key value violates unique constraint "states_userid_pkgname_key_key"` &&
err.Error() != `pq: duplicate key value violates unique constraint "states_flexid_flexidtype_pluginname_key_key"` {
sm.plugin.Log.Info("could not insert value into states.", err)
sm.state = 0
return
}
if in.User.ID > 0 {
q := `SELECT value FROM states
WHERE userid=$1 AND key=$2 AND pluginname=$3`
err = sm.plugin.DB.Get(&tmp, q, in.User.ID, StateKey,
sm.plugin.Config.Name)
} else {
q := `SELECT value FROM states
WHERE flexid=$1 AND flexidtype=$2 AND key=$3 AND pluginname=$4`
err = sm.plugin.DB.Get(&tmp, q, in.User.FlexID,
in.User.FlexIDType, StateKey, sm.plugin.Config.Name)
}
if err != nil {
sm.plugin.Log.Info("failed to get value from state.", err)
return
}
}
var val int
if err = json.Unmarshal(tmp, &val); err != nil {
sm.plugin.Log.Info("failed unmarshaling state from db.", err)
return
}
sm.state = val
// Have we already entered a state?
sm.stateEntered = sm.plugin.GetMemory(in, stateEnteredKey).Bool()
return
} | [
"func",
"(",
"sm",
"*",
"StateMachine",
")",
"LoadState",
"(",
"in",
"*",
"Msg",
")",
"{",
"tmp",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"sm",
".",
"state",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"sm",
".",
"plugin",
".",
"Log",
".",... | // LoadState upserts state into the database. If there is an existing state for
// a given user and plugin, the stateMachine will load it. If not, the
// stateMachine will insert a starting state into the database. | [
"LoadState",
"upserts",
"state",
"into",
"the",
"database",
".",
"If",
"there",
"is",
"an",
"existing",
"state",
"for",
"a",
"given",
"user",
"and",
"plugin",
"the",
"stateMachine",
"will",
"load",
"it",
".",
"If",
"not",
"the",
"stateMachine",
"will",
"in... | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/state_machine.go#L109-L163 |
4,998 | itsabot/itsabot | shared/datatypes/state_machine.go | setEntered | func (sm *StateMachine) setEntered(in *Msg) {
sm.stateEntered = true
sm.plugin.SetMemory(in, stateEnteredKey, true)
} | go | func (sm *StateMachine) setEntered(in *Msg) {
sm.stateEntered = true
sm.plugin.SetMemory(in, stateEnteredKey, true)
} | [
"func",
"(",
"sm",
"*",
"StateMachine",
")",
"setEntered",
"(",
"in",
"*",
"Msg",
")",
"{",
"sm",
".",
"stateEntered",
"=",
"true",
"\n",
"sm",
".",
"plugin",
".",
"SetMemory",
"(",
"in",
",",
"stateEnteredKey",
",",
"true",
")",
"\n",
"}"
] | // setEntered is used internally to set a state as having been entered both in
// memory and persisted to the database. This ensures that a stateMachine does
// not run a state's OnEntry function twice. | [
"setEntered",
"is",
"used",
"internally",
"to",
"set",
"a",
"state",
"as",
"having",
"been",
"entered",
"both",
"in",
"memory",
"and",
"persisted",
"to",
"the",
"database",
".",
"This",
"ensures",
"that",
"a",
"stateMachine",
"does",
"not",
"run",
"a",
"st... | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/datatypes/state_machine.go#L248-L251 |
4,999 | itsabot/itsabot | shared/plugin/plugin.go | New | func New(url string) (*dt.Plugin, error) {
if err := core.LoadEnvVars(); err != nil {
log.Fatal(err)
}
db, err := core.ConnectDB("")
if err != nil {
return nil, err
}
// Read plugin.json data from within plugins.go, unmarshal into struct
c := dt.PluginConfig{}
if len(os.Getenv("ABOT_PATH")) > 0 {
p := filepath.Join(os.Getenv("ABOT_PATH"), "plugins.go")
var scn *bufio.Scanner
fi, err := os.OpenFile(p, os.O_RDONLY, 0666)
if os.IsNotExist(err) {
goto makePlugin
}
if err != nil {
return nil, err
}
defer func() {
if err = fi.Close(); err != nil {
log.Info("failed to close file", fi.Name())
return
}
}()
var found bool
var data string
scn = bufio.NewScanner(fi)
for scn.Scan() {
t := scn.Text()
if !found && t != url {
continue
} else if t == url {
found = true
continue
} else if len(t) >= 1 && t[0] == '}' {
data += t
break
}
data += t
}
if err = scn.Err(); err != nil {
return nil, err
}
if len(data) > 0 {
if err = json.Unmarshal([]byte(data), &c); err != nil {
return nil, err
}
if len(c.Name) == 0 {
return nil, ErrMissingPluginName
}
}
}
makePlugin:
l := log.New(c.Name)
l.SetDebug(os.Getenv("ABOT_DEBUG") == "true")
plg := &dt.Plugin{
Trigger: &dt.StructuredInput{},
SetBranches: func(in *dt.Msg) [][]dt.State { return nil },
Events: &dt.PluginEvents{
PostReceive: func(cmd *string) {},
PreProcessing: func(cmd *string, u *dt.User) {},
PostProcessing: func(in *dt.Msg) {},
PreResponse: func(in *dt.Msg, resp *string) {},
},
Config: c,
DB: db,
Log: l,
}
plg.SM = dt.NewStateMachine(plg)
return plg, nil
} | go | func New(url string) (*dt.Plugin, error) {
if err := core.LoadEnvVars(); err != nil {
log.Fatal(err)
}
db, err := core.ConnectDB("")
if err != nil {
return nil, err
}
// Read plugin.json data from within plugins.go, unmarshal into struct
c := dt.PluginConfig{}
if len(os.Getenv("ABOT_PATH")) > 0 {
p := filepath.Join(os.Getenv("ABOT_PATH"), "plugins.go")
var scn *bufio.Scanner
fi, err := os.OpenFile(p, os.O_RDONLY, 0666)
if os.IsNotExist(err) {
goto makePlugin
}
if err != nil {
return nil, err
}
defer func() {
if err = fi.Close(); err != nil {
log.Info("failed to close file", fi.Name())
return
}
}()
var found bool
var data string
scn = bufio.NewScanner(fi)
for scn.Scan() {
t := scn.Text()
if !found && t != url {
continue
} else if t == url {
found = true
continue
} else if len(t) >= 1 && t[0] == '}' {
data += t
break
}
data += t
}
if err = scn.Err(); err != nil {
return nil, err
}
if len(data) > 0 {
if err = json.Unmarshal([]byte(data), &c); err != nil {
return nil, err
}
if len(c.Name) == 0 {
return nil, ErrMissingPluginName
}
}
}
makePlugin:
l := log.New(c.Name)
l.SetDebug(os.Getenv("ABOT_DEBUG") == "true")
plg := &dt.Plugin{
Trigger: &dt.StructuredInput{},
SetBranches: func(in *dt.Msg) [][]dt.State { return nil },
Events: &dt.PluginEvents{
PostReceive: func(cmd *string) {},
PreProcessing: func(cmd *string, u *dt.User) {},
PostProcessing: func(in *dt.Msg) {},
PreResponse: func(in *dt.Msg, resp *string) {},
},
Config: c,
DB: db,
Log: l,
}
plg.SM = dt.NewStateMachine(plg)
return plg, nil
} | [
"func",
"New",
"(",
"url",
"string",
")",
"(",
"*",
"dt",
".",
"Plugin",
",",
"error",
")",
"{",
"if",
"err",
":=",
"core",
".",
"LoadEnvVars",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"db... | // New builds a Plugin with its trigger, RPC, and configuration settings from
// its plugin.json. | [
"New",
"builds",
"a",
"Plugin",
"with",
"its",
"trigger",
"RPC",
"and",
"configuration",
"settings",
"from",
"its",
"plugin",
".",
"json",
"."
] | 48a5b1e70afca321d0c522922746b667c29a6070 | https://github.com/itsabot/itsabot/blob/48a5b1e70afca321d0c522922746b667c29a6070/shared/plugin/plugin.go#L31-L104 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.