ref

Author: sshaplygin

README.md

@@ -60,9 +60,9 @@ if err != nil {
 }
 if !isValid {
   log.Println("INN is invalid")
-  return
+} else {
+  log.Println("INN is valid")
 }
-log.Println("INN is valid")
 ```
 
 ## Documentation

fts/fts.go

@@ -51,9 +51,21 @@ func (trc *TaxRegionCode) Ints() []int {
 		return nil
 	}
 
-	res := make([]int, 0, subjectCodeLength+regionTaxServiceNumberLength)
-	res = append(res, utils.CodeToInts(int(trc.subjectCode))...)
-	res = append(res, utils.CodeToInts(int(trc.serviceNumber))...)
+	res := make([]int, subjectCodeLength+regionTaxServiceNumberLength)
+
+	nums := utils.CodeToInts(int(trc.subjectCode))
+	idx := subjectCodeLength - 1
+	for i := len(nums) - 1; i >= 0; i-- {
+		res[idx] = nums[i]
+		idx--
+	}
+
+	nums = utils.CodeToInts(int(trc.serviceNumber))
+	idx = len(res) - 1
+	for i := len(nums) - 1; i >= 0; i-- {
+		res[idx] = nums[i]
+		idx--
+	}
 
 	return res
 }

inn/inn.go

@@ -24,21 +24,10 @@ func Generate() string {
 
 // GenerateLegal generate legal type inn string value
 func GenerateLegal() string {
-	// inn := strconv.FormatInt(utils.RandomDigits(9), 10)
-	// innArr, _ := transformInn(inn)
-
-	// return strings.Join([]string{inn, strconv.Itoa(hash10(innArr))}, "")
 	return NewINN(INNType(utils.RandomDigits(1)%2 + 1)).String()
 }
 
 // GeneratePhysical generate physical type inn string value
 func GeneratePhysical() string {
-	// inn := strconv.FormatInt(utils.RandomDigits(10), 10)
-	// innArr, _ := transformInn(inn)
-
-	// hash1Num := hash11(innArr)
-	// innArr = append(innArr, hash1Num)
-
-	// return strings.Join([]string{inn, strconv.Itoa(hash1Num), strconv.Itoa(hash12(innArr))}, "")
 	return NewINN(INNType(Physical)).String()
 }

inn/inn_test.go

@@ -4,11 +4,9 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/sshaplygin/docs-code/models"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-
-	"github.com/sshaplygin/docs-code/models"
-	"github.com/sshaplygin/docs-code/utils"
 )
 
 func TestValidate(t *testing.T) {
@@ -107,9 +105,9 @@ func TestGenerate(t *testing.T) {
 		for i := 0; i < 10; i++ {
 			inn = GenerateLegal()
 			isValid, err := Validate(inn)
-			require.NoError(t, err)
+			require.NoError(t, err, inn)
 
-			require.True(t, isValid)
+			require.True(t, isValid, inn)
 		}
 	})
 
@@ -119,9 +117,9 @@ func TestGenerate(t *testing.T) {
 		for i := 0; i < 10; i++ {
 			inn = GeneratePhysical()
 			isValid, err := Validate(inn)
-			require.NoError(t, err)
+			require.NoError(t, err, inn)
 
-			require.True(t, isValid)
+			require.True(t, isValid, inn)
 		}
 	})
 
@@ -131,46 +129,9 @@ func TestGenerate(t *testing.T) {
 		for i := 0; i < 10; i++ {
 			inn = Generate()
 			isValid, err := Validate(inn)
-			require.NoError(t, err)
-
-			require.True(t, isValid)
-		}
-	})
-
-	t.Run("generate random digits", func(t *testing.T) {
-		tests := []struct {
-			len int
-			min int64
-			max int64
-		}{
-			{
-				-5,
-				0,
-				9,
-			},
-			{
-				-10,
-				0,
-				9,
-			},
-			{
-				1,
-				0,
-				9,
-			},
-			{
-				3,
-				100,
-				999,
-			},
-		}
-		var digits int64
-
-		for _, tc := range tests {
-			tc := tc
+			require.NoError(t, err, inn)
 
-			digits = utils.RandomDigits(tc.len)
-			assert.True(t, digits >= tc.min && digits <= tc.max)
+			require.True(t, isValid, inn)
 		}
 	})
 }

inn/models.go

@@ -19,8 +19,8 @@ const (
 )
 
 const (
-	legalSerialNumberLength    = 4
-	physicalSerialNumberLength = 5
+	legalSerialNumberLength    = 5
+	physicalSerialNumberLength = 6
 )
 
 type INNType uint
@@ -43,17 +43,44 @@ const (
 	ForeignLegal
 )
 
-type SerialNumber int
+type SerialNumber struct {
+	val  int
+	size int
+}
 
 func (sn SerialNumber) String() string {
-	return strconv.Itoa(int(sn))
+	return utils.StrCode(sn.val, sn.size)
+}
+
+func (sn *SerialNumber) Ints() []int {
+	if sn == nil {
+		return nil
+	}
+
+	res := make([]int, sn.size)
+	nums := utils.CodeToInts(sn.val)
+
+	idx := len(res) - 1
+	for i := len(nums) - 1; i >= 0; i-- {
+		res[idx] = nums[i]
+		idx--
+	}
+
+	return res
 }
 
 func GenerateSerailNumber(innType INNType) SerialNumber {
 	if innType == Physical {
-		return SerialNumber(utils.RandomDigits(physicalSerialNumberLength))
+		return SerialNumber{
+			val:  int(utils.RandomDigits(physicalSerialNumberLength)),
+			size: physicalSerialNumberLength,
+		}
+	}
+
+	return SerialNumber{
+		val:  int(utils.RandomDigits(legalSerialNumberLength)),
+		size: legalSerialNumberLength,
 	}
-	return SerialNumber(utils.RandomDigits(legalSerialNumberLength))
 }
 
 type CheckSums []int
@@ -67,6 +94,27 @@ func (cs CheckSums) String() string {
 	return res.String()
 }
 
+func GenerateCheckSums(innType INNType, nums []int) CheckSums {
+	checkFuncs := []checkSumFuncType{
+		hash10,
+	}
+
+	shiftIdx := -1
+	if innType == Physical {
+		shiftIdx = -2
+		checkFuncs = []checkSumFuncType{
+			hash11, hash12,
+		}
+	}
+
+	for _, f := range checkFuncs {
+		nums = append(nums, f(nums))
+	}
+
+	fmt.Println(nums[len(nums)+shiftIdx:])
+	return nums[len(nums)+shiftIdx:]
+}
+
 type INNStruct struct {
 	taxRegionCode *fts.TaxRegionCode
 	serialNumber  SerialNumber
@@ -82,6 +130,7 @@ func NewINN(innType INNType) *INNStruct {
 	return &INNStruct{
 		taxRegionCode: taxRegionCode,
 		serialNumber:  serialNumber,
+		checkSums:     GenerateCheckSums(innType, append(taxRegionCode.Ints(), serialNumber.Ints()...)),
 	}
 }
 
@@ -99,17 +148,19 @@ func ParseINN(inn string) (*INNStruct, error) {
 	}
 
 	t := Physical
-	parseIdx := len(inn) - 3
+	snSize := physicalSerialNumberLength
+	parseIdx := len(inn) - 2
 	if len(inn) == legalLength {
+		snSize = legalSerialNumberLength
 		t = Legal
-		parseIdx = len(inn) - 2
+		parseIdx = len(inn) - 1
 		const foreignLegalStartWith = "9909"
 		if inn[0:4] == foreignLegalStartWith {
 			t = ForeignLegal
 		}
 	}
 
-	seraclNumberArr, err := utils.StrToArr(inn[4:parseIdx])
+	serialNumberArr, err := utils.StrToArr(inn[4:parseIdx])
 	if err != nil {
 		return nil, fmt.Errorf("parse raw serial number %s: %w", packageName, err)
 	}
@@ -121,9 +172,12 @@ func ParseINN(inn string) (*INNStruct, error) {
 
 	return &INNStruct{
 		taxRegionCode: taxRegionCode,
-		serialNumber:  SerialNumber(utils.SliceToInt(seraclNumberArr)),
-		checkSums:     checkSums,
-		t:             t,
+		serialNumber: SerialNumber{
+			val:  utils.SliceToInt(serialNumberArr),
+			size: snSize,
+		},
+		checkSums: checkSums,
+		t:         t,
 	}, nil
 }
 
@@ -134,14 +188,14 @@ func (inn *INNStruct) IsValid() (bool, error) {
 		return false, ErrNilINN
 	}
 
-	nums := append(inn.taxRegionCode.Ints(), utils.CodeToInts(int(inn.serialNumber))...)
+	nums := append(inn.taxRegionCode.Ints(), inn.serialNumber.Ints()...)
 
 	checkFuncs := []checkSumFuncType{
 		hash10,
 	}
 
 	if inn.IsPhysical() {
-		if len(nums) != physicalLength {
+		if len(nums) != physicalLength-2 {
 			return false, fmt.Errorf("invalid nums length for %s type", inn.t)
 		}
 
@@ -155,7 +209,7 @@ func (inn *INNStruct) IsValid() (bool, error) {
 	}
 
 	if inn.IsLegal() {
-		if len(nums) != legalLength {
+		if len(nums) != legalLength-1 {
 			return false, fmt.Errorf("invalid nums length for %s type", inn.t)
 		}
 
@@ -176,23 +230,15 @@ func (inn *INNStruct) IsValid() (bool, error) {
 
 func (inn *INNStruct) String() string {
 	n := physicalLength
-	snRequired := physicalSerialNumberLength
 	if inn.IsLegal() {
 		n = legalLength
-		snRequired = legalSerialNumberLength
 	}
 
 	var res strings.Builder
 	res.Grow(n)
 
 	res.WriteString(inn.taxRegionCode.String())
-
-	sn := inn.serialNumber.String()
-	if len(sn) < snRequired {
-		sn = strings.Repeat("0", snRequired-len(sn)) + sn
-	}
-
-	res.WriteString(sn)
+	res.WriteString(inn.serialNumber.String())
 	res.WriteString(inn.checkSums.String())
 
 	return res.String()

utils/helpers_test.go

@@ -100,3 +100,40 @@ func Test_Generate_InvalidInput(t *testing.T) {
 		})
 	}
 }
+
+func Test_GenerateRandomDigits(t *testing.T) {
+	tests := []struct {
+		len int
+		min int64
+		max int64
+	}{
+		{
+			-5,
+			0,
+			9,
+		},
+		{
+			-10,
+			0,
+			9,
+		},
+		{
+			1,
+			0,
+			9,
+		},
+		{
+			3,
+			100,
+			999,
+		},
+	}
+	var digits int64
+
+	for _, tc := range tests {
+		tc := tc
+
+		digits = RandomDigits(tc.len)
+		assert.True(t, digits >= tc.min && digits <= tc.max)
+	}
+}