Semaphore/db/sql/webhook.go

package sql

import (
  "github.com/ansible-semaphore/semaphore/db"
  "github.com/masterminds/squirrel"
  "strings"
  // fmt"
  log "github.com/Sirupsen/logrus"
)

func (d *SqlDb) CreateWebhook(webhook db.Webhook) (newWebhook db.Webhook, err error) {
  err = webhook.Validate()

  if err != nil {
    return
  }

  insertID, err := d.insert(
    "id",
    "insert into project__webhook (project_id, name, template_id) values (?, ?, ?)",
    webhook.ProjectID,
    webhook.Name,
    webhook.TemplateID)

  if err != nil {
    return
  }

  newWebhook = webhook
  newWebhook.ID = insertID

  return
}

func (d *SqlDb) GetWebhooks(projectID int, params db.RetrieveQueryParams) (webhooks []db.Webhook, err error) {
  err = d.getObjects(projectID, db.WebhookProps, params, &webhooks)
  return webhooks, err
}

func (d *SqlDb) GetAllWebhooks() (webhooks []db.Webhook, err error) {
  var webhookObjects interface{}
  webhookObjects, err = d.GetAllObjects(db.WebhookProps)
  webhooks = webhookObjects.([]db.Webhook)
  return
}

func (d *SqlDb) GetWebhook(webhookID int) (webhook db.Webhook, err error) {
  query, args, err := squirrel.Select("w.*").
    From("project__webhook as w").
    Where(squirrel.And{
      squirrel.Eq{"w.id": webhookID},
    }).
    OrderBy("w.id").
    ToSql()

  if err != nil {
    return
  }
  err = d.selectOne(&webhook, query, args...)

  return
}

func (d *SqlDb) GetWebhookRefs(projectID int, webhookID int) (referrers db.WebhookReferrers, err error) {
	var extractorReferrer []db.ObjectReferrer
	extractorReferrer, err = d.GetObjectReferences(db.WebhookProps, db.WebhookExtractorProps, webhookID)
	referrers = db.WebhookReferrers{
		WebhookExtractors: extractorReferrer,
	}
  return
}

func (d *SqlDb) GetWebhookExtractorsByWebhookID(webhookID int) ([]db.WebhookExtractor, error) {
  var extractors []db.WebhookExtractor
  err := d.GetObjectsByForeignKeyQuery(db.WebhookExtractorProps, webhookID, db.WebhookProps, db.RetrieveQueryParams{}, &extractors);
  return extractors, err
}

func (d *SqlDb) DeleteWebhook(projectID int, webhookID int) error {
  extractors, err := d.GetWebhookExtractorsByWebhookID(webhookID)

  if err != nil {
    return err
  }

  for extractor := range extractors {
    d.DeleteWebhookExtractor(webhookID, extractors[extractor].ID)
  }
  return d.deleteObject(projectID, db.WebhookProps, webhookID)
}

func (d *SqlDb) UpdateWebhook(webhook db.Webhook) error {
  err := webhook.Validate()

  if err != nil {
    return err
  }

  _, err = d.exec(
    "update project__webhook set name=?, template_id=? where id=?",
    webhook.Name,
    webhook.TemplateID,
    webhook.ID)

  return err
}

func (d *SqlDb) CreateWebhookExtractor(webhookExtractor db.WebhookExtractor) (newWebhookExtractor db.WebhookExtractor, err error) {
  err = webhookExtractor.Validate()

  if err != nil {
    return
  }

  insertID, err := d.insert(
    "id",
    "insert into project__webhook_extractor (name, webhook_id) values (?, ?)",
    webhookExtractor.Name,
    webhookExtractor.WebhookID)

  if err != nil {
    return
  }

  newWebhookExtractor = webhookExtractor
  newWebhookExtractor.ID = insertID

  return
}

func (d *SqlDb) GetWebhookExtractor(extractorID int, webhookID int) (extractor db.WebhookExtractor, err error) {
  query, args, err := squirrel.Select("e.*").
    From("project__webhook_extractor as e").
    Where(squirrel.And{
      squirrel.Eq{"webhook_id": webhookID},
      squirrel.Eq{"id": extractorID},
    }).
    OrderBy("e.name").
    ToSql()

  if err != nil {
    return
  }

  err = d.selectOne(&extractor, query, args...)

  return extractor, err
}

func (d *SqlDb) GetAllWebhookExtractors() (extractors []db.WebhookExtractor, err error) {
  var extractorObjects interface{}
  extractorObjects, err = d.GetAllObjects(db.WebhookExtractorProps)
  extractors = extractorObjects.([]db.WebhookExtractor)
  return
}

func (d *SqlDb) GetWebhookExtractors(webhookID int, params db.RetrieveQueryParams) ([]db.WebhookExtractor, error) {
  var extractors []db.WebhookExtractor
  err := d.getObjectsByReferrer(webhookID, db.WebhookProps, db.WebhookExtractorProps, params, &extractors)

  return extractors, err
}

func (d *SqlDb) GetWebhookExtractorRefs(webhookID int, extractorID int) (refs db.WebhookExtractorReferrers, err error) {
  refs.WebhookMatchers, err = d.GetObjectReferences(db.WebhookMatcherProps, db.WebhookExtractorProps, extractorID)
  refs.WebhookExtractValues, err = d.GetObjectReferences(db.WebhookExtractValueProps, db.WebhookExtractorProps, extractorID)

  return
}

func (d *SqlDb) GetWebhookExtractValuesByExtractorID(extractorID int) (values []db.WebhookExtractValue, err error) {
  var sqlError error
  query, args, sqlError := squirrel.Select("v.*").
    From("project__webhook_extract_value as v").
    Where(squirrel.Eq{"extractor_id": extractorID}).
    OrderBy("v.id").
    ToSql()

  if sqlError != nil {
    return []db.WebhookExtractValue{}, sqlError
  }

  err = d.selectOne(&values, query, args...)

  return values, err
}

func (d *SqlDb) GetWebhookMatchersByExtractorID(extractorID int) (matchers []db.WebhookMatcher, err error) {
  var sqlError error
  query, args, sqlError := squirrel.Select("m.*").
    From("project__webhook_matcher as m").
    Where(squirrel.Eq{"extractor_id": extractorID}).
    OrderBy("m.id").
    ToSql()

  if sqlError != nil {
    return []db.WebhookMatcher{}, sqlError
  }

  err = d.selectOne(&matchers, query, args...)

  return matchers, err
}

func (d *SqlDb) DeleteWebhookExtractor(webhookID int, extractorID int) error {
  values, err := d.GetWebhookExtractValuesByExtractorID(extractorID)
  if err != nil && !strings.Contains(err.Error(), "no rows in result set") {
    return err
  }

  for value := range values {

    err = d.DeleteWebhookExtractValue(extractorID, values[value].ID)
    if err != nil && !strings.Contains(err.Error(), "no rows in result set") {
      log.Error(err)
      return err
    }
  }

  matchers, errExtractor := d.GetWebhookMatchersByExtractorID(extractorID)
  if errExtractor != nil && !strings.Contains(errExtractor.Error(), "no rows in result set") {
    log.Error(errExtractor)
    return errExtractor
  }

  for matcher := range matchers {
    err = d.DeleteWebhookMatcher(extractorID, matchers[matcher].ID)
    if err != nil && !strings.Contains(err.Error(), "no rows in result set") {
      log.Error(err)
      return err
    }
  }

  return d.deleteObjectByReferencedID(webhookID, db.WebhookProps, db.WebhookExtractorProps, extractorID)
}


func (d *SqlDb) UpdateWebhookExtractor(webhookExtractor db.WebhookExtractor) error {
  err := webhookExtractor.Validate()

  if err != nil {
    return err
  }

  _, err = d.exec(
    "update project__webhook_extractor set name=? where id=?",
    webhookExtractor.Name,
    webhookExtractor.ID)

  return err
}

func (d *SqlDb) CreateWebhookExtractValue(value db.WebhookExtractValue) (newValue db.WebhookExtractValue, err error) {
  err = value.Validate()

  if err != nil {
    return
  }

  insertID, err := d.insert("id",
    "insert into project__webhook_extract_value (value_source, body_data_type, key, variable, name, extractor_id) values (?, ?, ?, ?, ?, ?)",
    value.ValueSource,
    value.BodyDataType,
    value.Key,
    value.Variable,
    value.Name,
    value.ExtractorID)

  if err != nil {
    return
  }

  newValue = value
  newValue.ID = insertID

  return
}

func (d *SqlDb) GetWebhookExtractValues(extractorID int, params db.RetrieveQueryParams) ([]db.WebhookExtractValue, error) {
  var values []db.WebhookExtractValue
	err := d.getObjectsByReferrer(extractorID, db.WebhookExtractorProps, db.WebhookExtractValueProps, params, &values)
  return values, err
}

func (d *SqlDb) GetAllWebhookExtractValues() (values []db.WebhookExtractValue, err error) {
  var valueObjects interface{}
  valueObjects, err = d.GetAllObjects(db.WebhookExtractValueProps)
  values = valueObjects.([]db.WebhookExtractValue)
  return
}

func (d *SqlDb) GetWebhookExtractValue(valueID int, extractorID int) (value db.WebhookExtractValue, err error) {
  query, args, err := squirrel.Select("v.*").
    From("project__webhook_extract_value as v").
    Where(squirrel.Eq{"id": valueID}).
    OrderBy("v.id").
    ToSql()

  if err != nil {
    return
  }

  err = d.selectOne(&value, query, args...)

  return value, err
}

func (d *SqlDb) GetWebhookExtractValueRefs(extractorID int, valueID int) (refs db.WebhookExtractorChildReferrers, err error) {
  refs.WebhookExtractors, err = d.GetObjectReferences(db.WebhookExtractorProps, db.WebhookExtractValueProps, extractorID)
  return
}

func (d *SqlDb) DeleteWebhookExtractValue(extractorID int, valueID int) error {
  return d.deleteObjectByReferencedID(extractorID, db.WebhookExtractorProps, db.WebhookExtractValueProps, valueID)
}


func (d *SqlDb) UpdateWebhookExtractValue(webhookExtractValue db.WebhookExtractValue) error {
  err := webhookExtractValue.Validate()

  if err != nil {
    return err
  }

  _, err = d.exec(
    "update project__webhook_extract_value set value_source=?, body_data_type=?, key=?, variable=?, name=? where id=?",
    webhookExtractValue.ValueSource,
    webhookExtractValue.BodyDataType,
    webhookExtractValue.Key,
    webhookExtractValue.Variable,
    webhookExtractValue.Name,
    webhookExtractValue.ID)

  return err
}

func (d *SqlDb) CreateWebhookMatcher(matcher db.WebhookMatcher) (newMatcher db.WebhookMatcher, err error) {
  err = matcher.Validate()

  if err != nil {
    return
  }

  insertID, err := d.insert(
    "id",
    "insert into project__webhook_matcher (match_type, method, body_data_type, key, value, extractor_id, name) values (?, ?, ?, ?, ?, ?, ?)",
    matcher.MatchType,
    matcher.Method,
    matcher.BodyDataType,
    matcher.Key,
    matcher.Value,
    matcher.ExtractorID,
    matcher.Name)

  if err != nil {
    return
  }

  newMatcher = matcher
  newMatcher.ID = insertID

  return
}

func (d *SqlDb) GetWebhookMatchers(extractorID int, params db.RetrieveQueryParams) (matchers []db.WebhookMatcher, err error) {
  query, args, err := squirrel.Select("m.*").
    From("project__webhook_matcher as m").
    Where(squirrel.Eq{"extractor_id": extractorID}).
    OrderBy("m.id").
    ToSql()

  if err != nil {
    return
  }

  _, err = d.selectAll(&matchers, query, args...)

  return
}

func (d *SqlDb) GetAllWebhookMatchers() (matchers []db.WebhookMatcher, err error) {
  var matcherObjects interface{}
  matcherObjects, err = d.GetAllObjects(db.WebhookMatcherProps)
  matchers = matcherObjects.([]db.WebhookMatcher)

  return
}

func (d *SqlDb) GetWebhookMatcher(matcherID int, extractorID int) (matcher db.WebhookMatcher, err error) {
  query, args, err := squirrel.Select("m.*").
    From("project__webhook_matcher as m").
    Where(squirrel.Eq{"id": matcherID}).
    OrderBy("m.id").
    ToSql()

  if err != nil {
    return
  }

  err = d.selectOne(&matcher, query, args...)

  return matcher, err
}

func (d *SqlDb) GetWebhookMatcherRefs(extractorID int, matcherID int) (refs db.WebhookExtractorChildReferrers, err error) {
  refs.WebhookExtractors, err = d.GetObjectReferences(db.WebhookExtractorProps, db.WebhookMatcherProps, matcherID)

  return
}

func (d *SqlDb) DeleteWebhookMatcher(extractorID int, matcherID int) error {
  return d.deleteObjectByReferencedID(extractorID, db.WebhookExtractorProps, db.WebhookMatcherProps, matcherID)
}


func (d *SqlDb) UpdateWebhookMatcher(webhookMatcher db.WebhookMatcher) error {
  err := webhookMatcher.Validate()

  if err != nil {
    return err
  }

  _, err = d.exec(
    "update project__webhook_matcher set match_type=?, method=?, body_data_type=?, key=?, value=?, name=? where id=?",
    webhookMatcher.MatchType,
    webhookMatcher.Method,
    webhookMatcher.BodyDataType,
    webhookMatcher.Key,
    webhookMatcher.Value,
    webhookMatcher.Name,
    webhookMatcher.ID)

  return err
}