func (r Record) Insert() error {
conn, err := connection.Get()
if err != nil {
return err
}
args, err := json.Marshal(r.Args)
if err != nil {
return err
}
_, err = conn.Exec(
fmt.Sprintf(`INSERT INTO record__%d_%d
(uuid, domain, name, args, record_type, parser_date, parser) VALUES
($1, $2, $3, $4, $5, $6, $7)`,
r.Type.ID,
r.Domain.TLD.ID,
),
r.UUID.String(),
r.Domain.UUID.String(),
r.Name,
string(args),
r.Type.ID,
r.Date,
r.Parser.ID,
)
return err
}
func (n *Notification) Save() error {
conn, err := connection.Get()
if err != nil {
return err
}
messages, err := json.Marshal(n.Messages)
if err != nil {
return err
}
archived, err := json.Marshal(n.Archived)
if err != nil {
return err
}
_, err = conn.Exec(
`UPDATE notification SET
messages = $1,
alerts = $2,
archived = $3
WHERE user_id = $4`,
messages,
n.Alerts,
archived,
n.User.ID,
)
return err
}
func NewInsert(name, table string, args ...string) (Insert, error) {
conn, err := connection.Get()
if err != nil {
return Insert{}, err
}
bi := Insert{}
serial := uniuri.NewLen(5)
bi.name = fmt.Sprintf(name, serial)
bi.table = fmt.Sprintf(table, bi.name)
tx, err := conn.Begin()
if err != nil {
return bi, err
}
// close up our defer tx.Rollback()
bi.tx = tx
_, err = bi.tx.Exec(bi.table)
if err != nil {
return bi, err
}
// prepare args
for idx, i := range args {
args[idx] = fmt.Sprintf(`"%s"`, i)
}
bi.args = args
stmt := fmt.Sprintf(
`COPY %s (%s) FROM STDIN`,
bi.name,
strings.Join(bi.args, ", "),
)
bi.stmt, err = bi.tx.Prepare(stmt)
if err != nil {
return bi, err
}
return bi, nil
}
func New(email, password string) (User, error) {
if u, err := GetByEmail(email).One(); err == nil {
if CheckPassword(email, password) {
return u, nil
}
return User{}, errors.New("Email does not exists, or password does not match.")
}
u := User{}
pass, err := PasswordCrypt([]byte(password))
if err != nil {
return u, err
}
u.Email = email
u.Password = pass
conn, err := connection.Get()
if err != nil {
return u, err
}
var id int32
err = conn.QueryRow("SELECT insert_user($1, $2)", email, pass).Scan(&id)
if err == nil {
u.ID = id
}
return u, err
}
func Get(query string, args ...interface{}) (Record, error) {
conn, err := connection.Get()
if err != nil {
return Record{}, err
}
row := conn.QueryRow(query, args...)
return parseRow(row)
}
func Get(query string, args ...interface{}) (Watcher, error) {
var result Watcher
conn, err := connection.Get()
if err != nil {
return Watcher{}, err
}
row := conn.QueryRow(query, args...)
result, err = parseRow(row)
return result, err
}
func (p *Parser) Finish() error {
conn, err := connection.Get()
if err != nil {
return err
}
t := time.Now()
p.Finished.Time = t
_, err = conn.Exec("UPDATE parser SET finished_at = $1 WHERE id = $2", p.Finished, p.ID)
return err
}
func Get(query string, args ...interface{}) (Interval, error) {
var result Interval
conn, err := connection.Get()
if err != nil {
return Interval{}, err
}
row := conn.QueryRow(query, args...)
result, err = parseRow(row)
return result, err
}
func (r Record) Insert() error {
conn, err := connection.Get()
if err != nil {
return err
}
emails, err := json.Marshal(r.Emails)
if err != nil {
return err
}
data, err := r.Data.MarshalJSON()
if err != nil {
return err
}
raw, err := r.Raw.MarshalJSON()
if err != nil {
return err
}
contacts, err := r.Contacts.MarshalJSON()
if err != nil {
return err
}
organizations, err := json.Marshal(r.Organizations)
if err != nil {
return err
}
phones, err := json.Marshal(r.Phones)
if err != nil {
return err
}
postcodes, err := json.Marshal(r.Postcodes)
if err != nil {
return err
}
names, err := json.Marshal(r.Names)
if err != nil {
return err
}
_, err = conn.Exec(`INSERT INTO whois
(domain, data, raw_whois, contacts, emails, uuid, organizations, phones, postcodes, names)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
r.Domain.UUID.String(),
string(data),
string(raw),
string(contacts),
string(emails),
r.UUID.String(),
string(organizations),
string(phones),
string(postcodes),
string(names),
)
return err
}
func (d Domain) Insert() error {
conn, err := connection.Get()
if err != nil {
return err
}
_, err = conn.Exec("INSERT INTO domain (uuid, name, tld) VALUES ($1, $2, $3)",
d.UUID.String(),
d.Name,
d.TLD.ID,
)
return err
}
func New(value string) (Interval, error) {
i := Interval{}
i.Value = value
conn, err := connection.Get()
if err != nil {
return i, err
}
var id int32
err = conn.QueryRow("SELECT insert_interval($1)", value).Scan(&id)
i.ID = id
return i, err
}
func (p Parser) Save() error {
conn, err := connection.Get()
if err != nil {
return err
}
b, err := json.Marshal(p.Logs)
if err != nil {
return err
}
_, err = conn.Exec("UPDATE parser SET logs = $1 WHERE id = $2", string(b), p.ID)
return err
}
func SetupUserNotification(user users.User) (Notification, error) {
note := Notification{
User: user,
}
conn, err := connection.Get()
if err != nil {
return note, err
}
_, err = conn.Exec("INSERT INTO notification (user_id) VALUES ($1)", user.ID)
if err != nil {
return note, err
}
return note, nil
}
func (p *Parser) Insert() error {
conn, err := connection.Get()
if err != nil {
return err
}
var id int32
err = conn.QueryRow("INSERT INTO parser (filename, parser_date, tld) VALUES ($1, $2, $3) RETURNING id",
p.Filename,
p.Date,
p.TLD.ID,
).Scan(&id)
p.ID = id
return err
}
func New(name string) (TLD, error) {
if tld, ok := byName[name]; ok {
return tld, nil
}
conn, err := connection.Get()
if err != nil {
return TLD{}, err
}
var id int32
err = conn.QueryRow("SELECT insert_tld($1)", name).Scan(&id)
tld := TLD{
ID: id,
Name: name,
}
return tld, err
}
func CheckPassword(email, password string) bool {
conn, err := connection.Get()
if err != nil {
return false
}
var pass []byte
err = conn.QueryRow("SELECT password FROM users WHERE email = $1", email).Scan(&pass)
if err != nil {
return false
}
err = bcrypt.CompareHashAndPassword(pass, []byte(password))
if err != nil {
return false
}
return true
}
func newResult(query string, args ...interface{}) Result {
return Result{
func() (int, error) {
var count int
conn, err := connection.Get()
if err != nil {
return count, err
}
query = strings.Replace(query, "SELECT *", "SELECT COUNT(*)", 1)
err = conn.QueryRow(query, args...).Scan(&count)
return count, err
},
func() (Record, error) {
return Get(query, args...)
},
func() ([]Record, error) {
return GetList(query, args...)
},
}
}
func GetList(query string, args ...interface{}) ([]Record, error) {
conn, err := connection.Get()
if err != nil {
return []Record{}, err
}
rows, err := conn.Query(query, args...)
defer rows.Close()
if err != nil {
return []Record{}, err
}
var list []Record
for rows.Next() {
rt, err := parseRow(rows)
if err != nil {
return list, err
}
list = append(list, rt)
}
return list, rows.Err()
}
func (w *Watcher) Save() error {
conn, err := connection.Get()
if err != nil {
return err
}
w.Logs = append(w.Logs, Log{w.Updated})
w.Updated = time.Now()
b, err := json.Marshal(w.Logs)
if err != nil {
return err
}
var usersArr []int32
for _, u := range w.Users {
usersArr = append(usersArr, u.ID)
}
b2, err := json.Marshal(usersArr)
if err != nil {
return err
}
_, err = conn.Exec("UPDATE watcher SET updated = $1, logs = $2, users = $3 WHERE id = $4", w.Updated, b, b2, w.ID)
return err
}
func New(name string, tld tlds.TLD) (Type, error) {
if _, ok := byNameAndTLD[name]; ok {
if t, ok := byNameAndTLD[name][tld.ID]; ok {
return t, nil
}
}
conn, err := connection.Get()
if err != nil {
return Type{}, err
}
var id int32
err = conn.QueryRow("SELECT ensure_record_table($1, $2)", name, tld.ID).Scan(&id)
rt := Type{
ID: id,
Name: name,
}
if err == nil {
if _, ok := byNameAndTLD[name]; !ok {
byNameAndTLD[name] = make(map[int32]Type)
}
byNameAndTLD[name][tld.ID] = rt
}
return rt, err
}
func New(d domains.Domain, interval string) (Watcher, error) {
w := Watcher{}
w.Domain = d
i, err := intervals.New(interval)
if err != nil {
// TODO: better wrapper for our db errors so can see in log which package
return w, err
}
w.Interval = i
w.Updated = time.Now()
w.Added = time.Now()
conn, err := connection.Get()
if err != nil {
return w, err
}
err = conn.QueryRow("INSERT INTO watcher (domain, interval) VALUES ($1, $2) RETURNING id",
d.UUID.String(),
i.ID,
).Scan(&w.ID)
if err != nil {
return w, err
}
return GetByDomain(d).One()
}
