耗材参数

conf/app.conf

 appname = 血透
-httpport = 9531
+httpport = 9529
 runmode = dev
 
 #

controllers/his_api_controller.go

 		project.Pinyin = pinyin
 
 		wubi := projectM["wubi"].(string)
+		fmt.Println("五笔333333333333333333333333333333", wubi)
 		project.Wubi = wubi
 
 		statistical_classification := projectM["statistical_classification"].(string)
 		project.IsRecord = is_record
 
 		medical_code := projectM["medical_code"].(string)
-		project.Wubi = medical_code
+		project.MedicalCode = medical_code
 
 		tube_color := projectM["tube_color"].(string)
 
 
 		project.TubeColor = tube_color_id
 
+		single_dose := projectM["single_dose"].(string)
+		project.SingleDose = single_dose
 		execution_frequency := projectM["execution_frequency"].(string)
-		project.Wubi = execution_frequency
+		project.ExecutionFrequency = execution_frequency
 
 		delivery_way := projectM["delivery_way"].(string)
 		project.DeliveryWay = delivery_way
 		project.Total = total
 
 		medical_status := int64(projectM["medical_status"].(float64))
-		project.TubeColor = medical_status
+		project.MedicalStatus = medical_status
 
 		category := int64(projectM["category"].(float64))
 		project.Category = category
 		remark := projectM["remark"].(string)
 		project.Remark = remark
 
-		record_date := c.GetString("record_date")
+		record_date := projectM["record_date"].(string)
+		fmt.Println("日期222222222", record_date)
 		timeLayout := "2006-01-02"
 		loc, _ := time.LoadLocation("Local")
 
 	errLogs, _ := service.FindPatientExportLog(c.GetAdminUserInfo().CurrentOrgId, export_time)
 	if len(projectList) > 0 {
 		for _, item := range projectList {
-			service.CreateProjectInfomation(item, orgId)
+			project := models.HisProject{
+				ProjectName:                 item.ProjectName,
+				Price:                       item.Price,
+				Unit:                        item.Unit,
+				CostClassify:                item.CostClassify,
+				ExecutiveSection:            item.ExecutiveSection,
+				MedicalCoverage:             item.MedicalCoverage,
+				UserOrgId:                   orgId,
+				Status:                      1,
+				CreatedTime:                 time.Now().Unix(),
+				Pinyin:                      item.Pinyin,
+				Wubi:                        item.Wubi,
+				StatisticalClassification:   item.StatisticalClassification,
+				DiseaseDirectory:            item.DiseaseDirectory,
+				IsRecord:                    item.IsRecord,
+				MedicalCode:                 item.MedicalCode,
+				TubeColor:                   item.TubeColor,
+				SingleDose:                  item.SingleDose,
+				DeliveryWay:                 item.DeliveryWay,
+				NumberDays:                  item.NumberDays,
+				Total:                       item.Total,
+				Category:                    item.Category,
+				MedicalStatus:               item.MedicalStatus,
+				SpecailProject:              item.SpecailProject,
+				RecordDate:                  item.RecordDate,
+				Remark:                      item.Remark,
+				SocialSecurityDirectoryCode: item.SocialSecurityDirectoryCode,
+				ExecutionFrequency:          item.ExecutionFrequency,
+			}
+
+			_, errcodeproject := service.GetProjectByNameIsExsit(item.ProjectName, orgId)
+			if errcodeproject == gorm.ErrRecordNotFound {
+				service.CreateProjectInfomation(&project)
+			} else if errcodeproject == nil {
+				service.UpdateProjectByName(&project, item.ProjectName, orgId)
+			}
 
 			log := models.ExportLog{
 				LogType:    6,

controllers/manager_center_api_controller.go

 	//查询是否存在
 	_, errOne := service.GetDrugNameIsExist(id, adminInfo.CurrentOrgId)
 	if errOne == gorm.ErrRecordNotFound {
-		fmt.Println("进来了吗")
 		c.ServeSuccessJSON(map[string]interface{}{
 			"msg": "修改成功",
 		})
 	_, errThree := service.GetSelfMedicalIsExist(id, adminInfo.CurrentOrgId)
 
 	if errThree == gorm.ErrRecordNotFound {
-		fmt.Println("进来了吗2")
+
 		c.ServeSuccessJSON(map[string]interface{}{
 			"msg": "修改成功",
 		})
 
 	_, errFour := service.GetSelfStosckIsExist(id, adminInfo.CurrentOrgId)
 	if errFour == gorm.ErrRecordNotFound {
-		fmt.Println("进来了吗3")
+
 		c.ServeSuccessJSON(map[string]interface{}{
 			"msg": "修改成功",
 		})
 
 	_, errFive := service.GetOutSelfOutStockIsExist(id, adminInfo.CurrentOrgId)
 	if errFive == gorm.ErrRecordNotFound {
-		fmt.Println("进来了吗4")
+
 		c.ServeSuccessJSON(map[string]interface{}{
 			"msg": "修改成功",
 		})
 		ProductionType:              production_type,
 	}
 
-	totals := service.FindGoodInfoByNameOne(specification_name, adminUserInfo.CurrentOrgId, good_id, id)
+	totals := service.FindGoodInfoByNameOne(specification_name, adminUserInfo.CurrentOrgId, good_id, id, good_name)
 	if totals > 0 {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeGoodInfoNameExistError)
 		return

controllers/stock_in_api_controller.go

 			service.CreateExportErrLog(&err_log)
 			continue
 		}
-		fmt.Println("33333333", unit_id)
-		good.GoodUnit = unit_id
 
-		if goodNameM["retail_price"] == nil || reflect.TypeOf(goodNameM["retail_price"]).String() != "float64" {
-			utils.ErrorLog("retail_price")
-			return
-		}
+		good.GoodUnit = unit_id
 
-		retail_price := goodNameM["retail_price"].(float64)
+		retail_prices := goodNameM["retail_price"].(string)
+		retail_price, _ := strconv.ParseFloat(retail_prices, 64)
 		if retail_price <= 0 { //名字为空则生成一条导入错误日志
 			err_log := models.ExportErrLog{
 				LogType:    5,
 
 		var dealer_id int64
 		dealerName := goodNameM["dealer"].(string)
-
+		fmt.Println("经销商33333333", dealerName)
 		dealer := models.Dealer{
 			OrgId:      orgId,
 			Status:     1,
 		}
 		wubi := goodNameM["wubi"].(string)
 
-		good.Pinyin = wubi
+		good.Wubi = wubi
 
-		if goodNameM["buy_price"] == nil || reflect.TypeOf(goodNameM["buy_price"]).String() != "float64" {
-			utils.ErrorLog("buy_price")
-			return
-		}
-
-		buy_price := goodNameM["buy_price"].(float64)
+		buy_prices := goodNameM["buy_price"].(string)
+		buy_price, _ := strconv.ParseFloat(buy_prices, 64)
 		good.BuyPrice = buy_price
 
 		if goodNameM["social_security_directory_code"] == nil || reflect.TypeOf(goodNameM["social_security_directory_code"]).String() != "string" {
 		}
 
 		good.StatisticsCategory = statistic_id
+
+		special_medical := goodNameM["special_medical"].(string)
+		good.SpecialMedical = special_medical
 		goods = append(goods, &good)
+
 	}
 
 	export_time := time.Now().Unix()
 	if len(goods) > 0 {
 
 		for _, item := range goods {
-			service.CreateGoodsInfomation(item, orgId)
+
+			goodInfo := models.GoodInfo{
+				GoodName:          item.GoodName,
+				SpecificationName: item.SpecificationName,
+				GoodKind:          item.GoodKind,
+				GoodTypeId:        item.GoodTypeId,
+				Dealer:            item.Dealer,
+				GoodUnit:          item.GoodUnit,
+				IsRecord:          item.IsRecord,
+				IsSpecialDiseases: item.IsSpecialDiseases,
+				Manufacturer:      item.Manufacturer,
+				Pinyin:            item.Pinyin,
+
+				ProductionType:              item.ProductionType,
+				Remark:                      item.Remark,
+				RetailPrice:                 item.RetailPrice,
+				SocialSecurityDirectoryCode: item.SocialSecurityDirectoryCode,
+				SpecialMedical:              item.SpecialMedical,
+				Wubi:                        item.Wubi,
+				StockWarnCount:              item.StockWarnCount,
+				MedicalInsuranceLevel:       item.MedicalInsuranceLevel,
+				OrgId:                       orgId,
+				Status:                      1,
+				Ctime:                       time.Now().Unix(),
+				StatisticsCategory:          item.StatisticsCategory,
+				GoodCode:                    item.GoodCode,
+				BuyPrice:                    item.BuyPrice,
+				MedicalInsuranceNumber:      item.MedicalInsuranceNumber,
+			}
+
+			//查询同种耗材名称同种类型同种规格的耗材是否存在
+			_, errcodegood := service.GetGoodsInformaitonIsExist(item.GoodName, item.GoodTypeId, item.SpecificationName, orgId)
+
+			if errcodegood == gorm.ErrRecordNotFound {
+				service.CreateGoodsInfomation(&goodInfo)
+			} else if errcodegood == nil {
+				service.UpdateGoodsInformation(&goodInfo, item.GoodName, item.GoodTypeId, item.SpecificationName, orgId)
+			}
 
 			log := models.ExportLog{
 				LogType:    5,
 		}
 
 		drug_alias, _ := goodNameM["drug_alias"].(string)
-		if len(drug_alias) == 0 { //名字为空则生成一条导入错误日志
-			err_log := models.ExportErrLog{
-				LogType:    4,
-				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
-				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的药品别名不能为空",
-				Status:     1,
-				CreateTime: time.Now().Unix(),
-				UpdateTime: time.Now().Unix(),
-				ExportTime: time.Now().Unix(),
-			}
-			service.CreateExportErrLog(&err_log)
-			continue
-		}
 
 		drug.DrugAlias = drug_alias
 
 		drug.DrugOriginPlace = drug_origin_place
 
 		drug_dosage_form := goodNameM["drug_dosage_form"].(string)
-
+		fmt.Println("药品剂型2222222222", drug_dosage_form)
 		if len(drug_dosage_form) == 0 {
 			err_log := models.ExportErrLog{
 				LogType:    4,
 
 		drugDosageList, _ := service.GetParentDataConfig(drugDosageconfig.ID, orgId)
 		for _, it := range drugDosageList {
-			if drug_dosage == it.Name {
-				drug_dosage_form_id = int64(it.ID)
+			if drug_dosage_form == it.Name {
+				drug_dosage_form_id = int64(it.Value)
 			}
 		}
+		fmt.Println("hhhhhhh66666666666666", drug_dosage_form_id)
 		drug.DrugDosageForm = drug_dosage_form_id
 
 		medical_insurance_level := goodNameM["medical_insurance_level"].(string)
 		drug.LastPrice = last_price
 
 		drug_classify := goodNameM["drug_classify"].(string)
-		fmt.Println("drug_classify22222222222222222", drug_classify)
+
 		if len(drug_classify) == 0 { //名字为空则生成一条导入错误日志
 			err_log := models.ExportErrLog{
 				LogType:    4,
 		drugClassList, _ := service.GetParentDataConfig(drugClassifyConfig.ID, orgId)
 		for _, it := range drugClassList {
 			if drug_classify == it.Name {
-				fmt.Println("88888888888888888", it.Name)
-				fmt.Println("hhhhhhhhhhhh", drug_classify)
 				drug_classify_id = int64(it.Value)
 			}
 		}
-		drug.DrugCategory = drug_classify_id
+
+		drug.DrugClassify = strconv.FormatInt(drug_classify_id, 10)
 
 		manufacturer := goodNameM["manufacturer"].(string)
 		if len(manufacturer) == 0 { //名字为空则生成一条导入错误日志
 		social_security_directory_code := goodNameM["social_security_directory_code"].(string)
 		drug.SocialSecurityDirectoryCode = social_security_directory_code
 		record_date := goodNameM["record_date"].(string)
-		fmt.Println("日期2222222222", record_date)
+
 		timeLayout := "2006-01-02"
 		loc, _ := time.LoadLocation("Local")
 
 				drug_category_id = int64(it.Value)
 			}
 		}
-		fmt.Println("666666666666666666666", drug_category_id)
+
 		drug.DrugCategory = drug_category_id
 
+		drug_dose := goodNameM["drug_dose"].(string)
+
+		if len(drug_dose) == 0 {
+			err_log := models.ExportErrLog{
+				LogType:    4,
+				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
+				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的剂量不能为空",
+				Status:     1,
+				CreateTime: time.Now().Unix(),
+				UpdateTime: time.Now().Unix(),
+				ExportTime: time.Now().Unix(),
+			}
+			service.CreateExportErrLog(&err_log)
+			continue
+		}
+		drugDoses, _ := strconv.ParseFloat(drug_dose, 64)
+		drug.DrugDose = drugDoses
+
+		var units = "单位"
+		var unit_id int64
+		drugDoseUnit := goodNameM["drug_dose_unit"].(string)
+
+		if len(drugDoseUnit) == 0 {
+			err_log := models.ExportErrLog{
+				LogType:    4,
+				UserOrgId:  this.GetAdminUserInfo().CurrentOrgId,
+				ErrMsg:     "第" + strconv.Itoa(index+2) + "行" + "的剂量不能为空",
+				Status:     1,
+				CreateTime: time.Now().Unix(),
+				UpdateTime: time.Now().Unix(),
+				ExportTime: time.Now().Unix(),
+			}
+			service.CreateExportErrLog(&err_log)
+			continue
+		}
+
+		dataConfig, _ := service.GetDataConfigIsExist(0, units)
+		if len(drugDoseUnit) != 0 {
+			_, errcodedataconfig := service.GetChildeConfigIsExist(dataConfig.ID, drugDoseUnit, orgId)
+			if errcodedataconfig == gorm.ErrRecordNotFound {
+				dataconfig := models.Dataconfig{
+					ParentId:       dataConfig.ID,
+					Module:         "hemodialysis",
+					OrgId:          orgId,
+					Name:           drugDoseUnit,
+					FieldName:      "",
+					Value:          index + 50,
+					CreatedTime:    "",
+					UpdatedTime:    "",
+					CreateUserId:   adminUser.AdminUser.Id,
+					Status:         1,
+					Remark:         "",
+					DeleteIdSystem: 0,
+					Title:          "",
+					Content:        "",
+					Order:          0,
+					Code:           "",
+					FieldType:      0,
+				}
+				service.CreateDataConfig(&dataconfig)
+			}
+		}
+		list, _ := service.FindAllDataConfigList(orgId, dataConfig.ID)
+		for _, it := range list {
+			if drugDoseUnit == it.Name {
+				unit_id = int64(it.Value)
+			}
+		}
+		drug.DrugDoseUnit = unit_id
+
+		lmt_used_flags := int64(goodNameM["lmt_used_flag"].(float64))
+
+		drug.LmtUsedFlag = lmt_used_flags
 		drugList = append(drugList, &drug)
 	}
 
 				DrugStatus:                  item.DrugStatus,
 				LimitRemark:                 item.LimitRemark,
 				DrugCategory:                item.DrugCategory,
+				DrugDose:                    item.DrugDose,
+				DrugDoseUnit:                item.DrugDoseUnit,
+				LmtUsedFlag:                 item.LmtUsedFlag,
 			}
 
 			//查询同种药品同种规格是否存在

models/drug.go

 	SocialSecurityDirectoryCode string  `gorm:"column:social_security_directory_code" json:"social_security_directory_code" form:"social_security_directory_code"`
 	IsMark                      int64   `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
 	HospApprFlag                int64   `gorm:"column:hosp_appr_flag" json:"hosp_appr_flag" form:"hosp_appr_flag"`
+	LmtUsedFlag                 int64   `gorm:"column:lmt_used_flag" json:"lmt_used_flag" form:"lmt_used_flag"`
 	//MedicineInsurancePercentage []*MedicineInsurancePercentage `gorm:"ForeignKey:PatientId;AssociationForeignKey:PatientId" json:"monitoring_record"`
 }
 

service/stock_service.go

 	return
 }
 
-func FindGoodInfoByNameOne(name string, org_id int64, good_type_id int64, id int64) (total int64) {
-	readDb.Model(&models.GoodInfo{}).Where("org_id = ? AND status = 1 AND specification_name = ? AND good_type_id = ? and id <> ? ", org_id, name, good_type_id, id).Count(&total)
+func FindGoodInfoByNameOne(name string, org_id int64, good_type_id int64, id int64, goodname string) (total int64) {
+	readDb.Model(&models.GoodInfo{}).Where("org_id = ? AND status = 1 AND specification_name = ? AND good_type_id = ? and id <> ? and good_name = ? ", org_id, name, good_type_id, id, goodname).Count(&total)
 	return
 }
 
 	return err
 }
 
-func CreateGoodsInfomation(info *models.GoodInfo, orgid int64) error {
-
-	goodInfo := models.GoodInfo{
-		GoodName:                    info.GoodName,
-		SpecificationName:           info.SpecificationName,
-		GoodKind:                    info.GoodKind,
-		GoodTypeId:                  info.GoodTypeId,
-		Dealer:                      info.Dealer,
-		GoodUnit:                    info.GoodUnit,
-		IsRecord:                    info.IsRecord,
-		IsSpecialDiseases:           info.IsSpecialDiseases,
-		Manufacturer:                info.Manufacturer,
-		Pinyin:                      info.Pinyin,
-		ProductionType:              info.ProductionType,
-		Remark:                      info.Remark,
-		RetailPrice:                 info.RetailPrice,
-		SocialSecurityDirectoryCode: info.SocialSecurityDirectoryCode,
-		SpecialMedical:              info.SpecialMedical,
-		Wubi:                        info.Wubi,
-		StockWarnCount:              info.StockWarnCount,
-		MedicalInsuranceLevel:       info.MedicalInsuranceLevel,
-		OrgId:                       orgid,
-		Status:                      1,
-		Ctime:                       time.Now().Unix(),
-		StatisticsCategory:          info.StatisticsCategory,
-		GoodCode:                    info.GoodCode,
-	}
-	err := XTWriteDB().Create(&goodInfo).Error
+func GetGoodsInformaitonIsExist(goodName string, goodType int64, specificationName string, orgid int64) (*models.GoodInfo, error) {
+
+	var good models.GoodInfo
+	var err error
+	err = XTReadDB().Model(&good).Where("good_name = ? and good_type_id = ? and specification_name = ? and org_id = ? and status = 1", goodName, goodType, specificationName, orgid).Find(&good).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &good, nil
+
+}
+
+func CreateGoodsInfomation(info *models.GoodInfo) error {
+
+	err := XTWriteDB().Create(&info).Error
+	return err
+}
+
+func UpdateGoodsInformation(info *models.GoodInfo, goodName string, goodType int64, specificationName string, orgid int64) error {
+
+	err := XTWriteDB().Model(&info).Where("good_name = ? and good_type_id = ? and specification_name = ? and org_id = ? and status = 1", goodName, goodType, specificationName, orgid).Updates(map[string]interface{}{"good_name": info.GoodName, "good_type_id": info.GoodTypeId, "medical_insurance_level": info.MedicalInsuranceLevel, "good_kind": info.GoodKind, "specification_name": info.SpecificationName, "manufacturer": info.Manufacturer, "good_unit": info.GoodUnit, "retail_price": info.RetailPrice, "stock_warn_count": info.StockWarnCount, "dealer": info.Dealer, "pinyin": info.Pinyin, "wubi": info.Wubi, "buy_price": info.BuyPrice, "medical_insurance_number": info.MedicalInsuranceNumber, "is_special_diseases": info.IsSpecialDiseases, "is_record": info.IsRecord, "statistics_category": info.StatisticsCategory, "good_status": info.GoodStatus, "social_security_directory_code": info.SocialSecurityDirectoryCode, "production_type": info.ProductionType, "special_medical": info.SpecialMedical, "remark": info.Remark}).Error
 	return err
 }
 
 
 func UpdateDrugsInformation(drug *models.BaseDrugLib, drugName string, drugSpec string, orgid int64) error {
 
-	err := XTWriteDB().Model(&drug).Where("drug_name = ? and drug_spec = ? and org_id = ? and status = 1", drugName, drugSpec, orgid).Updates(map[string]interface{}{"drug_name": drug.DrugName, "drug_alias": drug.DrugAlias, "drug_spec": drug.DrugSpec, "drug_type": drug.DrugType, "drug_stock_limit": drug.DrugStockLimit, "drug_origin_place": drug.DrugOriginPlace, "drug_dosage_form": drug.DrugDosageForm, "medical_insurance_level": drug.MedicalInsuranceLevel, "max_unit": drug.MaxUnit, "min_unit": drug.MinUnit, "unit_matrixing": drug.UnitMatrixing, "retail_price": drug.RetailPrice, "last_price": drug.LastPrice, "drug_classify": drug.DrugClassify, "manufacturer": drug.Manufacturer, "dealer": drug.Dealer, "pinyin": drug.Pinyin, "wubi": drug.Wubi, "drug_alias_pinyin": drug.DrugAliasPinyin, "drug_alias_wubi": drug.DrugAliasWubi, "drug_category": drug.DrugCategory, "drug_control": drug.DrugControl, "number": drug.Number, "hosp_appr_flag": drug.HospApprFlag, "medical_insurance_number": drug.MedicalInsuranceNumber, "pharmacology_category": drug.PharmacologyCategory, "statistics_category": drug.StatisticsCategory, "code": drug.Code, "is_special_diseases": drug.IsSpecialDiseases, "is_record": drug.IsRecord, "prescription_mark": drug.PrescriptionMark, "social_security_directory_code": drug.SocialSecurityDirectoryCode, "record_date": drug.RecordDate, "drug_remark": drug.DrugRemark, "drug_status": drug.DrugStatus, "limit_remark": drug.LimitRemark}).Error
+	err := XTWriteDB().Model(&drug).Where("drug_name = ? and drug_spec = ? and org_id = ? and status = 1", drugName, drugSpec, orgid).Updates(map[string]interface{}{"drug_name": drug.DrugName, "drug_alias": drug.DrugAlias, "drug_spec": drug.DrugSpec, "drug_type": drug.DrugType, "drug_stock_limit": drug.DrugStockLimit, "drug_origin_place": drug.DrugOriginPlace, "drug_dosage_form": drug.DrugDosageForm, "medical_insurance_level": drug.MedicalInsuranceLevel, "max_unit": drug.MaxUnit, "min_unit": drug.MinUnit, "unit_matrixing": drug.UnitMatrixing, "retail_price": drug.RetailPrice, "last_price": drug.LastPrice, "drug_classify": drug.DrugClassify, "manufacturer": drug.Manufacturer, "dealer": drug.Dealer, "pinyin": drug.Pinyin, "wubi": drug.Wubi, "drug_alias_pinyin": drug.DrugAliasPinyin, "drug_alias_wubi": drug.DrugAliasWubi, "drug_category": drug.DrugCategory, "drug_control": drug.DrugControl, "number": drug.Number, "hosp_appr_flag": drug.HospApprFlag, "medical_insurance_number": drug.MedicalInsuranceNumber, "pharmacology_category": drug.PharmacologyCategory, "statistics_category": drug.StatisticsCategory, "code": drug.Code, "is_special_diseases": drug.IsSpecialDiseases, "is_record": drug.IsRecord, "prescription_mark": drug.PrescriptionMark, "social_security_directory_code": drug.SocialSecurityDirectoryCode, "record_date": drug.RecordDate, "drug_remark": drug.DrugRemark, "drug_status": drug.DrugStatus, "limit_remark": drug.LimitRemark, "drug_dose": drug.DrugDose, "drug_dose_unit": drug.DrugDoseUnit, "lmt_used_flag": drug.LmtUsedFlag}).Error
 	return err
 }
 
-func CreateProjectInfomation(info *models.HisProject, orgid int64) error {
-
-	project := models.HisProject{
-		ProjectName:                 info.ProjectName,
-		Price:                       info.Price,
-		Unit:                        info.Unit,
-		CostClassify:                info.CostClassify,
-		ExecutiveSection:            info.ExecutiveSection,
-		MedicalCoverage:             info.MedicalCoverage,
-		UserOrgId:                   orgid,
-		Status:                      1,
-		CreatedTime:                 time.Now().Unix(),
-		Pinyin:                      info.Pinyin,
-		Wubi:                        info.Wubi,
-		StatisticalClassification:   info.StatisticalClassification,
-		DiseaseDirectory:            info.DiseaseDirectory,
-		IsRecord:                    info.IsRecord,
-		MedicalCode:                 info.MedicalCode,
-		TubeColor:                   info.TubeColor,
-		SingleDose:                  info.SingleDose,
-		DeliveryWay:                 info.DeliveryWay,
-		NumberDays:                  info.NumberDays,
-		Total:                       info.Total,
-		Category:                    info.Category,
-		MedicalStatus:               info.MedicalStatus,
-		SpecailProject:              info.SpecailProject,
-		RecordDate:                  info.RecordDate,
-		Remark:                      info.Remark,
-		SocialSecurityDirectoryCode: info.SocialSecurityDirectoryCode,
-	}
-	err := XTWriteDB().Create(&project).Error
+func GetProjectByNameIsExsit(projectName string, orgid int64) (*models.HisProject, error) {
+
+	var projoect models.HisProject
+	var err error
+	err = XTReadDB().Model(&projoect).Where("project_name = ? and user_org_id = ? and status =1", projectName, orgid).Find(&projoect).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &projoect, nil
+}
+
+func CreateProjectInfomation(info *models.HisProject) error {
+
+	err := XTWriteDB().Create(&info).Error
 	return err
 }
 
+func UpdateProjectByName(project *models.HisProject, projectName string, orgid int64) error {
+
+	err := XTWriteDB().Model(&project).Where("project_name = ? and user_org_id = ? and status = 1", projectName, orgid).Updates(map[string]interface{}{"project_name": project.ProjectName, "price": project.Price, "unit": project.Unit, "cost_classify": project.CostClassify, "executive_section": project.ExecutiveSection, "medical_coverage": project.MedicalCoverage, "pinyin": project.Pinyin, "wubi": project.Wubi, "statistical_classification": project.StatisticalClassification, "disease_directory": project.DiseaseDirectory, "is_record": project.IsRecord, "medical_code": project.MedicalCode, "tube_color": project.TubeColor, "single_dose": project.SingleDose, "delivery_way": project.DeliveryWay, "execution_frequency": project.ExecutionFrequency, "number_days": project.NumberDays, "total": project.Total, "medical_status": project.MedicalStatus, "category": project.Category, "specail_project": project.SpecailProject, "social_security_directory_code": project.SocialSecurityDirectoryCode, "record_date": project.RecordDate, "remark": project.Remark}).Error
+	return err
+}
 func GetWareOutInfoById(warehouseoutid int64, orgid int64) (warehouseinfo []*models.WarehouseOutInfo, err error) {
 
 	err = XTReadDB().Model(&warehouseinfo).Where("warehouse_out_id = ? and org_id = ? and status= 1 and is_sys = 0", warehouseoutid, orgid).Find(&warehouseinfo).Error
 	}
 	return &department, nil
 }
+
+func GetDataConfigIsExist(orgid int64, name string) (models.Dataconfig, error) {
+	dataconfig := models.Dataconfig{}
+	err := XTReadDB().Model(&dataconfig).Where("org_id = ? and name = ? and status = 1", orgid, name).Find(&dataconfig).Error
+	return dataconfig, err
+}
+
+func GetChildeConfigIsExist(parentid int64, name string, orgid int64) (*models.Dataconfig, error) {
+
+	var dataconfig models.Dataconfig
+	var err error
+	err = XTReadDB().Model(&dataconfig).Where("parent_id = ? and (org_id = ? or org_id = 0) and name = ? and status = 1", parentid, orgid, name).Find(&dataconfig).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &dataconfig, nil
+}
+
+func CreateDataConfig(dataconfig *models.Dataconfig) error {
+
+	err := XTWriteDB().Create(&dataconfig).Error
+	return err
+}
+
+func FindAllDataConfigList(orgid int64, parentId int64) (dataconfig []*models.Dataconfig, err error) {
+
+	err = XTReadDB().Model(&dataconfig).Where("(org_id = ? or org_id = 0) and parent_id = ? and status = 1", orgid, parentId).Find(&dataconfig).Error
+	return dataconfig, err
+}