耗材参数

controllers/his_project_api_controller.go

 	execution_frequency := this.GetString("execution_frequency")
 	number_days := this.GetString("number_days")
 	total := this.GetString("total")
+	category, _ := this.GetInt64("category")
 	adminUserInfo := this.GetAdminUserInfo()
 	orgId := adminUserInfo.CurrentOrgId
 	hisProject := models.XtHisProject{
 		ExecutionFrequency:        execution_frequency,
 		NumberDays:                number_days,
 		Total:                     total,
+		Category:                  category,
 	}
 	//查询项目名称是否存在
 	_, errcode := service.GetHisProjectIsExist(project_name, orgId)
 	is_charge, _ := this.GetInt64("is_charge")
 
 	is_start, _ := this.GetInt64("is_start")
-
 	keyword := this.GetString("keyword")
-	projecList, total, err := service.GetHisProjectList(orgId, limit, page, is_charge, is_start, keyword)
+	is_mark, _ := this.GetInt64("is_mark")
+	projecList, total, err := service.GetHisProjectList(orgId, limit, page, is_charge, is_start, keyword, is_mark)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateConfig)
 		return
 	delivery_way := this.GetString("delivery_way")
 	execution_frequency := this.GetString("execution_frequency")
 	number_days := this.GetString("number_days")
+	category, _ := this.GetInt64("category")
 	total := this.GetString("total")
 	hisProject := models.XtHisProject{
 		ProjectName:               project_name,
 		ExecutionFrequency:        execution_frequency,
 		NumberDays:                number_days,
 		Total:                     total,
+		Category:                  category,
 	}
 
 	err := service.UpdatedProject(id, &hisProject)

controllers/manager_center_api_controller.go

 	is_statistics_work, _ := c.GetInt64("is_statistics_work")
 	is_charge_use, _ := c.GetInt64("is_charge_use")
 	dealer, _ := c.GetInt64("dealer")
+	prescription_mark, _ := c.GetInt64("prescription_mark")
+	social_security_directory_code := c.GetString("social_security_directory_code")
+	record_date := c.GetString("record_date")
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
+	drug_remark := c.GetString("drug_remark")
 	adminInfo := c.GetAdminUserInfo()
 
 	drugLib := &models.BaseDrugLib{
-		DrugName:               drug_name,
-		Pinyin:                 pinyin,
-		Wubi:                   wubi,
-		DrugAlias:              drug_alias,
-		DrugAliasPinyin:        drug_alias_pinyin,
-		DrugAliasWubi:          drug_alias_wubi,
-		DrugCategory:           drug_category,
-		DrugSpec:               drug_spec,
-		DrugType:               drug_type,
-		DrugStockLimit:         drug_stock_limit,
-		DrugOriginPlace:        drug_origin_place,
-		MedicalInsuranceLevel:  medical_insurance_level,
-		DrugDosageForm:         drug_dosage_form,
-		MaxUnit:                max_unit,
-		MinUnit:                min_unit,
-		UnitMatrixing:          unit_matrixing,
-		RetailPrice:            retail_price,
-		LastPrice:              last_price,
-		DrugControl:            drug_control,
-		Number:                 number,
-		DrugClassify:           drug_classify,
-		DrugDose:               drug_dose,
-		DrugDoseUnit:           drug_dose_unit,
-		MedicalInsuranceNumber: medical_insurance_number,
-		Manufacturer:           manufacturer,
-		PharmacologyCategory:   pharmacology_category,
-		StatisticsCategory:     statistics_category,
-		Code:                   code,
-		IsSpecialDiseases:      is_special_diseases,
-		IsRecord:               is_record,
-		Agent:                  agent,
-		DrugStatus:             drug_status,
-		LimitRemark:            limit_remark,
-		DeliveryWay:            delivery_way,
-		ExecutionFrequency:     execution_frequency,
-		SingleDose:             single_dose,
-		PrescribingNumber:      prescribing_number,
-		Label:                  label,
-		Sort:                   sort,
-		IsUseDoctorAdvice:      is_use_doctor_advice,
-		IsDefault:              is_default,
-		IsChargePredict:        is_charge_predict,
-		IsStatisticsWork:       is_statistics_work,
-		IsChargeUse:            is_charge_use,
-		OrgId:                  adminInfo.CurrentOrgId,
-		Status:                 1,
-		Ctime:                  time.Now().Unix(),
-		Mtime:                  time.Now().Unix(),
-		Dealer:                 dealer,
+		DrugName:                    drug_name,
+		Pinyin:                      pinyin,
+		Wubi:                        wubi,
+		DrugAlias:                   drug_alias,
+		DrugAliasPinyin:             drug_alias_pinyin,
+		DrugAliasWubi:               drug_alias_wubi,
+		DrugCategory:                drug_category,
+		DrugSpec:                    drug_spec,
+		DrugType:                    drug_type,
+		DrugStockLimit:              drug_stock_limit,
+		DrugOriginPlace:             drug_origin_place,
+		MedicalInsuranceLevel:       medical_insurance_level,
+		DrugDosageForm:              drug_dosage_form,
+		MaxUnit:                     max_unit,
+		MinUnit:                     min_unit,
+		UnitMatrixing:               unit_matrixing,
+		RetailPrice:                 retail_price,
+		LastPrice:                   last_price,
+		DrugControl:                 drug_control,
+		Number:                      number,
+		DrugClassify:                drug_classify,
+		DrugDose:                    drug_dose,
+		DrugDoseUnit:                drug_dose_unit,
+		MedicalInsuranceNumber:      medical_insurance_number,
+		Manufacturer:                manufacturer,
+		PharmacologyCategory:        pharmacology_category,
+		StatisticsCategory:          statistics_category,
+		Code:                        code,
+		IsSpecialDiseases:           is_special_diseases,
+		IsRecord:                    is_record,
+		Agent:                       agent,
+		DrugStatus:                  drug_status,
+		LimitRemark:                 limit_remark,
+		DeliveryWay:                 delivery_way,
+		ExecutionFrequency:          execution_frequency,
+		SingleDose:                  single_dose,
+		PrescribingNumber:           prescribing_number,
+		Label:                       label,
+		Sort:                        sort,
+		IsUseDoctorAdvice:           is_use_doctor_advice,
+		IsDefault:                   is_default,
+		IsChargePredict:             is_charge_predict,
+		IsStatisticsWork:            is_statistics_work,
+		IsChargeUse:                 is_charge_use,
+		OrgId:                       adminInfo.CurrentOrgId,
+		Status:                      1,
+		Ctime:                       time.Now().Unix(),
+		Mtime:                       time.Now().Unix(),
+		Dealer:                      dealer,
+		PrescriptionMark:            prescription_mark,
+		SocialSecurityDirectoryCode: social_security_directory_code,
+		RecordDate:                  theTime.Unix(),
+		DrugRemark:                  drug_remark,
 	}
 
 	total := service.FindAllDrugLibRecordTotal(adminInfo.CurrentOrgId)
 	drug_code := c.GetString("drug_code")
 	//unit := c.GetString("unit")
 	dealer, _ := c.GetInt64("dealer")
+	prescription_mark, _ := c.GetInt64("prescription_mark")
+	social_security_directory_code := c.GetString("social_security_directory_code")
+	record_date := c.GetString("record_date")
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
+	drug_remark := c.GetString("drug_remark")
 	adminInfo := c.GetAdminUserInfo()
 	drug, _ := service.FindBaseDrugLibRecord(adminInfo.CurrentOrgId, id)
 
 	drugLib := &models.BaseDrugLib{
-		ID:                     id,
-		DrugName:               drug_name,
-		Pinyin:                 pinyin,
-		Wubi:                   wubi,
-		DrugAlias:              drug_alias,
-		DrugAliasPinyin:        drug_alias_pinyin,
-		DrugAliasWubi:          drug_alias_wubi,
-		DrugCategory:           drug_category,
-		DrugSpec:               drug_spec,
-		DrugType:               drug_type,
-		DrugStockLimit:         drug_stock_limit,
-		DrugOriginPlace:        drug_origin_place,
-		MedicalInsuranceLevel:  medical_insurance_level,
-		DrugDosageForm:         drug_dosage_form,
-		MaxUnit:                max_unit,
-		MinUnit:                min_unit,
-		UnitMatrixing:          unit_matrixing,
-		RetailPrice:            retail_price,
-		LastPrice:              last_price,
-		DrugControl:            drug_control,
-		Number:                 number,
-		DrugClassify:           drug_classify,
-		DrugDose:               drug_dose,
-		DrugDoseUnit:           drug_dose_unit,
-		MedicalInsuranceNumber: medical_insurance_number,
-		Manufacturer:           manufacturer,
-		PharmacologyCategory:   pharmacology_category,
-		StatisticsCategory:     statistics_category,
-		Code:                   code,
-		IsSpecialDiseases:      is_special_diseases,
-		IsRecord:               is_record,
-		Agent:                  agent,
-		DrugStatus:             drug_status,
-		LimitRemark:            limit_remark,
-		DeliveryWay:            delivery_way,
-		ExecutionFrequency:     execution_frequency,
-		SingleDose:             single_dose,
-		PrescribingNumber:      prescribing_number,
-		Label:                  label,
-		Sort:                   sort,
-		IsUseDoctorAdvice:      is_use_doctor_advice,
-		IsDefault:              is_default,
-		IsChargePredict:        is_charge_predict,
-		IsStatisticsWork:       is_statistics_work,
-		IsChargeUse:            is_charge_use,
-		OrgId:                  adminInfo.CurrentOrgId,
-		Status:                 1,
-		Ctime:                  drug.Ctime,
-		Mtime:                  time.Now().Unix(),
-		DrugCode:               drug_code,
-		Dealer:                 dealer,
+		ID:                          id,
+		DrugName:                    drug_name,
+		Pinyin:                      pinyin,
+		Wubi:                        wubi,
+		DrugAlias:                   drug_alias,
+		DrugAliasPinyin:             drug_alias_pinyin,
+		DrugAliasWubi:               drug_alias_wubi,
+		DrugCategory:                drug_category,
+		DrugSpec:                    drug_spec,
+		DrugType:                    drug_type,
+		DrugStockLimit:              drug_stock_limit,
+		DrugOriginPlace:             drug_origin_place,
+		MedicalInsuranceLevel:       medical_insurance_level,
+		DrugDosageForm:              drug_dosage_form,
+		MaxUnit:                     max_unit,
+		MinUnit:                     min_unit,
+		UnitMatrixing:               unit_matrixing,
+		RetailPrice:                 retail_price,
+		LastPrice:                   last_price,
+		DrugControl:                 drug_control,
+		Number:                      number,
+		DrugClassify:                drug_classify,
+		DrugDose:                    drug_dose,
+		DrugDoseUnit:                drug_dose_unit,
+		MedicalInsuranceNumber:      medical_insurance_number,
+		Manufacturer:                manufacturer,
+		PharmacologyCategory:        pharmacology_category,
+		StatisticsCategory:          statistics_category,
+		Code:                        code,
+		IsSpecialDiseases:           is_special_diseases,
+		IsRecord:                    is_record,
+		Agent:                       agent,
+		DrugStatus:                  drug_status,
+		LimitRemark:                 limit_remark,
+		DeliveryWay:                 delivery_way,
+		ExecutionFrequency:          execution_frequency,
+		SingleDose:                  single_dose,
+		PrescribingNumber:           prescribing_number,
+		Label:                       label,
+		Sort:                        sort,
+		IsUseDoctorAdvice:           is_use_doctor_advice,
+		IsDefault:                   is_default,
+		IsChargePredict:             is_charge_predict,
+		IsStatisticsWork:            is_statistics_work,
+		IsChargeUse:                 is_charge_use,
+		OrgId:                       adminInfo.CurrentOrgId,
+		Status:                      1,
+		Ctime:                       drug.Ctime,
+		Mtime:                       time.Now().Unix(),
+		DrugCode:                    drug_code,
+		Dealer:                      dealer,
+		PrescriptionMark:            prescription_mark,
+		SocialSecurityDirectoryCode: social_security_directory_code,
+		RecordDate:                  theTime.Unix(),
+		DrugRemark:                  drug_remark,
 	}
 
 	err := service.UpdateBaseDrugLib(drugLib)
 	is_use, _ := c.GetInt64("is_use", 0)
 	is_charge, _ := c.GetInt64("is_charge", 0)
 	is_inject, _ := c.GetInt64("is_inject", 0)
+	manufacturer, _ := c.GetInt64("manufacturer")
+	is_record, _ := c.GetInt64("is_record")
+
 	keyword := c.GetString("keyword")
 	adminInfo := c.GetAdminUserInfo()
 
 	if limit <= 0 {
 		limit = 10
 	}
-	list, total, _ := service.GetBaseDrugLibList(adminInfo.CurrentOrgId, keyword, page, limit, is_use, is_charge, is_inject)
+	list, total, _ := service.GetBaseDrugLibList(adminInfo.CurrentOrgId, keyword, page, limit, is_use, is_charge, is_inject, manufacturer, is_record)
 
 	c.ServeSuccessJSON(map[string]interface{}{
 		"list":  list,
 	dataconfig.UpdatedTime = time.Now().Format("2006-01-02 15:04:05")
 	dataconfig.Remark = string(dataBody["remark"].(string))
 	dataconfig.Order = int64(dataBody["orders"].(float64))
+	dataconfig.Code = string(dataBody["code"].(string))
 	fmt.Println("dataconfitg------", dataconfig.Order)
 	//if dataBody["orders"] != nil {
 	//	dataconfig.Order = int64(dataBody["orders"].(float64))
 	dataconfig.CreatedTime = time.Now().Format("2006-01-02 15:04:05")
 	dataconfig.UpdatedTime = time.Now().Format("2006-01-02 15:04:05")
 	dataconfig.Remark = string(dataBody["remark"].(string))
+	dataconfig.Code = string(dataBody["code"].(string))
+	fmt.Println("3444444444", dataconfig.Code)
 	if dataBody["order"] != nil {
 		dataconfig.Order = int64(dataBody["order"].(float64))
 	} else {
 			return
 		}
 		dataconfig.Content = content
+
 	} else {
 		if configBody["parent_id"] == nil || reflect.TypeOf(configBody["parent_id"]).String() != "float64" {
 			utils.ErrorLog("module")
 			return
 		}
 		dataconfig.Name = name
+
 	}
 	return
 }
 	agent := c.GetString("agent")
 	good_number := c.GetString("good_number")
 
+	social_security_directory_code := c.GetString("social_security_directory_code")
+	production_type := c.GetString("production_type")
+	special_medical := c.GetString("special_medical")
 	adminUserInfo := c.GetAdminUserInfo()
 
 	totals := service.FindGoodInfoByName(specification_name, adminUserInfo.CurrentOrgId, good_id)
 	code = "24000000" + code
 
 	goodInfo := models.GoodInfo{
-		GoodCode:               code,
-		SpecificationName:      specification_name,
-		GoodTypeId:             good_id,
-		GoodUnit:               good_unit,
-		BuyPrice:               buy_price,
-		SellPrice:              sell_price,
-		Remark:                 remark,
-		Ctime:                  time.Now().Unix(),
-		Manufacturer:           manufacturer,
-		Dealer:                 dealer,
-		ExpiryDateWarnDayCount: expiry_date_warn_day_count,
-		StockWarnCount:         stock_warn_count,
-		IsReuse:                is_reuse,
-		Status:                 1,
-		OrgId:                  adminUserInfo.CurrentOrgId,
-		Creater:                adminUserInfo.AdminUser.Id,
-		GoodName:               good_name,
-		Pinyin:                 pinyin,
-		Wubi:                   wubi,
-		GoodKind:               good_kind,
-		MedicalInsuranceNumber: medical_insurance_number,
-		IsSpecialDiseases:      is_special_diseases,
-		IsRecord:               is_record,
-		StatisticsCategory:     statistics_category,
-		GoodStatus:             good_status,
-		DefaultCount:           default_count,
-		Sign:                   sign,
-		IsDefault:              is_default,
-		IsChargeUse:            is_charge_use,
-		IsChargePredict:        is_charge_predict,
-		IsStatisticsWork:       is_statistics_work,
-		Sort:                   sort,
-		IsDoctorUse:            is_doctor_use,
-		Agent:                  agent,
-		GoodNumber:             good_number,
-		MedicalInsuranceLevel:  medical_insurance_level,
-		RetailPrice:            retail_price,
+		GoodCode:                    code,
+		SpecificationName:           specification_name,
+		GoodTypeId:                  good_id,
+		GoodUnit:                    good_unit,
+		BuyPrice:                    buy_price,
+		SellPrice:                   sell_price,
+		Remark:                      remark,
+		Ctime:                       time.Now().Unix(),
+		Manufacturer:                manufacturer,
+		Dealer:                      dealer,
+		ExpiryDateWarnDayCount:      expiry_date_warn_day_count,
+		StockWarnCount:              stock_warn_count,
+		IsReuse:                     is_reuse,
+		Status:                      1,
+		OrgId:                       adminUserInfo.CurrentOrgId,
+		Creater:                     adminUserInfo.AdminUser.Id,
+		GoodName:                    good_name,
+		Pinyin:                      pinyin,
+		Wubi:                        wubi,
+		GoodKind:                    good_kind,
+		MedicalInsuranceNumber:      medical_insurance_number,
+		IsSpecialDiseases:           is_special_diseases,
+		IsRecord:                    is_record,
+		StatisticsCategory:          statistics_category,
+		GoodStatus:                  good_status,
+		DefaultCount:                default_count,
+		Sign:                        sign,
+		IsDefault:                   is_default,
+		IsChargeUse:                 is_charge_use,
+		IsChargePredict:             is_charge_predict,
+		IsStatisticsWork:            is_statistics_work,
+		Sort:                        sort,
+		IsDoctorUse:                 is_doctor_use,
+		Agent:                       agent,
+		GoodNumber:                  good_number,
+		MedicalInsuranceLevel:       medical_insurance_level,
+		RetailPrice:                 retail_price,
+		SocialSecurityDirectoryCode: social_security_directory_code,
+		ProductionType:              production_type,
+		SpecialMedical:              special_medical,
 	}
 	err, goodInfos := service.AddSigleGoodInfo(&goodInfo)
 	if err == nil {
 	agent := c.GetString("agent")
 	good_number := c.GetString("good_number")
 
+	social_security_directory_code := c.GetString("social_security_directory_code")
+	production_type := c.GetString("production_type")
+	special_medical := c.GetString("special_medical")
 	adminUserInfo := c.GetAdminUserInfo()
 
 	goodInfo := models.GoodInfo{
-		ID:                     id,
-		GoodCode:               code,
-		SpecificationName:      specification_name,
-		GoodTypeId:             good_id,
-		GoodUnit:               good_unit,
-		BuyPrice:               buy_price,
-		SellPrice:              sell_price,
-		Remark:                 remark,
-		Mtime:                  time.Now().Unix(),
-		Manufacturer:           manufacturer,
-		Dealer:                 dealer,
-		ExpiryDateWarnDayCount: expiry_date_warn_day_count,
-		StockWarnCount:         stock_warn_count,
-		IsReuse:                is_reuse,
-		Status:                 1,
-		OrgId:                  adminUserInfo.CurrentOrgId,
-		Modifier:               adminUserInfo.AdminUser.Id,
-		GoodName:               good_name,
-		Pinyin:                 pinyin,
-		Wubi:                   wubi,
-		GoodKind:               good_kind,
-		MedicalInsuranceNumber: medical_insurance_number,
-		IsSpecialDiseases:      is_special_diseases,
-		IsRecord:               is_record,
-		StatisticsCategory:     statistics_category,
-		GoodStatus:             good_status,
-		DefaultCount:           default_count,
-		Sign:                   sign,
-		IsDefault:              is_default,
-		IsChargeUse:            is_charge_use,
-		IsChargePredict:        is_charge_predict,
-		IsStatisticsWork:       is_statistics_work,
-		Sort:                   sort,
-		IsDoctorUse:            is_doctor_use,
-		Agent:                  agent,
-		GoodNumber:             good_number,
-		MedicalInsuranceLevel:  medical_insurance_level,
-		RetailPrice:            retail_price,
+		ID:                          id,
+		GoodCode:                    code,
+		SpecificationName:           specification_name,
+		GoodTypeId:                  good_id,
+		GoodUnit:                    good_unit,
+		BuyPrice:                    buy_price,
+		SellPrice:                   sell_price,
+		Remark:                      remark,
+		Mtime:                       time.Now().Unix(),
+		Manufacturer:                manufacturer,
+		Dealer:                      dealer,
+		ExpiryDateWarnDayCount:      expiry_date_warn_day_count,
+		StockWarnCount:              stock_warn_count,
+		IsReuse:                     is_reuse,
+		Status:                      1,
+		OrgId:                       adminUserInfo.CurrentOrgId,
+		Modifier:                    adminUserInfo.AdminUser.Id,
+		GoodName:                    good_name,
+		Pinyin:                      pinyin,
+		Wubi:                        wubi,
+		GoodKind:                    good_kind,
+		MedicalInsuranceNumber:      medical_insurance_number,
+		IsSpecialDiseases:           is_special_diseases,
+		IsRecord:                    is_record,
+		StatisticsCategory:          statistics_category,
+		GoodStatus:                  good_status,
+		DefaultCount:                default_count,
+		Sign:                        sign,
+		IsDefault:                   is_default,
+		IsChargeUse:                 is_charge_use,
+		IsChargePredict:             is_charge_predict,
+		IsStatisticsWork:            is_statistics_work,
+		Sort:                        sort,
+		IsDoctorUse:                 is_doctor_use,
+		Agent:                       agent,
+		GoodNumber:                  good_number,
+		MedicalInsuranceLevel:       medical_insurance_level,
+		RetailPrice:                 retail_price,
+		SpecialMedical:              special_medical,
+		SocialSecurityDirectoryCode: social_security_directory_code,
+		ProductionType:              production_type,
 	}
 
 	totals := service.FindGoodInfoByNameOne(specification_name, adminUserInfo.CurrentOrgId, good_id, id)
 	is_use, _ := c.GetInt64("is_use")
 	is_charge, _ := c.GetInt64("is_charge")
 	good_kind, _ := c.GetInt64("good_kind")
-
+	is_mark, _ := c.GetInt64("is_mark")
+	manufacturer, _ := c.GetInt64("manufacturer")
 	adminUserInfo := c.GetAdminUserInfo()
-	goodInfos, total, err := service.FindGoodInfoList(adminUserInfo.CurrentOrgId, page, limit, keyword, is_use, is_charge, good_kind)
+	goodInfos, total, err := service.FindGoodInfoList(adminUserInfo.CurrentOrgId, page, limit, keyword, is_use, is_charge, good_kind, is_mark, manufacturer)
 	if err == nil {
 		c.ServeSuccessJSON(map[string]interface{}{
 			"list":  goodInfos,

controllers/mobile_api_controllers/check_weight_api_controller.go

 			newprescribe.Dialyzer = dialysisSolution.Dialyzer
 			newprescribe.ReplacementTotal = dialysisSolution.ReplacementTotal
 			newprescribe.DialyzerPerfusionApparatus = dialysisSolution.DialyzerPerfusionApparatus
+			newprescribe.DialysisIrrigation = dialysisSolution.DialysisIrrigation
+			newprescribe.DialysisDialyszers = dialysisSolution.DialysisDialyszers
 			newprescribe.BodyFluidOther = dialysisSolution.BodyFluidOther
 			newprescribe.TargetKtv = dialysisSolution.TargetKtv
 
 				newprescribe.Dialyzer = lastDialysisPrescribe.Dialyzer
 				newprescribe.ReplacementTotal = lastDialysisPrescribe.ReplacementTotal
 				newprescribe.DialyzerPerfusionApparatus = lastDialysisPrescribe.DialyzerPerfusionApparatus
+				newprescribe.DialysisDialyszers = lastDialysisPrescribe.DialysisDialyszers
+				newprescribe.DialysisIrrigation = lastDialysisPrescribe.DialysisIrrigation
 				newprescribe.BodyFluidOther = lastDialysisPrescribe.BodyFluidOther
 				newprescribe.TargetKtv = lastDialysisPrescribe.TargetKtv
 				newprescribe.CreatedTime = time.Now().Unix()
 				newprescribe.DewaterAmount = dewater_amount
 				newprescribe.TargetUltrafiltration = dewater_amount
 				newprescribe.Status = 1
+
 				err := service.AddSigleRecord(&newprescribe)
 				if err != nil {
 					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
 				newprescribe.Dialyzer = system_dialysisPrescribe.Dialyzer
 				newprescribe.ReplacementTotal = system_dialysisPrescribe.ReplacementTotal
 				newprescribe.DialyzerPerfusionApparatus = system_dialysisPrescribe.DialyzerPerfusionApparatus
+				newprescribe.DialysisIrrigation = system_dialysisPrescribe.DialysisIrrigation
+				newprescribe.DialysisDialyszers = system_dialysisPrescribe.DialysisDialyszers
 				newprescribe.BodyFluidOther = system_dialysisPrescribe.BodyFluidOther
 				newprescribe.TargetKtv = system_dialysisPrescribe.TargetKtv
 				newprescribe.CreatedTime = time.Now().Unix()
 				newprescribe.DewaterAmount = dewater_amount
 				newprescribe.TargetUltrafiltration = dewater_amount
 				newprescribe.Status = 1
+
 				fmt.Println(newprescribe.DewaterAmount)
 				fmt.Println(newprescribe.TargetUltrafiltration)
 

controllers/mobile_api_controllers/dialysis_api_controller.go

 
 func (c *DialysisAPIController) GetPatientId() {
 	id, _ := c.GetInt64("id")
+	fmt.Println("id223333444444", id)
 	patientId, _ := service.GetPatientId(id)
+	//获取该患者的所有传染病
+	list, err := service.GetPatientInfectious(id)
+	fmt.Println("err222222222", err)
 	c.ServeSuccessJSON(map[string]interface{}{
-		"patient": patientId,
+		"patient":       patientId,
+		"infectioulist": list,
 	})
 }
 

controllers/mobile_api_controllers/patient_api_controller.go

 		newprescribe.DewaterAmount = dewater_amount
 		newprescribe.TargetUltrafiltration = dewater_amount
 		newprescribe.Status = 1
+		newprescribe.DialysisDialyszers = dialysisSolution.DialysisDialyszers
+		newprescribe.DialysisIrrigation = dialysisSolution.DialysisIrrigation
 
 		err := service.AddSigleRecord(&newprescribe)
 		if err != nil {
 			newprescribe.DewaterAmount = dewater_amount
 			newprescribe.TargetUltrafiltration = dewater_amount
 			newprescribe.Status = 1
+			newprescribe.DialysisIrrigation = lastDialysisPrescribe.DialysisIrrigation
+			newprescribe.DialysisDialyszers = lastDialysisPrescribe.DialysisDialyszers
 			err := service.AddSigleRecord(&newprescribe)
 			if err != nil {
 				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
 			newprescribe.DewaterAmount = dewater_amount
 			newprescribe.TargetUltrafiltration = dewater_amount
 			newprescribe.Status = 1
+			newprescribe.DialysisDialyszers = system_dialysisPrescribe.DialysisDialyszers
+			newprescribe.DialysisIrrigation = system_dialysisPrescribe.DialysisIrrigation
 			err := service.AddSigleRecord(&newprescribe)
 			if err != nil {
 				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)

controllers/role_controller.go

 package controllers
 
 import (
+	"fmt"
 	"github.com/jinzhu/gorm"
 	"strconv"
 	"strings"
 	beego.Router("/api/adminmain", &RoleAPIController{}, "get:AdminMainView")
 	beego.Router("/api/admins", &RoleAPIController{}, "get:Admins")
 	beego.Router("/api/admin/addinit", &RoleAPIController{}, "get:AddAdminInitData")
-	beego.Router("/api/admin/add", &RoleAPIController{}, "post:AddAdmin")
+	beego.Router("/api/admin/add", &RoleAPIController{}, "get:AddAdmin")
 	beego.Router("/api/admin/editinit", &RoleAPIController{}, "get:EditAdminInitData")
-	beego.Router("/api/admin/edit", &RoleAPIController{}, "post:EditAdmin")
+	beego.Router("/api/admin/edit", &RoleAPIController{}, "get:EditAdmin")
 	beego.Router("/api/admin/setstatus", &RoleAPIController{}, "post:AdminSetStatus")
 
 	beego.Router("/api/admin/specialpermission/initdata", &RoleAPIController{}, "get:SpecialPermissionInitData")
 	user_title_name := this.GetString("user_title_name")
 	department := this.GetString("department")
 	department_id, _ := this.GetInt64("department_id")
+
+	sex, _ := this.GetInt64("sex")
+
+	age, _ := this.GetInt64("age")
+	nation := this.GetString("nation")
+	card_type, _ := this.GetInt64("card_type")
+	id_card := this.GetString("id_card")
+	education, _ := this.GetInt64("education")
+	study_major_name := this.GetString("study_major_name")
+	work_major_name := this.GetString("work_major_name")
+	role_type, _ := this.GetInt64("role_type")
+	medical_code := this.GetString("medical_code")
+	doctor_code := this.GetString("doctor_code")
+	licensing, _ := this.GetInt64("licensing")
+	job_number := this.GetString("job_number")
+
+	prescription_qualification_identification, _ := this.GetInt64("prescription_qualification_identification")
+	identification_outpatients, _ := this.GetInt64("identification_outpatients")
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	start_time := this.GetString("start_time")
+
+	theStartTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+
+	medical_range_code, _ := this.GetInt64("medical_range_code")
+	medical_level, _ := this.GetInt64("medical_level")
+	medical_type_job, _ := this.GetInt64("medical_type_job")
+	pharmacist_registration_number := this.GetString("pharmacist_registration_number")
+	doctor_range_code, _ := this.GetInt64("doctor_range_code")
+	doctor_level, _ := this.GetInt64("doctor_level")
+	doctor_type_job, _ := this.GetInt64("doctor_type_job")
+	doctor_number := this.GetString("doctor_number")
+	outpatient_illnessCategory := this.GetString("outpatient_illnessCategory")
+	is_active, _ := this.GetInt64("is_active")
+	active_status, _ := this.GetInt64("active_status")
+	fmt.Println("active_status", active_status)
 	if len(mobile) == 0 || len(name) == 0 || (userType != 2 && userType != 3 && userType != 4) || len(roleIds) <= 0 {
+
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 	}
 		return
 	} else {
 		if adminUser == nil { //新增账号和用户
-			_, password, createErr := service.CreateGeneralAdminUser(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId, mobile, name, user_title_name, roleIds, userType, userTitle, department_id, department)
+			_, password, createErr := service.CreateGeneralAdminUserOne(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId, mobile, name, user_title_name, roleIds, userType, userTitle, department_id, department, sex, age, nation, card_type, id_card, education, study_major_name, work_major_name, role_type, medical_code, doctor_code, licensing, job_number, prescription_qualification_identification, identification_outpatients, theStartTime.Unix(), medical_range_code, medical_level, medical_type_job, pharmacist_registration_number, doctor_range_code, doctor_level, doctor_type_job, doctor_number, outpatient_illnessCategory, is_active, active_status)
 			if createErr != nil {
 				//beego.Error("创建管理员失败:", createErr)
 				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDBCreate)
 		} else {
 
 			total, _ := service.FindAdminUserByID(adminUser.Id, adminUserInfo.CurrentOrgId)
-
 			if total <= 0 {
 				//新增用户
 				app_role := &models.App_Role{
-					AdminUserId:   adminUser.Id,
-					OrgId:         adminUserInfo.CurrentOrgId,
-					AppId:         adminUserInfo.CurrentAppId,
-					Avatar:        "",
-					UserName:      name,
-					UserTitleName: user_title_name,
-					Status:        1,
-					UserType:      int8(userType),
-					UserTitle:     int8(userTitle),
-					CreateTime:    time.Now().Unix(),
-					ModifyTime:    time.Now().Unix(),
-					RoleIds:       roleIds,
-					Department:    department,
-					DepartmentId:  department_id,
+					AdminUserId:                             adminUser.Id,
+					OrgId:                                   adminUserInfo.CurrentOrgId,
+					AppId:                                   adminUserInfo.CurrentAppId,
+					Avatar:                                  "",
+					UserName:                                name,
+					UserTitleName:                           user_title_name,
+					Status:                                  1,
+					UserType:                                int8(userType),
+					UserTitle:                               int8(userTitle),
+					CreateTime:                              time.Now().Unix(),
+					ModifyTime:                              time.Now().Unix(),
+					RoleIds:                                 roleIds,
+					Department:                              department,
+					DepartmentId:                            department_id,
+					Sex:                                     sex,
+					Age:                                     age,
+					Nation:                                  nation,
+					CardType:                                card_type,
+					IdCard:                                  id_card,
+					Education:                               education,
+					StudyMajorName:                          study_major_name,
+					WorkMajorName:                           work_major_name,
+					RoleType:                                role_type,
+					MedicalCode:                             medical_code,
+					DoctorCode:                              doctor_code,
+					Licensing:                               licensing,
+					JobNumber:                               job_number,
+					PrescriptionQualificationIdentification: prescription_qualification_identification,
+					IdentificationOutpatients:               identification_outpatients,
+					StartTime:                               theStartTime.Unix(),
+					MedicalRangeCode:                        medical_range_code,
+					MedicalLevel:                            medical_level,
+					MedicalTypeJob:                          medical_type_job,
+					PharmacistRegistrationNumber:            pharmacist_registration_number,
+					DoctorRangeCode:                         doctor_range_code,
+					DoctorLevel:                             doctor_level,
+					DoctorTypeJob:                           doctor_type_job,
+					DoctorNumber:                            doctor_number,
+					OutpatientIllnesscategory:               outpatient_illnessCategory,
+					IsActive:                                is_active,
+					ActiveStatus:                            active_status,
 				}
 				err := service.CreateUserRole(app_role)
 				if err != nil {
 	department := this.GetString("department")
 	department_id, _ := this.GetInt64("department_id")
 	sort, _ := this.GetInt64("sort")
+
+	age, _ := this.GetInt64("age")
+	nation := this.GetString("nation")
+	card_type, _ := this.GetInt64("card_type")
+	id_card := this.GetString("id_card")
+	education, _ := this.GetInt64("education")
+	study_major_name := this.GetString("study_major_name")
+	work_major_name := this.GetString("work_major_name")
+	role_type, _ := this.GetInt64("role_type")
+	medical_code := this.GetString("medical_code")
+	doctor_code := this.GetString("doctor_code")
+	licensing, _ := this.GetInt64("licensing")
+	job_number := this.GetString("job_number")
+
+	prescription_qualification_identification, _ := this.GetInt64("prescription_qualification_identification")
+	identification_outpatients, _ := this.GetInt64("identification_outpatients")
+	timeLayout := "2006-01-02"
+	loc, _ := time.LoadLocation("Local")
+	start_time := this.GetString("start_time")
+	fmt.Println("start_time22222222222", start_time)
+	theStartTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
+
+	medical_range_code, _ := this.GetInt64("medical_range_code")
+	medical_level, _ := this.GetInt64("medical_level")
+	medical_type_job, _ := this.GetInt64("medical_type_job")
+	pharmacist_registration_number := this.GetString("pharmacist_registration_number")
+	doctor_range_code, _ := this.GetInt64("doctor_range_code")
+	doctor_level, _ := this.GetInt64("doctor_level")
+	doctor_type_job, _ := this.GetInt64("doctor_type_job")
+	doctor_number := this.GetString("doctor_number")
+	outpatient_illnessCategory := this.GetString("outpatient_illnessCategory")
+	is_active, _ := this.GetInt64("is_active")
+	active_status, _ := this.GetInt64("active_status")
+
 	_, titleExist := models.UserTitle[userTitle]
+	fmt.Println(titleExist)
 	if adminUserId <= 0 || len(name) == 0 || (userType != 2 && userType != 3 && userType != 4) || !titleExist || len(roleIds) <= 0 {
+		fmt.Println("进来了吗")
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 	}
 	appRole.UserTitleName = user_title_name
 	appRole.ModifyTime = time.Now().Unix()
 	appRole.Sort = sort
+	appRole.Age = age
+	appRole.Nation = nation
+	appRole.CardType = card_type
+	appRole.IdCard = id_card
+	appRole.Education = education
+	appRole.StudyMajorName = study_major_name
+	appRole.WorkMajorName = work_major_name
+	appRole.RoleType = role_type
+	appRole.MedicalCode = medical_code
+	appRole.DoctorCode = doctor_code
+	appRole.Licensing = licensing
+	appRole.JobNumber = job_number
+	appRole.PrescriptionQualificationIdentification = prescription_qualification_identification
+	appRole.IdentificationOutpatients = identification_outpatients
+	appRole.StartTime = theStartTime.Unix()
+	appRole.MedicalCode = medical_code
+	appRole.MedicalRangeCode = medical_range_code
+	appRole.MedicalLevel = medical_level
+	appRole.MedicalTypeJob = medical_type_job
+	appRole.PharmacistRegistrationNumber = pharmacist_registration_number
+	appRole.DoctorRangeCode = doctor_range_code
+	appRole.DoctorLevel = doctor_level
+	appRole.DoctorTypeJob = doctor_type_job
+	appRole.DoctorNumber = doctor_number
+	appRole.OutpatientIllnesscategory = outpatient_illnessCategory
+	appRole.IsActive = is_active
+	appRole.ActiveStatus = active_status
 	saveErr := service.SaveAppRole(appRole)
 	if saveErr != nil {
 		//beego.Error("修改App_Role失败:", saveErr)
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDBUpdate)
 
 	} else {
+		this.ServeSuccessJSON(map[string]interface{}{
+			"approle": appRole,
+		})
 		this.ServeSuccessJSON(nil)
 	}
 }

models/data_models.go

 	Title          string `gorm:"column:title" json:"title" form:"title"`
 	Content        string `gorm:"column:content" json:"content" form:"content"`
 	Order          int64  `gorm:"column:orders" json:"orders" form:"orders"`
+	Code           string `gorm:"column:code" json:"code" form:"code"`
 }
 
 func (DictionaryDataconfig) TableName() string {

models/drug.go

 package models
 
 type BaseDrugLib struct {
-	ID                     int64   `gorm:"column:id" json:"id" form:"id"`
-	DrugName               string  `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
-	Pinyin                 string  `gorm:"column:pinyin" json:"pinyin" form:"pinyin"`
-	Wubi                   string  `gorm:"column:wubi" json:"wubi" form:"wubi"`
-	DrugAlias              string  `gorm:"column:drug_alias" json:"drug_alias" form:"drug_alias"`
-	DrugAliasPinyin        string  `gorm:"column:drug_alias_pinyin" json:"drug_alias_pinyin" form:"drug_alias_pinyin"`
-	DrugAliasWubi          string  `gorm:"column:drug_alias_wubi" json:"drug_alias_wubi" form:"drug_alias_wubi"`
-	DrugCategory           int64   `gorm:"column:drug_category" json:"drug_category" form:"drug_category"`
-	DrugSpec               string  `gorm:"column:drug_spec" json:"drug_spec" form:"drug_spec"`
-	DrugType               int64   `gorm:"column:drug_type" json:"drug_type" form:"drug_type"`
-	DrugStockLimit         string  `gorm:"column:drug_stock_limit" json:"drug_stock_limit" form:"drug_stock_limit"`
-	DrugOriginPlace        string  `gorm:"column:drug_origin_place" json:"drug_origin_place" form:"drug_origin_place"`
-	DrugDosageForm         int64   `gorm:"column:drug_dosage_form" json:"drug_dosage_form" form:"drug_dosage_form"`
-	MedicalInsuranceLevel  int64   `gorm:"column:medical_insurance_level" json:"medical_insurance_level" form:"medical_insurance_level"`
-	MaxUnit                string  `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
-	MinUnit                string  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
-	UnitMatrixing          string  `gorm:"column:unit_matrixing" json:"unit_matrixing" form:"unit_matrixing"`
-	RetailPrice            float64 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
-	LastPrice              float64 `gorm:"column:last_price" json:"last_price" form:"last_price"`
-	DrugControl            int64   `gorm:"column:drug_control" json:"drug_control" form:"drug_control"`
-	Number                 string  `gorm:"column:number" json:"number" form:"number"`
-	DrugClassify           string  `gorm:"column:drug_classify" json:"drug_classify" form:"drug_classify"`
-	DrugDose               float64 `gorm:"column:drug_dose" json:"drug_dose" form:"drug_dose"`
-	DrugDoseUnit           int64   `gorm:"column:drug_dose_unit" json:"drug_dose_unit" form:"drug_dose_unit"`
-	MedicalInsuranceNumber string  `gorm:"column:medical_insurance_number" json:"medical_insurance_number" form:"medical_insurance_number"`
-	Manufacturer           int64   `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
-	PharmacologyCategory   int64   `gorm:"column:pharmacology_category" json:"pharmacology_category" form:"pharmacology_category"`
-	StatisticsCategory     int64   `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
-	Code                   string  `gorm:"column:code" json:"code" form:"code"`
-	IsSpecialDiseases      int64   `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
-	IsRecord               int64   `gorm:"column:is_record" json:"is_record" form:"is_record"`
-	Agent                  string  `gorm:"column:agent" json:"agent" form:"agent"`
-	DrugStatus             string  `gorm:"column:drug_status" json:"drug_status" form:"drug_status"`
-	LimitRemark            string  `gorm:"column:limit_remark" json:"limit_remark" form:"limit_remark"`
-	DeliveryWay            string  `gorm:"column:delivery_way" json:"delivery_way" form:"delivery_way"`
-	ExecutionFrequency     string  `gorm:"column:execution_frequency" json:"execution_frequency" form:"execution_frequency"`
-	SingleDose             float64 `gorm:"column:single_dose" json:"single_dose" form:"single_dose"`
-	PrescribingNumber      float64 `gorm:"column:prescribing_number" json:"prescribing_number" form:"prescribing_number"`
-	Label                  int64   `gorm:"column:label" json:"label" form:"label"`
-	Sort                   int64   `gorm:"column:sort" json:"sort" form:"sort"`
-	IsUseDoctorAdvice      int64   `gorm:"column:is_use_doctor_advice" json:"is_use_doctor_advice" form:"is_use_doctor_advice"`
-	IsDefault              int64   `gorm:"column:is_default" json:"is_default" form:"is_default"`
-	IsChargePredict        int64   `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
-	IsStatisticsWork       int64   `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
-	IsChargeUse            int64   `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
-	Status                 int64   `gorm:"column:status" json:"status" form:"status"`
-	Ctime                  int64   `gorm:"column:ctime" json:"ctime" form:"ctime"`
-	Mtime                  int64   `gorm:"column:mtime" json:"mtime" form:"mtime"`
-	OrgId                  int64   `gorm:"column:org_id" json:"org_id" form:"org_id"`
-	DrugCode               string  `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
-	Dealer                 int64   `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	ID                          int64   `gorm:"column:id" json:"id" form:"id"`
+	DrugName                    string  `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
+	Pinyin                      string  `gorm:"column:pinyin" json:"pinyin" form:"pinyin"`
+	Wubi                        string  `gorm:"column:wubi" json:"wubi" form:"wubi"`
+	DrugAlias                   string  `gorm:"column:drug_alias" json:"drug_alias" form:"drug_alias"`
+	DrugAliasPinyin             string  `gorm:"column:drug_alias_pinyin" json:"drug_alias_pinyin" form:"drug_alias_pinyin"`
+	DrugAliasWubi               string  `gorm:"column:drug_alias_wubi" json:"drug_alias_wubi" form:"drug_alias_wubi"`
+	DrugCategory                int64   `gorm:"column:drug_category" json:"drug_category" form:"drug_category"`
+	DrugSpec                    string  `gorm:"column:drug_spec" json:"drug_spec" form:"drug_spec"`
+	DrugType                    int64   `gorm:"column:drug_type" json:"drug_type" form:"drug_type"`
+	DrugStockLimit              string  `gorm:"column:drug_stock_limit" json:"drug_stock_limit" form:"drug_stock_limit"`
+	DrugOriginPlace             string  `gorm:"column:drug_origin_place" json:"drug_origin_place" form:"drug_origin_place"`
+	DrugDosageForm              int64   `gorm:"column:drug_dosage_form" json:"drug_dosage_form" form:"drug_dosage_form"`
+	MedicalInsuranceLevel       int64   `gorm:"column:medical_insurance_level" json:"medical_insurance_level" form:"medical_insurance_level"`
+	MaxUnit                     string  `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinUnit                     string  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	UnitMatrixing               string  `gorm:"column:unit_matrixing" json:"unit_matrixing" form:"unit_matrixing"`
+	RetailPrice                 float64 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	LastPrice                   float64 `gorm:"column:last_price" json:"last_price" form:"last_price"`
+	DrugControl                 int64   `gorm:"column:drug_control" json:"drug_control" form:"drug_control"`
+	Number                      string  `gorm:"column:number" json:"number" form:"number"`
+	DrugClassify                string  `gorm:"column:drug_classify" json:"drug_classify" form:"drug_classify"`
+	DrugDose                    float64 `gorm:"column:drug_dose" json:"drug_dose" form:"drug_dose"`
+	DrugDoseUnit                int64   `gorm:"column:drug_dose_unit" json:"drug_dose_unit" form:"drug_dose_unit"`
+	MedicalInsuranceNumber      string  `gorm:"column:medical_insurance_number" json:"medical_insurance_number" form:"medical_insurance_number"`
+	Manufacturer                int64   `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	PharmacologyCategory        int64   `gorm:"column:pharmacology_category" json:"pharmacology_category" form:"pharmacology_category"`
+	StatisticsCategory          int64   `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
+	Code                        string  `gorm:"column:code" json:"code" form:"code"`
+	IsSpecialDiseases           int64   `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
+	IsRecord                    int64   `gorm:"column:is_record" json:"is_record" form:"is_record"`
+	Agent                       string  `gorm:"column:agent" json:"agent" form:"agent"`
+	DrugStatus                  string  `gorm:"column:drug_status" json:"drug_status" form:"drug_status"`
+	LimitRemark                 string  `gorm:"column:limit_remark" json:"limit_remark" form:"limit_remark"`
+	DeliveryWay                 string  `gorm:"column:delivery_way" json:"delivery_way" form:"delivery_way"`
+	ExecutionFrequency          string  `gorm:"column:execution_frequency" json:"execution_frequency" form:"execution_frequency"`
+	SingleDose                  float64 `gorm:"column:single_dose" json:"single_dose" form:"single_dose"`
+	PrescribingNumber           float64 `gorm:"column:prescribing_number" json:"prescribing_number" form:"prescribing_number"`
+	Label                       int64   `gorm:"column:label" json:"label" form:"label"`
+	Sort                        int64   `gorm:"column:sort" json:"sort" form:"sort"`
+	IsUseDoctorAdvice           int64   `gorm:"column:is_use_doctor_advice" json:"is_use_doctor_advice" form:"is_use_doctor_advice"`
+	IsDefault                   int64   `gorm:"column:is_default" json:"is_default" form:"is_default"`
+	IsChargePredict             int64   `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
+	IsStatisticsWork            int64   `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
+	IsChargeUse                 int64   `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
+	Status                      int64   `gorm:"column:status" json:"status" form:"status"`
+	Ctime                       int64   `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                       int64   `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	OrgId                       int64   `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	DrugCode                    string  `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
+	Dealer                      int64   `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	PrescriptionMark            int64   `gorm:"column:prescription_mark" json:"prescription_mark" form:"prescription_mark"`
+	RecordDate                  int64   `gorm:"column:record_date" json:"record_date" form:"record_date"`
+	DrugRemark                  string  `gorm:"column:drug_remark" json:"drug_remark" form:"drug_remark"`
+	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"`
 	//MedicineInsurancePercentage []*MedicineInsurancePercentage `gorm:"ForeignKey:PatientId;AssociationForeignKey:PatientId" json:"monitoring_record"`
 }
 

models/good_models.go

 }
 
 type GoodInfo struct {
-	ID                     int64     `gorm:"column:id" json:"id" form:"id"`
-	GoodCode               string    `gorm:"column:good_code" json:"good_code" form:"good_code"`
-	SpecificationName      string    `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
-	GoodTypeId             int64     `gorm:"column:good_type_id" json:"good_type_id" form:"good_type_id"`
-	GoodUnit               int64     `gorm:"column:good_unit" json:"good_unit" form:"good_unit"`
-	BuyPrice               float64   `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
-	SellPrice              float64   `gorm:"column:sell_price" json:"sell_price" form:"sell_price"`
-	Remark                 string    `gorm:"column:remark" json:"remark" form:"remark"`
-	Ctime                  int64     `gorm:"column:ctime" json:"ctime" form:"ctime"`
-	Mtime                  int64     `gorm:"column:mtime" json:"mtime" form:"mtime"`
-	Manufacturer           int64     `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
-	Dealer                 int64     `gorm:"column:dealer" json:"dealer" form:"dealer"`
-	ExpiryDateWarnDayCount int64     `gorm:"column:expiry_date_warn_day_count" json:"expiry_date_warn_day_count" form:"expiry_date_warn_day_count"`
-	StockWarnCount         int64     `gorm:"column:stock_warn_count" json:"stock_warn_count" form:"stock_warn_count"`
-	IsReuse                int64     `gorm:"column:is_reuse" json:"is_reuse" form:"is_reuse"`
-	Status                 int64     `gorm:"column:status" json:"status" form:"status"`
-	FilmArea               string    `gorm:"column:film_area" json:"film_area" form:"film_area"`
-	IsUse                  int64     `gorm:"column:is_use" json:"is_use" form:"is_use"`
-	FilmMaterialQuality    string    `gorm:"column:film_material_quality" json:"film_material_quality" form:"film_material_quality"`
-	OrgId                  int64     `gorm:"column:org_id" json:"org_id" form:"org_id"`
-	Modifier               int64     `gorm:"column:modifier" json:"modifier" form:"modifier"`
-	Creater                int64     `gorm:"column:creater" json:"creater" form:"creater"`
-	GoodName               string    `gorm:"column:good_name" json:"good_name" form:"good_name"`
-	Pinyin                 string    `gorm:"column:pinyin" json:"pinyin" form:"pinyin"`
-	Wubi                   string    `gorm:"column:wubi" json:"wubi" form:"wubi"`
-	GoodKind               int64     `gorm:"column:good_kind" json:"good_kind" form:"good_kind"`
-	MedicalInsuranceLevel  int64     `gorm:"column:medical_insurance_level" json:"medical_insurance_level" form:"medical_insurance_level"`
-	RetailPrice            float64   `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
-	MedicalInsuranceNumber string    `gorm:"column:medical_insurance_number" json:"medical_insurance_number" form:"medical_insurance_number"`
-	IsSpecialDiseases      int64     `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
-	IsRecord               int64     `gorm:"column:is_record" json:"is_record" form:"is_record"`
-	StatisticsCategory     int64     `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
-	GoodStatus             string    `gorm:"column:good_status" json:"good_status" form:"good_status"`
-	DefaultCount           int64     `gorm:"column:default_count" json:"default_count" form:"default_count"`
-	Sign                   int64     `gorm:"column:sign" json:"sign" form:"sign"`
-	IsDefault              int64     `gorm:"column:is_default" json:"is_default" form:"is_default"`
-	IsChargeUse            int64     `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
-	IsChargePredict        int64     `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
-	IsStatisticsWork       int64     `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
-	Sort                   int64     `gorm:"column:sort" json:"sort" form:"sort"`
-	IsDoctorUse            int64     `gorm:"column:is_doctor_use" json:"is_doctor_use" form:"is_doctor_use"`
-	Agent                  string    `gorm:"column:agent" json:"agent" form:"agent"`
-	GoodNumber             string    `gorm:"column:good_number" json:"good_number" form:"good_number"`
-	GoodsType              GoodsType `gorm:"ForeignKey:ID;AssociationForeignKey:GoodTypeId" json:"type"`
-	CommdityCode           string    `gorm:"column:commdity_code" json:"commdity_code" form:"commdity_code"`
+	ID                          int64     `gorm:"column:id" json:"id" form:"id"`
+	GoodCode                    string    `gorm:"column:good_code" json:"good_code" form:"good_code"`
+	SpecificationName           string    `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
+	GoodTypeId                  int64     `gorm:"column:good_type_id" json:"good_type_id" form:"good_type_id"`
+	GoodUnit                    int64     `gorm:"column:good_unit" json:"good_unit" form:"good_unit"`
+	BuyPrice                    float64   `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
+	SellPrice                   float64   `gorm:"column:sell_price" json:"sell_price" form:"sell_price"`
+	Remark                      string    `gorm:"column:remark" json:"remark" form:"remark"`
+	Ctime                       int64     `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                       int64     `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Manufacturer                int64     `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	Dealer                      int64     `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	ExpiryDateWarnDayCount      int64     `gorm:"column:expiry_date_warn_day_count" json:"expiry_date_warn_day_count" form:"expiry_date_warn_day_count"`
+	StockWarnCount              int64     `gorm:"column:stock_warn_count" json:"stock_warn_count" form:"stock_warn_count"`
+	IsReuse                     int64     `gorm:"column:is_reuse" json:"is_reuse" form:"is_reuse"`
+	Status                      int64     `gorm:"column:status" json:"status" form:"status"`
+	FilmArea                    string    `gorm:"column:film_area" json:"film_area" form:"film_area"`
+	IsUse                       int64     `gorm:"column:is_use" json:"is_use" form:"is_use"`
+	FilmMaterialQuality         string    `gorm:"column:film_material_quality" json:"film_material_quality" form:"film_material_quality"`
+	OrgId                       int64     `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	Modifier                    int64     `gorm:"column:modifier" json:"modifier" form:"modifier"`
+	Creater                     int64     `gorm:"column:creater" json:"creater" form:"creater"`
+	GoodName                    string    `gorm:"column:good_name" json:"good_name" form:"good_name"`
+	Pinyin                      string    `gorm:"column:pinyin" json:"pinyin" form:"pinyin"`
+	Wubi                        string    `gorm:"column:wubi" json:"wubi" form:"wubi"`
+	GoodKind                    int64     `gorm:"column:good_kind" json:"good_kind" form:"good_kind"`
+	MedicalInsuranceLevel       int64     `gorm:"column:medical_insurance_level" json:"medical_insurance_level" form:"medical_insurance_level"`
+	RetailPrice                 float64   `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	MedicalInsuranceNumber      string    `gorm:"column:medical_insurance_number" json:"medical_insurance_number" form:"medical_insurance_number"`
+	IsSpecialDiseases           int64     `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
+	IsRecord                    int64     `gorm:"column:is_record" json:"is_record" form:"is_record"`
+	StatisticsCategory          int64     `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
+	GoodStatus                  string    `gorm:"column:good_status" json:"good_status" form:"good_status"`
+	DefaultCount                int64     `gorm:"column:default_count" json:"default_count" form:"default_count"`
+	Sign                        int64     `gorm:"column:sign" json:"sign" form:"sign"`
+	IsDefault                   int64     `gorm:"column:is_default" json:"is_default" form:"is_default"`
+	IsChargeUse                 int64     `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
+	IsChargePredict             int64     `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
+	IsStatisticsWork            int64     `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
+	Sort                        int64     `gorm:"column:sort" json:"sort" form:"sort"`
+	IsDoctorUse                 int64     `gorm:"column:is_doctor_use" json:"is_doctor_use" form:"is_doctor_use"`
+	Agent                       string    `gorm:"column:agent" json:"agent" form:"agent"`
+	GoodNumber                  string    `gorm:"column:good_number" json:"good_number" form:"good_number"`
+	GoodsType                   GoodsType `gorm:"ForeignKey:ID;AssociationForeignKey:GoodTypeId" json:"type"`
+	CommdityCode                string    `gorm:"column:commdity_code" json:"commdity_code" form:"commdity_code"`
+	SocialSecurityDirectoryCode string    `gorm:"column:social_security_directory_code" json:"social_security_directory_code" form:"social_security_directory_code"`
+	ProductionType              string    `gorm:"column:production_type" json:"production_type" form:"production_type"`
+	SpecialMedical              string    `gorm:"column:special_medical" json:"special_medical" form:"special_medical"`
+	IsMark                      int64     `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
 }
 
 func (GoodInfo) TableName() string {

models/his_models.go

 	DeliveryWay               string  `gorm:"column:delivery_way" json:"delivery_way" form:"delivery_way"`
 	NumberDays                string  `gorm:"column:number_days" json:"number_days" form:"number_days"`
 	Total                     string  `gorm:"column:total" json:"total" form:"total"`
+	Category                  int64   `gorm:"column:category" json:"category" form:"category"`
+	IsMark                    int64   `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
 }
 
 func (XtHisProject) TableName() string {

models/role_models.go

 	IsSort          int64  `gorm:"column:is_sort" json:"is_sort" form:"is_sort"`
 	DepartmentId    int64  `gorm:"column:department_id" json:"department_id" form:"department_id"`
 	Department      string `gorm:"column:department" json:"department" form:"department"`
+
+	Age                                     int64  `gorm:"column:age" json:"age" form:"age"`
+	Nation                                  string `gorm:"column:nation" json:"nation" form:"nation"`
+	CardType                                int64  `gorm:"column:card_type" json:"card_type" form:"card_type"`
+	IdCard                                  string `gorm:"column:id_card" json:"id_card" form:"id_card"`
+	Education                               int64  `gorm:"column:education" json:"education" form:"education"`
+	StudyMajorName                          string `gorm:"column:study_major_name" json:"study_major_name" form:"study_major_name"`
+	WorkMajorName                           string `gorm:"column:work_major_name" json:"work_major_name" form:"work_major_name"`
+	RoleType                                int64  `gorm:"column:role_type" json:"role_type" form:"role_type"`
+	MedicalCode                             string `gorm:"column:medical_code" json:"medical_code" form:"medical_code"`
+	DoctorCode                              string `gorm:"column:doctor_code" json:"doctor_code" form:"doctor_code"`
+	Licensing                               int64  `gorm:"column:licensing" json:"licensing" form:"licensing"`
+	JobNumber                               string `gorm:"column:job_number" json:"job_number" form:"job_number"`
+	PrescriptionQualificationIdentification int64  `gorm:"column:prescription_qualification_identification" json:"prescription_qualification_identification" form:"prescription_qualification_identification"`
+	IdentificationOutpatients               int64  `gorm:"column:identification_outpatients" json:"identification_outpatients" form:"identification_outpatients"`
+	StartTime                               int64  `gorm:"column:start_time" json:"start_time" form:"start_time"`
+	MedicalRangeCode                        int64  `gorm:"column:medical_range_code" json:"medical_range_code" form:"medical_range_code"`
+	MedicalLevel                            int64  `gorm:"column:medical_level" json:"medical_level" form:"medical_level"`
+	MedicalTypeJob                          int64  `gorm:"column:medical_type_job" json:"medical_type_job" form:"medical_type_job"`
+	PharmacistRegistrationNumber            string `gorm:"column:pharmacist_registration_number" json:"pharmacist_registration_number" form:"pharmacist_registration_number"`
+	DoctorRangeCode                         int64  `gorm:"column:doctor_range_code" json:"doctor_range_code" form:"doctor_range_code"`
+	DoctorLevel                             int64  `gorm:"column:doctor_level" json:"doctor_level" form:"doctor_level"`
+	DoctorTypeJob                           int64  `gorm:"column:doctor_type_job" json:"doctor_type_job" form:"doctor_type_job"`
+	DoctorNumber                            string `gorm:"column:doctor_number" json:"doctor_number" form:"doctor_number"`
+	OutpatientIllnesscategory               string `gorm:"column:outpatient_illness_category" json:"outpatient_illness_category" form:"outpatient_illness_category"`
+	IsActive                                int64  `gorm:"column:is_active" json:"is_active" form:"is_active"`
+	ActiveStatus                            int64  `gorm:"column:active_status" json:"active_status" form:"active_status"`
 }
 
 func (App_Role) TableName() string {

service/device_service.go

 	err := XTReadDB().Model(&patientsNew).Where("blood_id = ? and status = 1", id).Find(&patientsNew).Error
 	return patientsNew, err
 }
+
+func GetPatientInfectious(id int64) (infectious []*models.InfectiousDiseases, err error) {
+
+	err = XTReadDB().Where("patient_id=? and status=1", id).Find(&infectious).Error
+	return infectious, err
+}

service/his_project_service.go

 	return err
 }
 
-func GetHisProjectList(orgid int64, limit int64, page int64, charge int64, start int64, keyword string) (hisproject []*models.XtHisProject, total int64, err error) {
+func GetHisProjectList(orgid int64, limit int64, page int64, charge int64, start int64, keyword string, isMark int64) (hisproject []*models.XtHisProject, total int64, err error) {
 	offset := (page - 1) * limit
 	likeKey := "%" + keyword + "%"
 	db := XTReadDB().Table("xt_his_project as x").Where("x.status = 1")
 	if len(keyword) > 0 {
 		db = db.Where("x.project_name like ?", likeKey)
 	}
-	err = db.Select("x.id,x.project_name,x.pinyin,x.wubi,x.price,x.unit,x.cost_classify,x.executive_section,x.medical_coverage,x.statistical_classification,x.disease_directory,x.is_record,x.medical_code,x.tube_color,x.medical_status,x.remark,x.sign,x.default_number,x.is_default,x.is_charge,x.is_estimate,x.is_workload,x.sort,x.doctor_advice,x.user_org_id,x.status,x.created_time").Count(&total).Offset(offset).Limit(limit).Find(&hisproject).Error
+	if isMark > 0 {
+		db = db.Where("x.is_mark = ?", isMark)
+	}
+	err = db.Select("x.id,x.project_name,x.pinyin,x.wubi,x.price,x.unit,x.cost_classify,x.executive_section,x.medical_coverage,x.statistical_classification,x.disease_directory,x.is_record,x.medical_code,x.tube_color,x.medical_status,x.remark,x.sign,x.default_number,x.is_default,x.is_charge,x.is_estimate,x.is_workload,x.sort,x.doctor_advice,x.user_org_id,x.status,x.created_time,x.is_mark").Count(&total).Offset(offset).Limit(limit).Find(&hisproject).Error
 	return hisproject, total, err
 }
 
 
 func UpdatedProject(id int64, pro *models.XtHisProject) error {
 
-	err := XTWriteDB().Model(&pro).Where("id=?", id).Updates(map[string]interface{}{"project_name": pro.ProjectName, "pinyin": pro.Pinyin, "wubi": pro.Pinyin, "price": pro.Price, "unit": pro.Unit, "cost_classify": pro.CostClassify, "executive_section": pro.ExecutiveSection, "medical_coverage": pro.MedicalCoverage, "statistical_classification": pro.StatisticalClassification, "disease_directory": pro.DiseaseDirectory, "is_record": pro.IsRecord, "medical_code": pro.MedicalCode, "tube_color": pro.TubeColor, "medical_status": pro.MedicalStatus, "remark": pro.Remark, "sign": pro.Sign, "default_number": pro.DefaultNumber, "is_default": pro.IsDefault, "is_charge": pro.IsCharge, "is_estimate": pro.IsEstimate, "is_workload": pro.IsWorkload, "sort": pro.Sort, "doctor_advice": pro.DoctorAdvice, "single_dose": pro.SingleDose, "execution_frequency": pro.ExecutionFrequency, "delivery_way": pro.DeliveryWay, "number_days": pro.NumberDays, "total": pro.Total, "updated_time": pro.UpdatedTime}).Error
+	err := XTWriteDB().Model(&pro).Where("id=?", id).Updates(map[string]interface{}{"project_name": pro.ProjectName, "pinyin": pro.Pinyin, "wubi": pro.Pinyin, "price": pro.Price, "unit": pro.Unit, "cost_classify": pro.CostClassify, "executive_section": pro.ExecutiveSection, "medical_coverage": pro.MedicalCoverage, "statistical_classification": pro.StatisticalClassification, "disease_directory": pro.DiseaseDirectory, "is_record": pro.IsRecord, "medical_code": pro.MedicalCode, "tube_color": pro.TubeColor, "medical_status": pro.MedicalStatus, "remark": pro.Remark, "sign": pro.Sign, "default_number": pro.DefaultNumber, "is_default": pro.IsDefault, "is_charge": pro.IsCharge, "is_estimate": pro.IsEstimate, "is_workload": pro.IsWorkload, "sort": pro.Sort, "doctor_advice": pro.DoctorAdvice, "single_dose": pro.SingleDose, "execution_frequency": pro.ExecutionFrequency, "delivery_way": pro.DeliveryWay, "number_days": pro.NumberDays, "total": pro.Total, "updated_time": pro.UpdatedTime, "category": pro.Category}).Error
 	return err
 }
 

service/manage_center_service.go

 }
 
 func UpdateDictionaryChildConfig(dataconfig *models.DictionaryDataconfig) (err error) {
-	err = readDb.Model(&models.DictionaryDataconfig{}).Where("id =?", dataconfig.ID).Update(map[string]interface{}{"name": dataconfig.Name, "update_time": dataconfig.UpdatedTime, "remark": dataconfig.Remark, "orders": dataconfig.Order}).Error
+	err = readDb.Model(&models.DictionaryDataconfig{}).Where("id =?", dataconfig.ID).Update(map[string]interface{}{"name": dataconfig.Name, "update_time": dataconfig.UpdatedTime, "remark": dataconfig.Remark, "orders": dataconfig.Order, "code": dataconfig.Code}).Error
 	return
 }
 
 	return
 }
 
-func GetBaseDrugLibList(org_id int64, keyword string, page int64, limit int64, is_use int64, is_charge int64, is_inject int64) (list []*models.BaseDrugLib, total int64, err error) {
+func GetBaseDrugLibList(org_id int64, keyword string, page int64, limit int64, is_use int64, is_charge int64, is_inject int64, manufacturer int64, isRecord int64) (list []*models.BaseDrugLib, total int64, err error) {
 
 	db := readDb.Model(&models.BaseDrugLib{}).Where("org_id = ?  AND status = 1", org_id)
 	if len(keyword) != 0 {
 		} else {
 			db = db.Where("find_in_set('收费',drug_status) = 0")
 		}
-
 	}
 
 	if is_inject != 0 {
 		}
 
 	}
+
+	if manufacturer > 0 {
+		db = db.Where("manufacturer = ?", manufacturer)
+	}
+	if isRecord > 0 {
+		db = db.Where("is_mark = ?", isRecord)
+	}
 	offset := (page - 1) * limit
 
 	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&list).Error

service/role_service.go

 	TitleName       string `gorm:"-" json:"title_name"`
 	IsSubSuperAdmin bool   `gorm:"-" json:"is_sub_super_admin"`
 	//mobile          string `gorm:"-" json:"mobile"`
-	Sort int `gorm:"sort" json:"sort"`
+	Sort     int `gorm:"sort" json:"sort"`
+	IsMark   int `gorm:"is_mark" json:"is_mark"`
+	UserType int `gorm:"user_type" json:"user_type"`
 }
 
 func GetAdminUsersAndLoginInfo(orgID int64, appID int64, page int, count int) ([]*AdminUserManageViewModel, int, error) {
 		page = 1
 	}
 	var viewModels []*AdminUserManageViewModel = make([]*AdminUserManageViewModel, 0)
-	rows, err := readUserDb.Raw("SELECT u_a_r.admin_user_id, u_a_r.user_name, u_a_r.user_title, u_l.ip, u_l.ctime, u_a_r.status,u_a_r.avatar,u_a_r.role_ids,u_a_r.sort FROM sgj_user_admin_role AS u_a_r   LEFT JOIN (SELECT * FROM (SELECT admin_user_id, org_id, app_id, ip, ctime FROM sgj_user_admin_login_log WHERE org_id = ? AND app_id = ?  ORDER BY ctime DESC) AS t GROUP BY admin_user_id) AS u_l  ON u_a_r.org_id = u_l.org_id AND u_a_r.app_id = u_l.app_id AND u_a_r.admin_user_id = u_l.admin_user_id WHERE u_a_r.org_id = ? AND u_a_r.app_id = ? GROUP BY u_a_r.admin_user_id  LIMIT ? OFFSET ?;", orgID, appID, orgID, appID, count, (page-1)*count).Rows()
+	rows, err := readUserDb.Raw("SELECT u_a_r.admin_user_id, u_a_r.user_name, u_a_r.user_title, u_l.ip, u_l.ctime, u_a_r.status,u_a_r.avatar,u_a_r.role_ids,u_a_r.sort,u_a_r.is_mark,u_a_r.user_type FROM sgj_user_admin_role AS u_a_r   LEFT JOIN (SELECT * FROM (SELECT admin_user_id, org_id, app_id, ip, ctime FROM sgj_user_admin_login_log WHERE org_id = ? AND app_id = ?  ORDER BY ctime DESC) AS t GROUP BY admin_user_id) AS u_l  ON u_a_r.org_id = u_l.org_id AND u_a_r.app_id = u_l.app_id AND u_a_r.admin_user_id = u_l.admin_user_id WHERE u_a_r.org_id = ? AND u_a_r.app_id = ? GROUP BY u_a_r.admin_user_id  LIMIT ? OFFSET ?;", orgID, appID, orgID, appID, count, (page-1)*count).Rows()
 	defer rows.Close()
 	if err != nil {
 		if err == gorm.ErrRecordNotFound {
 	return user.IsSuperAdmin, nil
 }
 
+func CreateGeneralAdminUserOne(orgID int64, appID int64, mobile string, name string, userTitle string, roleIds string, user_type int, user_title int, department_id int64, deapartment_name string, sex int64, age int64, nation string, card_type int64, idCard string, education int64, studyMajorName string, workMajorName string, roletype int64, medicalCode string, doctorcode string, licensing int64, jobnumber string, prescriptionQualificationIdentification int64, identificationOutpatients int64, startime int64, medicalRangeCode int64, medicalLevel int64, medicalTypeJob int64, pharmacistRegistrationNumber string, doctorRangeCode int64, doctorLevel int64, doctorTypeJob int64, doctorNumber string, outpatientIllnessCategory string, isActive int64, activeStatus int64) (*models.AdminUser, string, error) {
+	now := time.Now().Unix()
+	tx := writeUserDb.Begin()
+	var adminUser models.AdminUser
+	err := readUserDb.Where("mobile = ? AND status = 1", mobile).First(&adminUser).Error
+	password := ""
+	if err != nil {
+		if err != gorm.ErrRecordNotFound {
+			return nil, "", err
+		} else {
+			password = utils.RandomNumberString(6)
+			adminUser.Mobile = mobile
+			adminUser.Password = utils.String2md5(password)
+			adminUser.IsSuperAdmin = false
+			adminUser.Status = 1
+			adminUser.CreateTime = now
+			adminUser.ModifyTime = now
+			if createErr := tx.Create(&adminUser).Error; createErr != nil {
+				tx.Rollback()
+				return nil, "", createErr
+			}
+		}
+	}
+	app_role := models.App_Role{
+		AdminUserId:                             adminUser.Id,
+		OrgId:                                   orgID,
+		AppId:                                   appID,
+		Avatar:                                  "",
+		UserName:                                name,
+		UserTitleName:                           userTitle,
+		UserTitle:                               int8(user_title),
+		UserType:                                int8(user_type),
+		Status:                                  1,
+		CreateTime:                              now,
+		ModifyTime:                              now,
+		RoleIds:                                 roleIds,
+		IsSort:                                  1,
+		Department:                              deapartment_name,
+		DepartmentId:                            department_id,
+		Sex:                                     sex,
+		Age:                                     age,
+		Nation:                                  nation,
+		CardType:                                card_type,
+		IdCard:                                  idCard,
+		Education:                               education,
+		StudyMajorName:                          studyMajorName,
+		WorkMajorName:                           workMajorName,
+		RoleType:                                roletype,
+		MedicalCode:                             medicalCode,
+		DoctorCode:                              doctorcode,
+		Licensing:                               licensing,
+		JobNumber:                               jobnumber,
+		PharmacistRegistrationNumber:            pharmacistRegistrationNumber,
+		IdentificationOutpatients:               identificationOutpatients,
+		StartTime:                               startime,
+		MedicalRangeCode:                        medicalRangeCode,
+		MedicalLevel:                            medicalLevel,
+		MedicalTypeJob:                          medicalTypeJob,
+		DoctorNumber:                            doctorNumber,
+		OutpatientIllnesscategory:               outpatientIllnessCategory,
+		IsActive:                                isActive,
+		ActiveStatus:                            activeStatus,
+		PrescriptionQualificationIdentification: prescriptionQualificationIdentification,
+		DoctorRangeCode:                         doctorRangeCode,
+		DoctorTypeJob:                           doctorTypeJob,
+		DoctorLevel:                             doctorLevel,
+	}
+	if createApp_RoleErr := tx.Create(&app_role).Error; createApp_RoleErr != nil {
+		tx.Rollback()
+		return nil, "", createApp_RoleErr
+	}
+
+	tx.Commit()
+	return &adminUser, password, nil
+}
+
 func CreateGeneralAdminUser(orgID int64, appID int64, mobile string, name string, userTitle string, roleIds string, user_type int, user_title int, department_id int64, deapartment_name string) (*models.AdminUser, string, error) {
 	now := time.Now().Unix()
 	tx := writeUserDb.Begin()

service/stock_service.go

 func ModifyGoodInfo(goodInfo *models.GoodInfo) (error, *models.GoodInfo) {
 
 	err := writeDb.Model(&models.GoodInfo{}).Where("id = ? AND status = 1", goodInfo.ID).Updates(map[string]interface{}{
-		"good_type_id":               goodInfo.GoodTypeId,
-		"modifier":                   goodInfo.Modifier,
-		"mtime":                      time.Now().Unix(),
-		"remark":                     goodInfo.Remark,
-		"specification_name":         goodInfo.SpecificationName,
-		"good_unit":                  goodInfo.GoodUnit,
-		"buy_price":                  goodInfo.BuyPrice,
-		"sell_price":                 goodInfo.SellPrice,
-		"manufacturer":               goodInfo.Manufacturer,
-		"dealer":                     goodInfo.Dealer,
-		"expiry_date_warn_day_count": goodInfo.ExpiryDateWarnDayCount,
-		"stock_warn_count":           goodInfo.StockWarnCount,
-		"is_reuse":                   goodInfo.IsReuse,
-		"good_name":                  goodInfo.GoodName,
-		"pinyin":                     goodInfo.Pinyin,
-		"wubi":                       goodInfo.Wubi,
-		"good_kind":                  goodInfo.GoodKind,
-		"medical_insurance_level":    goodInfo.MedicalInsuranceLevel,
-		"retail_price":               goodInfo.RetailPrice,
-		"medical_insurance_number":   goodInfo.MedicalInsuranceNumber,
-		"is_special_diseases":        goodInfo.IsSpecialDiseases,
-		"is_record":                  goodInfo.IsRecord,
-		"statistics_category":        goodInfo.StatisticsCategory,
-		"good_status":                goodInfo.GoodStatus,
-		"default_count":              goodInfo.DefaultCount,
-		"sign":                       goodInfo.Sign,
-		"is_default":                 goodInfo.IsDefault,
-		"is_charge_use":              goodInfo.IsChargeUse,
-		"is_charge_predict":          goodInfo.IsChargePredict,
-		"is_statistics_work":         goodInfo.IsStatisticsWork,
-		"sort":                       goodInfo.Sort,
-		"is_doctor_use":              goodInfo.IsDoctorUse,
-		"agent":                      goodInfo.Agent,
-		"good_number":                goodInfo.GoodNumber,
+		"good_type_id":                   goodInfo.GoodTypeId,
+		"modifier":                       goodInfo.Modifier,
+		"mtime":                          time.Now().Unix(),
+		"remark":                         goodInfo.Remark,
+		"specification_name":             goodInfo.SpecificationName,
+		"good_unit":                      goodInfo.GoodUnit,
+		"buy_price":                      goodInfo.BuyPrice,
+		"sell_price":                     goodInfo.SellPrice,
+		"manufacturer":                   goodInfo.Manufacturer,
+		"dealer":                         goodInfo.Dealer,
+		"expiry_date_warn_day_count":     goodInfo.ExpiryDateWarnDayCount,
+		"stock_warn_count":               goodInfo.StockWarnCount,
+		"is_reuse":                       goodInfo.IsReuse,
+		"good_name":                      goodInfo.GoodName,
+		"pinyin":                         goodInfo.Pinyin,
+		"wubi":                           goodInfo.Wubi,
+		"good_kind":                      goodInfo.GoodKind,
+		"medical_insurance_level":        goodInfo.MedicalInsuranceLevel,
+		"retail_price":                   goodInfo.RetailPrice,
+		"medical_insurance_number":       goodInfo.MedicalInsuranceNumber,
+		"is_special_diseases":            goodInfo.IsSpecialDiseases,
+		"is_record":                      goodInfo.IsRecord,
+		"statistics_category":            goodInfo.StatisticsCategory,
+		"good_status":                    goodInfo.GoodStatus,
+		"default_count":                  goodInfo.DefaultCount,
+		"sign":                           goodInfo.Sign,
+		"is_default":                     goodInfo.IsDefault,
+		"is_charge_use":                  goodInfo.IsChargeUse,
+		"is_charge_predict":              goodInfo.IsChargePredict,
+		"is_statistics_work":             goodInfo.IsStatisticsWork,
+		"sort":                           goodInfo.Sort,
+		"is_doctor_use":                  goodInfo.IsDoctorUse,
+		"agent":                          goodInfo.Agent,
+		"good_number":                    goodInfo.GoodNumber,
+		"social_security_directory_code": goodInfo.SocialSecurityDirectoryCode,
+		"special_medical":                goodInfo.SpecialMedical,
+		"production_type":                goodInfo.ProductionType,
 	}).Error
 
 	writeDb.Model(&models.WarehousingInfo{}).Where("good_id = ? AND org_id = ?", goodInfo.ID, goodInfo.OrgId).Updates(map[string]interface{}{"good_type_id": goodInfo.GoodTypeId})
 
 }
 
-func FindGoodInfoList(orgId int64, page int64, limit int64, keyword string, is_use int64, is_charge int64, good_kind int64) (list []*models.GoodInfo, total int64, err error) {
+func FindGoodInfoList(orgId int64, page int64, limit int64, keyword string, is_use int64, is_charge int64, good_kind int64, is_mark int64, manufacturer int64) (list []*models.GoodInfo, total int64, err error) {
 	offset := (page - 1) * limit
 	db := readDb.Model(&models.GoodInfo{})
 	db = db.Where("org_id = ? AND status = 1", orgId)
 			db = db.Where(" good_kind = ?", good_kind)
 		}
 
+		if is_mark > 0 {
+			db = db.Where("is_mark = ?", is_mark)
+		}
+		if manufacturer > 0 {
+			db = db.Where("manufacturer = ?", manufacturer)
+		}
 	}
 
 	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&list).Error