github.com/lologarithm/mattermost-server@v5.3.2-0.20181002060438-c82a84ed765b+incompatible/store/sqlstore/service_terms_store.go (about)

     1  // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
     2  // See License.txt for license information.
     3  
     4  package sqlstore
     5  
     6  import (
     7  	"database/sql"
     8  	"github.com/mattermost/mattermost-server/einterfaces"
     9  	"github.com/mattermost/mattermost-server/model"
    10  	"github.com/mattermost/mattermost-server/store"
    11  	"github.com/mattermost/mattermost-server/utils"
    12  	"net/http"
    13  )
    14  
    15  type SqlServiceTermsStore struct {
    16  	SqlStore
    17  	metrics einterfaces.MetricsInterface
    18  }
    19  
    20  var serviceTermsCache = utils.NewLru(model.SERVICE_TERMS_CACHE_SIZE)
    21  
    22  const serviceTermsCacheName = "ServiceTerms"
    23  
    24  func NewSqlTermStore(sqlStore SqlStore, metrics einterfaces.MetricsInterface) store.ServiceTermsStore {
    25  	s := SqlServiceTermsStore{sqlStore, metrics}
    26  
    27  	for _, db := range sqlStore.GetAllConns() {
    28  		table := db.AddTableWithName(model.ServiceTerms{}, "ServiceTerms").SetKeys(false, "Id")
    29  		table.ColMap("Id").SetMaxSize(26)
    30  		table.ColMap("UserId").SetMaxSize(26)
    31  		table.ColMap("Text").SetMaxSize(model.POST_MESSAGE_MAX_BYTES_V2)
    32  	}
    33  
    34  	return s
    35  }
    36  
    37  func (s SqlServiceTermsStore) CreateIndexesIfNotExists() {
    38  }
    39  
    40  func (s SqlServiceTermsStore) Save(serviceTerms *model.ServiceTerms) store.StoreChannel {
    41  	return store.Do(func(result *store.StoreResult) {
    42  		if len(serviceTerms.Id) > 0 {
    43  			result.Err = model.NewAppError(
    44  				"SqlServiceTermsStore.Save",
    45  				"store.sql_service_terms_store.save.existing.app_error",
    46  				nil,
    47  				"id="+serviceTerms.Id, http.StatusBadRequest,
    48  			)
    49  			return
    50  		}
    51  
    52  		serviceTerms.PreSave()
    53  
    54  		if result.Err = serviceTerms.IsValid(); result.Err != nil {
    55  			return
    56  		}
    57  
    58  		if err := s.GetMaster().Insert(serviceTerms); err != nil {
    59  			result.Err = model.NewAppError(
    60  				"SqlServiceTermsStore.Save",
    61  				"store.sql_service_terms.save.app_error",
    62  				nil,
    63  				"service_term_id="+serviceTerms.Id+",err="+err.Error(),
    64  				http.StatusInternalServerError,
    65  			)
    66  		}
    67  
    68  		result.Data = serviceTerms
    69  
    70  		serviceTermsCache.AddWithDefaultExpires(serviceTerms.Id, serviceTerms)
    71  	})
    72  }
    73  
    74  func (s SqlServiceTermsStore) GetLatest(allowFromCache bool) store.StoreChannel {
    75  	return store.Do(func(result *store.StoreResult) {
    76  		if allowFromCache {
    77  			if serviceTermsCache.Len() == 0 {
    78  				if s.metrics != nil {
    79  					s.metrics.IncrementMemCacheMissCounter(serviceTermsCacheName)
    80  				}
    81  			} else {
    82  				if cacheItem, ok := serviceTermsCache.Get(serviceTermsCache.Keys()[0]); ok {
    83  					if s.metrics != nil {
    84  						s.metrics.IncrementMemCacheHitCounter(serviceTermsCacheName)
    85  					}
    86  
    87  					result.Data = cacheItem.(*model.ServiceTerms)
    88  					return
    89  				} else if s.metrics != nil {
    90  					s.metrics.IncrementMemCacheMissCounter(serviceTermsCacheName)
    91  				}
    92  			}
    93  		}
    94  
    95  		var serviceTerms *model.ServiceTerms
    96  
    97  		err := s.GetReplica().SelectOne(&serviceTerms, "SELECT * FROM ServiceTerms ORDER BY CreateAt DESC LIMIT 1")
    98  		if err != nil {
    99  			if err == sql.ErrNoRows {
   100  				result.Err = model.NewAppError("SqlServiceTermsStore.GetLatest", "store.sql_service_terms_store.get.no_rows.app_error", nil, "err="+err.Error(), http.StatusNotFound)
   101  			} else {
   102  				result.Err = model.NewAppError("SqlServiceTermsStore.GetLatest", "store.sql_service_terms_store.get.app_error", nil, "err="+err.Error(), http.StatusInternalServerError)
   103  			}
   104  		} else {
   105  			result.Data = serviceTerms
   106  
   107  			if allowFromCache {
   108  				serviceTermsCache.AddWithDefaultExpires(serviceTerms.Id, serviceTerms)
   109  			}
   110  		}
   111  	})
   112  }
   113  
   114  func (s SqlServiceTermsStore) Get(id string, allowFromCache bool) store.StoreChannel {
   115  	return store.Do(func(result *store.StoreResult) {
   116  		if allowFromCache {
   117  			if serviceTermsCache.Len() == 0 {
   118  				if s.metrics != nil {
   119  					s.metrics.IncrementMemCacheMissCounter(serviceTermsCacheName)
   120  				}
   121  			} else {
   122  				if cacheItem, ok := serviceTermsCache.Get(id); ok {
   123  					if s.metrics != nil {
   124  						s.metrics.IncrementMemCacheHitCounter(serviceTermsCacheName)
   125  					}
   126  
   127  					result.Data = cacheItem.(*model.ServiceTerms)
   128  					return
   129  				} else if s.metrics != nil {
   130  					s.metrics.IncrementMemCacheMissCounter(serviceTermsCacheName)
   131  				}
   132  			}
   133  		}
   134  
   135  		if obj, err := s.GetReplica().Get(model.ServiceTerms{}, id); err != nil {
   136  			result.Err = model.NewAppError("SqlServiceTermsStore.Get", "store.sql_service_terms_store.get.app_error", nil, "err="+err.Error(), http.StatusInternalServerError)
   137  		} else if obj == nil {
   138  			result.Err = model.NewAppError("SqlServiceTermsStore.GetLatest", "store.sql_service_terms_store.get.no_rows.app_error", nil, "", http.StatusNotFound)
   139  		} else {
   140  			result.Data = obj.(*model.ServiceTerms)
   141  		}
   142  	})
   143  }