_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q6300
|
cacheNode
|
train
|
func (ndb *nodeDB) cacheNode(node *Node) {
elem := ndb.nodeCacheQueue.PushBack(node)
ndb.nodeCache[string(node.hash)] = elem
if ndb.nodeCacheQueue.Len() > ndb.nodeCacheSize {
oldest := ndb.nodeCacheQueue.Front()
hash := ndb.nodeCacheQueue.Remove(oldest).(*Node).hash
delete(ndb.nodeCache, string(hash))
}
}
|
go
|
{
"resource": ""
}
|
q6301
|
Commit
|
train
|
func (ndb *nodeDB) Commit() {
ndb.mtx.Lock()
defer ndb.mtx.Unlock()
ndb.batch.Write()
ndb.batch.Close()
ndb.batch = ndb.db.NewBatch()
}
|
go
|
{
"resource": ""
}
|
q6302
|
SaveRoot
|
train
|
func (ndb *nodeDB) SaveRoot(root *Node, version int64) error {
if len(root.hash) == 0 {
panic("Hash should not be empty")
}
return ndb.saveRoot(root.hash, version)
}
|
go
|
{
"resource": ""
}
|
q6303
|
SaveEmptyRoot
|
train
|
func (ndb *nodeDB) SaveEmptyRoot(version int64) error {
return ndb.saveRoot([]byte{}, version)
}
|
go
|
{
"resource": ""
}
|
q6304
|
Find
|
train
|
func Find(top *html.Node, expr string) []*html.Node {
exp, err := xpath.Compile(expr)
if err != nil {
panic(err)
}
var elems []*html.Node
t := exp.Select(CreateXPathNavigator(top))
for t.MoveNext() {
nav := t.Current().(*NodeNavigator)
n := getCurrentNode(nav)
// avoid adding duplicate nodes.
if len(elems) > 0 && (elems[0] == n || (nav.NodeType() == xpath.AttributeNode &&
nav.LocalName() == elems[0].Data && nav.Value() == InnerText(elems[0]))) {
continue
}
elems = append(elems, n)
}
return elems
}
|
go
|
{
"resource": ""
}
|
q6305
|
LoadURL
|
train
|
func LoadURL(url string) (*html.Node, error) {
resp, err := http.Get(url)
if err != nil {
return nil, err
}
defer resp.Body.Close()
r, err := charset.NewReader(resp.Body, resp.Header.Get("Content-Type"))
if err != nil {
return nil, err
}
return html.Parse(r)
}
|
go
|
{
"resource": ""
}
|
q6306
|
Parse
|
train
|
func Parse(r io.Reader) (*html.Node, error) {
return html.Parse(r)
}
|
go
|
{
"resource": ""
}
|
q6307
|
InnerText
|
train
|
func InnerText(n *html.Node) string {
var output func(*bytes.Buffer, *html.Node)
output = func(buf *bytes.Buffer, n *html.Node) {
switch n.Type {
case html.TextNode:
buf.WriteString(n.Data)
return
case html.CommentNode:
return
}
for child := n.FirstChild; child != nil; child = child.NextSibling {
output(buf, child)
}
}
var buf bytes.Buffer
output(&buf, n)
return buf.String()
}
|
go
|
{
"resource": ""
}
|
q6308
|
OutputHTML
|
train
|
func OutputHTML(n *html.Node, self bool) string {
var buf bytes.Buffer
if self {
html.Render(&buf, n)
} else {
for n := n.FirstChild; n != nil; n = n.NextSibling {
html.Render(&buf, n)
}
}
return buf.String()
}
|
go
|
{
"resource": ""
}
|
q6309
|
GetOrganization
|
train
|
func (c *Client) GetOrganization(orgID string, args Arguments) (organization *Organization, err error) {
path := fmt.Sprintf("organizations/%s", orgID)
err = c.Get(path, args, &organization)
if organization != nil {
organization.client = c
}
return
}
|
go
|
{
"resource": ""
}
|
q6310
|
GetToken
|
train
|
func (c *Client) GetToken(tokenID string, args Arguments) (token *Token, err error) {
path := fmt.Sprintf("tokens/%s", tokenID)
err = c.Get(path, args, &token)
if token != nil {
token.client = c
}
return
}
|
go
|
{
"resource": ""
}
|
q6311
|
FirstCardCreateAction
|
train
|
func (c ActionCollection) FirstCardCreateAction() *Action {
sort.Sort(c)
for _, action := range c {
if action.DidCreateCard() {
return action
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q6312
|
FilterToCardCreationActions
|
train
|
func (c ActionCollection) FilterToCardCreationActions() ActionCollection {
newSlice := make(ActionCollection, 0, len(c))
for _, action := range c {
if action.DidCreateCard() {
newSlice = append(newSlice, action)
}
}
return newSlice
}
|
go
|
{
"resource": ""
}
|
q6313
|
FilterToListChangeActions
|
train
|
func (c ActionCollection) FilterToListChangeActions() ActionCollection {
newSlice := make(ActionCollection, 0, len(c))
for _, action := range c {
if action.DidChangeListForCard() {
newSlice = append(newSlice, action)
}
}
return newSlice
}
|
go
|
{
"resource": ""
}
|
q6314
|
FilterToCardMembershipChangeActions
|
train
|
func (c ActionCollection) FilterToCardMembershipChangeActions() ActionCollection {
newSlice := make(ActionCollection, 0, len(c))
for _, action := range c {
if action.DidChangeCardMembership() || action.DidArchiveCard() || action.DidUnarchiveCard() {
newSlice = append(newSlice, action)
}
}
return newSlice
}
|
go
|
{
"resource": ""
}
|
q6315
|
GetMember
|
train
|
func (c *Client) GetMember(memberID string, args Arguments) (member *Member, err error) {
path := fmt.Sprintf("members/%s", memberID)
err = c.Get(path, args, &member)
if err == nil {
member.client = c
}
return
}
|
go
|
{
"resource": ""
}
|
q6316
|
GetMembers
|
train
|
func (o *Organization) GetMembers(args Arguments) (members []*Member, err error) {
path := fmt.Sprintf("organizations/%s/members", o.ID)
err = o.client.Get(path, args, &members)
for i := range members {
members[i].client = o.client
}
return
}
|
go
|
{
"resource": ""
}
|
q6317
|
GetMembers
|
train
|
func (b *Board) GetMembers(args Arguments) (members []*Member, err error) {
path := fmt.Sprintf("boards/%s/members", b.ID)
err = b.client.Get(path, args, &members)
for i := range members {
members[i].client = b.client
}
return
}
|
go
|
{
"resource": ""
}
|
q6318
|
GetMembers
|
train
|
func (c *Card) GetMembers(args Arguments) (members []*Member, err error) {
path := fmt.Sprintf("cards/%s/members", c.ID)
err = c.client.Get(path, args, &members)
for i := range members {
members[i].client = c.client
}
return
}
|
go
|
{
"resource": ""
}
|
q6319
|
GetCustomField
|
train
|
func (c *Client) GetCustomField(fieldID string, args Arguments) (customField *CustomField, err error) {
path := fmt.Sprintf("customFields/%s", fieldID)
err = c.Get(path, args, &customField)
return
}
|
go
|
{
"resource": ""
}
|
q6320
|
GetCustomFields
|
train
|
func (b *Board) GetCustomFields(args Arguments) (customFields []*CustomField, err error) {
path := fmt.Sprintf("boards/%s/customFields", b.ID)
err = b.client.Get(path, args, &customFields)
return
}
|
go
|
{
"resource": ""
}
|
q6321
|
Less
|
train
|
func (durs ByFirstEntered) Less(i, j int) bool {
return durs[i].FirstEntered.Before(durs[j].FirstEntered)
}
|
go
|
{
"resource": ""
}
|
q6322
|
GetMemberDurations
|
train
|
func (c *Card) GetMemberDurations() (durations []*MemberDuration, err error) {
var actions ActionCollection
if len(c.Actions) == 0 {
c.client.log("[trello] GetMemberDurations() called on card '%s' without any Card.Actions. Fetching fresh.", c.ID)
actions, err = c.GetMembershipChangeActions()
if err != nil {
err = errors.Wrap(err, "GetMembershipChangeActions() call failed.")
return
}
} else {
actions = c.Actions.FilterToCardMembershipChangeActions()
}
return actions.GetMemberDurations()
}
|
go
|
{
"resource": ""
}
|
q6323
|
NewBoard
|
train
|
func NewBoard(name string) Board {
b := Board{Name: name}
// default values in line with API POST
b.Prefs.SelfJoin = true
b.Prefs.CardCovers = true
return b
}
|
go
|
{
"resource": ""
}
|
q6324
|
CreatedAt
|
train
|
func (b *Board) CreatedAt() time.Time {
t, _ := IDToTime(b.ID)
return t
}
|
go
|
{
"resource": ""
}
|
q6325
|
Delete
|
train
|
func (b *Board) Delete(extraArgs Arguments) error {
path := fmt.Sprintf("boards/%s", b.ID)
return b.client.Delete(path, Arguments{}, b)
}
|
go
|
{
"resource": ""
}
|
q6326
|
GetBoard
|
train
|
func (c *Client) GetBoard(boardID string, args Arguments) (board *Board, err error) {
path := fmt.Sprintf("boards/%s", boardID)
err = c.Get(path, args, &board)
if board != nil {
board.client = c
}
return
}
|
go
|
{
"resource": ""
}
|
q6327
|
GetMyBoards
|
train
|
func (c *Client) GetMyBoards(args Arguments) (boards []*Board, err error) {
path := "members/me/boards"
err = c.Get(path, args, &boards)
for i := range boards {
boards[i].client = c
}
return
}
|
go
|
{
"resource": ""
}
|
q6328
|
GetBoards
|
train
|
func (m *Member) GetBoards(args Arguments) (boards []*Board, err error) {
path := fmt.Sprintf("members/%s/boards", m.ID)
err = m.client.Get(path, args, &boards)
for i := range boards {
boards[i].client = m.client
}
return
}
|
go
|
{
"resource": ""
}
|
q6329
|
NewClient
|
train
|
func NewClient(key, token string) *Client {
return &Client{
Client: http.DefaultClient,
BaseURL: DefaultBaseURL,
Key: key,
Token: token,
throttle: time.Tick(time.Second / 8), // Actually 10/second, but we're extra cautious
testMode: false,
ctx: context.Background(),
}
}
|
go
|
{
"resource": ""
}
|
q6330
|
WithContext
|
train
|
func (c *Client) WithContext(ctx context.Context) *Client {
newC := *c
newC.ctx = ctx
return &newC
}
|
go
|
{
"resource": ""
}
|
q6331
|
GetMyNotifications
|
train
|
func (c *Client) GetMyNotifications(args Arguments) (notifications []*Notification, err error) {
path := "members/me/notifications"
err = c.Get(path, args, ¬ifications)
for i := range notifications {
notifications[i].client = c
}
return
}
|
go
|
{
"resource": ""
}
|
q6332
|
CreateWebhook
|
train
|
func (c *Client) CreateWebhook(webhook *Webhook) error {
path := "webhooks"
args := Arguments{"idModel": webhook.IDModel, "description": webhook.Description, "callbackURL": webhook.CallbackURL}
err := c.Post(path, args, webhook)
if err == nil {
webhook.client = c
}
return err
}
|
go
|
{
"resource": ""
}
|
q6333
|
GetWebhook
|
train
|
func (c *Client) GetWebhook(webhookID string, args Arguments) (webhook *Webhook, err error) {
path := fmt.Sprintf("webhooks/%s", webhookID)
err = c.Get(path, args, &webhook)
if webhook != nil {
webhook.client = c
}
return
}
|
go
|
{
"resource": ""
}
|
q6334
|
GetWebhooks
|
train
|
func (t *Token) GetWebhooks(args Arguments) (webhooks []*Webhook, err error) {
path := fmt.Sprintf("tokens/%s/webhooks", t.ID)
err = t.client.Get(path, args, &webhooks)
return
}
|
go
|
{
"resource": ""
}
|
q6335
|
GetBoardWebhookRequest
|
train
|
func GetBoardWebhookRequest(r *http.Request) (whr *BoardWebhookRequest, err error) {
if r.Method == "HEAD" {
return &BoardWebhookRequest{}, nil
}
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&whr)
if err != nil {
err = errors.Wrapf(err, "GetBoardWebhookRequest() failed to decode '%s'.", r.URL)
}
return
}
|
go
|
{
"resource": ""
}
|
q6336
|
CreatedAt
|
train
|
func (c *Card) CreatedAt() time.Time {
t, _ := IDToTime(c.ID)
return t
}
|
go
|
{
"resource": ""
}
|
q6337
|
CustomFields
|
train
|
func (c *Card) CustomFields(boardCustomFields []*CustomField) map[string]interface{} {
cfm := c.customFieldMap
if cfm == nil {
cfm = &(map[string]interface{}{})
// bcfOptionNames[CustomField ID] = Custom Field Name
bcfOptionNames := map[string]string{}
// bcfOptionsMap[CustomField ID][ID of the option] = Value of the option
bcfOptionsMap := map[string]map[string]interface{}{}
for _, bcf := range boardCustomFields {
bcfOptionNames[bcf.ID] = bcf.Name
for _, cf := range bcf.Options {
// create 2nd level map when not available yet
map2, ok := bcfOptionsMap[cf.IDCustomField]
if !ok {
map2 = map[string]interface{}{}
bcfOptionsMap[bcf.ID] = map2
}
bcfOptionsMap[bcf.ID][cf.ID] = cf.Value.Text
}
}
for _, cf := range c.CustomFieldItems {
name := bcfOptionNames[cf.IDCustomField]
// create 2nd level map when not available yet
map2, ok := bcfOptionsMap[cf.IDCustomField]
if !ok {
continue
}
value, ok := map2[cf.IDValue]
if ok {
(*cfm)[name] = value
}
}
c.customFieldMap = cfm
}
return *cfm
}
|
go
|
{
"resource": ""
}
|
q6338
|
MoveToList
|
train
|
func (c *Card) MoveToList(listID string, args Arguments) error {
path := fmt.Sprintf("cards/%s", c.ID)
args["idList"] = listID
return c.client.Put(path, args, &c)
}
|
go
|
{
"resource": ""
}
|
q6339
|
SetPos
|
train
|
func (c *Card) SetPos(newPos float64) error {
path := fmt.Sprintf("cards/%s", c.ID)
return c.client.Put(path, Arguments{"pos": fmt.Sprintf("%f", newPos)}, c)
}
|
go
|
{
"resource": ""
}
|
q6340
|
RemoveMember
|
train
|
func (c *Card) RemoveMember(memberID string) error {
path := fmt.Sprintf("cards/%s/idMembers/%s", c.ID, memberID)
return c.client.Delete(path, Defaults(), nil)
}
|
go
|
{
"resource": ""
}
|
q6341
|
AddMemberID
|
train
|
func (c *Card) AddMemberID(memberID string) (member []*Member, err error) {
path := fmt.Sprintf("cards/%s/idMembers", c.ID)
err = c.client.Post(path, Arguments{"value": memberID}, &member)
return member, err
}
|
go
|
{
"resource": ""
}
|
q6342
|
RemoveIDLabel
|
train
|
func (c *Card) RemoveIDLabel(labelID string, label *Label) error {
path := fmt.Sprintf("cards/%s/idLabels/%s", c.ID, labelID)
return c.client.Delete(path, Defaults(), label)
}
|
go
|
{
"resource": ""
}
|
q6343
|
AddIDLabel
|
train
|
func (c *Card) AddIDLabel(labelID string) error {
path := fmt.Sprintf("cards/%s/idLabels", c.ID)
err := c.client.Post(path, Arguments{"value": labelID}, &c.IDLabels)
return err
}
|
go
|
{
"resource": ""
}
|
q6344
|
MoveToTopOfList
|
train
|
func (c *Card) MoveToTopOfList() error {
path := fmt.Sprintf("cards/%s", c.ID)
return c.client.Put(path, Arguments{"pos": "top"}, c)
}
|
go
|
{
"resource": ""
}
|
q6345
|
Update
|
train
|
func (c *Card) Update(args Arguments) error {
path := fmt.Sprintf("cards/%s", c.ID)
return c.client.Put(path, args, c)
}
|
go
|
{
"resource": ""
}
|
q6346
|
CreateCard
|
train
|
func (c *Client) CreateCard(card *Card, extraArgs Arguments) error {
path := "cards"
args := Arguments{
"name": card.Name,
"desc": card.Desc,
"pos": strconv.FormatFloat(card.Pos, 'g', -1, 64),
"idList": card.IDList,
"idMembers": strings.Join(card.IDMembers, ","),
"idLabels": strings.Join(card.IDLabels, ","),
}
if card.Due != nil {
args["due"] = card.Due.Format(time.RFC3339)
}
// Allow overriding the creation position with 'top' or 'botttom'
if pos, ok := extraArgs["pos"]; ok {
args["pos"] = pos
}
err := c.Post(path, args, &card)
if err == nil {
card.client = c
}
return err
}
|
go
|
{
"resource": ""
}
|
q6347
|
AddCard
|
train
|
func (l *List) AddCard(card *Card, extraArgs Arguments) error {
path := fmt.Sprintf("lists/%s/cards", l.ID)
args := Arguments{
"name": card.Name,
"desc": card.Desc,
"idMembers": strings.Join(card.IDMembers, ","),
"idLabels": strings.Join(card.IDLabels, ","),
}
if card.Due != nil {
args["due"] = card.Due.Format(time.RFC3339)
}
// Allow overwriting the creation position with 'top' or 'bottom'
if pos, ok := extraArgs["pos"]; ok {
args["pos"] = pos
}
err := l.client.Post(path, args, &card)
if err == nil {
card.client = l.client
} else {
err = errors.Wrapf(err, "Error adding card to list %s", l.ID)
}
return err
}
|
go
|
{
"resource": ""
}
|
q6348
|
AddComment
|
train
|
func (c *Card) AddComment(comment string, args Arguments) (*Action, error) {
path := fmt.Sprintf("cards/%s/actions/comments", c.ID)
args["text"] = comment
action := Action{}
err := c.client.Post(path, args, &action)
if err != nil {
err = errors.Wrapf(err, "Error commenting on card %s", c.ID)
}
return &action, err
}
|
go
|
{
"resource": ""
}
|
q6349
|
AddURLAttachment
|
train
|
func (c *Card) AddURLAttachment(attachment *Attachment) error {
path := fmt.Sprintf("cards/%s/attachments", c.ID)
args := Arguments{
"url": attachment.URL,
"name": attachment.Name,
}
err := c.client.Post(path, args, &attachment)
if err != nil {
err = errors.Wrapf(err, "Error adding attachment to card %s", c.ID)
}
return err
}
|
go
|
{
"resource": ""
}
|
q6350
|
GetParentCard
|
train
|
func (c *Card) GetParentCard(args Arguments) (*Card, error) {
// Hopefully the card came pre-loaded with Actions including the card creation
action := c.Actions.FirstCardCreateAction()
if action == nil {
// No luck. Go get copyCard actions for this card.
c.client.log("Creation action wasn't supplied before GetParentCard() on '%s'. Getting copyCard actions.", c.ID)
actions, err := c.GetActions(Arguments{"filter": "copyCard"})
if err != nil {
err = errors.Wrapf(err, "GetParentCard() failed to GetActions() for card '%s'", c.ID)
return nil, err
}
action = actions.FirstCardCreateAction()
}
if action != nil && action.Data != nil && action.Data.CardSource != nil {
card, err := c.client.GetCard(action.Data.CardSource.ID, args)
return card, err
}
return nil, nil
}
|
go
|
{
"resource": ""
}
|
q6351
|
GetAncestorCards
|
train
|
func (c *Card) GetAncestorCards(args Arguments) (ancestors []*Card, err error) {
// Get the first parent
parent, err := c.GetParentCard(args)
if IsNotFound(err) || IsPermissionDenied(err) {
c.client.log("[trello] Can't get details about the parent of card '%s' due to lack of permissions or card deleted.", c.ID)
return ancestors, nil
}
for parent != nil {
ancestors = append(ancestors, parent)
parent, err = parent.GetParentCard(args)
if IsNotFound(err) || IsPermissionDenied(err) {
c.client.log("[trello] Can't get details about the parent of card '%s' due to lack of permissions or card deleted.", c.ID)
return ancestors, nil
} else if err != nil {
return ancestors, err
}
}
return ancestors, err
}
|
go
|
{
"resource": ""
}
|
q6352
|
GetOriginatingCard
|
train
|
func (c *Card) GetOriginatingCard(args Arguments) (*Card, error) {
ancestors, err := c.GetAncestorCards(args)
if err != nil {
return c, err
}
if len(ancestors) > 0 {
return ancestors[len(ancestors)-1], nil
}
return c, nil
}
|
go
|
{
"resource": ""
}
|
q6353
|
CreatorMember
|
train
|
func (c *Card) CreatorMember() (*Member, error) {
var actions ActionCollection
var err error
if len(c.Actions) == 0 {
c.Actions, err = c.GetActions(Arguments{"filter": "all", "limit": "1000", "memberCreator_fields": "all"})
if err != nil {
err = errors.Wrapf(err, "GetActions() call failed.")
return nil, err
}
}
actions = c.Actions.FilterToCardCreationActions()
if len(actions) > 0 {
return actions[0].MemberCreator, nil
}
return nil, errors.Errorf("No card creation actions on Card %s with a .MemberCreator", c.ID)
}
|
go
|
{
"resource": ""
}
|
q6354
|
CreatorMemberID
|
train
|
func (c *Card) CreatorMemberID() (string, error) {
var actions ActionCollection
var err error
if len(c.Actions) == 0 {
c.client.log("[trello] CreatorMemberID() called on card '%s' without any Card.Actions. Fetching fresh.", c.ID)
c.Actions, err = c.GetActions(Defaults())
if err != nil {
err = errors.Wrapf(err, "GetActions() call failed.")
}
}
actions = c.Actions.FilterToCardCreationActions()
if len(actions) > 0 {
if actions[0].IDMemberCreator != "" {
return actions[0].IDMemberCreator, err
}
}
return "", errors.Wrapf(err, "No Actions on card '%s' could be used to find its creator.", c.ID)
}
|
go
|
{
"resource": ""
}
|
q6355
|
ContainsCopyOfCard
|
train
|
func (b *Board) ContainsCopyOfCard(cardID string, args Arguments) (bool, error) {
args["filter"] = "copyCard"
actions, err := b.GetActions(args)
if err != nil {
err := errors.Wrapf(err, "GetCards() failed inside ContainsCopyOf() for board '%s' and card '%s'.", b.ID, cardID)
return false, err
}
for _, action := range actions {
if action.Data != nil && action.Data.CardSource != nil && action.Data.CardSource.ID == cardID {
return true, nil
}
}
return false, nil
}
|
go
|
{
"resource": ""
}
|
q6356
|
GetCard
|
train
|
func (c *Client) GetCard(cardID string, args Arguments) (card *Card, err error) {
path := fmt.Sprintf("cards/%s", cardID)
err = c.Get(path, args, &card)
if card != nil {
card.client = c
}
return card, err
}
|
go
|
{
"resource": ""
}
|
q6357
|
GetCards
|
train
|
func (b *Board) GetCards(args Arguments) (cards []*Card, err error) {
path := fmt.Sprintf("boards/%s/cards", b.ID)
err = b.client.Get(path, args, &cards)
// Naive implementation would return here. To make sure we get all
// cards, we begin
if len(cards) > 0 {
moreCards := true
for moreCards == true {
nextCardBatch := make([]*Card, 0)
args["before"] = earliestCardID(cards)
err = b.client.Get(path, args, &nextCardBatch)
if len(nextCardBatch) > 0 {
cards = append(cards, nextCardBatch...)
} else {
moreCards = false
}
}
}
for i := range cards {
cards[i].client = b.client
}
return
}
|
go
|
{
"resource": ""
}
|
q6358
|
GetCards
|
train
|
func (l *List) GetCards(args Arguments) (cards []*Card, err error) {
path := fmt.Sprintf("lists/%s/cards", l.ID)
err = l.client.Get(path, args, &cards)
for i := range cards {
cards[i].client = l.client
}
return
}
|
go
|
{
"resource": ""
}
|
q6359
|
GetLabels
|
train
|
func (b *Board) GetLabels(args Arguments) (labels []*Label, err error) {
path := fmt.Sprintf("boards/%s/labels", b.ID)
err = b.client.Get(path, args, &labels)
return
}
|
go
|
{
"resource": ""
}
|
q6360
|
ToURLValues
|
train
|
func (args Arguments) ToURLValues() url.Values {
v := url.Values{}
for key, value := range args {
v.Set(key, value)
}
return v
}
|
go
|
{
"resource": ""
}
|
q6361
|
GetActions
|
train
|
func (b *Board) GetActions(args Arguments) (actions ActionCollection, err error) {
path := fmt.Sprintf("boards/%s/actions", b.ID)
err = b.client.Get(path, args, &actions)
return
}
|
go
|
{
"resource": ""
}
|
q6362
|
GetActions
|
train
|
func (l *List) GetActions(args Arguments) (actions ActionCollection, err error) {
path := fmt.Sprintf("lists/%s/actions", l.ID)
err = l.client.Get(path, args, &actions)
return
}
|
go
|
{
"resource": ""
}
|
q6363
|
GetActions
|
train
|
func (c *Card) GetActions(args Arguments) (actions ActionCollection, err error) {
path := fmt.Sprintf("cards/%s/actions", c.ID)
err = c.client.Get(path, args, &actions)
return
}
|
go
|
{
"resource": ""
}
|
q6364
|
GetMembershipChangeActions
|
train
|
func (c *Card) GetMembershipChangeActions() (actions ActionCollection, err error) {
// We include updateCard:closed as if the member is implicitly removed from the card when it's closed.
// This allows us to "close out" the duration length.
return c.GetActions(Arguments{"filter": "addMemberToCard,removeMemberFromCard,updateCard:closed"})
}
|
go
|
{
"resource": ""
}
|
q6365
|
DidArchiveCard
|
train
|
func (a *Action) DidArchiveCard() bool {
return (a.Type == "updateCard") && a.Data != nil && a.Data.Card != nil && a.Data.Card.Closed
}
|
go
|
{
"resource": ""
}
|
q6366
|
DidUnarchiveCard
|
train
|
func (a *Action) DidUnarchiveCard() bool {
return (a.Type == "updateCard") && a.Data != nil && a.Data.Old != nil && a.Data.Old.Closed
}
|
go
|
{
"resource": ""
}
|
q6367
|
SearchCards
|
train
|
func (c *Client) SearchCards(query string, args Arguments) (cards []*Card, err error) {
args["query"] = query
args["modelTypes"] = "cards"
res := SearchResult{}
err = c.Get("search", args, &res)
cards = res.Cards
return
}
|
go
|
{
"resource": ""
}
|
q6368
|
SearchBoards
|
train
|
func (c *Client) SearchBoards(query string, args Arguments) (boards []*Board, err error) {
args["query"] = query
args["modelTypes"] = "boards"
res := SearchResult{}
err = c.Get("search", args, &res)
boards = res.Boards
for _, board := range boards {
board.client = c
}
return
}
|
go
|
{
"resource": ""
}
|
q6369
|
SearchMembers
|
train
|
func (c *Client) SearchMembers(query string, args Arguments) (members []*Member, err error) {
args["query"] = query
err = c.Get("search/members", args, &members)
return
}
|
go
|
{
"resource": ""
}
|
q6370
|
IsRateLimit
|
train
|
func IsRateLimit(err error) bool {
re, ok := err.(rateLimitError)
return ok && re.IsRateLimit()
}
|
go
|
{
"resource": ""
}
|
q6371
|
IsNotFound
|
train
|
func IsNotFound(err error) bool {
nf, ok := err.(notFoundError)
return ok && nf.IsNotFound()
}
|
go
|
{
"resource": ""
}
|
q6372
|
IsPermissionDenied
|
train
|
func IsPermissionDenied(err error) bool {
pd, ok := err.(permissionDeniedError)
return ok && pd.IsPermissionDenied()
}
|
go
|
{
"resource": ""
}
|
q6373
|
CreatedAt
|
train
|
func (l *List) CreatedAt() time.Time {
t, _ := IDToTime(l.ID)
return t
}
|
go
|
{
"resource": ""
}
|
q6374
|
GetList
|
train
|
func (c *Client) GetList(listID string, args Arguments) (list *List, err error) {
path := fmt.Sprintf("lists/%s", listID)
err = c.Get(path, args, &list)
if list != nil {
list.client = c
for i := range list.Cards {
list.Cards[i].client = c
}
}
return
}
|
go
|
{
"resource": ""
}
|
q6375
|
GetLists
|
train
|
func (b *Board) GetLists(args Arguments) (lists []*List, err error) {
path := fmt.Sprintf("boards/%s/lists", b.ID)
err = b.client.Get(path, args, &lists)
for i := range lists {
lists[i].client = b.client
for j := range lists[i].Cards {
lists[i].Cards[j].client = b.client
}
}
return
}
|
go
|
{
"resource": ""
}
|
q6376
|
IDToTime
|
train
|
func IDToTime(id string) (t time.Time, err error) {
if id == "" {
return time.Time{}, nil
}
// The first 8 characters in the object ID are a Unix timestamp
ts, err := strconv.ParseUint(id[:8], 16, 64)
if err != nil {
err = errors.Wrapf(err, "ID '%s' failed to convert to timestamp.", id)
} else {
t = time.Unix(int64(ts), 0)
}
return
}
|
go
|
{
"resource": ""
}
|
q6377
|
AddDuration
|
train
|
func (l *ListDuration) AddDuration(d time.Duration) {
l.Duration = l.Duration + d
l.TimesInList++
}
|
go
|
{
"resource": ""
}
|
q6378
|
GetListDurations
|
train
|
func (c *Card) GetListDurations() (durations []*ListDuration, err error) {
var actions ActionCollection
if len(c.Actions) == 0 {
// Get all actions which affected the Card's List
c.client.log("[trello] GetListDurations() called on card '%s' without any Card.Actions. Fetching fresh.", c.ID)
actions, err = c.GetListChangeActions()
if err != nil {
err = errors.Wrap(err, "GetListChangeActions() call failed.")
return
}
} else {
actions = c.Actions.FilterToListChangeActions()
}
return actions.GetListDurations()
}
|
go
|
{
"resource": ""
}
|
q6379
|
GetListDurations
|
train
|
func (actions ActionCollection) GetListDurations() (durations []*ListDuration, err error) {
sort.Sort(actions)
var prevTime time.Time
var prevList *List
durs := make(map[string]*ListDuration)
for _, action := range actions {
if action.DidChangeListForCard() {
if prevList != nil {
duration := action.Date.Sub(prevTime)
_, durExists := durs[prevList.ID]
if !durExists {
durs[prevList.ID] = &ListDuration{ListID: prevList.ID, ListName: prevList.Name, Duration: duration, TimesInList: 1, FirstEntered: prevTime}
} else {
durs[prevList.ID].AddDuration(duration)
}
}
prevList = ListAfterAction(action)
prevTime = action.Date
}
}
if prevList != nil {
duration := time.Now().Sub(prevTime)
_, durExists := durs[prevList.ID]
if !durExists {
durs[prevList.ID] = &ListDuration{ListID: prevList.ID, ListName: prevList.Name, Duration: duration, TimesInList: 1, FirstEntered: prevTime}
} else {
durs[prevList.ID].AddDuration(duration)
}
}
durations = make([]*ListDuration, 0, len(durs))
for _, ld := range durs {
durations = append(durations, ld)
}
sort.Sort(ByFirstEntered(durations))
return durations, nil
}
|
go
|
{
"resource": ""
}
|
q6380
|
DefaultAlertConfig
|
train
|
func DefaultAlertConfig() *ConsulAlertConfig {
checks := &ChecksConfig{
Enabled: true,
ChangeThreshold: 60,
}
events := &EventsConfig{
Enabled: true,
Handlers: []string{},
}
email := ¬ifier.EmailNotifier{
ClusterName: "Consul-Alerts",
Enabled: false,
SenderAlias: "Consul Alerts",
Receivers: []string{},
}
log := ¬ifier.LogNotifier{
Enabled: true,
Path: "/tmp/consul-notifications.log",
}
influxdb := ¬ifier.InfluxdbNotifier{
Enabled: false,
SeriesName: "consul-alerts",
}
slack := ¬ifier.SlackNotifier{
Enabled: false,
ClusterName: "Consul-Alerts",
}
mattermost := ¬ifier.MattermostNotifier{
Enabled: false,
ClusterName: "Consul-Alerts",
}
mattermostWebhook := ¬ifier.MattermostWebhookNotifier{
Enabled: false,
ClusterName: "Consul-Alerts",
}
pagerduty := ¬ifier.PagerDutyNotifier{
Enabled: false,
}
hipchat := ¬ifier.HipChatNotifier{
Enabled: false,
ClusterName: "Consul-Alerts",
}
opsgenie := ¬ifier.OpsGenieNotifier{
Enabled: false,
ClusterName: "Consul-Alerts",
}
awsSns := ¬ifier.AwsSnsNotifier{
Enabled: false,
ClusterName: "Consul-Alerts",
}
victorOps := ¬ifier.VictorOpsNotifier{
Enabled: false,
}
ilert := ¬ifier.ILertNotifier{
Enabled: false,
IncidentKeyTemplate: "{{.Node}}:{{.Service}}:{{.Check}}",
}
notifiers := ¬ifier.Notifiers{
Email: email,
Log: log,
Influxdb: influxdb,
Slack: slack,
Mattermost: mattermost,
MattermostWebhook: mattermostWebhook,
PagerDuty: pagerduty,
HipChat: hipchat,
OpsGenie: opsgenie,
AwsSns: awsSns,
VictorOps: victorOps,
ILert: ilert,
Custom: []string{},
}
return &ConsulAlertConfig{
Checks: checks,
Events: events,
Notifiers: notifiers,
}
}
|
go
|
{
"resource": ""
}
|
q6381
|
sendEvent
|
train
|
func (il *ILertNotifier) sendEvent(event iLertEvent) error {
body, err := json.Marshal(event)
if err != nil {
return err
}
res, err := http.Post(apiEndpoint, "application/json", bytes.NewBuffer(body))
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode != 200 {
body, _ := ioutil.ReadAll(res.Body)
return errors.New(fmt.Sprintf("Unexpected HTTP status code: %d (%s)", res.StatusCode, string(body)))
}
return nil
}
|
go
|
{
"resource": ""
}
|
q6382
|
GetReminders
|
train
|
func (c *ConsulAlertClient) GetReminders() []notifier.Message {
remindersList, _, _ := c.api.KV().List("consul-alerts/reminders", nil)
var messages []notifier.Message
for _, kvpair := range remindersList {
var message notifier.Message
json.Unmarshal(kvpair.Value, &message)
messages = append(messages, message)
}
log.Println("Getting reminders")
return messages
}
|
go
|
{
"resource": ""
}
|
q6383
|
SetReminder
|
train
|
func (c *ConsulAlertClient) SetReminder(m notifier.Message) {
data, _ := json.Marshal(m)
key := fmt.Sprintf("consul-alerts/reminders/%s/%s", m.Node, m.CheckId)
c.api.KV().Put(&consulapi.KVPair{Key: key, Value: data}, nil)
log.Println("Setting reminder for node: ", m.Node)
}
|
go
|
{
"resource": ""
}
|
q6384
|
DeleteReminder
|
train
|
func (c *ConsulAlertClient) DeleteReminder(node string, checkid string) {
key := fmt.Sprintf("consul-alerts/reminders/%s/%s", node, checkid)
c.api.KV().Delete(key, nil)
log.Println("Deleting reminder for node: ", node)
}
|
go
|
{
"resource": ""
}
|
q6385
|
NewAlerts
|
train
|
func (c *ConsulAlertClient) NewAlerts() []Check {
allChecks, _, _ := c.api.KV().List("consul-alerts/checks", nil)
var alerts []Check
for _, kvpair := range allChecks {
key := kvpair.Key
if strings.HasSuffix(key, "/") {
continue
}
var status Status
json.Unmarshal(kvpair.Value, &status)
if status.ForNotification {
status.ForNotification = false
data, _ := json.Marshal(status)
c.api.KV().Put(&consulapi.KVPair{Key: key, Value: data}, nil)
// check if blacklisted
if !c.IsBlacklisted(status.HealthCheck) {
alerts = append(alerts, *status.HealthCheck)
}
}
}
return alerts
}
|
go
|
{
"resource": ""
}
|
q6386
|
CustomNotifiers
|
train
|
func (c *ConsulAlertClient) CustomNotifiers() (customNotifs map[string]string) {
if kvPairs, _, err := c.api.KV().List("consul-alerts/config/notifiers/custom", nil); err == nil {
customNotifs = make(map[string]string)
for _, kvPair := range kvPairs {
rp := regexp.MustCompile("/([^/]*)$")
match := rp.FindStringSubmatch(kvPair.Key)
custNotifName := match[1]
if custNotifName == "" {
continue
}
customNotifs[custNotifName] = string(kvPair.Value)
}
}
return customNotifs
}
|
go
|
{
"resource": ""
}
|
q6387
|
getProfileForEntity
|
train
|
func (c *ConsulAlertClient) getProfileForEntity(entity string, id string) string {
kvPair, _, _ := c.api.KV().Get(
fmt.Sprintf("consul-alerts/config/notif-selection/%ss/%s",
entity, id), nil)
if kvPair != nil {
log.Printf("%s selection key found.\n", entity)
return string(kvPair.Value)
} else if kvPair, _, _ := c.api.KV().Get(
fmt.Sprintf("consul-alerts/config/notif-selection/%ss", entity),
nil); kvPair != nil {
var regexMap map[string]string
json.Unmarshal(kvPair.Value, ®exMap)
for pattern, profile := range regexMap {
matched, err := regexp.MatchString(pattern, id)
if err != nil {
log.Printf("unable to match %s %s against pattern %s. Error: %s\n",
entity, id, pattern, err.Error())
} else if matched {
log.Printf("Regexp matching %s found (%s).\n", entity, pattern)
return profile
}
}
}
return ""
}
|
go
|
{
"resource": ""
}
|
q6388
|
GetProfileInfo
|
train
|
func (c *ConsulAlertClient) GetProfileInfo(node, serviceID, checkID, status string) ProfileInfo {
log.Println("Getting profile for node: ", node, " service: ", serviceID, " check: ", checkID)
var profile string
profile = c.getProfileForService(serviceID)
if profile == "" {
profile = c.getProfileForCheck(checkID)
}
if profile == "" {
profile = c.getProfileForNode(node)
}
if profile == "" {
profile = c.getProfileForStatus(status)
}
if profile == "" {
profile = "default"
}
var checkProfile ProfileInfo
key := fmt.Sprintf("consul-alerts/config/notif-profiles/%s", profile)
log.Println("profile key: ", key)
kvPair, _, _ := c.api.KV().Get(key, nil)
if kvPair == nil {
log.Println("profile key not found.")
return checkProfile
}
if err := json.Unmarshal(kvPair.Value, &checkProfile); err != nil {
log.Error("Profile unmarshalling error: ", err.Error())
} else {
log.Println("Interval: ", checkProfile.Interval, " List: ", checkProfile.NotifList)
}
return checkProfile
}
|
go
|
{
"resource": ""
}
|
q6389
|
IsBlacklisted
|
train
|
func (c *ConsulAlertClient) IsBlacklisted(check *Check) bool {
blacklistExist := func() bool {
kvPairs, _, err := c.api.KV().List("consul-alerts/config/checks/blacklist/", nil)
return len(kvPairs) != 0 && err == nil
}
node := check.Node
nodeCheckKey := fmt.Sprintf("consul-alerts/config/checks/blacklist/nodes/%s", node)
nodeBlacklisted := func() bool {
return c.CheckKeyExists(nodeCheckKey) || c.CheckKeyMatchesRegexp("consul-alerts/config/checks/blacklist/nodes", node)
}
service := "_"
serviceBlacklisted := func() bool { return false }
if check.ServiceID != "" {
service = check.ServiceID
serviceCheckKey := fmt.Sprintf("consul-alerts/config/checks/blacklist/services/%s", service)
serviceBlacklisted = func() bool {
return c.CheckKeyExists(serviceCheckKey) || c.CheckKeyMatchesRegexp("consul-alerts/config/checks/blacklist/services", service)
}
}
checkID := check.CheckID
checkCheckKey := fmt.Sprintf("consul-alerts/config/checks/blacklist/checks/%s", checkID)
checkBlacklisted := func() bool {
return c.CheckKeyExists(checkCheckKey) || c.CheckKeyMatchesRegexp("consul-alerts/config/checks/blacklist/checks", checkID)
}
status := "_"
statusBlacklisted := func() bool { return false }
if check.Status != "" {
status = check.Status
statusCheckKey := fmt.Sprintf("consul-alerts/config/checks/blacklist/status/%s", status)
statusBlacklisted = func() bool {
return c.CheckKeyExists(statusCheckKey) || c.CheckKeyMatchesRegexp("consul-alerts/config/checks/blacklist/status", status)
}
}
singleKey := fmt.Sprintf("consul-alerts/config/checks/blacklist/single/%s/%s/%s", node, service, checkID)
singleBlacklisted := func() bool { return c.CheckKeyExists(singleKey) }
return blacklistExist() && (nodeBlacklisted() || serviceBlacklisted() || checkBlacklisted() || statusBlacklisted() || singleBlacklisted())
}
|
go
|
{
"resource": ""
}
|
q6390
|
New
|
train
|
func New(possible []string, subsetSize []int) *ClosestMatch {
cm := new(ClosestMatch)
cm.SubstringSizes = subsetSize
cm.SubstringToID = make(map[string]map[uint32]struct{})
cm.ID = make(map[uint32]IDInfo)
for i, s := range possible {
substrings := cm.splitWord(strings.ToLower(s))
cm.ID[uint32(i)] = IDInfo{Key: s, NumSubstrings: len(substrings)}
for substring := range substrings {
if _, ok := cm.SubstringToID[substring]; !ok {
cm.SubstringToID[substring] = make(map[uint32]struct{})
}
cm.SubstringToID[substring][uint32(i)] = struct{}{}
}
}
return cm
}
|
go
|
{
"resource": ""
}
|
q6391
|
Load
|
train
|
func Load(filename string) (*ClosestMatch, error) {
cm := new(ClosestMatch)
f, err := os.Open(filename)
defer f.Close()
if err != nil {
return cm, err
}
w, err := gzip.NewReader(f)
if err != nil {
return cm, err
}
err = json.NewDecoder(w).Decode(&cm)
return cm, err
}
|
go
|
{
"resource": ""
}
|
q6392
|
Add
|
train
|
func (cm *ClosestMatch) Add(possible []string) {
cm.mux.Lock()
for i, s := range possible {
substrings := cm.splitWord(strings.ToLower(s))
cm.ID[uint32(i)] = IDInfo{Key: s, NumSubstrings: len(substrings)}
for substring := range substrings {
if _, ok := cm.SubstringToID[substring]; !ok {
cm.SubstringToID[substring] = make(map[uint32]struct{})
}
cm.SubstringToID[substring][uint32(i)] = struct{}{}
}
}
cm.mux.Unlock()
}
|
go
|
{
"resource": ""
}
|
q6393
|
Save
|
train
|
func (cm *ClosestMatch) Save(filename string) error {
f, err := os.Create(filename)
if err != nil {
return err
}
defer f.Close()
w := gzip.NewWriter(f)
defer w.Close()
enc := json.NewEncoder(w)
// enc.SetIndent("", " ")
return enc.Encode(cm)
}
|
go
|
{
"resource": ""
}
|
q6394
|
Closest
|
train
|
func (cm *ClosestMatch) Closest(searchWord string) string {
for _, pair := range rankByWordCount(cm.match(searchWord)) {
return pair.Key
}
return ""
}
|
go
|
{
"resource": ""
}
|
q6395
|
ClosestN
|
train
|
func (cm *ClosestMatch) ClosestN(searchWord string, max int) []string {
matches := make([]string, 0, max)
for i, pair := range rankByWordCount(cm.match(searchWord)) {
if i >= max {
break
}
matches = append(matches, pair.Key)
}
return matches
}
|
go
|
{
"resource": ""
}
|
q6396
|
Open
|
train
|
func Open(address string) (*Connection, error) {
c := new(Connection)
c.Address = address
resp, err := http.Get(c.Address + "/uptime")
if err != nil {
return c, err
}
defer resp.Body.Close()
return c, nil
}
|
go
|
{
"resource": ""
}
|
q6397
|
UnmarshalYAML
|
train
|
func (u *URL) UnmarshalYAML(unmarshal func(interface{}) error) error {
var s string
if err := unmarshal(&s); err != nil {
return err
}
urlp, err := url.Parse(s)
if err != nil {
return err
}
u.URL = urlp
return nil
}
|
go
|
{
"resource": ""
}
|
q6398
|
MarshalYAML
|
train
|
func (u URL) MarshalYAML() (interface{}, error) {
if u.URL != nil {
return u.String(), nil
}
return nil, nil
}
|
go
|
{
"resource": ""
}
|
q6399
|
Validate
|
train
|
func (c *HTTPClientConfig) Validate() error {
if len(c.BearerToken) > 0 && len(c.BearerTokenFile) > 0 {
return fmt.Errorf("at most one of bearer_token & bearer_token_file must be configured")
}
if c.BasicAuth != nil && (len(c.BearerToken) > 0 || len(c.BearerTokenFile) > 0) {
return fmt.Errorf("at most one of basic_auth, bearer_token & bearer_token_file must be configured")
}
if c.BasicAuth != nil && (string(c.BasicAuth.Password) != "" && c.BasicAuth.PasswordFile != "") {
return fmt.Errorf("at most one of basic_auth password & password_file must be configured")
}
return nil
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.