func domainFilter(domainDAO dao.DomainDAO) { numberOfItems := 20 for i := 0; i < numberOfItems; i++ { domain := model.Domain{ FQDN: fmt.Sprintf("example%d.com.br", i), } if err := domainDAO.Save(&domain); err != nil { utils.Fatalln("Error saving domain in database", err) } } pagination := dao.DomainDAOPagination{ PageSize: 10, Page: 5, OrderBy: []dao.DomainDAOSort{ { Field: dao.DomainDAOOrderByFieldFQDN, Direction: dao.DAOOrderByDirectionAscending, }, }, } domains, err := domainDAO.FindAll(&pagination, true, "example1\\.com.*") if err != nil { utils.Fatalln("Error retrieving domains", err) } if len(domains) != 1 { utils.Fatalln(fmt.Sprintf("Wrong number of domains when there's filter. "+ "Expected '1' and got '%d'", len(domains)), nil) } if domains[0].FQDN != "example1.com.br" { utils.Fatalln("Wrong domain returned", nil) } for i := 0; i < numberOfItems; i++ { fqdn := fmt.Sprintf("example%d.com.br", i) if err := domainDAO.RemoveByFQDN(fqdn); err != nil { utils.Fatalln("Error removing domain from database", err) } } }
func domainsPagination(domainDAO dao.DomainDAO) { numberOfItems := 1000 for i := 0; i < numberOfItems; i++ { domain := model.Domain{ FQDN: fmt.Sprintf("example%d.com.br", i), } if err := domainDAO.Save(&domain); err != nil { utils.Fatalln("Error saving domain in database", err) } } pagination := dao.DomainDAOPagination{ PageSize: 10, Page: 5, OrderBy: []dao.DomainDAOSort{ { Field: dao.DomainDAOOrderByFieldFQDN, Direction: dao.DAOOrderByDirectionAscending, }, }, } domains, err := domainDAO.FindAll(&pagination, true, "") if err != nil { utils.Fatalln("Error retrieving domains", err) } if pagination.NumberOfItems != numberOfItems { utils.Errorln("Number of items not calculated correctly", nil) } if pagination.NumberOfPages != numberOfItems/pagination.PageSize { utils.Errorln("Number of pages not calculated correctly", nil) } if len(domains) != pagination.PageSize { utils.Errorln("Number of domains not following page size", nil) } pagination = dao.DomainDAOPagination{ PageSize: 10000, Page: 1, OrderBy: []dao.DomainDAOSort{ { Field: dao.DomainDAOOrderByFieldFQDN, Direction: dao.DAOOrderByDirectionAscending, }, }, } domains, err = domainDAO.FindAll(&pagination, true, "") if err != nil { utils.Fatalln("Error retrieving domains", err) } if pagination.NumberOfPages != 1 { utils.Fatalln("Calculating wrong number of pages when there's only one page", nil) } for i := 0; i < numberOfItems; i++ { fqdn := fmt.Sprintf("example%d.com.br", i) if err := domainDAO.RemoveByFQDN(fqdn); err != nil { utils.Fatalln("Error removing domain from database", err) } } }
func domainsExpand(domainDAO dao.DomainDAO) { newDomains := newDomains() domainsResult := domainDAO.SaveMany(newDomains) for _, domainResult := range domainsResult { if domainResult.Error != nil { utils.Fatalln("Error creating domains", domainResult.Error) } } pagination := dao.DomainDAOPagination{} domains, err := domainDAO.FindAll(&pagination, false, "") if err != nil { utils.Fatalln("Error retrieving domains", err) } for _, domain := range domains { if len(domain.Owners) > 0 { utils.Fatalln("Not compressing owners in results", nil) } for _, nameserver := range domain.Nameservers { if len(nameserver.Host) > 0 || nameserver.IPv4 != nil || nameserver.IPv6 != nil || !nameserver.LastCheckAt.Equal(time.Time{}) || !nameserver.LastOKAt.Equal(time.Time{}) { utils.Fatalln("Not compressing nameservers in results", nil) } } for _, ds := range domain.DSSet { if ds.Algorithm != 0 || len(ds.Digest) > 0 || ds.DigestType != 0 || ds.Keytag != 0 || !ds.ExpiresAt.Equal(time.Time{}) || !ds.LastCheckAt.Equal(time.Time{}) || !ds.LastOKAt.Equal(time.Time{}) { utils.Fatalln("Not compressing ds set in results", nil) } } } domains, err = domainDAO.FindAll(&pagination, true, "") if err != nil { utils.Fatalln("Error retrieving domains", err) } for _, domain := range domains { if len(domain.Owners) == 0 { utils.Fatalln("Compressing owners in results when it shouldn't", nil) } for _, nameserver := range domain.Nameservers { if len(nameserver.Host) == 0 || nameserver.IPv4 == nil || nameserver.IPv6 == nil || nameserver.LastCheckAt.Equal(time.Time{}) || nameserver.LastOKAt.Equal(time.Time{}) || nameserver.LastStatus != model.NameserverStatusOK { utils.Fatalln("Compressing nameservers in results when it shouldn't", nil) } } for _, ds := range domain.DSSet { if ds.Algorithm == 0 || len(ds.Digest) == 0 || ds.DigestType == 0 || ds.Keytag == 0 || ds.ExpiresAt.Equal(time.Time{}) || ds.LastCheckAt.Equal(time.Time{}) || ds.LastOKAt.Equal(time.Time{}) || ds.LastStatus != model.DSStatusOK { utils.Fatalln("Compressing ds set in results when it shouldn't", nil) } } } domainsResult = domainDAO.RemoveMany(newDomains) for _, domainResult := range domainsResult { if domainResult.Error != nil { utils.Fatalln("Error removing domains", domainResult.Error) } } }
// The HEAD method is identical to GET except that the server MUST NOT return a message- // body in the response. But now the responsability for don't adding the body is from the // mux while writing the response func (h *DomainsHandler) retrieveDomains(w http.ResponseWriter, r *http.Request) { var pagination dao.DomainDAOPagination expand := false filter := "" for key, values := range r.URL.Query() { key = strings.TrimSpace(key) key = strings.ToLower(key) // A key can have multiple values in a query string, we are going to always consider // the last one (overwrite strategy) for _, value := range values { value = strings.TrimSpace(value) value = strings.ToLower(value) switch key { case "orderby": // OrderBy parameter will store the fields that the user want to be the keys of the sort // algorithm in the result set and the direction that each sort field will have. The format // that will be used is: // // <field1>:<direction1>@<field2>:<direction2>@...@<fieldN>:<directionN> orderByParts := strings.Split(value, "@") for _, orderByPart := range orderByParts { orderByPart = strings.TrimSpace(orderByPart) orderByAndDirection := strings.Split(orderByPart, ":") var field, direction string if len(orderByAndDirection) == 1 { field, direction = orderByAndDirection[0], "asc" } else if len(orderByAndDirection) == 2 { field, direction = orderByAndDirection[0], orderByAndDirection[1] } else { if err := h.MessageResponse("invalid-query-order-by", ""); err == nil { w.WriteHeader(http.StatusBadRequest) } else { log.Println("Error while writing response. Details:", err) w.WriteHeader(http.StatusInternalServerError) } return } orderByField, err := dao.DomainDAOOrderByFieldFromString(field) if err != nil { if err := h.MessageResponse("invalid-query-order-by", ""); err == nil { w.WriteHeader(http.StatusBadRequest) } else { log.Println("Error while writing response. Details:", err) w.WriteHeader(http.StatusInternalServerError) } return } orderByDirection, err := dao.DAOOrderByDirectionFromString(direction) if err != nil { if err := h.MessageResponse("invalid-query-order-by", ""); err == nil { w.WriteHeader(http.StatusBadRequest) } else { log.Println("Error while writing response. Details:", err) w.WriteHeader(http.StatusInternalServerError) } return } pagination.OrderBy = append(pagination.OrderBy, dao.DomainDAOSort{ Field: orderByField, Direction: orderByDirection, }) } case "pagesize": var err error pagination.PageSize, err = strconv.Atoi(value) if err != nil { if err := h.MessageResponse("invalid-query-page-size", ""); err == nil { w.WriteHeader(http.StatusBadRequest) } else { log.Println("Error while writing response. Details:", err) w.WriteHeader(http.StatusInternalServerError) } return } case "page": var err error pagination.Page, err = strconv.Atoi(value) if err != nil { if err := h.MessageResponse("invalid-query-page", ""); err == nil { w.WriteHeader(http.StatusBadRequest) } else { log.Println("Error while writing response. Details:", err) w.WriteHeader(http.StatusInternalServerError) } return } case "expand": expand = true case "filter": filter = value } } } domainDAO := dao.DomainDAO{ Database: h.GetDatabase(), } domains, err := domainDAO.FindAll(&pagination, expand, filter) if err != nil { log.Println("Error while filtering domains objects. Details:", err) w.WriteHeader(http.StatusInternalServerError) return } domainsResponse := protocol.ToDomainsResponse(domains, pagination, expand, filter) h.Response = &domainsResponse // Last-Modified is going to be the most recent date of the list for _, domain := range domains { if domain.LastModifiedAt.After(h.lastModifiedAt) { h.lastModifiedAt = domain.LastModifiedAt } } w.Header().Add("ETag", h.GetETag()) w.Header().Add("Last-Modified", h.lastModifiedAt.Format(time.RFC1123)) w.WriteHeader(http.StatusOK) }