package handlers //go:generate make import ( "errors" "github.com/aclindsa/moneygo/internal/models" "github.com/aclindsa/moneygo/internal/store" "github.com/aclindsa/moneygo/internal/store/db" "log" "net/http" "net/url" "strconv" "strings" ) func SearchSecurityTemplates(search string, _type models.SecurityType, limit int64) []*models.Security { upperSearch := strings.ToUpper(search) var results []*models.Security for i, security := range SecurityTemplates { if strings.Contains(strings.ToUpper(security.Name), upperSearch) || strings.Contains(strings.ToUpper(security.Description), upperSearch) || strings.Contains(strings.ToUpper(security.Symbol), upperSearch) { if _type == 0 || _type == security.Type { results = append(results, &SecurityTemplates[i]) if limit != -1 && int64(len(results)) >= limit { break } } } } return results } func FindSecurityTemplate(name string, _type models.SecurityType) *models.Security { for _, security := range SecurityTemplates { if name == security.Name && _type == security.Type { return &security } } return nil } func FindCurrencyTemplate(iso4217 int64) *models.Security { iso4217string := strconv.FormatInt(iso4217, 10) for _, security := range SecurityTemplates { if security.Type == models.Currency && security.AlternateId == iso4217string { return &security } } return nil } func UpdateSecurity(tx *db.Tx, s *models.Security) (err error) { user, err := tx.GetUser(s.UserId) if err != nil { return } else if user.DefaultCurrency == s.SecurityId && s.Type != models.Currency { return errors.New("Cannot change security which is user's default currency to be non-currency") } err = tx.UpdateSecurity(s) if err != nil { return } return nil } func ImportGetCreateSecurity(tx *db.Tx, userid int64, security *models.Security) (*models.Security, error) { security.UserId = userid if len(security.AlternateId) == 0 { // Always create a new local security if we can't match on the AlternateId err := tx.InsertSecurity(security) if err != nil { return nil, err } return security, nil } securities, err := tx.FindMatchingSecurities(security) if err != nil { return nil, err } // First try to find a case insensitive match on the name or symbol upperName := strings.ToUpper(security.Name) upperSymbol := strings.ToUpper(security.Symbol) for _, s := range *securities { if (len(s.Name) > 0 && strings.ToUpper(s.Name) == upperName) || (len(s.Symbol) > 0 && strings.ToUpper(s.Symbol) == upperSymbol) { return s, nil } } // if strings.Contains(strings.ToUpper(security.Name), upperSearch) || // Try to find a partial string match on the name or symbol for _, s := range *securities { sUpperName := strings.ToUpper(s.Name) sUpperSymbol := strings.ToUpper(s.Symbol) if (len(upperName) > 0 && len(s.Name) > 0 && (strings.Contains(upperName, sUpperName) || strings.Contains(sUpperName, upperName))) || (len(upperSymbol) > 0 && len(s.Symbol) > 0 && (strings.Contains(upperSymbol, sUpperSymbol) || strings.Contains(sUpperSymbol, upperSymbol))) { return s, nil } } // Give up and return the first security in the list if len(*securities) > 0 { return (*securities)[0], nil } // If there wasn't even one security in the list, make a new one err = tx.InsertSecurity(security) if err != nil { return nil, err } return security, nil } func SecurityHandler(r *http.Request, context *Context) ResponseWriterWriter { user, err := GetUserFromSession(context.Tx, r) if err != nil { return NewError(1 /*Not Signed In*/) } if r.Method == "POST" { if !context.LastLevel() { securityid, err := context.NextID() if err != nil { return NewError(3 /*Invalid Request*/) } if context.NextLevel() != "prices" { return NewError(3 /*Invalid Request*/) } return PriceHandler(r, context, user, securityid) } var security models.Security if err := ReadJSON(r, &security); err != nil { return NewError(3 /*Invalid Request*/) } security.SecurityId = -1 security.UserId = user.UserId err = context.Tx.InsertSecurity(&security) if err != nil { log.Print(err) return NewError(999 /*Internal Error*/) } return ResponseWrapper{201, &security} } else if r.Method == "GET" { if context.LastLevel() { //Return all securities var sl models.SecurityList securities, err := context.Tx.GetSecurities(user.UserId) if err != nil { log.Print(err) return NewError(999 /*Internal Error*/) } sl.Securities = securities return &sl } else { securityid, err := context.NextID() if err != nil { return NewError(3 /*Invalid Request*/) } if !context.LastLevel() { if context.NextLevel() != "prices" { return NewError(3 /*Invalid Request*/) } return PriceHandler(r, context, user, securityid) } security, err := context.Tx.GetSecurity(securityid, user.UserId) if err != nil { return NewError(3 /*Invalid Request*/) } return security } } else { securityid, err := context.NextID() if err != nil { return NewError(3 /*Invalid Request*/) } if !context.LastLevel() { if context.NextLevel() != "prices" { return NewError(3 /*Invalid Request*/) } return PriceHandler(r, context, user, securityid) } if r.Method == "PUT" { var security models.Security if err := ReadJSON(r, &security); err != nil || security.SecurityId != securityid { return NewError(3 /*Invalid Request*/) } security.UserId = user.UserId err = UpdateSecurity(context.Tx, &security) if err != nil { log.Print(err) return NewError(999 /*Internal Error*/) } return &security } else if r.Method == "DELETE" { security, err := context.Tx.GetSecurity(securityid, user.UserId) if err != nil { return NewError(3 /*Invalid Request*/) } err = context.Tx.DeleteSecurity(security) if _, ok := err.(store.SecurityInUseError); ok { return NewError(7 /*In Use Error*/) } else if err != nil { log.Print(err) return NewError(999 /*Internal Error*/) } return SuccessWriter{} } } return NewError(3 /*Invalid Request*/) } func SecurityTemplateHandler(r *http.Request, context *Context) ResponseWriterWriter { if r.Method == "GET" { var sl models.SecurityList query, _ := url.ParseQuery(r.URL.RawQuery) var limit int64 = -1 search := query.Get("search") var _type models.SecurityType = 0 typestring := query.Get("type") if len(typestring) > 0 { _type = models.GetSecurityType(typestring) if _type == 0 { return NewError(3 /*Invalid Request*/) } } limitstring := query.Get("limit") if limitstring != "" { limitint, err := strconv.ParseInt(limitstring, 10, 0) if err != nil { return NewError(3 /*Invalid Request*/) } limit = limitint } securities := SearchSecurityTemplates(search, _type, limit) sl.Securities = &securities return &sl } else { return NewError(3 /*Invalid Request*/) } }