_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q37500 | Handle | train | func (eh messageReactionRemoveAllEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*MessageReactionRemoveAll); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37501 | Handle | train | func (eh messageUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*MessageUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37502 | Handle | train | func (eh presenceUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*PresenceUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37503 | Handle | train | func (eh presencesReplaceEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*PresencesReplace); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37504 | Handle | train | func (eh rateLimitEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*RateLimit); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37505 | Handle | train | func (eh readyEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*Ready); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37506 | Handle | train | func (eh relationshipAddEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*RelationshipAdd); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37507 | Handle | train | func (eh relationshipRemoveEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*RelationshipRemove); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37508 | Handle | train | func (eh resumedEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*Resumed); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37509 | Handle | train | func (eh typingStartEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*TypingStart); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37510 | Handle | train | func (eh userGuildSettingsUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*UserGuildSettingsUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37511 | Handle | train | func (eh userNoteUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*UserNoteUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37512 | Handle | train | func (eh userSettingsUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*UserSettingsUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37513 | Handle | train | func (eh userUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*UserUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37514 | Handle | train | func (eh voiceServerUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*VoiceServerUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37515 | Handle | train | func (eh voiceStateUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*VoiceStateUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37516 | Handle | train | func (eh webhooksUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*WebhooksUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37517 | AddHandlerOnce | train | func (s *Session) AddHandlerOnce(handler interface{}) func() {
eh := handlerForInterface(handler)
if eh == nil {
s.log(LogError, "Invalid handler type, handler will never be called")
return func() {}
}
return s.addEventHandlerOnce(eh)
} | go | {
"resource": ""
} |
q37518 | removeEventHandlerInstance | train | func (s *Session) removeEventHandlerInstance(t string, ehi *eventHandlerInstance) {
s.handlersMu.Lock()
defer s.handlersMu.Unlock()
handlers := s.handlers[t]
for i := range handlers {
if handlers[i] == ehi {
s.handlers[t] = append(handlers[:i], handlers[i+1:]...)
}
}
onceHandlers := s.onceHandlers[t]
fo... | go | {
"resource": ""
} |
q37519 | handle | train | func (s *Session) handle(t string, i interface{}) {
for _, eh := range s.handlers[t] {
if s.SyncEvents {
eh.eventHandler.Handle(s, i)
} else {
go eh.eventHandler.Handle(s, i)
}
}
if len(s.onceHandlers[t]) > 0 {
for _, eh := range s.onceHandlers[t] {
if s.SyncEvents {
eh.eventHandler.Handle(s, i... | go | {
"resource": ""
} |
q37520 | setGuildIds | train | func setGuildIds(g *Guild) {
for _, c := range g.Channels {
c.GuildID = g.ID
}
for _, m := range g.Members {
m.GuildID = g.ID
}
for _, vs := range g.VoiceStates {
vs.GuildID = g.ID
}
} | go | {
"resource": ""
} |
q37521 | onInterface | train | func (s *Session) onInterface(i interface{}) {
switch t := i.(type) {
case *Ready:
for _, g := range t.Guilds {
setGuildIds(g)
}
s.onReady(t)
case *GuildCreate:
setGuildIds(t.Guild)
case *GuildUpdate:
setGuildIds(t.Guild)
case *VoiceServerUpdate:
go s.onVoiceServerUpdate(t)
case *VoiceStateUpdate:
... | go | {
"resource": ""
} |
q37522 | Parse | train | func (t Timestamp) Parse() (time.Time, error) {
return time.Parse(time.RFC3339, string(t))
} | go | {
"resource": ""
} |
q37523 | listen | train | func (s *Session) listen(wsConn *websocket.Conn, listening <-chan interface{}) {
s.log(LogInformational, "called")
for {
messageType, message, err := wsConn.ReadMessage()
if err != nil {
// Detect if we have been closed manually. If a Close() has already
// happened, the websocket we are listening on w... | go | {
"resource": ""
} |
q37524 | HeartbeatLatency | train | func (s *Session) HeartbeatLatency() time.Duration {
return s.LastHeartbeatAck.Sub(s.LastHeartbeatSent)
} | go | {
"resource": ""
} |
q37525 | heartbeat | train | func (s *Session) heartbeat(wsConn *websocket.Conn, listening <-chan interface{}, heartbeatIntervalMsec time.Duration) {
s.log(LogInformational, "called")
if listening == nil || wsConn == nil {
return
}
var err error
ticker := time.NewTicker(heartbeatIntervalMsec * time.Millisecond)
defer ticker.Stop()
for... | go | {
"resource": ""
} |
q37526 | UpdateStatus | train | func (s *Session) UpdateStatus(idle int, game string) (err error) {
return s.UpdateStatusComplex(*newUpdateStatusData(idle, GameTypeGame, game, ""))
} | go | {
"resource": ""
} |
q37527 | UpdateStreamingStatus | train | func (s *Session) UpdateStreamingStatus(idle int, game string, url string) (err error) {
gameType := GameTypeGame
if url != "" {
gameType = GameTypeStreaming
}
return s.UpdateStatusComplex(*newUpdateStatusData(idle, gameType, game, url))
} | go | {
"resource": ""
} |
q37528 | UpdateListeningStatus | train | func (s *Session) UpdateListeningStatus(game string) (err error) {
return s.UpdateStatusComplex(*newUpdateStatusData(0, GameTypeListening, game, ""))
} | go | {
"resource": ""
} |
q37529 | UpdateStatusComplex | train | func (s *Session) UpdateStatusComplex(usd UpdateStatusData) (err error) {
s.RLock()
defer s.RUnlock()
if s.wsConn == nil {
return ErrWSNotFound
}
s.wsMutex.Lock()
err = s.wsConn.WriteJSON(updateStatusOp{3, usd})
s.wsMutex.Unlock()
return
} | go | {
"resource": ""
} |
q37530 | onVoiceStateUpdate | train | func (s *Session) onVoiceStateUpdate(st *VoiceStateUpdate) {
// If we don't have a connection for the channel, don't bother
if st.ChannelID == "" {
return
}
// Check if we have a voice connection to update
s.RLock()
voice, exists := s.VoiceConnections[st.GuildID]
s.RUnlock()
if !exists {
return
}
// We... | go | {
"resource": ""
} |
q37531 | onVoiceServerUpdate | train | func (s *Session) onVoiceServerUpdate(st *VoiceServerUpdate) {
s.log(LogInformational, "called")
s.RLock()
voice, exists := s.VoiceConnections[st.GuildID]
s.RUnlock()
// If no VoiceConnection exists, just skip this
if !exists {
return
}
// If currently connected to voice ws/udp, then disconnect.
// Has n... | go | {
"resource": ""
} |
q37532 | identify | train | func (s *Session) identify() error {
properties := identifyProperties{runtime.GOOS,
"Discordgo v" + VERSION,
"",
"",
"",
}
data := identifyData{s.Token,
properties,
250,
s.Compress,
nil,
}
if s.ShardCount > 1 {
if s.ShardID >= s.ShardCount {
return ErrWSShardBounds
}
data.Shard = &[2]... | go | {
"resource": ""
} |
q37533 | Applications | train | func (s *Session) Applications() (st []*Application, err error) {
body, err := s.RequestWithBucketID("GET", EndpointApplications, nil, EndpointApplications)
if err != nil {
return
}
err = unmarshal(body, &st)
return
} | go | {
"resource": ""
} |
q37534 | log | train | func (s *Session) log(msgL int, format string, a ...interface{}) {
if msgL > s.LogLevel {
return
}
msglog(msgL, 2, format, a...)
} | go | {
"resource": ""
} |
q37535 | log | train | func (v *VoiceConnection) log(msgL int, format string, a ...interface{}) {
if msgL > v.LogLevel {
return
}
msglog(msgL, 2, format, a...)
} | go | {
"resource": ""
} |
q37536 | loadSound | train | func loadSound() error {
file, err := os.Open("airhorn.dca")
if err != nil {
fmt.Println("Error opening dca file :", err)
return err
}
var opuslen int16
for {
// Read opus frame length from dca file.
err = binary.Read(file, binary.LittleEndian, &opuslen)
// If this is the end of the file, just return... | go | {
"resource": ""
} |
q37537 | playSound | train | func playSound(s *discordgo.Session, guildID, channelID string) (err error) {
// Join the provided voice channel.
vc, err := s.ChannelVoiceJoin(guildID, channelID, false, true)
if err != nil {
return err
}
// Sleep for a specified amount of time before playing the sound
time.Sleep(250 * time.Millisecond)
//... | go | {
"resource": ""
} |
q37538 | NewMessageEdit | train | func NewMessageEdit(channelID string, messageID string) *MessageEdit {
return &MessageEdit{
Channel: channelID,
ID: messageID,
}
} | go | {
"resource": ""
} |
q37539 | SetContent | train | func (m *MessageEdit) SetContent(str string) *MessageEdit {
m.Content = &str
return m
} | go | {
"resource": ""
} |
q37540 | SetEmbed | train | func (m *MessageEdit) SetEmbed(embed *MessageEmbed) *MessageEdit {
m.Embed = embed
return m
} | go | {
"resource": ""
} |
q37541 | ContentWithMentionsReplaced | train | func (m *Message) ContentWithMentionsReplaced() (content string) {
content = m.Content
for _, user := range m.Mentions {
content = strings.NewReplacer(
"<@"+user.ID+">", "@"+user.Username,
"<@!"+user.ID+">", "@"+user.Username,
).Replace(content)
}
return
} | go | {
"resource": ""
} |
q37542 | ContentWithMoreMentionsReplaced | train | func (m *Message) ContentWithMoreMentionsReplaced(s *Session) (content string, err error) {
content = m.Content
if !s.StateEnabled {
content = m.ContentWithMentionsReplaced()
return
}
channel, err := s.State.Channel(m.ChannelID)
if err != nil {
content = m.ContentWithMentionsReplaced()
return
}
for _,... | go | {
"resource": ""
} |
q37543 | UseProviders | train | func UseProviders(viders ...Provider) {
for _, provider := range viders {
providers[provider.Name()] = provider
}
} | go | {
"resource": ""
} |
q37544 | GetProvider | train | func GetProvider(name string) (Provider, error) {
provider := providers[name]
if provider == nil {
return nil, fmt.Errorf("no provider for %s exists", name)
}
return provider, nil
} | go | {
"resource": ""
} |
q37545 | ContextForClient | train | func ContextForClient(h *http.Client) context.Context {
if h == nil {
return oauth2.NoContext
}
return context.WithValue(oauth2.NoContext, oauth2.HTTPClient, h)
} | go | {
"resource": ""
} |
q37546 | HTTPClientWithFallBack | train | func HTTPClientWithFallBack(h *http.Client) *http.Client {
if h != nil {
return h
}
return http.DefaultClient
} | go | {
"resource": ""
} |
q37547 | Authorize | train | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
if p.Method == "private" {
return p.ClientKey, nil
}
accessToken, err := p.consumer.AuthorizeToken(s.RequestToken, params.Get("oauth_verifier"))
if err != nil {
return "", err
}
s.AccessTokenE... | go | {
"resource": ""
} |
q37548 | Marshal | train | func (s Session) Marshal() string {
b, _ := json.Marshal(s)
return string(b)
} | go | {
"resource": ""
} |
q37549 | New | train | func New(clientKey, secret, callbackURL string, scopes ...string) *Provider {
domain := os.Getenv(domainEnvKey)
if domain == "" {
domain = defaultDomain
}
tokenURL := fmt.Sprintf("https://%s%s", domain, tokenPath)
authURL := fmt.Sprintf("https://%s%s", domain, authPath)
userAPIEndpoint := fmt.Sprintf("https://%... | go | {
"resource": ""
} |
q37550 | RefreshToken | train | func (p *Provider) RefreshToken(refreshToken string) (*oauth2.Token, error) {
return nil, errors.New("Refresh token is not provided by influxcloud")
} | go | {
"resource": ""
} |
q37551 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
Provider: p.Name(),
}
if sess.AccessToken == nil {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", ... | go | {
"resource": ""
} |
q37552 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// data is not yet retrieved since acc... | go | {
"resource": ""
} |
q37553 | Authorize | train | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
if params.Get("openid.mode") != "id_res" {
return "", errors.New("Mode must equal to \"id_res\".")
}
if params.Get("openid.return_to") != s.CallbackURL {
return "", errors.New("The \"return_to ur... | go | {
"resource": ""
} |
q37554 | BeginAuth | train | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
c := &oauth2.Config{
Endpoint: oauth2.Endpoint{
AuthURL: "http://example.com/auth",
},
}
url := c.AuthCodeURL(state)
return &Session{
ID: "id",
AuthURL: url,
}, nil
} | go | {
"resource": ""
} |
q37555 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
UserID: sess.ID,
Name: sess.Name,
Email: sess.Email,
Provider: p.Name(),
AccessToken: sess.AccessToken,
}
if user.AccessToken == "" {
return user, fmt.Errorf("%s ca... | go | {
"resource": ""
} |
q37556 | Authorize | train | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
s.AccessToken = "access"
return s.AccessToken, nil
} | go | {
"resource": ""
} |
q37557 | New | train | func New(clientKey, secret, callbackURL string) *Provider {
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
//Method determines how you will connect to Xero.
//Options are public, private, and partner
//Use public if this is your first time.
//More details here: htt... | go | {
"resource": ""
} |
q37558 | BeginAuth | train | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
requestToken, url, err := p.consumer.GetRequestTokenAndUrl(p.CallbackURL)
if err != nil {
return nil, err
}
session := &Session{
AuthURL: url,
RequestToken: requestToken,
}
return session, err
} | go | {
"resource": ""
} |
q37559 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
Provider: p.Name(),
}
if sess.AccessToken == nil {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", ... | go | {
"resource": ""
} |
q37560 | RefreshOAuth1Token | train | func (p *Provider) RefreshOAuth1Token(session *Session) error {
newAccessToken, err := p.consumer.RefreshToken(session.AccessToken)
if err != nil {
return err
}
session.AccessToken = newAccessToken
session.AccessTokenExpires = time.Now().UTC().Add(30 * time.Minute)
return nil
} | go | {
"resource": ""
} |
q37561 | BeginAuth | train | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
authURL := p.config.AuthCodeURL(state)
return &Session{
AuthURL: authURL,
}, nil
} | go | {
"resource": ""
} |
q37562 | GetFromSession | train | func GetFromSession(key string, req *http.Request) (string, error) {
session, _ := Store.Get(req, SessionName)
value, err := getSessionValue(session, key)
if err != nil {
return "", errors.New("could not find a matching session for this request")
}
return value, nil
} | go | {
"resource": ""
} |
q37563 | New | train | func New(apiKey string, callbackURL string) *Provider {
p := &Provider{
APIKey: apiKey,
CallbackURL: callbackURL,
providerName: "steam",
}
return p
} | go | {
"resource": ""
} |
q37564 | BeginAuth | train | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
u, err := p.getAuthURL()
s := &Session{
AuthURL: u.String(),
CallbackURL: p.CallbackURL,
}
return s, err
} | go | {
"resource": ""
} |
q37565 | getAuthURL | train | func (p *Provider) getAuthURL() (*url.URL, error) {
callbackURL, err := url.Parse(p.CallbackURL)
if err != nil {
return nil, err
}
urlValues := map[string]string{
"openid.claimed_id": openIDIdentifier,
"openid.identity": openIDIdentifier,
"openid.mode": openIDMode,
"openid.ns": openIDNs,
... | go | {
"resource": ""
} |
q37566 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
s := session.(*Session)
u := goth.User{
Provider: p.Name(),
AccessToken: s.ResponseNonce,
}
if s.SteamID == "" {
// data is not yet retrieved since SteamID is still empty
return u, fmt.Errorf("%s cannot get user information without ... | go | {
"resource": ""
} |
q37567 | buildUserObject | train | func buildUserObject(r io.Reader, u goth.User) (goth.User, error) {
// Response object from Steam
apiResponse := struct {
Response struct {
Players []struct {
UserID string `json:"steamid"`
NickName string `json:"personaname"`
Name string `json:"realname"`
A... | go | {
"resource": ""
} |
q37568 | Authorize | train | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
v := url.Values{
"grant_type": {"authorization_code"},
"code": CondVal(params.Get("code")),
"redirect_uri": CondVal(p.config.RedirectURL),
"scope": CondVal(strings.Join(p.config... | go | {
"resource": ""
} |
q37569 | retrieveAuthData | train | func retrieveAuthData(p *Provider, TokenURL string, v url.Values) (map[string]map[string]interface{}, error) {
v.Set("client_id", p.ClientKey)
v.Set("client_secret", p.Secret)
req, err := http.NewRequest("POST", TokenURL, strings.NewReader(v.Encode()))
if err != nil {
return nil, err
}
req.Header.Set("Content-T... | go | {
"resource": ""
} |
q37570 | BeginAuth | train | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
var opts []oauth2.AuthCodeOption
if p.prompt != nil {
opts = append(opts, p.prompt)
}
url := p.config.AuthCodeURL(state, opts...)
session := &Session{
AuthURL: url,
}
return session, nil
} | go | {
"resource": ""
} |
q37571 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// Data is not yet retrieved, since ac... | go | {
"resource": ""
} |
q37572 | New | train | func New(clientID, clientSecret, redirectURL string, scopes ...string) *Provider {
var c = &oauth2.Config{
ClientID: clientID,
ClientSecret: clientSecret,
RedirectURL: redirectURL,
Endpoint: oauth2.Endpoint{
AuthURL: authURL,
TokenURL: tokenURL,
},
Scopes: []string{},
}
for _, scope := range... | go | {
"resource": ""
} |
q37573 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (_ goth.User, err error) {
var (
sess = session.(*Session)
user = goth.User{
AccessToken: sess.AccessToken,
RefreshToken: sess.RefreshToken,
Provider: p.Name(),
ExpiresAt: sess.ExpiresAt,
}
)
if user.AccessToken == "" {
return user, fmt.... | go | {
"resource": ""
} |
q37574 | RefreshToken | train | func (p *Provider) RefreshToken(refreshToken string) (*oauth2.Token, error) {
t := &oauth2.Token{RefreshToken: refreshToken}
ts := p.oauthConfig.TokenSource(goth.ContextForClient(p.Client()), t)
return ts.Token()
} | go | {
"resource": ""
} |
q37575 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
expiresAt := sess.ExpiresAt
if sess.IDToken == "" {
return goth.User{}, fmt.Errorf("%s cannot get user information without id_token", p.providerName)
}
// decode returned id token to get expiry
claims, err := d... | go | {
"resource": ""
} |
q37576 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// data is not yet retrieved since acc... | go | {
"resource": ""
} |
q37577 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
Provider: p.Name(),
}
if sess.AccessToken == nil {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user information without accessToken", ... | go | {
"resource": ""
} |
q37578 | Marshal | train | func (s Session) Marshal() string {
j, _ := json.Marshal(s)
return string(j)
} | go | {
"resource": ""
} |
q37579 | Authorize | train | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
sess, err := p.GetSession(params.Get("token"))
if err != nil {
return "", err
}
s.AccessToken = sess["token"]
s.Login = sess["login"]
return sess["token"], err
} | go | {
"resource": ""
} |
q37580 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
RefreshToken: sess.RefreshToken,
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// data is not yet retrieved since acc... | go | {
"resource": ""
} |
q37581 | New | train | func New(clientKey, secret, callbackURL string, resources []string, scopes ...string) *Provider {
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
providerName: "azuread",
}
p.resources = make([]string, 0, 1+len(resources))
p.resources = append(p.resources, graphAPI... | go | {
"resource": ""
} |
q37582 | BeginAuth | train | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
authURL := p.config.AuthCodeURL(state)
// Azure ad requires at least one resource
authURL += "&resource=" + url.QueryEscape(strings.Join(p.resources, " "))
return &Session{
AuthURL: authURL,
}, nil
} | go | {
"resource": ""
} |
q37583 | BeginAuth | train | func (p *Provider) BeginAuth(state string) (goth.Session, error) {
urlParams := url.Values{}
urlParams.Add("api_key", p.ClientKey)
urlParams.Add("callback", p.CallbackURL)
session := &Session{
AuthURL: authURL + "?" + urlParams.Encode(),
}
return session, nil
} | go | {
"resource": ""
} |
q37584 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s has no user inf... | go | {
"resource": ""
} |
q37585 | GetSession | train | func (p *Provider) GetSession(token string) (map[string]string, error) {
sess := struct {
Name string `xml:"name"`
Key string `xml:"key"`
Subscriber bool `xml:"subscriber"`
}{}
err := p.request(true, map[string]string{"method": "auth.getSession", "token": token}, &sess)
return map[string]strin... | go | {
"resource": ""
} |
q37586 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
ExpiresAt: sess.ExpiresAt,
Email: sess.email,
}
if user.AccessToken == "" {
return user, fmt.Errorf("%s cannot get user infor... | go | {
"resource": ""
} |
q37587 | New | train | func New(clientKey, secret, callbackURL string, scopes ...string) *Provider {
return NewCustomisedURL(clientKey, secret, callbackURL, AuthURL, TokenURL, ProfileURL, EmailURL, scopes...)
} | go | {
"resource": ""
} |
q37588 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user, fmt.Errorf("%s cannot get user... | go | {
"resource": ""
} |
q37589 | GetAuthURL | train | func (s *Session) GetAuthURL() (string, error) {
if s.AuthURL == "" {
return "", errors.New(goth.NoAuthUrlErrorMessage)
}
return s.AuthURL, nil
} | go | {
"resource": ""
} |
q37590 | Authorize | train | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
token, err := p.config.Exchange(goth.ContextForClient(p.Client()), params.Get("code"))
if err != nil {
return "", err
}
if !token.Valid() {
return "", errors.New("Invalid token received from pro... | go | {
"resource": ""
} |
q37591 | Authorize | train | func (s *Session) Authorize(provider goth.Provider, params goth.Params) (string, error) {
p := provider.(*Provider)
accessToken, err := p.consumer.AuthorizeToken(s.RequestToken, params.Get("oauth_verifier"))
if err != nil {
return "", err
}
s.AccessToken = accessToken
return accessToken.Token, err
} | go | {
"resource": ""
} |
q37592 | FetchUser | train | func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
sess := session.(*Session)
user := goth.User{
AccessToken: sess.AccessToken,
Provider: p.Name(),
ExpiresAt: sess.ExpiresAt,
}
if user.AccessToken == "" {
// data is not yet retrieved since accessToken is still empty
return user,... | go | {
"resource": ""
} |
q37593 | New | train | func New(uaaURL, clientKey, secret, callbackURL string, scopes ...string) *Provider {
uaaURL = strings.TrimSuffix(uaaURL, "/")
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
AuthURL: uaaURL + "/oauth/authorize",
TokenURL: uaaURL + "/oauth/token",
UserInf... | go | {
"resource": ""
} |
q37594 | New | train | func New(clientKey, secret, callbackURL string) *Provider {
p := &Provider{
ClientKey: clientKey,
Secret: secret,
CallbackURL: callbackURL,
providerName: "naver",
}
p.config = newConfig(p)
return p
} | go | {
"resource": ""
} |
q37595 | New | train | func New(clientKey, secret, callbackURL string, scopes ...string) *Provider {
paypalEnv := os.Getenv(envKey)
authURL := authURLProduction
tokenURL := tokenURLProduction
profileEndPoint := endpointProfileProduction
if paypalEnv == sandbox {
authURL = authURLSandbox
tokenURL = tokenURLSandbox
profileEndPoint... | go | {
"resource": ""
} |
q37596 | setStatus | train | func setStatus(fd syscall.Handle, status bool) error {
var bytesReturned uint32
rdbbuf := make([]byte, syscall.MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
code := []byte{0x00, 0x00, 0x00, 0x00}
if status {
code[0] = 0x01
}
return syscall.DeviceIoControl(fd, tap_ioctl_set_media_status, &code[0], uint32(4), &rdbbuf[0], uin... | go | {
"resource": ""
} |
q37597 | setTUN | train | func setTUN(fd syscall.Handle, network string) error {
var bytesReturned uint32
rdbbuf := make([]byte, syscall.MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
localIP, remoteNet, err := net.ParseCIDR(network)
if err != nil {
return fmt.Errorf("Failed to parse network CIDR in config, %v", err)
}
if localIP.To4() == nil {
r... | go | {
"resource": ""
} |
q37598 | openDev | train | func openDev(config Config) (ifce *Interface, err error) {
// find the device in registry.
deviceid, err := getdeviceid(config.PlatformSpecificParams.ComponentID, config.PlatformSpecificParams.InterfaceName)
if err != nil {
return nil, err
}
path := "\\\\.\\Global\\" + deviceid + ".tap"
pathp, err := syscall.UT... | go | {
"resource": ""
} |
q37599 | SetMaxPoolSize | train | func (hd *halfDuplexSocketTransport) SetMaxPoolSize(size int) {
if size > 0 {
pool := make(chan *halfDuplexConnEntry, size)
for i := 0; i < len(hd.connPool); i++ {
select {
case pool <- <-hd.connPool:
default:
}
}
hd.connPool = pool
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.