hunk.code_window: 	EnableEmailBatching               *bool
   	EmailBatchingBufferSize           *int
   	EmailBatchingInterval             *int
   	SkipServerCertificateVerification *bool
   	EmailNotificationContentsType     *string
   }
   func (s *EmailSettings) SetDefaults() {
   	if len(s.InviteSalt) == 0 {
   		s.InviteSalt = NewRandomString(32)
  
hunk.labels: keep keep keep keep add keep keep keep keep keep
hunk.after_edit: 	LoginButtonColor                  *string
   	LoginButtonBorderColor            *string
   	LoginButtonTextColor              *string
  
hunk.file_path: model/config.go
hunk.type: add
file: /*
  	{4} ({1} and []{1})
  	--------------------------------------------------
  */
  
  // {4} gets the value as a {1}, returns the optionalDefault
  // value or a system default object if the value is the wrong type.
  func (v *Value) {4}(optionalDefault ...{1}) {1} {
  	if s, ok := v.data.({1}); ok {
  		return s
  	}
  	if len(optionalDefault) == 1 {
  		return optionalDefault[0]
  	}
  	return {3}
  }
  
  // Must{4} gets the value as a {1}.
  //
  // Panics if the object is not a {1}.
  func (v *Value) Must{4}() {1} {
  	return v.data.({1})
  }
  
  // {4}Slice gets the value as a []{1}, returns the optionalDefault
  // value or nil if the value is not a []{1}.
  func (v *Value) {4}Slice(optionalDefault ...[]{1}) []{1} {
  	if s, ok := v.data.([]{1}); ok {
  		return s
  	}
  	if len(optionalDefault) == 1 {
  		return optionalDefault[0]
  	}
  	return nil
  }
  
  // Must{4}Slice gets the value as a []{1}.
  //
  // Panics if the object is not a []{1}.
  func (v *Value) Must{4}Slice() []{1} {
  	return v.data.([]{1})
  }
  
  // Is{4} gets whether the object contained is a {1} or not.
  func (v *Value) Is{4}() bool {
    _, ok := v.data.({1})
    return ok
  }
  
  // Is{4}Slice gets whether the object contained is a []{1} or not.
  func (v *Value) Is{4}Slice() bool {
  	_, ok := v.data.([]{1})
  	return ok
  }
  
  // Each{4} calls the specified callback for each object
  // in the []{1}.
  //
  // Panics if the object is the wrong type.
  func (v *Value) Each{4}(callback func(int, {1}) bool) *Value {
  
  	for index, val := range v.Must{4}Slice() {
  		carryon := callback(index, val)
  		if carryon == false {
  			break
  		}
  	}
  
  	return v
  
  }
  
  // Where{4} uses the specified decider function to select items
  // from the []{1}.  The object contained in the result will contain
  // only the selected items.
  func (v *Value) Where{4}(decider func(int, {1}) bool) *Value {
  
  	var selected []{1}
  
  	v.Each{4}(func(index int, val {1}) bool {
  		shouldSelect := decider(index, val)
  		if shouldSelect == false {
  			selected = append(selected, val)
  		}
  		return true
  	})
  
  	return &Value{data:selected}
  
  }
  
  // Group{4} uses the specified grouper function to group the items
  // keyed by the return of the grouper.  The object contained in the
  // result will contain a map[string][]{1}.
  func (v *Value) Group{4}(grouper func(int, {1}) string) *Value {
  
  	groups := make(map[string][]{1})
  
  	v.Each{4}(func(index int, val {1}) bool {
  		group := grouper(index, val)
  		if _, ok := groups[group]; !ok {
  			groups[group] = make([]{1}, 0)
  		}
  		groups[group] = append(groups[group], val)
  		return true
  	})
  
  	return &Value{data:groups}
  
  }
  
  // Replace{4} uses the specified function to replace each {1}s
  // by iterating each item.  The data in the returned result will be a
  // []{1} containing the replaced items.
  func (v *Value) Replace{4}(replacer func(int, {1}) {1}) *Value {
  
  	arr := v.Must{4}Slice()
  	replaced := make([]{1}, len(arr))
  
  	v.Each{4}(func(index int, val {1}) bool {
  		replaced[index] = replacer(index, val)
  		return true
  	})
  
  	return &Value{data:replaced}
  
  }
  
  // Collect{4} uses the specified collector function to collect a value
  // for each of the {1}s in the slice.  The data returned will be a
  // []interface{}.
  func (v *Value) Collect{4}(collector func(int, {1}) interface{}) *Value {
  
  	arr := v.Must{4}Slice()
  	collected := make([]interface{}, len(arr))
  
  	v.Each{4}(func(index int, val {1}) bool {
  		collected[index] = collector(index, val)
  		return true
  	})
  
  	return &Value{data:collected}
  }
  
  // ************************************************************
  // TESTS
  // ************************************************************
  
  func Test{4}(t *testing.T) {
  
    val := {1}( {2} )
  	m := map[string]interface{}{"value": val, "nothing": nil}
  	assert.Equal(t, val, New(m).Get("value").{4}())
  	assert.Equal(t, val, New(m).Get("value").Must{4}())
  	assert.Equal(t, {1}({3}), New(m).Get("nothing").{4}())
  	assert.Equal(t, val, New(m).Get("nothing").{4}({2}))
  
  	assert.Panics(t, func() {
  		New(m).Get("age").Must{4}()
  	})
  
  }
  
  func Test{4}Slice(t *testing.T) {
  
    val := {1}( {2} )
  	m := map[string]interface{}{"value": []{1}{ val }, "nothing": nil}
  	assert.Equal(t, val, New(m).Get("value").{4}Slice()[0])
  	assert.Equal(t, val, New(m).Get("value").Must{4}Slice()[0])
  	assert.Equal(t, []{1}(nil), New(m).Get("nothing").{4}Slice())
  	assert.Equal(t, val, New(m).Get("nothing").{4}Slice( []{1}{ {1}({2}) } )[0])
  
  	assert.Panics(t, func() {
  		New(m).Get("nothing").Must{4}Slice()
  	})
  
  }
  
  func TestIs{4}(t *testing.T) {
  
  	var v *Value
  
  	v = &Value{data: {1}({2})}
  	assert.True(t, v.Is{4}())
  
  	v = &Value{data: []{1}{ {1}({2}) }}
  	assert.True(t, v.Is{4}Slice())
  
  }
  
  func TestEach{4}(t *testing.T) {
  
  	v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
  	count := 0
  	replacedVals := make([]{1}, 0)
  	assert.Equal(t, v, v.Each{4}(func(i int, val {1}) bool {
  
  		count++
  		replacedVals = append(replacedVals, val)
  
  		// abort early
  		if i == 2 {
  			return false
  		}
  
  		return true
  
  	}))
  
  	assert.Equal(t, count, 3)
  	assert.Equal(t, replacedVals[0], v.Must{4}Slice()[0])
  	assert.Equal(t, replacedVals[1], v.Must{4}Slice()[1])
  	assert.Equal(t, replacedVals[2], v.Must{4}Slice()[2])
  
  }
  
  func TestWhere{4}(t *testing.T) {
  
  	v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
  
  	selected := v.Where{4}(func(i int, val {1}) bool {
  		return i%2==0
  	}).Must{4}Slice()
  
  	assert.Equal(t, 3, len(selected))
  
  }
  
  func TestGroup{4}(t *testing.T) {
  
  	v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
  
  	grouped := v.Group{4}(func(i int, val {1}) string {
  		return fmt.Sprintf("%v", i%2==0)
  	}).data.(map[string][]{1})
  
  	assert.Equal(t, 2, len(grouped))
  	assert.Equal(t, 3, len(grouped["true"]))
  	assert.Equal(t, 3, len(grouped["false"]))
  
  }
  
  func TestReplace{4}(t *testing.T) {
  
  	v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
  
  	rawArr := v.Must{4}Slice()
  
  	replaced := v.Replace{4}(func(index int, val {1}) {1} {
  		if index < len(rawArr)-1 {
  			return rawArr[index+1]
  		}
  		return rawArr[0]
  	})
  
  	replacedArr := replaced.Must{4}Slice()
  	if assert.Equal(t, 6, len(replacedArr)) {
  		assert.Equal(t, replacedArr[0], rawArr[1])
  		assert.Equal(t, replacedArr[1], rawArr[2])
  		assert.Equal(t, replacedArr[2], rawArr[3])
  		assert.Equal(t, replacedArr[3], rawArr[4])
  		assert.Equal(t, replacedArr[4], rawArr[5])
  		assert.Equal(t, replacedArr[5], rawArr[0])
  	}
  
  }
  
  func TestCollect{4}(t *testing.T) {
  
  	v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
  
  	collected := v.Collect{4}(func(index int, val {1}) interface{} {
  		return index
  	})
  
  	collectedArr := collected.MustInterSlice()
  	if assert.Equal(t, 6, len(collectedArr)) {
  		assert.Equal(t, collectedArr[0], 0)
  		assert.Equal(t, collectedArr[1], 1)
  		assert.Equal(t, collectedArr[2], 2)
  		assert.Equal(t, collectedArr[3], 3)
  		assert.Equal(t, collectedArr[4], 4)
  		assert.Equal(t, collectedArr[5], 5)
  	}
  
  }
  