Esempio n. 1
0
func ExportTrace() {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	traceArr := make([]TraceDBInfo, 0)
	err := session.DB("detector").C("detector_report").Find(bson.M{"org_code": bson.M{"$ne": "555400905"}}).Sort("-_id").Limit(1000).All(&traceArr)
	if err != nil {
		log.Println(err)
		return
	}

	outArr := make([]TraceInfo, 0)
	for _, e := range traceArr {
		detectorDBInfo := DetectorDBInfo{}
		session.DB("detector").C("detector_info").FindId(e.ApMac).One(&detectorDBInfo)
		ApMac := strings.ToUpper(e.ApMac[len(e.ApMac)-12:])
		var trace TraceInfo
		trace.MAC = FormatMac(e.DeviceMac)
		trace.TYPE = 2
		trace.START_TIME = e.Time
		trace.BSSID = FormatMac(ApMac)
		trace.XPOINT = strconv.FormatFloat(e.Longitude, 'f', 6, 64)
		trace.YPOINT = strconv.FormatFloat(e.Latitude, 'f', 6, 64)
		trace.DEVMAC = FormatMac(ApMac)
		trace.DEVICENUM = OrgCode + ApMac
		trace.SERVICECODE = ServiceCodePrefix + fmt.Sprintf("%06d", detectorDBInfo.No)
		outArr = append(outArr, trace)
	}

	jsonString, err := json.Marshal(outArr)
	if err != nil {
		return
	}
	log.Print(string(jsonString))
	SaveFile(string(jsonString), "001")
}
Esempio n. 2
0
func SaveBehaviorLog(orgcode string, data []map[string]string) {
	log.Println("SaveLog")
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	c := session.DB("person_info").C("behavior_log")
	bulk := c.Bulk()
	for i, fields := range data {
		log.Println(i, fields)
		mac := fields["MAC"]
		mac = filterMac(mac)
		IpInt, err4 := strconv.ParseInt(fields["DST_IP"], 10, 64)
		Ip := inet_ntoa(IpInt)
		port := fields["DST_PORT"]
		lng, err1 := strconv.ParseFloat(fields["LONGITUDE"], 64)
		lat, err2 := strconv.ParseFloat(fields["LATITUDE"], 64)
		if orgcode == "779852855" && err2 != nil {
			lat, err2 = strconv.ParseFloat(fields["LAITTUDE"], 64)
		}
		time, err3 := strconv.Atoi(fields["CAPTURE_TIME"])
		if err1 != nil || err2 != nil || err3 != nil || err4 != nil {
			log.Println("error:", err1, err2, err3, err4)
			continue
		}
		lng, lat = data_file.Bd09towgs84(lng, lat)
		if saveToDB {
			//c.Insert(fields)
			bulk.Insert(bson.M{"mac": mac, "dst_ip": Ip, "dst_port": port, "longitude": lng, "latitude": lat, "org_code": orgcode, "time": uint32(time)})
		}
	}
	bulk.Run()
}
Esempio n. 3
0
func ConvertGeo() {
	c := db.GetDBSession().DB("detector").C("detector_report")
	c2 := db.GetDBSession().Copy().DB("detector").C("detector_report")
	query := c.Find(bson.M{"org_code": "555400905"})
	iter := query.Iter()
	e := bson.M{}
	for iter.Next(&e) {
		id, _ := e["_id"]
		idStr := id.(bson.ObjectId)
		log.Println(idStr)
		lng := GetNumber(e, "longitude")
		lat := GetNumber(e, "latitude")
		lng, lat = data_file.Bd09towgs84(lng, lat)
		c2.UpdateId(e["_id"], bson.M{"$set": bson.M{"longitude": lng, "latitude": lat}})
	}
}
Esempio n. 4
0
func SaveTraceInfo(orgcode string, data []map[string]string) {
	log.Println("SaveTraceInfo")
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	c := session.DB("detector").C("detector_report")
	bulk := c.Bulk()
	for i, fields := range data {
		//log.Println(fields)
		mac := fields["MAC"]
		mac = filterMac(mac)
		ap_mac := fields["ACCESS_AP_MAC"]
		ap_mac = filterMac(ap_mac)
		lng, err1 := strconv.ParseFloat(fields["COLLECTION_EQUIPMENT_LONGITUDE"], 64)
		lat, err2 := strconv.ParseFloat(fields["COLLECTION_EQUIPMENT_LATITUDE"], 64)
		time, err3 := strconv.Atoi(fields["CAPTURE_TIME"])
		if err1 != nil || err2 != nil || err3 != nil {
			continue
		}
		lng, lat = data_file.Bd09towgs84(lng, lat)
		log.Println(i, ": mac", mac, "ap_mac", ap_mac, "lng", lng, "lat", lat, "time", time)

		if saveToDB {
			bulk.Insert(bson.M{"ap_mac": ap_mac, "device_mac": mac, "longitude": lng, "latitude": lat, "org_code": orgcode, "time": uint32(time)})
		}
	}
	bulk.Run()
}
Esempio n. 5
0
func ExportAPTrace() {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	detectorArr := make([]DetectorDBInfo, 0)
	err := session.DB("detector").C("detector_info").Find(bson.M{"company": "02"}).All(&detectorArr)
	if err != nil {
		log.Println(err)
		return
	}

	outArr := make([]TraceInfo, 0)
	for _, e := range detectorArr {
		if len(e.Mac) < 12 {
			continue
		}
		service := protocol.ServiceInfo{}
		err := session.DB("platform").C("service").Find(bson.M{"id": e.OrgCode + "_" + e.NetbarWacode}).One(&service)
		if err != nil {
			continue
		}

		no, _ := strconv.Atoi(service.NO)
		service.SERVICE_CODE = service.NETBAR_WACODE[:8] + fmt.Sprintf("%06d", no)
		traceArr := make([]TraceDBInfo, 0)
		err = session.DB("detector").C("detector_report").Find(bson.M{"ap_mac": e.Mac}).Sort("-time").Limit(1).All(&traceArr)
		if err != nil {
			log.Println(err)
			return
		}

		for _, e := range traceArr {
			detectorDBInfo := DetectorDBInfo{}
			session.DB("detector").C("detector_info").FindId(e.ApMac).One(&detectorDBInfo)
			ApMac := strings.ToUpper(e.ApMac[len(e.ApMac)-12:])
			var trace TraceInfo
			trace.MAC = FormatMac(e.DeviceMac)
			trace.TYPE = 2
			trace.START_TIME = e.Time
			trace.BSSID = FormatMac(ApMac)
			trace.XPOINT = strconv.FormatFloat(e.Longitude, 'f', 6, 64)
			trace.YPOINT = strconv.FormatFloat(e.Latitude, 'f', 6, 64)
			trace.DEVMAC = FormatMac(ApMac)
			trace.DEVICENUM = OrgCode + ApMac
			trace.SERVICECODE = service.SERVICE_CODE
			outArr = append(outArr, trace)
		}
	}

	jsonString, err := json.Marshal(outArr)
	if err != nil {
		return
	}
	log.Print(string(jsonString))
	SaveFile(string(jsonString), "001")
}
Esempio n. 6
0
func ExportDetectorInfo() {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	detectorArr := make([]DetectorDBInfo, 0)
	err := session.DB("detector").C("detector_info").Find(bson.M{"company": "01"}).All(&detectorArr)
	if err != nil {
		log.Println(err)
		return
	}
	outArr := make([]DetectorInfo, 0)
	outServiceArr := make([]ServiceInfo, 0)
	for _, e := range detectorArr {
		if len(e.Mac) < 12 {
			continue
		}
		service := ExportService(e.No, e.Longitude, e.Latitude)
		outServiceArr = append(outServiceArr, service)
		Mac := strings.ToUpper(e.Mac[len(e.Mac)-12:])
		var detector DetectorInfo
		detector.MAC = FormatMac(Mac)
		detector.EQUIPMENT_NUM = OrgCode + Mac
		detector.EQUIPMENT_NAME = "广晟通信_梅州_" + Mac[6:]
		detector.SECURITY_FACTORY_ORGCODE = OrgCode
		detector.SERVICE_CODE = service.SERVICE_CODE
		detector.PROVINCE_CODE = "440000"
		detector.CITY_CODE = "441400"
		detector.AREA_CODE = service.AREA_CODE
		detector.EQUIPMENT_TYPE = "10"
		detector.LATITUDE = strconv.FormatFloat(e.Latitude, 'f', 6, 64)
		detector.LONGITUDE = strconv.FormatFloat(e.Longitude, 'f', 6, 64)
		detector.CREATE_TIME = "2016-07-03 12:32:00"
		detector.LAST_CONNECT_TIME = time.Now().Format("2006-01-02 15:04:05")
		detector.WDA_VERSION = "1.10"
		detector.FIRMWARE_VERSION = "1.0"
		detector.COLLECTION_RADIUS = 150
		detector.UPLOAD_TIME_INTERVAL = 60
		detector.CREATER = "黄工"
		outArr = append(outArr, detector)
	}

	jsonString, err := json.Marshal(outArr)
	if err != nil {
		return
	}
	log.Print(string(jsonString))
	SaveFile(string(jsonString), "010")

	jsonString, err = json.Marshal(outServiceArr)
	if err != nil {
		return
	}
	log.Print(string(jsonString))
	SaveFile(string(jsonString), "008")
}
Esempio n. 7
0
func SaveFeature(waitgroup *sync.WaitGroup, f1 Feature, f2 Feature) error {
	if f1.Type == "" || f2.Type == "" {
		log.Println("SaveFeature:type is empty, orgCode:" + f1.OrgCode)
		waitgroup.Done()
		return errors.New("type is empty")
	}

	if strings.Contains(f1.Type, " ") {
		log.Println("SaveFeature:type contains space, orgCode:" + f1.OrgCode + ", type:" + f1.Type)
		f1.Type = strings.Replace(f1.Type, " ", "", -1)
	}

	if strings.Contains(f2.Type, " ") {
		log.Println("SaveFeature:type contains space, orgCode:" + f2.OrgCode + ", type:" + f2.Type)
		f2.Type = strings.Replace(f2.Type, " ", "", -1)
	}

	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	c := session.DB("feature").C("feature_set")
	f1Obj := bson.M{}
	f2Obj := bson.M{}
	SaveFeatureLocker.Lock()
	err1 := c.Find(bson.M{"feature.value": f1.Value, "feature.type": f1.Type}).One(f1Obj)
	err2 := c.Find(bson.M{"feature.value": f2.Value, "feature.type": f2.Type}).One(f2Obj)
	if err1 == nil && err2 == nil {
		if f1Obj["_id"].(string) != f2Obj["_id"].(string) {
			//merge
			feature2, ok := f2Obj["feature"]
			if ok {
				c.UpdateId(f1Obj["_id"].(string), bson.M{"$pushAll": bson.M{"feature": feature2.([]interface{})}})
				c.RemoveId(f2Obj["_id"].(string))
			}
		}

	} else if err1 == nil && err2 != nil {
		//push f2 in f1
		c.UpdateId(f1Obj["_id"].(string), bson.M{"$push": bson.M{"feature": bson.M{"type": f2.Type, "value": f2.Value, "org_code": f2.OrgCode, "time": f2.Time}}})
	} else if err1 != nil && err2 == nil {
		//push f1 in f2
		c.UpdateId(f2Obj["_id"].(string), bson.M{"$push": bson.M{"feature": bson.M{"type": f1.Type, "value": f1.Value, "org_code": f1.OrgCode, "time": f1.Time}}})
	} else {
		//insert new
		featureArr := []bson.M{bson.M{"type": f1.Type, "value": f1.Value, "org_code": f1.OrgCode, "time": f1.Time},
			bson.M{"type": f2.Type, "value": f2.Value, "org_code": f2.OrgCode, "time": f2.Time}}
		c.Insert(bson.M{"_id": bson.NewObjectId().Hex(), "feature": featureArr})
	}

	SaveFeatureV2(session, f1, f2)
	SaveFeatureLocker.Unlock()
	waitgroup.Done()
	return nil
}
Esempio n. 8
0
func ExportAPInfo() {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	detectorArr := make([]DetectorDBInfo, 0)
	err := session.DB("detector").C("detector_info").Find(bson.M{"company": "02"}).All(&detectorArr)
	if err != nil {
		log.Println(err)
		return
	}

	outArr := make([]DetectorInfo, 0)
	for _, e := range detectorArr {
		if len(e.Mac) < 12 {
			continue
		}
		service := protocol.ServiceInfo{}
		err := session.DB("platform").C("service").Find(bson.M{"id": e.OrgCode + "_" + e.NetbarWacode}).One(&service)
		if err != nil {
			continue
		}
		no, _ := strconv.Atoi(service.NO)
		service.SERVICE_CODE = service.NETBAR_WACODE[:8] + fmt.Sprintf("%06d", no)
		Mac := strings.ToUpper(e.Mac[len(e.Mac)-12:])
		var detector DetectorInfo
		detector.MAC = FormatMac(Mac)
		detector.EQUIPMENT_NUM = OrgCode + Mac
		detector.EQUIPMENT_NAME = service.SERVICE_NAME + Mac[6:]
		detector.SECURITY_FACTORY_ORGCODE = OrgCode
		detector.SERVICE_CODE = service.SERVICE_CODE
		detector.PROVINCE_CODE = service.PROVINCE_CODE
		detector.CITY_CODE = service.CITY_CODE
		detector.AREA_CODE = service.AREA_CODE
		detector.EQUIPMENT_TYPE = "00"
		detector.LATITUDE = strconv.FormatFloat(e.Latitude, 'f', 6, 64)
		detector.LONGITUDE = strconv.FormatFloat(e.Longitude, 'f', 6, 64)
		detector.CREATE_TIME = "2016-07-03 12:32:00"
		detector.LAST_CONNECT_TIME = time.Now().Format("2006-01-02 15:04:05")
		detector.WDA_VERSION = "1.10"
		detector.FIRMWARE_VERSION = "1.0"
		detector.COLLECTION_RADIUS = 150
		detector.UPLOAD_TIME_INTERVAL = 60
		detector.CREATER = service.PERSON_NAME
		outArr = append(outArr, detector)
	}

	jsonString, err := json.Marshal(outArr)
	if err != nil {
		return
	}
	log.Print(string(jsonString))
	SaveFile(string(jsonString), "010")
}
Esempio n. 9
0
func ExportDeviceInfo() {
	rawData := make([]RawData, 0)
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	err := session.DB("3rd_data").C("raw_data").Find(bson.M{"org_code": "555400905", "type": "WA_SOURCE_FJ_0001"}).Sort("-_id").Limit(10).All(&rawData)
	if err != nil {
		log.Println(err)
		return
	}

	outArr := make([]protocol.DeviceInfo, 0)
	for _, data := range rawData {
		fields := make(map[string]string)
		for _, e := range data.Fields {
			fields[e.Key] = e.Value
		}
		wc := fields["G020004"]
		service := protocol.ServiceInfo{}
		err := session.DB("platform").C("service").Find(bson.M{"id": data.OrgCode + "_" + wc}).One(&service)
		if err != nil {
			continue
		}

		no, _ := strconv.Atoi(service.NO)
		service.SERVICE_CODE = service.NETBAR_WACODE[:8] + fmt.Sprintf("%06d", no)

		deviceInfo := protocol.DeviceInfo{}
		deviceInfo.SERVICE_CODE = service.SERVICE_CODE
		tmp, _ := strconv.ParseUint(fields["H010015"], 10, 32)
		deviceInfo.ONLINE_TIME = uint32(tmp)
		deviceInfo.NET_ENDING_NAME = ""
		tmp, _ = strconv.ParseUint(fields["F020001"], 10, 32)
		deviceInfo.NET_ENDING_IP = uint32(tmp)
		deviceInfo.NET_ENDING_MAC = fields["C040002"]
		deviceInfo.SESSION_ID = fields["H010013"]
		deviceInfo.AP_MAC = fields["F030011"]
		deviceInfo.AP_NUM = data.OrgCode + filterMac(deviceInfo.AP_MAC)
		deviceInfo.COMPANY_ID = data.OrgCode
		outArr = append(outArr, deviceInfo)
	}

	jsonString, err := json.Marshal(outArr)
	if err != nil {
		return
	}
	log.Print(string(jsonString))
	SaveFile(string(jsonString), "005")
}
Esempio n. 10
0
func CreateServiceNo() (int, error) {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	change := mgo.Change{
		Update:    bson.M{"$inc": bson.M{"value": 1}},
		ReturnNew: true,
		Upsert:    true,
	}
	doc := bson.M{}
	_, err := session.DB("platform").C("ids").Find(bson.M{"_id": "service_no"}).Apply(change, &doc)
	if err == nil {
		no := int(db.GetNumber(doc, "value"))
		return no, nil
	}
	return -1, err
}
Esempio n. 11
0
func SaveRawData(data *data_file.BCPFile) {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	c := session.DB("3rd_data").C("raw_data")
	bulk := c.Bulk()
	orgCode := data.Meta.OrgCode
	dataType := data.Meta.DataType
	for _, fields := range data.RawData {
		RawData := RawData{}
		RawData.OrgCode = orgCode
		RawData.Type = dataType
		RawData.Fields = fields
		bulk.Insert(RawData)
	}
	bulk.Run()
}
Esempio n. 12
0
func ExportServiceFromDB(onlyStatus bool) {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	serviceArr := make([]protocol.ServiceInfo, 0)
	outServiceStatusArr := make([]ServiceStatus, 0)
	err := session.DB("platform").C("service").Find(bson.M{}).All(&serviceArr)
	if err != nil {
		log.Println(err)
		return
	}
	for i := range serviceArr {
		service := &serviceArr[i]
		no, _ := strconv.Atoi(service.NO)
		service.SERVICE_CODE = service.NETBAR_WACODE[:8] + fmt.Sprintf("%06d", no)

		serviceStatus := ServiceStatus{}
		serviceStatus.SERVICE_CODE = service.SERVICE_CODE
		serviceStatus.SERVICE_ONLINE_STATUS = 1
		serviceStatus.DATA_ONLINE_STATUS = 1
		serviceStatus.EQUIPMENT_RUNNING_STATUS = 1
		serviceStatus.ACTIVE_PC = 0
		serviceStatus.REPORT_PC = 0
		serviceStatus.ONLINE_PERSON = 0
		serviceStatus.VITRUAL_NUM = 0
		serviceStatus.EXIT_IP = "0.0.0.0"
		serviceStatus.UPDATE_TIME = time.Now().Format("2006-01-02 15:04:05")
		outServiceStatusArr = append(outServiceStatusArr, serviceStatus)
	}

	if !onlyStatus {
		jsonString, err := json.Marshal(serviceArr)
		if err != nil {
			return
		}
		log.Print(string(jsonString))
		SaveFile(string(jsonString), "008")
	}

	jsonString, err := json.Marshal(outServiceStatusArr)
	if err != nil {
		return
	}
	log.Print(string(jsonString))
	SaveFile(string(jsonString), "009")
}
Esempio n. 13
0
func SaveServiceInfo(data *data_file.BCPFile) {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	orgCode := data.Meta.OrgCode
	for _, fields := range data.KeyFields {
		serviceInfo := protocol.ServiceInfo{}
		serviceInfo.NETBAR_WACODE = fields["G020004"]
		serviceInfo.ID = orgCode + "_" + serviceInfo.NETBAR_WACODE
		serviceInfo.SERVICE_NAME = fields["F040002"]
		serviceInfo.PRINCIPAL = fields["E020001"]
		serviceInfo.PERSON_NAME = fields["E020001"]
		serviceInfo.PERSON_TEL = fields["B070003"]
		serviceInfo.BUSINESS_NATURE = fields["E010007"]
		serviceInfo.STATUS = 1
		serviceInfo.SERVICE_TYPE = 9
		serviceInfo.PROVINCE_CODE = serviceInfo.NETBAR_WACODE[:2] + "0000"
		serviceInfo.CITY_CODE = serviceInfo.NETBAR_WACODE[:4] + "00"
		serviceInfo.AREA_CODE = serviceInfo.NETBAR_WACODE[:6]
		serviceInfo.ADDRESS = fields["G020017"]
		serviceInfo.ORG_CODE = orgCode
		lng, _ := strconv.ParseFloat(fields["F010016"], 64)
		lat, _ := strconv.ParseFloat(fields["F010017"], 64)
		lng, lat = data_file.Bd09towgs84(lng, lat)
		serviceInfo.XPOINT = fmt.Sprintf("%.6f", lng)
		serviceInfo.YPOINT = fmt.Sprintf("%.6f", lat)
		serviceInfo.CREATE_TIME = "2016-07-02 00:00:00"
		serviceInfo.CAP_TYPE = "2"

		serviceInfoOld := protocol.ServiceInfo{}
		err := session.DB("platform").C("service").Find(bson.M{"id": serviceInfo.ID}).One(&serviceInfoOld)
		if err != nil {
			no, err := CreateServiceNo()
			serviceInfo.NO = strconv.Itoa(no)
			if err != nil {
				continue
			}
			session.DB("platform").C("service").Insert(serviceInfo)
		} else {
			serviceInfo.NO = serviceInfoOld.NO
			session.DB("platform").C("service").Update(bson.M{"id": serviceInfo.ID}, serviceInfo)
		}
	}
}
Esempio n. 14
0
func ExportServiceStatus() {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	detectorArr := make([]DetectorDBInfo, 0)
	err := session.DB("detector").C("detector_info").Find(bson.M{"company": "01"}).All(&detectorArr)
	if err != nil {
		log.Println(err)
		return
	}

	outServiceStatusArr := make([]ServiceStatus, 0)
	for _, e := range detectorArr {
		if len(e.Mac) < 12 {
			continue
		}

		serviceStatus := ServiceStatus{}
		serviceStatus.SERVICE_CODE = ServiceCodePrefix + fmt.Sprintf("%06d", e.No)
		serviceStatus.SERVICE_ONLINE_STATUS = 1
		if e.Latitude != 0 {
			serviceStatus.DATA_ONLINE_STATUS = 1
			serviceStatus.EQUIPMENT_RUNNING_STATUS = 1
		} else {
			serviceStatus.DATA_ONLINE_STATUS = 2
			serviceStatus.EQUIPMENT_RUNNING_STATUS = 2
		}
		serviceStatus.ACTIVE_PC = 0
		serviceStatus.REPORT_PC = 0
		serviceStatus.ONLINE_PERSON = 0
		serviceStatus.VITRUAL_NUM = 0
		serviceStatus.EXIT_IP = "0.0.0.0"
		serviceStatus.UPDATE_TIME = time.Now().Format("2006-01-02 15:04:05")
		outServiceStatusArr = append(outServiceStatusArr, serviceStatus)
	}
	jsonString, err := json.Marshal(outServiceStatusArr)
	if err != nil {
		return
	}
	log.Print(string(jsonString))
	SaveFile(string(jsonString), "009")
}
Esempio n. 15
0
func UpdateApData(orgcode string, data []map[string]string) {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	c := session.DB("detector").C("detector_info")
	for i, fields := range data {
		mac := fields["AP_MAC"]
		mac = filterMac(mac)
		netbar_wacode := fields["NETBAR_WACODE"]
		lng, err1 := strconv.ParseFloat(fields["LONGITUDE"], 64)
		lat, err2 := strconv.ParseFloat(fields["LATITUDE"], 64)
		if orgcode == "779852855" && err2 != nil {
			lat, err2 = strconv.ParseFloat(fields["LAITTUDE"], 64)
		}
		if err1 != nil || err2 != nil {
			continue
		}
		lng, lat = data_file.Bd09towgs84(lng, lat)
		log.Println(i, ": mac", mac, "lng", lng, "lat", lat)
		if saveToDB {
			c.UpsertId(mac, bson.M{"_id": mac, "longitude": lng, "latitude": lat, "last_active_time": uint32(time.Now().Unix()), "company": "02", "org_code": orgcode, "netbar_wacode": netbar_wacode})
		}
	}
}
Esempio n. 16
0
func StatsFeatureNum(orgCode string) {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	count, _ := session.DB("feature").C("feature").Find(bson.M{"org_code": orgCode}).Count()
	fmt.Println("feature_num:", count)
}
Esempio n. 17
0
func StatsDeviceLogNum(orgCode string) {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	count, _ := session.DB("person_info").C("behavior_log").Find(bson.M{"org_code": orgCode}).Count()
	fmt.Println("log_num:", count)
}
Esempio n. 18
0
func StatsDeviceFeatureNum(orgCode string) {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	count, _ := session.DB("person_info").C("mac").Find(bson.M{"org_code": orgCode}).Count()
	fmt.Println("device_feature_num:", count)
}
Esempio n. 19
0
func StatsDetectorNum(orgCode string) {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	count, _ := session.DB("detector").C("detector_info").Find(bson.M{"org_code": orgCode}).Count()
	fmt.Println("detector_num:", count)
}
Esempio n. 20
0
func SaveDeviceInfo(orgcode string, data []map[string]string) {
	session := db.GetDBSession()
	defer db.ReleaseDBSession(session)
	c := session.DB("person_info").C("mac")
	bulk := c.Bulk()
	var waitgroup sync.WaitGroup
	for i, fields := range data {
		mac := fields["MAC"]
		mac = filterMac(mac)
		ap_mac := fields["AP_MAC"]
		ap_mac = filterMac(ap_mac)
		authType := fields["AUTH_TYPE"]
		authAccount := fields["AUTH_ACCOUNT"]
		time, err3 := strconv.Atoi(fields["START_TIME"])
		if err3 != nil {
			continue
		}
		log.Println(i, ": mac", mac, "ap_mac", ap_mac, "auth_type", authType, "account", authAccount, "time", time)

		if saveToDB {
			f1 := data_import.Feature{}
			f2 := data_import.Feature{}
			f1.Type = "1020002"
			f1.Value = mac
			f1.OrgCode = orgcode
			f1.Time = uint32(time)
			if authType == "1020004" {
				bulk.Upsert(bson.M{"mac": mac, "phone": authAccount}, bson.M{"mac": mac, "phone": authAccount, "org_code": orgcode, "time": uint32(time)})
			} else if authType == "1029999" {
				if isPhoneNo(authAccount) {
					bulk.Upsert(bson.M{"mac": mac, "phone": authAccount}, bson.M{"mac": mac, "phone": authAccount, "org_code": orgcode, "time": uint32(time)})
				}
			}

			if authType == "1029999" {
				if isPhoneNo(authAccount) {
					f2.Type = "1020004"
					f2.Value = authAccount
					f2.OrgCode = orgcode
					f2.Time = uint32(time)
				} else {
					continue
				}
			} else {
				f2.Type = authType
				if f2.Type == "1020002" {
					f2.Value = filterMac(authAccount)
				} else {
					f2.Value = authAccount
				}

				f2.OrgCode = orgcode
				f2.Time = uint32(time)
			}
			waitgroup.Add(1)
			go data_import.SaveFeature(&waitgroup, f1, f2)
		}
	}
	bulk.Run()
	waitgroup.Wait()
}