Golang agi.Session类代码示例

func ConfBridgeChannelRedirect(sess *agi.Session) {
	confno, err := sess.GetVariable("CONFNO")
	if err != nil {
		LoggerErr(err)
	} else {
		if confno.Dat == sess.Env["callerid"] {
			bridgepeer, err := sess.GetVariable("BRIDGEPEER")
			if err != nil {
				LoggerErr(err)
			}
			var rc1 = make(map[string]string)
			rc1["Channel"] = sess.Env["channel"]
			rc1["Exten"] = confno.Dat
			rc1["Context"] = CONFBRIDGE_CONTEXT
			var rc2 = make(map[string]string)
			rc2["Channel"] = bridgepeer.Dat
			rc2["Exten"] = confno.Dat
			rc2["Context"] = CONFBRIDGE_CONTEXT
			ConfBridgeSettings(sess.Env["uniqueid"])
			RedirectChan(rc1)
			RedirectChan(rc2)
			LoggerString(fmt.Sprintf("Try create Confbridge CONFNO %s Channel1 %s Channel2 %s",
				confno.Dat, sess.Env["channel"], bridgepeer.Dat))
		}
	}
}

func BlockedFromPSTN(sess *agi.Session) {
	dbinfo := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=%s",
		DBHost, DBPort, DBUser, DBPass, DBName, DBSSL)
	db, err := sql.Open(DBType, dbinfo)
	if err != nil {
		LoggerErr(err)
	}
	rows, err := db.Query(fmt.Sprintf(BLOCKPSTNQUERY, sess.Env["callerid"]))
	if err != nil {
		LoggerErr(err)
	}
	defer rows.Close()
	var arg1, arg2 string
	for rows.Next() {
		rows.Scan(&arg1, &arg2)
	}
	db.Close()
	if len(arg1) != 0 && len(arg2) != 0 {
		_, err := sess.Exec("UserEvent", fmt.Sprintf(UEBLOCKEDABON, sess.Env["callerid"], sess.Env["uniqueid"]))
		if err != nil {
			LoggerErr(err)
		}
		sess.Hangup()
	}
}

//test
func checkIP(ipip string, sess *agi.Session) {
	useragent, err := sess.GetVariable("CHANNEL(useragent)")
	if err != nil {
		LoggerErr(err)
	}
	sipuri, err := sess.GetVariable("SIPURI")
	if err != nil {
		LoggerErr(err)
	}
	anet := false
	cip := net.ParseIP(ipip)
	for _, iprange := range ALLOW {
		ip, ipnet, err := net.ParseCIDR(iprange)
		if err != nil {
			LoggerErr(err)
		}
		for ip := ip.Mask(ipnet.Mask); ipnet.Contains(ip); inc(ip) {
			if ip.String() == cip.String() {
				LoggerString("IP FROM ALLOW NETWORK " + ip.String())
				msg := fmt.Sprintf("User Agent: %s\nSIPURI: %s\nExtension: %s\nCallerid: %s",
					useragent.Dat, sipuri.Dat, sess.Env["extension"], sess.Env["callerid"])
				NotifyTG(msg)
				anet = true
				return
			}
		}
	}
	if anet == false {
		whoisIP(ipip)
	}
}

func Gegensprechanlage(sess *agi.Session) {
	tf := timeFormat2()
	rf := fmt.Sprintf("%s%s_%s_%s%s", DFVAR0[0], tf, sess.Env[DFVAR1[0]], sess.Env[DFVAR1[1]], DFVAR0[1])
	_, err := sess.Exec(DFVAR2, rf)
	if err != nil {
		LoggerErr(err)
	}
}

func eBackground(sess *agi.Session, dir string, phrases []string) {
	for _, phrase := range phrases {
		sess.Verbose("Phrase: " + phrase)
		_, err := sess.Exec("Background", fmt.Sprintf("%s%s", dir, phrase))
		if err != nil {
			LoggerErr(err)
		}
	}
}

func SetNY(sess *agi.Session) {
	NYG = arrayShuffle(NYG)
	f := strings.Split(NYG[0], ".")
	find := false
	for _, g := range f {
		if g == NYVAR1 {
			find = true
		}
	}
	if find == true {
		_, err := sess.Exec(NYVAR2, fmt.Sprintf("%s%s", NYVAR0[1], f[0]))
		if err != nil {
			LoggerErr(err)
		}
	}
}

func QueuePrio(sess *agi.Session) {
	var r = make(map[string]string)
	r[AMIVAR0[0]] = AMIVAR0[1]
	r[AMIVAR0[1]] = AMIVARUE0
	v6, err := sess.GetVariable(CUSTVARA6)
	v7, err := sess.GetVariable(CUSTVARA7)
	v8, err := sess.GetVariable(CUSTVARA8)
	if err != nil {
		LoggerErr(err)
	}
	r[AMIVARQ0[0]] = AMIVARQ0[1]
	r[AMIVARQ1] = sess.Env[CUSTVARC1]
	r[AMIVARQ2] = sess.Env[CUSTVARC2]
	r[AMIVARQ3] = sess.Env[CUSTVARC3]
	r[AMIVARQ6] = v6.Dat
	r[AMIVARQ7] = v7.Dat
	r[AMIVARQ8] = v8.Dat
	LoggerMap(r)
	amiAction(r)
}

func BanIpFromPSTN(sess *agi.Session) {
	useragent, err := sess.GetVariable("CHANNEL(useragent)")
	if err != nil {
		LoggerErr(err)
	} else {
		LoggerString("UserAgent " + useragent.Dat)
	}
	sipuri, err := sess.GetVariable("SIPURI")
	if err != nil {
		LoggerErr(err)
	} else {
		LoggerString("SIPURI " + sipuri.Dat)
	}
	var BAN = make(map[string]string)
	rex, err := regexp.Compile(`^sip:(\S*)\@(\S*)\:(\S*)$`)
	res := rex.FindStringSubmatch(sipuri.Dat)
	if res != nil {
		BAN["num"] = res[1]
		BAN["ip"] = res[2]
		BAN["port"] = res[3]
	}
	rex1, err := regexp.Compile(`^sip:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$`)
	res1 := rex1.FindStringSubmatch(sipuri.Dat)
	if res1 != nil {
		BAN["num"] = ""
		BAN["ip"] = res1[1]
		BAN["port"] = ""
	}
	rex2, err := regexp.Compile(`^sip:(\S*)\@(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$`)
	res2 := rex2.FindStringSubmatch(sipuri.Dat)
	if res2 != nil {
		BAN["num"] = res2[1]
		BAN["ip"] = res2[2]
		BAN["port"] = ""
	}
	LoggerMap(BAN)
	if err != nil {
		LoggerString("ERR")
	}
	checkIP(BAN["ip"], sess)
}

func CustomerGet(sess *agi.Session, cc string) ([]CustomerJ, error) {
	var q string
	if cc == "p" {
		q = fmt.Sprintf(CUSTURLQ0[0], sess.Env[CUSTVARC0])
	} else if cc == "c" {
		c, err := sess.GetVariable(CUSTVARA3)
		if err != nil {
			LoggerErr(err)
		} else {
			LoggerString(c.Dat)
		}
		q = fmt.Sprintf(CUSTURLQ0[1], c.Dat)
	}
	rsp, err := http.NewRequest(CUSTURL2[0], fmt.Sprintf(CUSTURL2[1], q), nil)
	rq, err := http.DefaultClient.Do(rsp)
	if err != nil {
		return nil, err
	}
	defer rq.Body.Close()
	body, err := ioutil.ReadAll(rq.Body)
	line := strings.Replace(string(body), CUSTVARR0[0], CUSTVARR0[1], -1)
	line = strings.Replace(string(line), CUSTVARR1[0], CUSTVARR1[1], -1)
	line = strings.Replace(string(line), CUSTVARR2[0], CUSTVARR2[1], -1)
	line = strings.Replace(string(line), CUSTVARR3[0], CUSTVARR3[1], -1)
	line = strings.Replace(string(line), CUSTVARR4[0], CUSTVARR4[1], -1)
	line = strings.Replace(string(line), CUSTVARR5[0], CUSTVARR5[1], -1)
	line = strings.Replace(string(line), CUSTVARR6[0], CUSTVARR6[1], -1)
	line = strings.Replace(string(line), CUSTVARR7[0], CUSTVARR7[1], -1)
	line = strings.Replace(string(line), CUSTVARR8[0], CUSTVARR8[1], -1)
	var customerJ []CustomerJ
	err = json.Unmarshal([]byte(line), &customerJ)
	if err != nil {
		return nil, err
	}
	return customerJ, nil
}

func agiSess(sess *agi.Session) {
	var err error
	startvar, err := sess.GetVariable("STARTVAR")
	if err == nil {
		switch startvar.Dat {
		case "inbound":
			InboundCall(sess)
		case "block":
			BanIpFromPSTN(sess)
		case "confbridge_access":
			ConfBridgeAccess(sess)
		case "confbridge_channelredirect":
			ConfBridgeChannelRedirect(sess)
		case "confbridge_confs":
			ConfBridgeConfs(sess)
		case "callback_call":
			CallbackCheck(sess)
		case "fax_receive":
			FaxRecv(sess)
		case "blocked_from_pstn":
			BlockedFromPSTN(sess)
		case "balance":
			BalanceInfo(sess)
		case "target_call":
			TargetCall(sess)
		case "call1":
			Call1(sess)
		case "customer_get_test_0":
			CustomerCheck(sess, "p")
		case "customer_get_test_1":
			CustomerCheck(sess, "c")
		case "queue_prio":
			QueuePrio(sess)
		case "ny":
			SetNY(sess)
		case "df":
			Gegensprechanlage(sess)
		default:
			sess.Verbose("DEFAULT STARTVAR")
		}
	}
	sess.Verbose("================== Complete ======================")
	sess.Verbose("STARTVAR IS " + startvar.Dat)
	return
}

func InboundCall(sess *agi.Session) {
	//	LoggerString("INCOMING NUM    " + sess.Env["callerid"])
	rex, err := regexp.Compile(`^[7|8](\d{10})$`)
	res := rex.FindStringSubmatch(sess.Env["callerid"])
	if res != nil {
		LoggerString("RES NOT NIL " + sess.Env["callerid"])
		_, err := sess.SetVariable("CALLERID(num)", res[1])
		if err != nil {
			LoggerErr(err)
		} else {
			LoggerString("NUM CHANGED TO  " + res[1])
		}
		_, err = sess.SetVariable("CALLERID(name)", res[1])
		if err != nil {
			LoggerErr(err)
		}
	} else {
		//		LoggerString("NUM NOT CHANGED " + sess.Env["callerid"])
	}
	if err != nil {
		LoggerErr(err)
	}
	rex2, err := regexp.Compile(`^([a|A]nonymous|unknown)$`)
	res2 := rex2.FindStringSubmatch(sess.Env["calleridname"])
	if res2 != nil {
		LoggerString("RES2 " + res2[1])
		_, err := sess.SetVariable("CALLERID(name)", "0")
		if err != nil {
			LoggerErr(err)
		} else {
			LoggerString("NAME CHANGED TO 0")
		}
	}
	rex3, err := regexp.Compile(`^([a|A]nonymous|unknown)$`)
	res3 := rex3.FindStringSubmatch(sess.Env["callerid"])
	if res3 != nil {
		LoggerString("RES3 " + res3[1])
		_, err := sess.SetVariable("CALLERID(num)", "0")
		if err != nil {
			LoggerErr(err)
		} else {
			LoggerString("NUM CHANGED TO 0")
		}
	}
}

func ConfBridgeConfs(sess *agi.Session) {
	_, err := sess.Exec("DumpChan", "255")
	if err != nil {
		LoggerErr(err)
	}
	_, err = sess.SetVariable("__CONFNO", sess.Env["extension"])
	if err != nil {
		LoggerErr(err)
	}
	_, err = sess.Exec("ConfBridge", fmt.Sprintf("%s,,,%s", sess.Env["extension"], UMENU))
	if err != nil {
		LoggerErr(err)
	}
	LoggerString("Confbridge Admin add " + sess.Env["extension"])
}

func FaxRecv(sess *agi.Session) {
	sess.Answer()
	uid := strings.Split(sess.Env["uniqueid"], ".")
	_, err := sess.SetVariable("FAXFILENAME", fmt.Sprintf("%s_%s_%s", sess.Env["callerid"], sess.Env["dnid"], uid[0]))
	_, err = sess.SetVariable("FAXOPT(headerinfo)", fmt.Sprintf("Received_by_%s_%s", sess.Env["callerid"], uid[0]))
	_, err = sess.SetVariable("FAXOPT(localstationid)", sess.Env["callerid"])
	_, err = sess.SetVariable("FAXOPT(maxrate)", "14400")
	_, err = sess.SetVariable("FAXOPT(minrate)", "4800")
	filename, err := sess.GetVariable("FAXFILENAME")
	_, err = sess.Exec("ReceiveFax", fmt.Sprintf(FAXDIR+FAXRECVSTR, filename.Dat))
	if err != nil {
		LoggerErr(err)
	} else {
		fs, err := sess.GetVariable("FAXSTATUS")
		fp, err := sess.GetVariable("FAXPAGES")
		fb, err := sess.GetVariable("FAXBITRATE")
		fr, err := sess.GetVariable("FAXRESOLUTION")
		if err != nil {
			LoggerErr(err)
		}
		if fs.Dat == "" || fs.Dat == "FAILED" {
			fs.Dat = "FAILED"
		}
		msg := fmt.Sprintf("Статус: %s\nС номера: %s\nНа номер: %s\nКоличество страниц: %s\nСкорость передачи(bitrate): %s\nРазрешение файла: %s",
			fs.Dat,
			sess.Env["callerid"],
			sess.Env["dnid"],
			fp.Dat,
			fb.Dat,
			fr.Dat)
		NotifyMail("ФаксВходящий", sess.Env["callerid"], msg, MAIL)
		NotifyMail("ФаксВходящий", sess.Env["callerid"], msg, "fax-"+sess.Env["dnid"])
	}
	sess.Hangup()
}

func BalanceInfo(sess *agi.Session) {
	b, err := sess.GetVariable(BALANCE)
	if err != nil {
		LoggerErr(err)
	} else {
		LoggerString(b.Dat)
	}
	c, err := sess.GetVariable(BALCONTRACT)
	if err != nil {
		LoggerErr(err)
	}
	sess.Verbose(fmt.Sprintf("BALANCE: %s %s %s", b.Dat, c.Dat, sess.Env["callerid"]))
	LoggerString(fmt.Sprintf("BALANCE: %s %s %s", b.Dat, c.Dat, sess.Env["callerid"]))
	bi, err := strconv.Atoi(b.Dat)
	sess.Verbose("BALANCE TO INT")
	bif, err := strconv.ParseFloat(b.Dat, 64)
	sess.Verbose(bi)
	sess.Verbose(bif)
	FILES := make([]string, 0)
	if bif < 0 {
		sess.Verbose("< 0")
		FILES = []string{BALNOMONEY, BALONCONRACT, BALMINUS}
		eBackground(sess, BALDIR, FILES)
		/*
			} else if bif > 0 && bif < 500 {
				sess.Verbose("0 > < 500")
				FILES = []string{BALONCONRACT}
				eBackground(sess, BALDIR, FILES)
			} else if bif > 500 {
				sess.Verbose("> 500")
				FILES = []string{BALRICH, BALONCONRACT}
				eBackground(sess, BALDIR, FILES)
		*/
	} else {
		sess.Verbose("ELSE")
		FILES = []string{BALONCONRACT}
		eBackground(sess, BALDIR, FILES)
	}
	bii := strconv.FormatFloat(bif, 'g', 10, 64)
	rex, err := regexp.Compile(`^(\d+)\.(\d{2})\d*$`)
	res := rex.FindStringSubmatch(bii)
	if res != nil {
		sess.Verbose(res[1] + " " + res[2])
		rub := res[1]
		kop := res[2]
		rex2, err := regexp.Compile(`^0(\d+)$`)
		res2 := rex2.FindStringSubmatch(kop)
		if res2 != nil {
			kop = res2[1]
		}
		if err != nil {
			LoggerErr(err)
		}
		BalanceDigits(sess, BALRUB, rub)
		BalanceDigits(sess, BALKOP, kop)
	}
	rex3, err := regexp.Compile(`^(\d+)\.(\d{1})$`)
	res3 := rex3.FindStringSubmatch(bii)
	if res3 != nil {
		sess.Verbose(res3[1] + " " + res3[2])
		rub := res3[1]
		kop := res3[2]
		BalanceDigits(sess, BALRUB, rub)
		BalanceDigits(sess, BALKOP, kop)
	}
	rex4, err := regexp.Compile(`^(\d+)$`)
	res4 := rex4.FindStringSubmatch(bii)
	if res4 != nil {
		sess.Verbose(res4[1])
		rub := res4[1]
		if rub == "0" {
			FILES = []string{"0", BALRUB + "-i", "0", BALKOP + "-k"}
			eBackground(sess, BALDDIR, FILES)
		} else {
			BalanceDigits(sess, BALRUB, rub)
		}
	}
	rex5, err := regexp.Compile(`^\-(\d+)\.(\d{2})\d*$`)
	res5 := rex5.FindStringSubmatch(bii)
	if res5 != nil {
		sess.Verbose(res5[1] + " " + res5[2])
		rub := res5[1]
		kop := res5[2]
		rex55, err := regexp.Compile(`^0(\d+)$`)
		res55 := rex55.FindStringSubmatch(kop)
		if res55 != nil {
			kop = res55[1]
		}
		if err != nil {
			LoggerErr(err)
		}
		BalanceDigits(sess, BALRUB, rub)
		BalanceDigits(sess, BALKOP, kop)
	}
	rex6, err := regexp.Compile(`^\-(\d+)$`)
	res6 := rex6.FindStringSubmatch(bii)
	if res6 != nil {
		sess.Verbose(res6[1])
		rub := res6[1]
		if rub == "0" {
//.........这里部分代码省略.........

func CustomerCheck(sess *agi.Session, cc string) {
	CSTMR := make(map[int][]map[string]string)
	customer, err := CustomerGet(sess, cc)
	if err != nil {
		fmt.Println(err.Error())
	} else {
		i := 0
		for _, cust := range customer {
			cstmr := make(map[string]string)
			if cust.Var6 == "2" && cust.Var3 == "0" {
				if sess.Env[CUSTVARC0] != cust.Var7[1:] {
					LoggerString(fmt.Sprintf("%s != %s %s", sess.Env[CUSTVARC0], cust.Var7[1:], "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"))
				}
				cstmr[CUSTVARR0[0]] = cust.Var0
				cstmr[CUSTVARR1[0]] = cust.Var1
				cstmr[CUSTVARR2[0]] = cust.Var2
				cstmr[CUSTVARR3[0]] = cust.Var3
				cstmr[CUSTVARR4[0]] = cust.Var4
				cstmr[CUSTVARR5[0]] = cust.Var5
				cstmr[CUSTVARR6[0]] = cust.Var6
				cstmr[CUSTVARR7[0]] = cust.Var7
				cstmr[CUSTVARR8[0]] = cust.Var8
				LoggerString("\n" +
					CUSTVARC0 + " " + sess.Env[CUSTVARC0] + "\n" +
					CUSTVARR0[0] + " " + cust.Var0 + "\n" +
					CUSTVARR1[0] + " " + cust.Var1 + "\n" +
					CUSTVARR2[0] + " " + cust.Var2 + "\n" +
					CUSTVARR3[0] + " " + cust.Var3 + "\n" +
					CUSTVARR4[0] + " " + cust.Var4 + "\n" +
					CUSTVARR5[0] + " " + cust.Var5 + "\n" +
					CUSTVARR6[0] + " " + cust.Var6 + "\n" +
					CUSTVARR7[0] + " " + cust.Var7[1:] + "\n" +
					CUSTVARR8[0] + " " + cust.Var8 + "\n")
				CSTMR[i] = append(CSTMR[i], cstmr)
				i++
			}
		}
		ii := strconv.Itoa(i)
		if i == 1 {
			/*
				_, err := sess.SetVariable(CUSTVARA0, ii)
			*/

			_, err = sess.SetVariable(CUSTVARA1, CSTMR[0][0][CUSTVARR1[0]])
			/*
				_, err = sess.SetVariable(CUSTVARA2, CSTMR[0][0][CUSTVARR2[0]])
				_, err = sess.SetVariable(CUSTVARA5, CSTMR[0][0][CUSTVARR5[0]])
			*/
			if err != nil {
				LoggerErr(err)
			}
			LoggerString("\n===================================================\n" +
				CUSTVARA0 + " " + ii + "\n" +
				CUSTVARA1 + " " + CSTMR[0][0][CUSTVARR1[0]] + "\n" +
				CUSTVARA2 + " " + CSTMR[0][0][CUSTVARR2[0]] + "\n" +
				CUSTVARA5 + " " + CSTMR[0][0][CUSTVARR5[0]] + "\n" +
				CUSTVARR0[0] + " Count: " + ii + "\n" +
				"===================================================\n")
		} else if i > 1 {
			/*
				_, err := sess.SetVariable(CUSTVARA0, ii)
				if err != nil {
					LoggerErr(err)
				}
			*/
			LoggerString("\n===================================================\n")
			LoggerString(CUSTVARA0 + " " + ii)
			/*
			   			for _, vr := range CSTMR {
			   				LoggerString("++++++!!!!!!!!!!!!!!!!")
			   //				LoggerMap2(vr)

			   				if vr[0][CUSTVARR5[0]] == "1" {
			   					LoggerString(vr[0][CUSTVARR5[0]])
			   					_, err = sess.SetVariable(CUSTVARA5, CSTMR[0][0][CUSTVARR5[0]])
			   					if err != nil {
			   						LoggerErr(err)
			   					}
			   				}

			   				LoggerString("++++++!!!!!!!!!!!!!!!!")
			   			}
			*/
			LoggerString(CUSTVARR0[0] + " Count: " + ii + "\n" +
				"===================================================\n")
		} else {
			LoggerString("\n===================================================\n" +
				CUSTVARC0 + " " + sess.Env[CUSTVARC0] + "\n" +
				CUSTVARR0[0] + " Count: " + ii + "\n" +
				"===================================================\n")
			/*
				_, err = sess.SetVariable(CUSTVARA0, "0")
			*/
			_, err = sess.SetVariable(CUSTVARA1, "0")
			/*
				_, err = sess.SetVariable(CUSTVARA2, "N")
				_, err = sess.SetVariable(CUSTVARA5, "N")
			*/
			if err != nil {
				LoggerErr(err)
//.........这里部分代码省略.........