_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q32900 | FileContainsBytes | train | func FileContainsBytes(fs Fs, filename string, subslice []byte) (bool, error) {
f, err := fs.Open(filename)
if err != nil {
return false, err
}
defer f.Close()
return readerContainsAny(f, subslice), nil
} | go | {
"resource": ""
} |
q32901 | FileContainsAnyBytes | train | func FileContainsAnyBytes(fs Fs, filename string, subslices [][]byte) (bool, error) {
f, err := fs.Open(filename)
if err != nil {
return false, err
}
defer f.Close()
return readerContainsAny(f, subslices...), nil
} | go | {
"resource": ""
} |
q32902 | readerContainsAny | train | func readerContainsAny(r io.Reader, subslices ...[]byte) bool {
if r == nil || len(subslices) == 0 {
return false
}
largestSlice := 0
for _, sl := range subslices {
if len(sl) > largestSlice {
largestSlice = len(sl)
}
}
if largestSlice == 0 {
return false
}
bufflen := largestSlice * 4
halflen :... | go | {
"resource": ""
} |
q32903 | IsEmpty | train | func IsEmpty(fs Fs, path string) (bool, error) {
if b, _ := Exists(fs, path); !b {
return false, fmt.Errorf("%q path does not exist", path)
}
fi, err := fs.Stat(path)
if err != nil {
return false, err
}
if fi.IsDir() {
f, err := fs.Open(path)
if err != nil {
return false, err
}
defer f.Close()
li... | go | {
"resource": ""
} |
q32904 | Name | train | func (s *FileInfo) Name() string {
s.Lock()
_, name := filepath.Split(s.name)
s.Unlock()
return name
} | go | {
"resource": ""
} |
q32905 | normalizePath | train | func normalizePath(path string) string {
path = filepath.Clean(path)
switch path {
case ".":
return FilePathSeparator
case "..":
return FilePathSeparator
default:
return path
}
} | go | {
"resource": ""
} |
q32906 | RealPath | train | func (b *BasePathFs) RealPath(name string) (path string, err error) {
if err := validateBasePathName(name); err != nil {
return name, err
}
bpath := filepath.Clean(b.path)
path = filepath.Clean(filepath.Join(bpath, name))
if !strings.HasPrefix(path, bpath) {
return name, os.ErrNotExist
}
return path, nil
} | go | {
"resource": ""
} |
q32907 | Readdir | train | func (f *UnionFile) Readdir(c int) (ofi []os.FileInfo, err error) {
var merge DirsMerger = f.Merger
if merge == nil {
merge = defaultUnionMergeDirsFn
}
if f.off == 0 {
var lfi []os.FileInfo
if f.Layer != nil {
lfi, err = f.Layer.Readdir(-1)
if err != nil {
return nil, err
}
}
var bfi []os.F... | go | {
"resource": ""
} |
q32908 | isBaseFile | train | func (u *CopyOnWriteFs) isBaseFile(name string) (bool, error) {
if _, err := u.layer.Stat(name); err == nil {
return false, nil
}
_, err := u.base.Stat(name)
if err != nil {
if oerr, ok := err.(*os.PathError); ok {
if oerr.Err == os.ErrNotExist || oerr.Err == syscall.ENOENT || oerr.Err == syscall.ENOTDIR {
... | go | {
"resource": ""
} |
q32909 | Rename | train | func (u *CopyOnWriteFs) Rename(oldname, newname string) error {
b, err := u.isBaseFile(oldname)
if err != nil {
return err
}
if b {
return syscall.EPERM
}
return u.layer.Rename(oldname, newname)
} | go | {
"resource": ""
} |
q32910 | Remove | train | func (u *CopyOnWriteFs) Remove(name string) error {
err := u.layer.Remove(name)
switch err {
case syscall.ENOENT:
_, err = u.base.Stat(name)
if err == nil {
return syscall.EPERM
}
return syscall.ENOENT
default:
return err
}
} | go | {
"resource": ""
} |
q32911 | lstatIfPossible | train | func lstatIfPossible(fs Fs, path string) (os.FileInfo, error) {
if lfs, ok := fs.(Lstater); ok {
fi, _, err := lfs.LstatIfPossible(path)
return fi, err
}
return fs.Stat(path)
} | go | {
"resource": ""
} |
q32912 | toBson | train | func (o *OAuthProvider) toBson() bson.M {
return bson.M{"baseurl": struct {
Scheme string
Host string
Path string
}{o.BaseURL.Scheme, o.BaseURL.Host, o.BaseURL.Path},
"id": o.ID,
"secret": o.Secret,
"service": o.Service}
} | go | {
"resource": ""
} |
q32913 | URLMustParse | train | func URLMustParse(s string) *url.URL {
u, err := url.Parse(s)
if err != nil {
log.Errorf("Expected URL to parse: %q, got error: %v", s, err)
}
return u
} | go | {
"resource": ""
} |
q32914 | GetVersion | train | func GetVersion() string {
if currentGitHead == "" {
b, err := ioutil.ReadFile(".git/HEAD")
if err != nil {
currentGitHead = "unknown"
return currentGitHead
}
p := refRE.FindStringSubmatch(string(b))
if len(p) < 2 {
currentGitHead = string(b)
return currentGitHead
}
b, err = ioutil.ReadFi... | go | {
"resource": ""
} |
q32915 | Cache | train | func (user *User) Cache(key string, res interface{}) (exists bool) {
return user.ctx.getCacheVal("user", key, res)
} | go | {
"resource": ""
} |
q32916 | Cache | train | func (chat *Chat) Cache(key string, res interface{}) (exists bool) {
return chat.ctx.getCacheVal("chat", key, res)
} | go | {
"resource": ""
} |
q32917 | ServiceCache | train | func (c *Context) ServiceCache(key string, res interface{}) (exists bool) {
return c.getCacheVal("service", key, res)
} | go | {
"resource": ""
} |
q32918 | SetCache | train | func (user *User) SetCache(key string, val interface{}, ttl time.Duration) error {
expiresAt := time.Now().Add(ttl)
serviceID := user.ctx.getServiceID()
key = strings.ToLower(key)
if val == nil {
err := user.ctx.db.C("users_cache").Remove(bson.M{"userid": user.ID, "service": serviceID, "key": key})
return err... | go | {
"resource": ""
} |
q32919 | UpdateCache | train | func (user *User) UpdateCache(key string, update interface{}, res interface{}) error {
exists := user.ctx.updateCacheVal("user", key, update, res)
if !exists {
log.WithField("key", key).Error("Can't update user cache value")
}
return nil
} | go | {
"resource": ""
} |
q32920 | SetServiceCache | train | func (c *Context) SetServiceCache(key string, val interface{}, ttl time.Duration) error {
expiresAt := time.Now().Add(ttl)
serviceID := c.getServiceID()
key = strings.ToLower(key)
if val == nil {
err := c.db.C("services_cache").Remove(bson.M{"service": serviceID, "key": key})
return err
}
_, err := c.db.C("... | go | {
"resource": ""
} |
q32921 | Settings | train | func (user *User) Settings(out interface{}) error {
data, err := user.getData()
if err != nil {
return err
}
serviceID := user.ctx.getServiceID()
if _, ok := data.Settings[serviceID]; ok {
// TODO: workaround that creepy bindInterfaceToInterface
err = bindInterfaceToInterface(data.Settings[serviceID], out)... | go | {
"resource": ""
} |
q32922 | Settings | train | func (chat *Chat) Settings(out interface{}) error {
data, err := chat.getData()
if err != nil {
return err
}
serviceID := chat.ctx.getServiceID()
if _, ok := data.Settings[serviceID]; ok {
// TODO: workaround that creepy bindInterfaceToInterface
err = bindInterfaceToInterface(data.Settings[serviceID], out... | go | {
"resource": ""
} |
q32923 | SaveSettings | train | func (chat *Chat) SaveSettings(allSettings interface{}) error {
serviceID := chat.ctx.getServiceID()
_, err := chat.ctx.db.C("chats").UpsertId(chat.ID, bson.M{"$set": bson.M{"settings." + serviceID: allSettings}, "$setOnInsert": bson.M{"createdat": time.Now()}})
if chat.data == nil {
chat.data = &chatData{}
}
... | go | {
"resource": ""
} |
q32924 | SaveSettings | train | func (user *User) SaveSettings(allSettings interface{}) error {
serviceID := user.ctx.getServiceID()
_, err := user.ctx.db.C("users").UpsertId(user.ID, bson.M{"$set": bson.M{"settings." + serviceID: allSettings}, "$setOnInsert": bson.M{"createdat": time.Now()}})
if user.data == nil {
user.data = &userData{}
}
... | go | {
"resource": ""
} |
q32925 | ServiceHookToken | train | func (chat *Chat) ServiceHookToken() string {
data, _ := chat.getData()
//TODO: test backward compatibility cases
for _, hook := range data.Hooks {
for _, service := range hook.Services {
if service == chat.ctx.ServiceName {
return hook.Token
}
}
}
token := "c" + rndStr.Get(10)
chat.addHook(serviceH... | go | {
"resource": ""
} |
q32926 | ServiceHookURL | train | func (user *User) ServiceHookURL() string {
return Config.BaseURL + "/" + user.ctx.ServiceName + "/" + user.ServiceHookToken()
} | go | {
"resource": ""
} |
q32927 | ServiceHookURL | train | func (chat *Chat) ServiceHookURL() string {
return Config.BaseURL + "/" + chat.ctx.ServiceName + "/" + chat.ServiceHookToken()
} | go | {
"resource": ""
} |
q32928 | AddChatToHook | train | func (user *User) AddChatToHook(chatID int64) error {
data, _ := user.getData()
token := user.ServiceHookToken()
for i, hook := range data.Hooks {
if hook.Token == token {
for _, service := range hook.Services {
if service == user.ctx.ServiceName {
for _, existingChatID := range hook.Chats {
if ... | go | {
"resource": ""
} |
q32929 | SaveSetting | train | func (chat *Chat) SaveSetting(key string, value interface{}) error {
key = strings.ToLower(key)
serviceID := chat.ctx.getServiceID()
var cd chatData
_, err := chat.ctx.db.C("chats").FindId(chat.ID).Select(bson.M{"settings." + serviceID: 1}).
Apply(
mgo.Change{
Update: bson.M{
"$set": bson.M{"set... | go | {
"resource": ""
} |
q32930 | SaveSetting | train | func (user *User) SaveSetting(key string, value interface{}) error {
if user.ID == 0 {
return errors.New("SaveSetting: user is empty")
}
key = strings.ToLower(key)
serviceID := user.ctx.getServiceID()
var ud userData
_, err := user.ctx.db.C("users").FindId(user.ID).Select(bson.M{"settings." + serviceID: 1}).... | go | {
"resource": ""
} |
q32931 | AuthTempToken | train | func (user *User) AuthTempToken() string {
host := user.ctx.ServiceBaseURL.Host
if host == "" {
host = user.ctx.Service().DefaultBaseURL.Host
}
serviceBaseURL := user.ctx.ServiceBaseURL.String()
if serviceBaseURL == "" {
serviceBaseURL = user.ctx.Service().DefaultBaseURL.String()
}
ps, _ := user.protected... | go | {
"resource": ""
} |
q32932 | OauthRedirectURL | train | func (user *User) OauthRedirectURL() string {
providerID := user.ctx.OAuthProvider().internalID()
if providerID == user.ctx.ServiceName {
return fmt.Sprintf("%s/auth/%s", Config.BaseURL, user.ctx.ServiceName)
}
return fmt.Sprintf("%s/auth/%s/%s", Config.BaseURL, user.ctx.ServiceName, providerID)
} | go | {
"resource": ""
} |
q32933 | OauthInitURL | train | func (user *User) OauthInitURL() string {
authTempToken := user.AuthTempToken()
s := user.ctx.Service()
if authTempToken == "" {
user.ctx.Log().Error("authTempToken is empty")
return ""
}
if s.DefaultOAuth2 != nil {
provider := user.ctx.OAuthProvider()
return provider.OAuth2Client(user.ctx).AuthCodeURL(au... | go | {
"resource": ""
} |
q32934 | OAuthHTTPClient | train | func (user *User) OAuthHTTPClient() *http.Client {
ps, _ := user.protectedSettings()
if ps == nil {
return nil
}
if ps.OAuthToken == "" {
return nil
}
if user.ctx.Service().DefaultOAuth2 != nil {
ts := user.ctx.OAuthProvider().OAuth2Client(user.ctx).TokenSource(oauth2.NoContext, &oauth2.Token{AccessToke... | go | {
"resource": ""
} |
q32935 | OAuthToken | train | func (user *User) OAuthToken() string {
// todo: oauthtoken per host?
/*
host := user.ctx.ServiceBaseURL.Host
if host == "" {
host = user.ctx.Service().DefaultBaseURL.Host
}
*/
ps, _ := user.protectedSettings()
if ps != nil {
if ps.OAuthExpireDate != nil && ps.OAuthExpireDate.Before(time.Now().Add(tim... | go | {
"resource": ""
} |
q32936 | ResetOAuthToken | train | func (user *User) ResetOAuthToken() error {
err := user.saveProtectedSetting("OAuthToken", "")
if err != nil {
user.ctx.Log().WithError(err).Error("ResetOAuthToken error")
}
return err
} | go | {
"resource": ""
} |
q32937 | WebPreview | train | func (c *Context) WebPreview(title string, headline string, text string, serviceURL string, imageURL string) (WebPreviewURL string) {
token := rndStr.Get(10)
if title == "" {
title = c.Service().NameToPrint
c.Log().WithField("token", token).Warn("webPreview: title is empty")
}
if headline == "" {
c.Log().Wit... | go | {
"resource": ""
} |
q32938 | SetServiceBaseURL | train | func (c *Context) SetServiceBaseURL(domainOrURL string) {
u, _ := getBaseURL(domainOrURL)
if u != nil && u.Host != "" {
c.ServiceBaseURL = *u
} else if domainOrURL != "" {
c.ServiceBaseURL = url.URL{Scheme: "https", Host: domainOrURL}
} else {
c.Log().Error("Can't use SetServiceHostFromURL with empty arg")
... | go | {
"resource": ""
} |
q32939 | SaveOAuthProvider | train | func (c *Context) SaveOAuthProvider(baseURL url.URL, id string, secret string) (*OAuthProvider, error) {
if id == "" || secret == "" {
return nil, errors.New("id and secret must not be empty")
}
baseURL.Host = strings.ToLower(baseURL.Host)
provider := OAuthProvider{BaseURL: baseURL, ID: id, Secret: secret, Serv... | go | {
"resource": ""
} |
q32940 | OAuthProvider | train | func (c *Context) OAuthProvider() *OAuthProvider {
service := c.Service()
if c.ServiceBaseURL.Host == "" || c.ServiceBaseURL.Host == service.DefaultBaseURL.Host {
return service.DefaultOAuthProvider()
} else if c.ServiceBaseURL.Host != "" {
p, _ := findOauthProviderByHost(c.db, c.ServiceBaseURL.Host)
if p ==... | go | {
"resource": ""
} |
q32941 | OAuth1Client | train | func (o *OAuthProvider) OAuth1Client(c *Context) *oauth.Consumer {
if o.ID == "" {
log.Error(errors.New("Can't get OAuth1Client – ID not set"))
return nil
}
service := c.Service()
config := service.DefaultOAuth1
if config.AccessTokenReceiver == nil {
log.Error(errors.New("Can't get OAuth1Client – AccessTo... | go | {
"resource": ""
} |
q32942 | OAuth2Client | train | func (o *OAuthProvider) OAuth2Client(c *Context) *oauth2.Config {
if o.ID == "" {
return nil
}
service := c.Service()
if service.DefaultOAuth2 == nil {
return nil
}
config := service.DefaultOAuth2.Config
config.ClientID = o.ID
config.ClientSecret = o.Secret
if c.User.ID != 0 {
config.RedirectURL = c... | go | {
"resource": ""
} |
q32943 | Param | train | func (wc *WebhookContext) Param(s string) string {
return wc.gin.Param(s)
} | go | {
"resource": ""
} |
q32944 | Headers | train | func (wc *WebhookContext) Headers() map[string][]string {
return map[string][]string(wc.gin.Request.Header)
} | go | {
"resource": ""
} |
q32945 | Redirect | train | func (wc *WebhookContext) Redirect(code int, s string) {
wc.gin.Redirect(code, s)
} | go | {
"resource": ""
} |
q32946 | KeyboardAnswer | train | func (c *Context) KeyboardAnswer() (data string, buttonText string) {
keyboard, err := c.keyboard()
if err != nil || keyboard.ChatID == 0 {
log.WithError(err).Error("Can't get stored keyboard")
return
}
// In group chat keyboard answer always include msg_id of original message that generate this keyboard
if ... | go | {
"resource": ""
} |
q32947 | keyboard | train | func (c *Context) keyboard() (chatKeyboard, error) {
udata, _ := c.User.getData()
chatID := c.Chat.ID
for _, kb := range udata.KeyboardPerChat {
if kb.ChatID == chatID && kb.BotID == c.Bot().ID {
return kb, nil
}
}
cdata, _ := c.Chat.getData()
for _, kb := range cdata.KeyboardPerBot {
if kb.ChatID =... | go | {
"resource": ""
} |
q32948 | Log | train | func (c *Context) Log() *log.Entry {
fields := log.Fields{"service": c.ServiceName}
if Config.Debug {
pc := make([]uintptr, 10)
runtime.Callers(2, pc)
f := runtime.FuncForPC(pc[0])
fields["file"], fields["line"] = f.FileLine(pc[0])
fields["func"] = f.Name()
}
if c.User.ID > 0 {
fields["user"] = c.User... | go | {
"resource": ""
} |
q32949 | Service | train | func (c *Context) Service() *Service {
s, _ := serviceByName(c.ServiceName)
return s
} | go | {
"resource": ""
} |
q32950 | EditPressedMessageText | train | func (c *Context) EditPressedMessageText(text string) error {
if c.Callback == nil {
return errors.New("EditPressedMessageText: Callback is not presented")
}
return c.EditMessageText(c.Callback.Message, text)
} | go | {
"resource": ""
} |
q32951 | EditPressedMessageTextAndInlineKeyboard | train | func (c *Context) EditPressedMessageTextAndInlineKeyboard(text string, kb InlineKeyboard) error {
if c.Callback == nil {
return errors.New("EditPressedMessageTextAndInlineKeyboard: Callback is not presented")
}
return c.EditMessageTextAndInlineKeyboard(c.Callback.Message, c.Callback.Message.InlineKeyboardMarkup.S... | go | {
"resource": ""
} |
q32952 | EditPressedInlineKeyboard | train | func (c *Context) EditPressedInlineKeyboard(kb InlineKeyboard) error {
if c.Callback == nil {
return errors.New("EditPressedInlineKeyboard: Callback is not presented")
}
return c.EditInlineKeyboard(c.Callback.Message, c.Callback.Message.InlineKeyboardMarkup.State, kb)
} | go | {
"resource": ""
} |
q32953 | EditPressedInlineButton | train | func (c *Context) EditPressedInlineButton(newState int, newText string) error {
log.WithField("newText", newText).WithField("newState", newState).Info("EditPressedInlineButton")
if c.Callback == nil {
return errors.New("EditPressedInlineButton: Callback is not presented")
}
return c.EditInlineStateButton(c.Callb... | go | {
"resource": ""
} |
q32954 | EditMessageText | train | func (c *Context) EditMessageText(om *OutgoingMessage, text string) error {
if om == nil {
return errors.New("Empty message provided")
}
bot := c.Bot()
if om.ParseMode == "HTML" {
textCleared, err := sanitize.HTMLAllowing(text, []string{"a", "b", "strong", "i", "em", "a", "code", "pre"}, []string{"href"})
i... | go | {
"resource": ""
} |
q32955 | EditMessagesTextWithEventID | train | func (c *Context) EditMessagesTextWithEventID(eventID string, text string) (edited int, err error) {
var messages []OutgoingMessage
//update MAX_MSGS_TO_UPDATE_WITH_EVENTID last bot messages
c.db.C("messages").Find(bson.M{"botid": c.Bot().ID, "eventid": eventID}).Sort("-_id").Limit(MaxMsgsToUpdateWithEventID).All(&m... | go | {
"resource": ""
} |
q32956 | EditMessageTextWithMessageID | train | func (c *Context) EditMessageTextWithMessageID(msgID bson.ObjectId, text string) (edited int, err error) {
var message OutgoingMessage
c.db.C("messages").Find(bson.M{"_id": msgID, "botid": c.Bot().ID}).One(&message)
err = c.EditMessageText(&message, text)
if err != nil {
c.Log().WithError(err).WithField("msgid",... | go | {
"resource": ""
} |
q32957 | EditMessagesWithEventID | train | func (c *Context) EditMessagesWithEventID(eventID string, fromState string, text string, kb InlineKeyboard) (edited int, err error) {
var messages []OutgoingMessage
f := bson.M{"botid": c.Bot().ID, "eventid": eventID}
if fromState != "" {
f["inlinekeyboardmarkup.state"] = fromState
}
//update MAX_MSGS_TO_UPDATE... | go | {
"resource": ""
} |
q32958 | DeleteMessagesWithEventID | train | func (c *Context) DeleteMessagesWithEventID(eventID string) (deleted int, err error) {
var messages []OutgoingMessage
f := bson.M{"botid": c.Bot().ID, "eventid": eventID}
//update MAX_MSGS_TO_UPDATE_WITH_EVENTID last bot messages
c.db.C("messages").Find(f).Sort("-_id").Limit(MaxMsgsToUpdateWithEventID).All(&messag... | go | {
"resource": ""
} |
q32959 | DeleteMessage | train | func (c *Context) DeleteMessage(om *OutgoingMessage) error {
bot := c.Bot()
if om.MsgID != 0 {
log.WithField("msgID", om.MsgID).Debug("DeleteMessage")
} else {
om.ChatID = 0
log.WithField("inlineMsgID", om.InlineMsgID).Debug("DeleteMessage")
}
var msg OutgoingMessage
var ci *mgo.ChangeInfo
var err error
... | go | {
"resource": ""
} |
q32960 | EditInlineKeyboard | train | func (c *Context) EditInlineKeyboard(om *OutgoingMessage, fromState string, kb InlineKeyboard) error {
bot := c.Bot()
if om.MsgID != 0 {
log.WithField("msgID", om.MsgID).Debug("EditMessageTextAndInlineKeyboard")
} else {
om.ChatID = 0
log.WithField("inlineMsgID", om.InlineMsgID).Debug("EditMessageTextAndInlin... | go | {
"resource": ""
} |
q32961 | EditInlineButton | train | func (c *Context) EditInlineButton(om *OutgoingMessage, kbState string, buttonData string, newButtonText string) error {
return c.EditInlineStateButton(om, kbState, 0, buttonData, 0, newButtonText)
} | go | {
"resource": ""
} |
q32962 | EditInlineStateButton | train | func (c *Context) EditInlineStateButton(om *OutgoingMessage, kbState string, oldButtonState int, buttonData string, newButtonState int, newButtonText string) error {
if oldButtonState > 9 || oldButtonState < 0 {
c.Log().WithField("data", buttonData).WithField("text", newButtonText).Errorf("EditInlineStateButton – ol... | go | {
"resource": ""
} |
q32963 | AnswerInlineQueryWithPM | train | func (c *Context) AnswerInlineQueryWithPM(text string, parameter string) error {
bot := c.Bot()
_, err := bot.API.AnswerInlineQuery(tg.InlineConfig{IsPersonal: true, InlineQueryID: c.InlineQuery.ID, SwitchPMText: text, SwitchPMParameter: parameter})
n := time.Now()
c.inlineQueryAnsweredAt = &n
return err
} | go | {
"resource": ""
} |
q32964 | AnswerCallbackQuery | train | func (c *Context) AnswerCallbackQuery(text string, showAlert bool) error {
if c.Callback == nil {
return errors.New("Callback to answer is not presented")
}
if c.Callback.AnsweredAt != nil {
return errors.New("Callback already answered")
}
bot := c.Bot()
_, err := bot.API.AnswerCallbackQuery(tg.CallbackCon... | go | {
"resource": ""
} |
q32965 | NewMessage | train | func (c *Context) NewMessage() *OutgoingMessage {
bot := c.Bot()
msg := &OutgoingMessage{}
msg.BotID = bot.ID
msg.FromID = bot.ID
msg.WebPreview = true
if c.Chat.ID != 0 {
msg.ChatID = c.Chat.ID
} else {
msg.ChatID = c.User.ID
}
msg.ctx = c
return msg
} | go | {
"resource": ""
} |
q32966 | SendAction | train | func (c *Context) SendAction(s string) error {
_, err := c.Bot().API.Send(tg.NewChatAction(c.Chat.ID, s))
return err
} | go | {
"resource": ""
} |
q32967 | DownloadURL | train | func (c *Context) DownloadURL(url string) (filePath string, err error) {
ext := filepath.Ext(url)
out, err := ioutil.TempFile("", fmt.Sprintf("%d_%d", c.Bot().ID, c.Chat.ID))
if err != nil {
return "", err
}
out.Close()
os.Rename(out.Name(), out.Name()+ext)
out, err = os.OpenFile(out.Name()+ext, os.O_RDWR,... | go | {
"resource": ""
} |
q32968 | RAW | train | func (wc *WebhookContext) RAW() (*[]byte, error) {
var err error
if wc.body == nil {
wc.firstParse = true
wc.body, err = ioutil.ReadAll(wc.gin.Request.Body)
if err != nil {
return nil, err
}
}
return &wc.body, nil
} | go | {
"resource": ""
} |
q32969 | JSON | train | func (wc *WebhookContext) JSON(out interface{}) error {
var err error
if wc.body == nil {
wc.firstParse = true
wc.body, err = ioutil.ReadAll(wc.gin.Request.Body)
if err != nil {
return err
}
}
err = json.Unmarshal(wc.body, out)
if err != nil && strings.HasPrefix(string(wc.body), "payload=") {
s := s... | go | {
"resource": ""
} |
q32970 | Form | train | func (wc *WebhookContext) Form() uurl.Values {
//todo: bug, RAW() unavailable after ParseForm()
wc.gin.Request.ParseForm()
return wc.gin.Request.PostForm
} | go | {
"resource": ""
} |
q32971 | IsEventBotAddedToGroup | train | func (m *IncomingMessage) IsEventBotAddedToGroup() bool {
if (len(m.NewChatMembers) > 0 && m.NewChatMembers[0].ID == m.BotID) || m.GroupChatCreated || m.SuperGroupChatCreated {
return true
}
return false
} | go | {
"resource": ""
} |
q32972 | GetCommand | train | func (m *IncomingMessage) GetCommand() (string, string) {
text := m.Text
if !strings.HasPrefix(text, "/") {
return "", text
}
r, _ := regexp.Compile("^/([a-zA-Z0-9_]+)(?:@[a-zA-Z0-9_]+)?.?(.*)?$")
match := r.FindStringSubmatch(text)
if len(match) == 3 {
return match[1], match[2]
} else if len(match) == 2 {
... | go | {
"resource": ""
} |
q32973 | Find | train | func (keyboard *InlineKeyboard) Find(buttonData string) (i, j int, but *InlineButton) {
for i, buttonsRow := range keyboard.Buttons {
for j, button := range buttonsRow {
if button.Data == buttonData {
return i, j, &button
}
}
}
return -1, -1, nil
} | go | {
"resource": ""
} |
q32974 | EditText | train | func (keyboard *InlineKeyboard) EditText(buttonData string, newText string) {
for i, buttonsRow := range keyboard.Buttons {
for j, button := range buttonsRow {
if button.Data == buttonData {
keyboard.Buttons[i][j].Text = newText
return
}
}
}
} | go | {
"resource": ""
} |
q32975 | AddPMSwitchButton | train | func (keyboard *InlineKeyboard) AddPMSwitchButton(b *Bot, text string, param string) {
if len(keyboard.Buttons) > 0 && len(keyboard.Buttons[0]) > 0 && keyboard.Buttons[0][0].Text == text {
return
}
keyboard.PrependRows(InlineButtons{InlineButton{Text: text, URL: b.PMURL(param)}})
} | go | {
"resource": ""
} |
q32976 | FindMessageByEventID | train | func (c *Context) FindMessageByEventID(id string) (*Message, error) {
if c.Bot() == nil {
return nil, errors.New("Bot not set for the service")
}
return findMessageByEventID(c.db, c.Chat.ID, c.Bot().ID, id)
} | go | {
"resource": ""
} |
q32977 | SetChat | train | func (m *OutgoingMessage) SetChat(id int64) *OutgoingMessage {
m.ChatID = id
return m
} | go | {
"resource": ""
} |
q32978 | SetDocument | train | func (m *OutgoingMessage) SetDocument(localPath string, fileName string) *OutgoingMessage {
m.FilePath = localPath
m.FileName = fileName
m.FileType = "document"
return m
} | go | {
"resource": ""
} |
q32979 | SetKeyboard | train | func (m *OutgoingMessage) SetKeyboard(k KeyboardMarkup, selective bool) *OutgoingMessage {
m.Keyboard = true
m.KeyboardMarkup = k.Keyboard()
m.Selective = selective
//todo: here is workaround for QT version. Keyboard with selective is not working
return m
} | go | {
"resource": ""
} |
q32980 | SetInlineKeyboard | train | func (m *OutgoingMessage) SetInlineKeyboard(k InlineKeyboardMarkup) *OutgoingMessage {
m.InlineKeyboardMarkup = k.Keyboard()
return m
} | go | {
"resource": ""
} |
q32981 | SetSelective | train | func (m *OutgoingMessage) SetSelective(b bool) *OutgoingMessage {
m.Selective = b
return m
} | go | {
"resource": ""
} |
q32982 | SetSilent | train | func (m *OutgoingMessage) SetSilent(b bool) *OutgoingMessage {
m.Silent = b
return m
} | go | {
"resource": ""
} |
q32983 | SetOneTimeKeyboard | train | func (m *OutgoingMessage) SetOneTimeKeyboard(b bool) *OutgoingMessage {
m.OneTimeKeyboard = b
return m
} | go | {
"resource": ""
} |
q32984 | SetResizeKeyboard | train | func (m *OutgoingMessage) SetResizeKeyboard(b bool) *OutgoingMessage {
m.ResizeKeyboard = b
return m
} | go | {
"resource": ""
} |
q32985 | SetCallbackAction | train | func (m *OutgoingMessage) SetCallbackAction(handlerFunc interface{}, args ...interface{}) *OutgoingMessage {
m.Message.SetCallbackAction(handlerFunc, args...)
return m
} | go | {
"resource": ""
} |
q32986 | Send | train | func (m *OutgoingMessage) Send() error {
if m.ChatID == 0 {
return errors.New("ChatID is empty")
}
if m.BotID == 0 {
return errors.New("BotID is empty")
}
if m.Text == "" && m.FilePath == "" && m.Location == nil {
return errors.New("Text, FilePath and Location are empty")
}
if m.ctx != nil && m.ctx.mess... | go | {
"resource": ""
} |
q32987 | SetSendAfter | train | func (m *OutgoingMessage) SetSendAfter(after time.Time) *OutgoingMessage {
m.SendAfter = &after
return m
} | go | {
"resource": ""
} |
q32988 | AddEventID | train | func (m *OutgoingMessage) AddEventID(id ...string) *OutgoingMessage {
m.EventID = append(m.EventID, id...)
return m
} | go | {
"resource": ""
} |
q32989 | SetText | train | func (m *OutgoingMessage) SetText(text string) *OutgoingMessage {
m.Text = text
return m
} | go | {
"resource": ""
} |
q32990 | SetLocation | train | func (m *OutgoingMessage) SetLocation(latitude, longitude float64) *OutgoingMessage {
m.Location = &Location{Latitude: latitude, Longitude: longitude}
return m
} | go | {
"resource": ""
} |
q32991 | GetTextHash | train | func (m *Message) GetTextHash() string {
if m.Text != "" {
return fmt.Sprintf("%x", md5.Sum([]byte(m.Text)))
}
return ""
} | go | {
"resource": ""
} |
q32992 | UpdateEventsID | train | func (m *Message) UpdateEventsID(db *mgo.Database, eventID ...string) error {
m.EventID = append(m.EventID, eventID...)
f := bson.M{"botid": m.BotID}
if m.InlineMsgID != "" {
f["inlinemsgid"] = m.InlineMsgID
} else {
f["chatid"] = m.ChatID
f["msgid"] = m.MsgID
}
return db.C("messages").Update(f, bson.M{"$ad... | go | {
"resource": ""
} |
q32993 | Update | train | func (m *Message) Update(db *mgo.Database) error {
if m.ID.Valid() {
return db.C("messages").UpdateId(m.ID, bson.M{"$set": m})
}
return errors.New("Can't update message: ID is not set")
} | go | {
"resource": ""
} |
q32994 | decode | train | func decode(reply []byte, dest interface{}) error {
// Check the type of dest and make sure it is a pointer to something,
// otherwise we can't set its value in any meaningful way.
val := reflect.ValueOf(dest)
if val.Kind() != reflect.Ptr {
return fmt.Errorf("Argument to decode must be pointer. Got %T", dest)
}
... | go | {
"resource": ""
} |
q32995 | encode | train | func encode(data interface{}) ([]byte, error) {
if data == nil {
return nil, nil
}
buf := bytes.NewBuffer([]byte{})
enc := gob.NewEncoder(buf)
if err := enc.Encode(data); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q32996 | Bot | train | func (s *Service) Bot() *Bot {
if bot, exists := botPerService[s.Name]; exists {
return bot
}
log.WithField("service", s.Name).Error("Can't get bot for service")
return nil
} | go | {
"resource": ""
} |
q32997 | Walk | train | func Walk(hfs http.FileSystem, root string, walkFn filepath.WalkFunc) error {
dh, err := hfs.Open(root)
if err != nil {
return err
}
di, err := dh.Stat()
if err != nil {
return err
}
fis, err := dh.Readdir(-1)
dh.Close()
if err = walkFn(root, di, err); err != nil {
if err == filepath.SkipDir {
return ... | go | {
"resource": ""
} |
q32998 | ReadFile | train | func ReadFile(hfs http.FileSystem, name string) ([]byte, error) {
fh, err := hfs.Open(name)
if err != nil {
return nil, err
}
var buf bytes.Buffer
_, err = io.Copy(&buf, fh)
fh.Close()
return buf.Bytes(), err
} | go | {
"resource": ""
} |
q32999 | rename | train | func rename(src, dest string) error {
// Try to rename generated source.
if err := os.Rename(src, dest); err == nil {
return nil
}
// If the rename failed (might do so due to temporary file residing on a
// different device), try to copy byte by byte.
rc, err := os.Open(src)
if err != nil {
return err
}
de... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.